Changeset 6652 for trunk/src


Ignore:
Timestamp:
Sep 5, 2001, 4:16:46 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

Location:
trunk/src/avifil32
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/avifil32/guid.c

    r6386 r6652  
     1/* $Id: guid.c,v 1.2 2001-09-05 14:16:44 bird Exp $ */
    12#define INITGUID
    23

  • trunk/src/avifil32/iafile.c

    r6386 r6652  
     1/* $Id: iafile.c,v 1.2 2001-09-05 14:16:44 bird Exp $ */
    12/*
    23 * Copyright 1999 Marcus Meissner
    … …  
    2021DEFAULT_DEBUG_CHANNEL(avifile);
    2122
    22 #define AVIFILE_STREAMS_MAX     4
     23#define AVIFILE_STREAMS_MAX 4
    2324
    2425
    … …  
    5253typedef struct IAVIFileImpl
    5354{
    54         ICOM_VFIELD(IAVIFile);
    55         /* IUnknown stuff */
    56         DWORD                   ref;
    57         /* IAVIFile stuff */
    58         HANDLE                  hf;
    59         DWORD                   dwAVIFileCaps;
    60         DWORD                   dwAVIFileScale;
    61         DWORD                   dwAVIFileRate;
    62         DWORD                   dwAVIFileLength;
    63         DWORD                   dwAVIFileEditCount;
    64         MainAVIHeader           hdr;
    65         IAVIStream*             pStreams[AVIFILE_STREAMS_MAX];
    66         AVIStreamHeader         strhdrs[AVIFILE_STREAMS_MAX];
    67         DWORD                   dwMoviTop;
    68         DWORD                   dwCountOfIndexEntry;
    69         AVIINDEXENTRY*          pIndexEntry;
    70         AVIINDEXENTRY*          pStreamIndexEntry[AVIFILE_STREAMS_MAX+1];
     55    ICOM_VFIELD(IAVIFile);
     56    /* IUnknown stuff */
     57    DWORD           ref;
     58    /* IAVIFile stuff */
     59    HANDLE          hf;
     60    DWORD           dwAVIFileCaps;
     61    DWORD           dwAVIFileScale;
     62    DWORD           dwAVIFileRate;
     63    DWORD           dwAVIFileLength;
     64    DWORD           dwAVIFileEditCount;
     65    MainAVIHeader       hdr;
     66    IAVIStream*     pStreams[AVIFILE_STREAMS_MAX];
     67    AVIStreamHeader     strhdrs[AVIFILE_STREAMS_MAX];
     68    DWORD           dwMoviTop;
     69    DWORD           dwCountOfIndexEntry;
     70    AVIINDEXENTRY*      pIndexEntry;
     71    AVIINDEXENTRY*      pStreamIndexEntry[AVIFILE_STREAMS_MAX+1];
    7172} IAVIFileImpl;
    7273
    … …  
    7778
    7879static HRESULT AVIFILE_IAVIFile_ReadNextChunkHeader(
    79                 IAVIFileImpl* This, FOURCC* pfcc, DWORD* pdwSize )
    80 {
    81         BYTE    buf[8];
    82         DWORD   dwRead;
    83 
    84         if ( ( !ReadFile( This->hf, buf, 8, &dwRead, NULL ) ) ||
    85              ( 8 != dwRead ) )
    86                 return AVIERR_FILEREAD;
    87         *pfcc = mmioFOURCC(buf[0],buf[1],buf[2],buf[3]);
    88         *pdwSize = ( ((DWORD)buf[4])       ) |
    89                    ( ((DWORD)buf[5]) <<  8 ) |
    90                    ( ((DWORD)buf[6]) << 16 ) |
    91                    ( ((DWORD)buf[7]) << 24 );
    92 
    93         return S_OK;
     80        IAVIFileImpl* This, FOURCC* pfcc, DWORD* pdwSize )
     81{
     82    BYTE    buf[8];
     83    DWORD   dwRead;
     84
     85    if ( ( !ReadFile( This->hf, buf, 8, &dwRead, NULL ) ) ||
     86         ( 8 != dwRead ) )
     87        return AVIERR_FILEREAD;
     88    *pfcc = mmioFOURCC(buf[0],buf[1],buf[2],buf[3]);
     89    *pdwSize = ( ((DWORD)buf[4])       ) |
     90           ( ((DWORD)buf[5]) <<  8 ) |
     91           ( ((DWORD)buf[6]) << 16 ) |
     92           ( ((DWORD)buf[7]) << 24 );
     93
     94    return S_OK;
    9495}
    9596
    9697static HRESULT AVIFILE_IAVIFile_SkipChunkData(
    97                 IAVIFileImpl* This, DWORD dwChunkSize )
    98 {
    99         LONG    lHigh = 0;
    100         DWORD   dwRes;
    101 
    102         if ( dwChunkSize == 0 )
    103                 return S_OK;
    104 
    105         SetLastError(NO_ERROR);
    106         dwRes = SetFilePointer( This->hf, (LONG)dwChunkSize,
    107                                 &lHigh, FILE_CURRENT );
    108         if ( dwRes == (DWORD)0xffffffff && GetLastError() != NO_ERROR )
    109                 return AVIERR_FILEREAD;
    110 
    111         return S_OK;
     98        IAVIFileImpl* This, DWORD dwChunkSize )
     99{
     100    LONG    lHigh = 0;
     101    DWORD   dwRes;
     102
     103    if ( dwChunkSize == 0 )
     104        return S_OK;
     105
     106    SetLastError(NO_ERROR);
     107    dwRes = SetFilePointer( This->hf, (LONG)dwChunkSize,
     108                &lHigh, FILE_CURRENT );
     109    if ( dwRes == (DWORD)0xffffffff && GetLastError() != NO_ERROR )
     110        return AVIERR_FILEREAD;
     111
     112    return S_OK;
    112113}
    113114
    114115static HRESULT AVIFILE_IAVIFile_ReadChunkData(
    115                 IAVIFileImpl* This, DWORD dwChunkSize,
    116                 LPVOID lpvBuf, DWORD dwBufSize, LPDWORD lpdwRead )
    117 {
    118         if ( dwBufSize > dwChunkSize )
    119                 dwBufSize = dwChunkSize;
    120         if ( ( !ReadFile( This->hf, lpvBuf, dwBufSize, lpdwRead, NULL ) ) ||
    121              ( dwBufSize != *lpdwRead ) )
    122                 return AVIERR_FILEREAD;
    123 
    124         return AVIFILE_IAVIFile_SkipChunkData( This, dwChunkSize - dwBufSize );
     116        IAVIFileImpl* This, DWORD dwChunkSize,
     117        LPVOID lpvBuf, DWORD dwBufSize, LPDWORD lpdwRead )
     118{
     119    if ( dwBufSize > dwChunkSize )
     120        dwBufSize = dwChunkSize;
     121    if ( ( !ReadFile( This->hf, lpvBuf, dwBufSize, lpdwRead, NULL ) ) ||
     122         ( dwBufSize != *lpdwRead ) )
     123        return AVIERR_FILEREAD;
     124
     125    return AVIFILE_IAVIFile_SkipChunkData( This, dwChunkSize - dwBufSize );
    125126}
    126127
    127128static HRESULT AVIFILE_IAVIFile_SeekToSpecifiedChunk(
    128                 IAVIFileImpl* This, FOURCC fccType, DWORD* pdwLen )
    129 {
    130         HRESULT hr;
    131         FOURCC  fcc;
    132         BYTE    buf[4];
    133         DWORD   dwRead;
    134 
    135         while ( 1 )
    136         {
    137                 hr = AVIFILE_IAVIFile_ReadNextChunkHeader(
    138                                 This, &fcc, pdwLen );
    139                 if ( hr != S_OK )
    140                         return hr;
    141                 if ( fcc == fccType )
    142                         return S_OK;
    143 
    144                 if ( fcc == FOURCC_LIST )
    145                 {
    146                     if ( ( !ReadFile( This->hf, buf, 4, &dwRead, NULL ) ) ||
    147                         ( 4 != dwRead ) )
    148                         return AVIERR_FILEREAD;
    149                 }
    150                 else
    151                 {
    152                     hr = AVIFILE_IAVIFile_SkipChunkData(
    153                                         This, *pdwLen );
    154                     if ( hr != S_OK )
    155                         return hr;
    156                 }
    157         }
     129        IAVIFileImpl* This, FOURCC fccType, DWORD* pdwLen )
     130{
     131    HRESULT hr;
     132    FOURCC  fcc;
     133    BYTE    buf[4];
     134    DWORD   dwRead;
     135
     136    while ( 1 )
     137    {
     138        hr = AVIFILE_IAVIFile_ReadNextChunkHeader(
     139                This, &fcc, pdwLen );
     140        if ( hr != S_OK )
     141            return hr;
     142        if ( fcc == fccType )
     143            return S_OK;
     144
     145        if ( fcc == FOURCC_LIST )
     146        {
     147            if ( ( !ReadFile( This->hf, buf, 4, &dwRead, NULL ) ) ||
     148            ( 4 != dwRead ) )
     149            return AVIERR_FILEREAD;
     150        }
     151        else
     152        {
     153            hr = AVIFILE_IAVIFile_SkipChunkData(
     154                    This, *pdwLen );
     155            if ( hr != S_OK )
     156            return hr;
     157        }
     158    }
    158159}
    159160
    … …  
    161162WINE_AVISTREAM_DATA* AVIFILE_Alloc_IAVIStreamData( DWORD dwFmtLen )
    162163{
    163         WINE_AVISTREAM_DATA*    pData;
    164 
    165         pData = (WINE_AVISTREAM_DATA*)
    166                 HeapAlloc( AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    167                            sizeof(WINE_AVISTREAM_DATA) );
    168         if ( pData == NULL )
    169                 return NULL;
    170         if ( dwFmtLen > 0 )
    171         {
    172                 pData->pbFmt = (BYTE*)
    173                         HeapAlloc( AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    174                                    sizeof(BYTE)*dwFmtLen );
    175                 if ( pData->pbFmt == NULL )
    176                 {
    177                         AVIFILE_Free_IAVIStreamData( pData );
    178                         return NULL;
    179                 }
    180         }
    181         pData->dwFmtLen = dwFmtLen;
    182 
    183         return pData;
     164    WINE_AVISTREAM_DATA*    pData;
     165
     166    pData = (WINE_AVISTREAM_DATA*)
     167        HeapAlloc( AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     168               sizeof(WINE_AVISTREAM_DATA) );
     169    if ( pData == NULL )
     170        return NULL;
     171    if ( dwFmtLen > 0 )
     172    {
     173        pData->pbFmt = (BYTE*)
     174            HeapAlloc( AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     175                   sizeof(BYTE)*dwFmtLen );
     176        if ( pData->pbFmt == NULL )
     177        {
     178            AVIFILE_Free_IAVIStreamData( pData );
     179            return NULL;
     180        }
     181    }
     182    pData->dwFmtLen = dwFmtLen;
     183
     184    return pData;
    184185}
    185186
    186187void AVIFILE_Free_IAVIStreamData( WINE_AVISTREAM_DATA* pData )
    187188{
    188         if ( pData != NULL )
    189         {
    190                 if ( pData->pbFmt != NULL )
    191                         HeapFree( AVIFILE_data.hHeap,0,pData->pbFmt );
    192                 HeapFree( AVIFILE_data.hHeap,0,pData );
    193         }
     189    if ( pData != NULL )
     190    {
     191        if ( pData->pbFmt != NULL )
     192            HeapFree( AVIFILE_data.hHeap,0,pData->pbFmt );
     193        HeapFree( AVIFILE_data.hHeap,0,pData );
     194    }
    194195}
    195196
    196197static void AVIFILE_IAVIFile_InitIndexTable(
    197                 IAVIFileImpl* This,
    198                 AVIINDEXENTRY* pIndexBuf,
    199                 AVIINDEXENTRY* pIndexData,
    200                 DWORD dwCountOfIndexEntry )
    201 {
    202         DWORD   dwStreamIndex;
    203         DWORD   dwIndex;
    204         FOURCC  ckid;
    205 
    206         dwStreamIndex = 0;
    207         for ( ; dwStreamIndex < (AVIFILE_STREAMS_MAX+1); dwStreamIndex ++ )
    208                 This->pStreamIndexEntry[dwStreamIndex] = NULL;
    209 
    210         dwStreamIndex = 0;
    211         for ( ; dwStreamIndex < This->hdr.dwStreams; dwStreamIndex ++ )
    212         {
    213                 ckid = mmioFOURCC('0','0'+dwStreamIndex,0,0);
    214                 TRACE( "testing ckid %c%c%c%c\n",
    215                         (int)(ckid>> 0)&0xff,
    216                         (int)(ckid>> 8)&0xff,
    217                         (int)(ckid>>16)&0xff,
    218                         (int)(ckid>>24)&0xff );
    219                 This->pStreamIndexEntry[dwStreamIndex] = pIndexBuf;
    220                 FIXME( "pIndexBuf = %p\n", pIndexBuf );
    221                 for ( dwIndex = 0; dwIndex < dwCountOfIndexEntry; dwIndex++ )
    222                 {
    223                     TRACE( "ckid %c%c%c%c\n",
    224                             (int)(pIndexData[dwIndex].ckid>> 0)&0xff,
     198        IAVIFileImpl* This,
     199        AVIINDEXENTRY* pIndexBuf,
     200        AVIINDEXENTRY* pIndexData,
     201        DWORD dwCountOfIndexEntry )
     202{
     203    DWORD   dwStreamIndex;
     204    DWORD   dwIndex;
     205    FOURCC  ckid;
     206
     207    dwStreamIndex = 0;
     208    for ( ; dwStreamIndex < (AVIFILE_STREAMS_MAX+1); dwStreamIndex ++ )
     209        This->pStreamIndexEntry[dwStreamIndex] = NULL;
     210
     211    dwStreamIndex = 0;
     212    for ( ; dwStreamIndex < This->hdr.dwStreams; dwStreamIndex ++ )
     213    {
     214        ckid = mmioFOURCC('0','0'+dwStreamIndex,0,0);
     215        TRACE( "testing ckid %c%c%c%c\n",
     216            (int)(ckid>> 0)&0xff,
     217            (int)(ckid>> 8)&0xff,
     218            (int)(ckid>>16)&0xff,
     219            (int)(ckid>>24)&0xff );
     220        This->pStreamIndexEntry[dwStreamIndex] = pIndexBuf;
     221        FIXME( "pIndexBuf = %p\n", pIndexBuf );
     222        for ( dwIndex = 0; dwIndex < dwCountOfIndexEntry; dwIndex++ )
     223        {
     224            TRACE( "ckid %c%c%c%c\n",
     225                (int)(pIndexData[dwIndex].ckid>> 0)&0xff,
    225226                            (int)(pIndexData[dwIndex].ckid>> 8)&0xff,
    226227                            (int)(pIndexData[dwIndex].ckid>>16)&0xff,
    227228                            (int)(pIndexData[dwIndex].ckid>>24)&0xff );
    228                            
    229                     if ( (pIndexData[dwIndex].ckid & mmioFOURCC(0xff,0xff,0,0))
    230                                                                 == ckid )
    231                     {
    232                         memcpy( pIndexBuf, &pIndexData[dwIndex],
    233                                 sizeof(AVIINDEXENTRY) );
    234                         pIndexBuf ++;
    235                     }
    236                 }
     229
     230            if ( (pIndexData[dwIndex].ckid & mmioFOURCC(0xff,0xff,0,0))
     231                                == ckid )
     232            {
     233            memcpy( pIndexBuf, &pIndexData[dwIndex],
     234                sizeof(AVIINDEXENTRY) );
     235            pIndexBuf ++;
     236            }
     237        }
    237238                FIXME( "pIndexBuf = %p\n", pIndexBuf );
    238         }
    239         This->pStreamIndexEntry[This->hdr.dwStreams] = pIndexBuf;
     239    }
     240    This->pStreamIndexEntry[This->hdr.dwStreams] = pIndexBuf;
    240241}
    241242
    … …  
    250251HRESULT AVIFILE_CreateIAVIFile(void** ppobj)
    251252{
    252         IAVIFileImpl    *This;
    253         HRESULT         hr;
    254 
    255         TRACE("(%p)\n",ppobj);
    256         *ppobj = NULL;
    257         This = (IAVIFileImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    258                                         sizeof(IAVIFileImpl));
    259         if ( This == NULL )
    260                 return AVIERR_MEMORY;
    261         This->ref = 1;
    262         ICOM_VTBL(This) = &iavift;
    263         hr = AVIFILE_IAVIFile_Construct( This );
    264         if ( hr != S_OK )
    265         {
    266                 AVIFILE_IAVIFile_Destruct( This );
    267                 return hr;
    268         }
    269 
    270         TRACE("new -> %p\n",This);
    271         *ppobj = (LPVOID)This;
    272 
    273         return S_OK;
     253    IAVIFileImpl    *This;
     254    HRESULT     hr;
     255
     256    TRACE("(%p)\n",ppobj);
     257    *ppobj = NULL;
     258    This = (IAVIFileImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     259                    sizeof(IAVIFileImpl));
     260    if ( This == NULL )
     261        return AVIERR_MEMORY;
     262    This->ref = 1;
     263    ICOM_VTBL(This) = &iavift;
     264    hr = AVIFILE_IAVIFile_Construct( This );
     265    if ( hr != S_OK )
     266    {
     267        AVIFILE_IAVIFile_Destruct( This );
     268        return hr;
     269    }
     270
     271    TRACE("new -> %p\n",This);
     272    *ppobj = (LPVOID)This;
     273
     274    return S_OK;
    274275}
    275276
    … …  
    279280
    280281static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile* iface,REFIID refiid,LPVOID *obj) {
    281         ICOM_THIS(IAVIFileImpl,iface);
    282 
    283         TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
    284         if ( IsEqualGUID(&IID_IUnknown,refiid) ||
    285              IsEqualGUID(&IID_IAVIFile,refiid) )
    286         {
    287                 *obj = iface;
    288                 IAVIFile_AddRef(iface);
    289                 return S_OK;
    290         }
    291         return OLE_E_ENUM_NOMORE;
     282    ICOM_THIS(IAVIFileImpl,iface);
     283
     284    TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
     285    if ( IsEqualGUID(&IID_IUnknown,refiid) ||
     286         IsEqualGUID(&IID_IAVIFile,refiid) )
     287    {
     288        *obj = iface;
     289        IAVIFile_AddRef(iface);
     290        return S_OK;
     291    }
     292    return OLE_E_ENUM_NOMORE;
    292293}
    293294
    294295static ULONG WINAPI IAVIFile_fnAddRef(IAVIFile* iface) {
    295         ICOM_THIS(IAVIFileImpl,iface);
    296 
    297         TRACE("(%p)->AddRef()\n",iface);
    298         return ++(This->ref);
     296    ICOM_THIS(IAVIFileImpl,iface);
     297
     298    TRACE("(%p)->AddRef()\n",iface);
     299    return ++(This->ref);
    299300}
    300301
    301302static ULONG WINAPI IAVIFile_fnRelease(IAVIFile* iface) {
    302         ICOM_THIS(IAVIFileImpl,iface);
    303 
    304         TRACE("(%p)->Release()\n",iface);
    305         if ( (--(This->ref)) > 0 )
    306                 return This->ref;
    307 
    308         AVIFILE_IAVIFile_Destruct(This);
    309         HeapFree(AVIFILE_data.hHeap,0,iface);
    310         return 0;
     303    ICOM_THIS(IAVIFileImpl,iface);
     304
     305    TRACE("(%p)->Release()\n",iface);
     306    if ( (--(This->ref)) > 0 )
     307        return This->ref;
     308
     309    AVIFILE_IAVIFile_Destruct(This);
     310    HeapFree(AVIFILE_data.hHeap,0,iface);
     311    return 0;
    311312}
    312313
    … …  
    317318static HRESULT AVIFILE_IAVIFile_Construct( IAVIFileImpl* This )
    318319{
    319         DWORD   dwIndex;
    320 
    321         This->hf = INVALID_HANDLE_VALUE;
    322         This->dwAVIFileCaps = 0;
    323         This->dwAVIFileScale = 0;
    324         This->dwAVIFileRate = 0;
    325         This->dwAVIFileLength = 0;
    326         This->dwAVIFileEditCount = 0;
    327         for ( dwIndex = 0; dwIndex < AVIFILE_STREAMS_MAX; dwIndex++ )
    328                 This->pStreams[dwIndex] = NULL;
    329         This->dwCountOfIndexEntry = 0;
    330         This->pIndexEntry = NULL;
    331 
    332         AVIFILE_data.dwClassObjRef ++;
    333 
    334         return S_OK;
     320    DWORD   dwIndex;
     321
     322    This->hf = INVALID_HANDLE_VALUE;
     323    This->dwAVIFileCaps = 0;
     324    This->dwAVIFileScale = 0;
     325    This->dwAVIFileRate = 0;
     326    This->dwAVIFileLength = 0;
     327    This->dwAVIFileEditCount = 0;
     328    for ( dwIndex = 0; dwIndex < AVIFILE_STREAMS_MAX; dwIndex++ )
     329        This->pStreams[dwIndex] = NULL;
     330    This->dwCountOfIndexEntry = 0;
     331    This->pIndexEntry = NULL;
     332
     333    AVIFILE_data.dwClassObjRef ++;
     334
     335    return S_OK;
    335336}
    336337
    337338static void AVIFILE_IAVIFile_Destruct( IAVIFileImpl* This )
    338339{
    339         DWORD   dwIndex;
    340 
    341         if ( This->pIndexEntry != NULL )
    342         {
    343                 HeapFree(AVIFILE_data.hHeap,0,This->pIndexEntry);
    344                 This->pIndexEntry = NULL;
    345         }
    346 
    347         for ( dwIndex = 0; dwIndex < AVIFILE_STREAMS_MAX; dwIndex++ )
    348         {
    349                 if ( This->pStreams[dwIndex] != NULL )
    350                 {
    351                         IAVIStream_Release( This->pStreams[dwIndex] );
    352                         This->pStreams[dwIndex] = NULL;
    353                 }
    354         }
    355 
    356         if ( This->hf != INVALID_HANDLE_VALUE )
    357                 CloseHandle( This->hf );
    358 
    359         AVIFILE_data.dwClassObjRef --;
     340    DWORD   dwIndex;
     341
     342    if ( This->pIndexEntry != NULL )
     343    {
     344        HeapFree(AVIFILE_data.hHeap,0,This->pIndexEntry);
     345        This->pIndexEntry = NULL;
     346    }
     347
     348    for ( dwIndex = 0; dwIndex < AVIFILE_STREAMS_MAX; dwIndex++ )
     349    {
     350        if ( This->pStreams[dwIndex] != NULL )
     351        {
     352            IAVIStream_Release( This->pStreams[dwIndex] );
     353            This->pStreams[dwIndex] = NULL;
     354        }
     355    }
     356
     357    if ( This->hf != INVALID_HANDLE_VALUE )
     358        CloseHandle( This->hf );
     359
     360    AVIFILE_data.dwClassObjRef --;
    360361}
    361362
    362363static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile*iface,AVIFILEINFOW*afi,LONG size)
    363364{
    364         ICOM_THIS(IAVIFileImpl,iface);
    365         AVIFILEINFOW    fiw;
    366 
    367         FIXME("(%p)->Info(%p,%ld)\n",iface,afi,size);
    368 
    369         memset( &fiw, 0, sizeof(fiw) );
    370         fiw.dwMaxBytesPerSec = This->hdr.dwMaxBytesPerSec;
    371         fiw.dwFlags = This->hdr.dwFlags;
    372         fiw.dwCaps = This->dwAVIFileCaps;
    373         fiw.dwStreams = This->hdr.dwStreams;
    374         fiw.dwSuggestedBufferSize = This->hdr.dwSuggestedBufferSize;
    375         fiw.dwWidth = This->hdr.dwWidth;
    376         fiw.dwHeight = This->hdr.dwHeight;
    377         fiw.dwScale = This->dwAVIFileScale; /* FIXME */
    378         fiw.dwRate = This->dwAVIFileRate; /* FIXME */
    379         fiw.dwLength = This->dwAVIFileLength; /* FIXME */
    380         fiw.dwEditCount = This->dwAVIFileEditCount; /* FIXME */
    381         /* fiw.szFileType[64]; */
    382 
    383         if ( size > sizeof(AVIFILEINFOW) )
    384                 size = sizeof(AVIFILEINFOW);
    385         memcpy( afi, &fiw, size );
    386 
    387         return S_OK;
     365    ICOM_THIS(IAVIFileImpl,iface);
     366    AVIFILEINFOW    fiw;
     367
     368    FIXME("(%p)->Info(%p,%ld)\n",iface,afi,size);
     369
     370    memset( &fiw, 0, sizeof(fiw) );
     371    fiw.dwMaxBytesPerSec = This->hdr.dwMaxBytesPerSec;
     372    fiw.dwFlags = This->hdr.dwFlags;
     373    fiw.dwCaps = This->dwAVIFileCaps;
     374    fiw.dwStreams = This->hdr.dwStreams;
     375    fiw.dwSuggestedBufferSize = This->hdr.dwSuggestedBufferSize;
     376    fiw.dwWidth = This->hdr.dwWidth;
     377    fiw.dwHeight = This->hdr.dwHeight;
     378    fiw.dwScale = This->dwAVIFileScale; /* FIXME */
     379    fiw.dwRate = This->dwAVIFileRate; /* FIXME */
     380    fiw.dwLength = This->dwAVIFileLength; /* FIXME */
     381    fiw.dwEditCount = This->dwAVIFileEditCount; /* FIXME */
     382    /* fiw.szFileType[64]; */
     383
     384    if ( size > sizeof(AVIFILEINFOW) )
     385        size = sizeof(AVIFILEINFOW);
     386    memcpy( afi, &fiw, size );
     387
     388    return S_OK;
    388389}
    389390
    390391static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam)
    391392{
    392         ICOM_THIS(IAVIFileImpl,iface);
    393 
    394         FIXME("(%p)->GetStream(%p,0x%08lx,%ld)\n",iface,avis,fccType,lParam);
    395         if ( fccType != 0 )
    396                 return E_FAIL;
    397         if ( lParam < 0 || lParam >= This->hdr.dwStreams )
    398                 return E_FAIL;
    399         *avis = This->pStreams[lParam];
    400         IAVIStream_AddRef( *avis );
    401 
    402         return S_OK;
     393    ICOM_THIS(IAVIFileImpl,iface);
     394
     395    FIXME("(%p)->GetStream(%p,0x%08lx,%ld)\n",iface,avis,fccType,lParam);
     396    if ( fccType != 0 )
     397        return E_FAIL;
     398    if ( lParam < 0 || lParam >= This->hdr.dwStreams )
     399        return E_FAIL;
     400    *avis = This->pStreams[lParam];
     401    IAVIStream_AddRef( *avis );
     402
     403    return S_OK;
    403404}
    404405
    405406static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi)
    406407{
    407         ICOM_THIS(IAVIFileImpl,iface);
    408 
    409         FIXME("(%p,%p,%p)\n",This,avis,asi);
    410         return E_FAIL;
     408    ICOM_THIS(IAVIFileImpl,iface);
     409
     410    FIXME("(%p,%p,%p)\n",This,avis,asi);
     411    return E_FAIL;
    411412}
    412413
    413414static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG size)
    414415{
    415         ICOM_THIS(IAVIFileImpl,iface);
    416 
    417         FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,ckid,lpData,size);
    418         /* FIXME: write data to file */
    419         return E_FAIL;
     416    ICOM_THIS(IAVIFileImpl,iface);
     417
     418    FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,ckid,lpData,size);
     419    /* FIXME: write data to file */
     420    return E_FAIL;
    420421}
    421422
    422423static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG *size)
    423424{
    424         ICOM_THIS(IAVIFileImpl,iface);
    425 
    426         FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,ckid,lpData,size);
    427         /* FIXME: read at most size bytes from file */
    428 
    429         return E_FAIL;
     425    ICOM_THIS(IAVIFileImpl,iface);
     426
     427    FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,ckid,lpData,size);
     428    /* FIXME: read at most size bytes from file */
     429
     430    return E_FAIL;
    430431}
    431432
    432433static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile*iface)
    433434{
    434         ICOM_THIS(IAVIFileImpl,iface);
    435 
    436         FIXME("(%p)->EndRecord()\n",This);
    437         /* FIXME: end record? */
    438         return E_FAIL;
     435    ICOM_THIS(IAVIFileImpl,iface);
     436
     437    FIXME("(%p)->EndRecord()\n",This);
     438    /* FIXME: end record? */
     439    return E_FAIL;
    439440}
    440441
    441442static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG lParam)
    442443{
    443         ICOM_THIS(IAVIFileImpl,iface);
    444 
    445         FIXME("(%p)->DeleteStream(0x%08lx,%ld)\n",This,fccType,lParam);
    446         /* FIXME: delete stream? */
    447         return E_FAIL;
     444    ICOM_THIS(IAVIFileImpl,iface);
     445
     446    FIXME("(%p)->DeleteStream(0x%08lx,%ld)\n",This,fccType,lParam);
     447    /* FIXME: delete stream? */
     448    return E_FAIL;
    448449}
    449450
    450451/*****************************************************************************
    451  *      AVIFILE_IAVIFile_Open (internal)
     452 *  AVIFILE_IAVIFile_Open (internal)
    452453 */
    453454HRESULT AVIFILE_IAVIFile_Open( PAVIFILE paf, LPCWSTR szFile, UINT uMode )
    454455{
    455         ICOM_THIS(IAVIFileImpl,paf);
    456         HRESULT         hr;
    457         DWORD           dwAcc;
    458         DWORD           dwShared;
    459         DWORD           dwCreate;
    460         BYTE            buf[12];
    461         DWORD           dwRead;
    462         FOURCC          fccFileType;
    463         DWORD           dwLen;
    464         DWORD           dwIndex;
    465 
    466         FIXME("(%p)->Open(%p,%u)\n",This,szFile,uMode);
    467 
    468         if ( This->hf != INVALID_HANDLE_VALUE )
    469         {
    470                 CloseHandle( This->hf );
    471                 This->hf = INVALID_HANDLE_VALUE;
    472         }
    473 
    474         switch ( uMode & 0x3 )
    475         {
    476         case OF_READ: /* 0x0 */
    477                 dwAcc = GENERIC_READ;
    478                 dwCreate = OPEN_EXISTING;
    479                 This->dwAVIFileCaps = AVIFILECAPS_CANREAD;
    480                 break;
    481         case OF_WRITE: /* 0x1 */
    482                 dwAcc = GENERIC_WRITE;
    483                 dwCreate = OPEN_ALWAYS;
    484                 This->dwAVIFileCaps = AVIFILECAPS_CANWRITE;
    485                 break;
    486         case OF_READWRITE: /* 0x2 */
    487                 dwAcc = GENERIC_READ|GENERIC_WRITE;
    488                 dwCreate = OPEN_ALWAYS;
    489                 This->dwAVIFileCaps = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE;
    490                 break;
    491         default:
    492                 return E_FAIL;
    493         }
    494 
    495         if ( This->dwAVIFileCaps & AVIFILECAPS_CANWRITE )
    496         {
    497                 FIXME( "editing AVI is currently not supported!\n" );
    498                 return E_FAIL;
    499         }
    500 
    501         switch ( uMode & 0x70 )
    502         {
    503         case OF_SHARE_COMPAT: /* 0x00 */
    504                 dwShared = FILE_SHARE_READ|FILE_SHARE_WRITE;
    505                 break;
    506         case OF_SHARE_EXCLUSIVE: /* 0x10 */
    507                 dwShared = 0;
    508                 break;
    509         case OF_SHARE_DENY_WRITE: /* 0x20 */
    510                 dwShared = FILE_SHARE_READ;
    511                 break;
    512         case OF_SHARE_DENY_READ: /* 0x30 */
    513                 dwShared = FILE_SHARE_WRITE;
    514                 break;
    515         case OF_SHARE_DENY_NONE: /* 0x40 */
    516                 dwShared = FILE_SHARE_READ|FILE_SHARE_WRITE;
    517                 break;
    518         default:
    519                 return E_FAIL;
    520         }
    521         if ( uMode & OF_CREATE )
    522                 dwCreate = CREATE_ALWAYS;
    523 
    524         This->hf = CreateFileW( szFile, dwAcc, dwShared, NULL,
    525                                 dwCreate, FILE_ATTRIBUTE_NORMAL,
    526                                 (HANDLE)NULL );
    527         if ( This->hf == INVALID_HANDLE_VALUE )
    528                 return AVIERR_FILEOPEN;
    529 
    530         if ( dwAcc & GENERIC_READ )
    531         {
    532             if ( !ReadFile( This->hf, buf, 12, &dwRead, NULL ) )
    533                 return AVIERR_FILEREAD;
    534             if ( dwRead == 12 )
    535             {
    536                 if ( mmioFOURCC(buf[0],buf[1],buf[2],buf[3]) != FOURCC_RIFF )
    537                         return AVIERR_BADFORMAT;
    538 
    539                 fccFileType = mmioFOURCC(buf[8],buf[9],buf[10],buf[11]);
    540                 if ( fccFileType != formtypeAVI )
    541                         return AVIERR_BADFORMAT;
    542 
    543                 /* get AVI main header. */
    544                 hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
    545                                 This, ckidAVIMAINHDR, &dwLen );
    546                 if ( hr != S_OK )
    547                         return hr;
    548                 if ( dwLen < (sizeof(DWORD)*10) )
    549                         return AVIERR_BADFORMAT;
    550                 hr = AVIFILE_IAVIFile_ReadChunkData(
    551                                 This, dwLen,
    552                                 &(This->hdr), sizeof(MainAVIHeader), &dwLen );
    553                 if ( This->hdr.dwStreams == 0 ||
    554                      This->hdr.dwStreams > AVIFILE_STREAMS_MAX )
    555                         return AVIERR_BADFORMAT;
    556 
    557                 /* get stream headers. */
    558                 dwIndex = 0;
    559                 while ( dwIndex < This->hdr.dwStreams )
    560                 {
    561                         WINE_AVISTREAM_DATA*    pData;
    562 
    563                         hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
    564                                         This, ckidSTREAMHEADER, &dwLen );
    565                         if ( hr != S_OK )
    566                                 return hr;
    567                         if ( dwLen < (sizeof(DWORD)*12) )
    568                                 return AVIERR_BADFORMAT;
    569                         hr = AVIFILE_IAVIFile_ReadChunkData(
    570                                 This, dwLen,
    571                                 &This->strhdrs[dwIndex],
    572                                 sizeof(AVIStreamHeader), &dwLen );
    573 
    574                         hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
    575                                         This, ckidSTREAMFORMAT, &dwLen );
    576                         if ( hr != S_OK )
    577                                 return hr;
    578                         pData = AVIFILE_Alloc_IAVIStreamData( dwLen );
    579                         if ( pData == NULL )
    580                                 return AVIERR_MEMORY;
    581                         hr = AVIFILE_IAVIFile_ReadChunkData(
    582                                 This, dwLen,
    583                                 pData->pbFmt, dwLen, &dwLen );
    584                         if ( hr != S_OK )
    585                         {
    586                                 AVIFILE_Free_IAVIStreamData( pData );
    587                                 return hr;
    588                         }
    589                         pData->dwStreamIndex = dwIndex;
    590                         pData->pstrhdr = &This->strhdrs[dwIndex];
    591 
    592                         hr = AVIStreamCreate(&This->pStreams[dwIndex],
    593                                              (LONG)paf, (LONG)(pData), NULL );
    594                         if ( hr != S_OK )
    595                         {
    596                                 AVIFILE_Free_IAVIStreamData( pData );
    597                                 return hr;
    598                         }
    599 
    600                         if ( (This->strhdrs[dwIndex].fccType
    601                                         == mmioFOURCC('v','i','d','s')) ||
    602                              (This->strhdrs[dwIndex].fccType
    603                                         == mmioFOURCC('V','I','D','S')) )
    604                         {
    605                                 This->dwAVIFileScale =
    606                                         This->strhdrs[dwIndex].dwScale;
    607                                 This->dwAVIFileRate =
    608                                         This->strhdrs[dwIndex].dwRate;
    609                                 This->dwAVIFileLength =
    610                                         This->strhdrs[dwIndex].dwLength;
    611                         }
    612                         else
    613                         if ( This->dwAVIFileScale == 0 )
    614                         {
    615                                 This->dwAVIFileScale =
    616                                         This->strhdrs[dwIndex].dwScale;
    617                                 This->dwAVIFileRate =
    618                                         This->strhdrs[dwIndex].dwRate;
    619                                 This->dwAVIFileLength =
    620                                         This->strhdrs[dwIndex].dwLength;
    621                         }
    622 
    623                         dwIndex ++;
    624                 }
    625 
    626                 /* skip movi. */
    627                 while ( 1 )
    628                 {
    629                         hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
    630                                         This, FOURCC_LIST, &dwLen );
    631                         if ( hr != S_OK )
    632                                 return hr;
    633                         if ( dwLen < 4 )
    634                                 return AVIERR_BADFORMAT;
    635 
    636                         This->dwMoviTop = SetFilePointer( This->hf,0,NULL,FILE_CURRENT );
    637                         if ( This->dwMoviTop == 0xffffffff )
    638                                 return AVIERR_BADFORMAT;
    639 
    640                         if ( ( !ReadFile(This->hf, buf, 4, &dwRead, NULL) ) ||
    641                              ( dwRead != 4 ) )
    642                                 return AVIERR_FILEREAD;
    643 
    644                         hr = AVIFILE_IAVIFile_SkipChunkData(
    645                                         This, dwLen - 4 );
    646                         if ( hr != S_OK )
    647                                 return hr;
    648                         if ( mmioFOURCC(buf[0],buf[1],buf[2],buf[3])
    649                                 == mmioFOURCC('m', 'o', 'v', 'i') )
    650                                 break;
    651                 }
    652 
    653                 /* get idx1. */
    654                 hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
    655                                 This, ckidAVINEWINDEX, &dwLen );
    656                 if ( hr != S_OK )
    657                         return hr;
    658 
    659                 This->dwCountOfIndexEntry = dwLen / sizeof(AVIINDEXENTRY);
    660                 This->pIndexEntry = (AVIINDEXENTRY*)
    661                         HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    662                                   sizeof(AVIINDEXENTRY) *
    663                                   This->dwCountOfIndexEntry * 2 );
    664                 if ( This->pIndexEntry == NULL )
    665                         return AVIERR_MEMORY;
    666                 hr = AVIFILE_IAVIFile_ReadChunkData(
    667                                 This, dwLen,
    668                                 This->pIndexEntry + This->dwCountOfIndexEntry,
    669                                 sizeof(AVIINDEXENTRY) *
    670                                 This->dwCountOfIndexEntry, &dwLen );
    671                 if ( hr != S_OK )
    672                         return hr;
    673                 AVIFILE_IAVIFile_InitIndexTable(
    674                                 This, This->pIndexEntry,
    675                                 This->pIndexEntry + This->dwCountOfIndexEntry,
    676                                 This->dwCountOfIndexEntry );
    677             }
    678             else
    679             {
    680                 /* FIXME - create the handle has GENERIC_WRITE access. */
    681                 return AVIERR_FILEREAD;
    682             }
    683         }
    684         else
    685         {
    686             return AVIERR_FILEOPEN; /* FIXME */
    687         }
    688 
    689         return S_OK;
     456    ICOM_THIS(IAVIFileImpl,paf);
     457    HRESULT     hr;
     458    DWORD       dwAcc;
     459    DWORD       dwShared;
     460    DWORD       dwCreate;
     461    BYTE        buf[12];
     462    DWORD       dwRead;
     463    FOURCC      fccFileType;
     464    DWORD       dwLen;
     465    DWORD       dwIndex;
     466
     467    FIXME("(%p)->Open(%p,%u)\n",This,szFile,uMode);
     468
     469    if ( This->hf != INVALID_HANDLE_VALUE )
     470    {
     471        CloseHandle( This->hf );
     472        This->hf = INVALID_HANDLE_VALUE;
     473    }
     474
     475    switch ( uMode & 0x3 )
     476    {
     477    case OF_READ: /* 0x0 */
     478        dwAcc = GENERIC_READ;
     479        dwCreate = OPEN_EXISTING;
     480        This->dwAVIFileCaps = AVIFILECAPS_CANREAD;
     481        break;
     482    case OF_WRITE: /* 0x1 */
     483        dwAcc = GENERIC_WRITE;
     484        dwCreate = OPEN_ALWAYS;
     485        This->dwAVIFileCaps = AVIFILECAPS_CANWRITE;
     486        break;
     487    case OF_READWRITE: /* 0x2 */
     488        dwAcc = GENERIC_READ|GENERIC_WRITE;
     489        dwCreate = OPEN_ALWAYS;
     490        This->dwAVIFileCaps = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE;
     491        break;
     492    default:
     493        return E_FAIL;
     494    }
     495
     496    if ( This->dwAVIFileCaps & AVIFILECAPS_CANWRITE )
     497    {
     498        FIXME( "editing AVI is currently not supported!\n" );
     499        return E_FAIL;
     500    }
     501
     502    switch ( uMode & 0x70 )
     503    {
     504    case OF_SHARE_COMPAT: /* 0x00 */
     505        dwShared = FILE_SHARE_READ|FILE_SHARE_WRITE;
     506        break;
     507    case OF_SHARE_EXCLUSIVE: /* 0x10 */
     508        dwShared = 0;
     509        break;
     510    case OF_SHARE_DENY_WRITE: /* 0x20 */
     511        dwShared = FILE_SHARE_READ;
     512        break;
     513    case OF_SHARE_DENY_READ: /* 0x30 */
     514        dwShared = FILE_SHARE_WRITE;
     515        break;
     516    case OF_SHARE_DENY_NONE: /* 0x40 */
     517        dwShared = FILE_SHARE_READ|FILE_SHARE_WRITE;
     518        break;
     519    default:
     520        return E_FAIL;
     521    }
     522    if ( uMode & OF_CREATE )
     523        dwCreate = CREATE_ALWAYS;
     524
     525    This->hf = CreateFileW( szFile, dwAcc, dwShared, NULL,
     526                dwCreate, FILE_ATTRIBUTE_NORMAL,
     527                (HANDLE)NULL );
     528    if ( This->hf == INVALID_HANDLE_VALUE )
     529        return AVIERR_FILEOPEN;
     530
     531    if ( dwAcc & GENERIC_READ )
     532    {
     533        if ( !ReadFile( This->hf, buf, 12, &dwRead, NULL ) )
     534        return AVIERR_FILEREAD;
     535        if ( dwRead == 12 )
     536        {
     537        if ( mmioFOURCC(buf[0],buf[1],buf[2],buf[3]) != FOURCC_RIFF )
     538            return AVIERR_BADFORMAT;
     539
     540        fccFileType = mmioFOURCC(buf[8],buf[9],buf[10],buf[11]);
     541        if ( fccFileType != formtypeAVI )
     542            return AVIERR_BADFORMAT;
     543
     544        /* get AVI main header. */
     545        hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
     546                This, ckidAVIMAINHDR, &dwLen );
     547        if ( hr != S_OK )
     548            return hr;
     549        if ( dwLen < (sizeof(DWORD)*10) )
     550            return AVIERR_BADFORMAT;
     551        hr = AVIFILE_IAVIFile_ReadChunkData(
     552                This, dwLen,
     553                &(This->hdr), sizeof(MainAVIHeader), &dwLen );
     554        if ( This->hdr.dwStreams == 0 ||
     555             This->hdr.dwStreams > AVIFILE_STREAMS_MAX )
     556            return AVIERR_BADFORMAT;
     557
     558        /* get stream headers. */
     559        dwIndex = 0;
     560        while ( dwIndex < This->hdr.dwStreams )
     561        {
     562            WINE_AVISTREAM_DATA*    pData;
     563
     564            hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
     565                    This, ckidSTREAMHEADER, &dwLen );
     566            if ( hr != S_OK )
     567                return hr;
     568            if ( dwLen < (sizeof(DWORD)*12) )
     569                return AVIERR_BADFORMAT;
     570            hr = AVIFILE_IAVIFile_ReadChunkData(
     571                This, dwLen,
     572                &This->strhdrs[dwIndex],
     573                sizeof(AVIStreamHeader), &dwLen );
     574
     575            hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
     576                    This, ckidSTREAMFORMAT, &dwLen );
     577            if ( hr != S_OK )
     578                return hr;
     579            pData = AVIFILE_Alloc_IAVIStreamData( dwLen );
     580            if ( pData == NULL )
     581                return AVIERR_MEMORY;
     582            hr = AVIFILE_IAVIFile_ReadChunkData(
     583                This, dwLen,
     584                pData->pbFmt, dwLen, &dwLen );
     585            if ( hr != S_OK )
     586            {
     587                AVIFILE_Free_IAVIStreamData( pData );
     588                return hr;
     589            }
     590            pData->dwStreamIndex = dwIndex;
     591            pData->pstrhdr = &This->strhdrs[dwIndex];
     592
     593            hr = AVIStreamCreate(&This->pStreams[dwIndex],
     594                         (LONG)paf, (LONG)(pData), NULL );
     595            if ( hr != S_OK )
     596            {
     597                AVIFILE_Free_IAVIStreamData( pData );
     598                return hr;
     599            }
     600
     601            if ( (This->strhdrs[dwIndex].fccType
     602                    == mmioFOURCC('v','i','d','s')) ||
     603                 (This->strhdrs[dwIndex].fccType
     604                    == mmioFOURCC('V','I','D','S')) )
     605            {
     606                This->dwAVIFileScale =
     607                    This->strhdrs[dwIndex].dwScale;
     608                This->dwAVIFileRate =
     609                    This->strhdrs[dwIndex].dwRate;
     610                This->dwAVIFileLength =
     611                    This->strhdrs[dwIndex].dwLength;
     612            }
     613            else
     614            if ( This->dwAVIFileScale == 0 )
     615            {
     616                This->dwAVIFileScale =
     617                    This->strhdrs[dwIndex].dwScale;
     618                This->dwAVIFileRate =
     619                    This->strhdrs[dwIndex].dwRate;
     620                This->dwAVIFileLength =
     621                    This->strhdrs[dwIndex].dwLength;
     622            }
     623
     624            dwIndex ++;
     625        }
     626
     627        /* skip movi. */
     628        while ( 1 )
     629        {
     630            hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
     631                    This, FOURCC_LIST, &dwLen );
     632            if ( hr != S_OK )
     633                return hr;
     634            if ( dwLen < 4 )
     635                return AVIERR_BADFORMAT;
     636
     637            This->dwMoviTop = SetFilePointer( This->hf,0,NULL,FILE_CURRENT );
     638            if ( This->dwMoviTop == 0xffffffff )
     639                return AVIERR_BADFORMAT;
     640
     641            if ( ( !ReadFile(This->hf, buf, 4, &dwRead, NULL) ) ||
     642                 ( dwRead != 4 ) )
     643                return AVIERR_FILEREAD;
     644
     645            hr = AVIFILE_IAVIFile_SkipChunkData(
     646                    This, dwLen - 4 );
     647            if ( hr != S_OK )
     648                return hr;
     649            if ( mmioFOURCC(buf[0],buf[1],buf[2],buf[3])
     650                == mmioFOURCC('m', 'o', 'v', 'i') )
     651                break;
     652        }
     653
     654        /* get idx1. */
     655        hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
     656                This, ckidAVINEWINDEX, &dwLen );
     657        if ( hr != S_OK )
     658            return hr;
     659
     660        This->dwCountOfIndexEntry = dwLen / sizeof(AVIINDEXENTRY);
     661        This->pIndexEntry = (AVIINDEXENTRY*)
     662            HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     663                  sizeof(AVIINDEXENTRY) *
     664                  This->dwCountOfIndexEntry * 2 );
     665        if ( This->pIndexEntry == NULL )
     666            return AVIERR_MEMORY;
     667        hr = AVIFILE_IAVIFile_ReadChunkData(
     668                This, dwLen,
     669                This->pIndexEntry + This->dwCountOfIndexEntry,
     670                sizeof(AVIINDEXENTRY) *
     671                This->dwCountOfIndexEntry, &dwLen );
     672        if ( hr != S_OK )
     673            return hr;
     674        AVIFILE_IAVIFile_InitIndexTable(
     675                This, This->pIndexEntry,
     676                This->pIndexEntry + This->dwCountOfIndexEntry,
     677                This->dwCountOfIndexEntry );
     678        }
     679        else
     680        {
     681        /* FIXME - create the handle has GENERIC_WRITE access. */
     682        return AVIERR_FILEREAD;
     683        }
     684    }
     685    else
     686    {
     687        return AVIERR_FILEOPEN; /* FIXME */
     688    }
     689
     690    return S_OK;
    690691}
    691692
    692693/*****************************************************************************
    693  *      AVIFILE_IAVIFile_GetIndexTable (internal)
     694 *  AVIFILE_IAVIFile_GetIndexTable (internal)
    694695 */
    695696HRESULT AVIFILE_IAVIFile_GetIndexTable( PAVIFILE paf, DWORD dwStreamIndex,
    696                                         AVIINDEXENTRY** ppIndexEntry,
    697                                         DWORD* pdwCountOfIndexEntry )
    698 {
    699         ICOM_THIS(IAVIFileImpl,paf);
    700 
    701         if ( dwStreamIndex < 0 || dwStreamIndex >= This->hdr.dwStreams )
    702         {
    703                 FIXME( "invalid stream index %lu\n", dwStreamIndex );
    704                 return E_FAIL;
    705         }
    706         FIXME( "cur %p, next %p\n",
    707                 This->pStreamIndexEntry[dwStreamIndex],
    708                 This->pStreamIndexEntry[dwStreamIndex+1] );
    709         *ppIndexEntry = This->pStreamIndexEntry[dwStreamIndex];
    710         *pdwCountOfIndexEntry =
    711                 This->pStreamIndexEntry[dwStreamIndex+1] -
    712                         This->pStreamIndexEntry[dwStreamIndex];
    713 
    714         return S_OK;
     697                    AVIINDEXENTRY** ppIndexEntry,
     698                    DWORD* pdwCountOfIndexEntry )
     699{
     700    ICOM_THIS(IAVIFileImpl,paf);
     701
     702    if ( dwStreamIndex < 0 || dwStreamIndex >= This->hdr.dwStreams )
     703    {
     704        FIXME( "invalid stream index %lu\n", dwStreamIndex );
     705        return E_FAIL;
     706    }
     707    FIXME( "cur %p, next %p\n",
     708        This->pStreamIndexEntry[dwStreamIndex],
     709        This->pStreamIndexEntry[dwStreamIndex+1] );
     710    *ppIndexEntry = This->pStreamIndexEntry[dwStreamIndex];
     711    *pdwCountOfIndexEntry =
     712        This->pStreamIndexEntry[dwStreamIndex+1] -
     713            This->pStreamIndexEntry[dwStreamIndex];
     714
     715    return S_OK;
    715716}
    716717
    717718/*****************************************************************************
    718  *      AVIFILE_IAVIFile_ReadMovieData (internal)
     719 *  AVIFILE_IAVIFile_ReadMovieData (internal)
    719720 */
    720721HRESULT AVIFILE_IAVIFile_ReadMovieData( PAVIFILE paf, DWORD dwOffset,
    721                                         DWORD dwLength, LPVOID lpvBuf )
    722 {
    723         ICOM_THIS(IAVIFileImpl,paf);
    724         LONG    lHigh = 0;
    725         DWORD   dwRes;
    726 
    727         if ( dwLength == 0 )
    728                 return S_OK;
    729         SetLastError(NO_ERROR);
    730         dwRes = SetFilePointer( This->hf, (LONG)(dwOffset+This->dwMoviTop),
    731                                 &lHigh, FILE_BEGIN );
    732         if ( dwRes == (DWORD)0xffffffff && GetLastError() != NO_ERROR )
    733                 return AVIERR_FILEREAD;
    734 
    735         if ( ( !ReadFile(This->hf, lpvBuf, dwLength, &dwRes, NULL) ) ||
    736              ( dwLength != dwRes ) )
    737         {
    738                 FIXME( "error in ReadFile()\n" );
    739                 return AVIERR_FILEREAD;
    740         }
    741 
    742         return S_OK;
    743 }
    744 
     722                    DWORD dwLength, LPVOID lpvBuf )
     723{
     724    ICOM_THIS(IAVIFileImpl,paf);
     725    LONG    lHigh = 0;
     726    DWORD   dwRes;
     727
     728    if ( dwLength == 0 )
     729        return S_OK;
     730    SetLastError(NO_ERROR);
     731    dwRes = SetFilePointer( This->hf, (LONG)(dwOffset+This->dwMoviTop),
     732                &lHigh, FILE_BEGIN );
     733    if ( dwRes == (DWORD)0xffffffff && GetLastError() != NO_ERROR )
     734        return AVIERR_FILEREAD;
     735
     736    if ( ( !ReadFile(This->hf, lpvBuf, dwLength, &dwRes, NULL) ) ||
     737         ( dwLength != dwRes ) )
     738    {
     739        FIXME( "error in ReadFile()\n" );
     740        return AVIERR_FILEREAD;
     741    }
     742
     743    return S_OK;
     744}
     745

  • trunk/src/avifil32/iastream.c

    r6386 r6652  
     1/* $Id: iastream.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
    12/*
    23 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    5556typedef struct IAVIStreamImpl
    5657{
    57         ICOM_VFIELD(IAVIStream);
    58         /* IUnknown stuff */
    59         DWORD           ref;
    60         /* IAVIStream stuff */
    61         IAVIFile*               paf;
    62         WINE_AVISTREAM_DATA*    pData;
     58    ICOM_VFIELD(IAVIStream);
     59    /* IUnknown stuff */
     60    DWORD       ref;
     61    /* IAVIStream stuff */
     62    IAVIFile*       paf;
     63    WINE_AVISTREAM_DATA*    pData;
    6364} IAVIStreamImpl;
    6465
    … …  
    6869HRESULT AVIFILE_CreateIAVIStream(void** ppobj)
    6970{
    70         IAVIStreamImpl  *This;
    71         HRESULT         hr;
    72 
    73         *ppobj = NULL;
    74         This = (IAVIStreamImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    75                                           sizeof(IAVIStreamImpl));
    76         This->ref = 1;
    77         ICOM_VTBL(This) = &iavist;
    78         hr = IAVIStream_Construct( This );
    79         if ( hr != S_OK )
    80         {
    81                 IAVIStream_Destruct( This );
    82                 return hr;
    83         }
    84 
    85         *ppobj = (LPVOID)This;
    86 
    87         return S_OK;
     71    IAVIStreamImpl  *This;
     72    HRESULT     hr;
     73
     74    *ppobj = NULL;
     75    This = (IAVIStreamImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     76                      sizeof(IAVIStreamImpl));
     77    This->ref = 1;
     78    ICOM_VTBL(This) = &iavist;
     79    hr = IAVIStream_Construct( This );
     80    if ( hr != S_OK )
     81    {
     82        IAVIStream_Destruct( This );
     83        return hr;
     84    }
     85
     86    *ppobj = (LPVOID)This;
     87
     88    return S_OK;
    8889}
    8990
    … …  
    9495
    9596static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj) {
    96         ICOM_THIS(IAVIStreamImpl,iface);
    97 
    98         TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
    99         if ( IsEqualGUID(&IID_IUnknown,refiid) ||
    100              IsEqualGUID(&IID_IAVIStream,refiid) )
    101         {
    102                 IAVIStream_AddRef(iface);
    103                 *obj = iface;
    104                 return S_OK;
    105         }
    106         /* can return IGetFrame interface too */
    107 
    108         return OLE_E_ENUM_NOMORE;
     97    ICOM_THIS(IAVIStreamImpl,iface);
     98
     99    TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
     100    if ( IsEqualGUID(&IID_IUnknown,refiid) ||
     101         IsEqualGUID(&IID_IAVIStream,refiid) )
     102    {
     103        IAVIStream_AddRef(iface);
     104        *obj = iface;
     105        return S_OK;
     106    }
     107    /* can return IGetFrame interface too */
     108
     109    return OLE_E_ENUM_NOMORE;
    109110}
    110111
    111112static ULONG WINAPI IAVIStream_fnAddRef(IAVIStream*iface) {
    112         ICOM_THIS(IAVIStreamImpl,iface);
    113 
    114         TRACE("(%p)->AddRef()\n",iface);
    115         return ++(This->ref);
     113    ICOM_THIS(IAVIStreamImpl,iface);
     114
     115    TRACE("(%p)->AddRef()\n",iface);
     116    return ++(This->ref);
    116117}
    117118
    118119static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface) {
    119         ICOM_THIS(IAVIStreamImpl,iface);
    120 
    121         TRACE("(%p)->Release()\n",iface);
    122         if ((--(This->ref)) > 0 )
    123                 return This->ref;
    124         IAVIStream_Destruct(This);
    125 
    126         HeapFree(AVIFILE_data.hHeap,0,iface);
    127         return 0;
     120    ICOM_THIS(IAVIStreamImpl,iface);
     121
     122    TRACE("(%p)->Release()\n",iface);
     123    if ((--(This->ref)) > 0 )
     124        return This->ref;
     125    IAVIStream_Destruct(This);
     126
     127    HeapFree(AVIFILE_data.hHeap,0,iface);
     128    return 0;
    128129}
    129130
    … …  
    134135static HRESULT IAVIStream_Construct( IAVIStreamImpl* This )
    135136{
    136         This->paf = NULL;
    137         This->pData = NULL;
    138 
    139         AVIFILE_data.dwClassObjRef ++;
    140 
    141         return S_OK;
     137    This->paf = NULL;
     138    This->pData = NULL;
     139
     140    AVIFILE_data.dwClassObjRef ++;
     141
     142    return S_OK;
    142143}
    143144
    144145static void IAVIStream_Destruct( IAVIStreamImpl* This )
    145146{
    146         AVIFILE_data.dwClassObjRef --;
     147    AVIFILE_data.dwClassObjRef --;
    147148}
    148149
    149150static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2)
    150151{
    151         ICOM_THIS(IAVIStreamImpl,iface);
    152 
    153         FIXME("(%p)->Create(%ld,%ld)\n",iface,lParam1,lParam2);
    154 
    155         This->paf = (IAVIFile*)lParam1;
    156         This->pData = (WINE_AVISTREAM_DATA*)lParam2;
    157 
    158         return S_OK;
     152    ICOM_THIS(IAVIStreamImpl,iface);
     153
     154    FIXME("(%p)->Create(%ld,%ld)\n",iface,lParam1,lParam2);
     155
     156    This->paf = (IAVIFile*)lParam1;
     157    This->pData = (WINE_AVISTREAM_DATA*)lParam2;
     158
     159    return S_OK;
    159160}
    160161
    161162static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size)
    162163{
    163         ICOM_THIS(IAVIStreamImpl,iface);
    164         AVISTREAMINFOW  siw;
    165 
    166         FIXME("(%p)->Info(%p,%ld)\n",iface,psi,size);
    167         if ( This->pData == NULL )
    168                 return E_UNEXPECTED;
    169 
    170         memset( &siw, 0, sizeof(AVISTREAMINFOW) );
    171         siw.fccType = This->pData->pstrhdr->fccType;
    172         siw.fccHandler = This->pData->pstrhdr->fccHandler;
    173         siw.dwFlags = This->pData->pstrhdr->dwFlags;
    174         siw.dwCaps = 0; /* FIXME */
    175         siw.wPriority = This->pData->pstrhdr->wPriority;
    176         siw.wLanguage = This->pData->pstrhdr->wLanguage;
    177         siw.dwScale = This->pData->pstrhdr->dwScale;
    178         siw.dwRate = This->pData->pstrhdr->dwRate;
    179         siw.dwStart = This->pData->pstrhdr->dwStart;
    180         siw.dwLength = This->pData->pstrhdr->dwLength;
    181         siw.dwInitialFrames = This->pData->pstrhdr->dwInitialFrames;
    182         siw.dwSuggestedBufferSize = This->pData->pstrhdr->dwSuggestedBufferSize;
    183         siw.dwQuality = This->pData->pstrhdr->dwQuality;
    184         siw.dwSampleSize = This->pData->pstrhdr->dwSampleSize;
    185         siw.rcFrame.left = This->pData->pstrhdr->rcFrame.left;
    186         siw.rcFrame.top = This->pData->pstrhdr->rcFrame.top;
    187         siw.rcFrame.right = This->pData->pstrhdr->rcFrame.right;
    188         siw.rcFrame.bottom = This->pData->pstrhdr->rcFrame.bottom;
    189         siw.dwEditCount = 0; /* FIXME */
    190         siw.dwFormatChangeCount = 0; /* FIXME */
    191         /* siw.szName[64] */
    192 
    193         if ( size > sizeof(AVISTREAMINFOW) )
    194                 size = sizeof(AVISTREAMINFOW);
    195         memcpy( psi, &siw, size );
    196 
    197         return S_OK;
     164    ICOM_THIS(IAVIStreamImpl,iface);
     165    AVISTREAMINFOW  siw;
     166
     167    FIXME("(%p)->Info(%p,%ld)\n",iface,psi,size);
     168    if ( This->pData == NULL )
     169        return E_UNEXPECTED;
     170
     171    memset( &siw, 0, sizeof(AVISTREAMINFOW) );
     172    siw.fccType = This->pData->pstrhdr->fccType;
     173    siw.fccHandler = This->pData->pstrhdr->fccHandler;
     174    siw.dwFlags = This->pData->pstrhdr->dwFlags;
     175    siw.dwCaps = 0; /* FIXME */
     176    siw.wPriority = This->pData->pstrhdr->wPriority;
     177    siw.wLanguage = This->pData->pstrhdr->wLanguage;
     178    siw.dwScale = This->pData->pstrhdr->dwScale;
     179    siw.dwRate = This->pData->pstrhdr->dwRate;
     180    siw.dwStart = This->pData->pstrhdr->dwStart;
     181    siw.dwLength = This->pData->pstrhdr->dwLength;
     182    siw.dwInitialFrames = This->pData->pstrhdr->dwInitialFrames;
     183    siw.dwSuggestedBufferSize = This->pData->pstrhdr->dwSuggestedBufferSize;
     184    siw.dwQuality = This->pData->pstrhdr->dwQuality;
     185    siw.dwSampleSize = This->pData->pstrhdr->dwSampleSize;
     186    siw.rcFrame.left = This->pData->pstrhdr->rcFrame.left;
     187    siw.rcFrame.top = This->pData->pstrhdr->rcFrame.top;
     188    siw.rcFrame.right = This->pData->pstrhdr->rcFrame.right;
     189    siw.rcFrame.bottom = This->pData->pstrhdr->rcFrame.bottom;
     190    siw.dwEditCount = 0; /* FIXME */
     191    siw.dwFormatChangeCount = 0; /* FIXME */
     192    /* siw.szName[64] */
     193
     194    if ( size > sizeof(AVISTREAMINFOW) )
     195        size = sizeof(AVISTREAMINFOW);
     196    memcpy( psi, &siw, size );
     197
     198    return S_OK;
    198199}
    199200
    200201static LONG WINAPI IAVIStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags)
    201202{
    202         ICOM_THIS(IAVIStreamImpl,iface);
    203         HRESULT hr;
    204         AVIINDEXENTRY*  pIndexEntry;
    205         DWORD           dwCountOfIndexEntry;
    206         LONG            lCur, lAdd, lEnd;
    207 
    208         FIXME("(%p)->FindSample(%ld,0x%08lx)\n",This,pos,flags);
    209 
    210         hr = AVIFILE_IAVIFile_GetIndexTable(
    211                 This->paf, This->pData->dwStreamIndex,
    212                 &pIndexEntry, &dwCountOfIndexEntry );
    213         if ( hr != S_OK )
    214                 return -1L;
    215 
    216         if ( flags & (~(FIND_DIR|FIND_TYPE|FIND_RET)) )
    217         {
    218                 FIXME( "unknown flag %08lx\n", flags );
    219                 return -1L;
    220         }
    221 
    222         switch ( flags & FIND_DIR )
    223         {
    224         case FIND_NEXT:
    225                 lCur = pos;
    226                 lAdd = 1;
    227                 lEnd = dwCountOfIndexEntry;
    228                 if ( lCur > dwCountOfIndexEntry )
    229                         return -1L;
    230                 break;
    231         case FIND_PREV:
    232                 lCur = pos;
    233                 if ( lCur > dwCountOfIndexEntry )
    234                         lCur = dwCountOfIndexEntry;
    235                 lAdd = -1;
    236                 lEnd = 0;
    237                 break;
    238         case FIND_FROM_START:
    239                 lCur = 0;
    240                 lAdd = 1;
    241                 lEnd = dwCountOfIndexEntry;
    242                 break;
    243         default:
    244                 FIXME( "unknown direction flag %08lx\n", (flags & FIND_DIR) );
    245                 return -1L;
    246         }
    247 
    248         switch ( flags & FIND_TYPE )
    249         {
    250         case FIND_KEY:
    251                 while ( 1 )
    252                 {
    253                         if ( pIndexEntry[lCur].dwFlags & AVIIF_KEYFRAME )
    254                                 break;
    255                         if ( lCur == lEnd )
    256                                 return -1L;
    257                         lCur += lAdd;
    258                 }
    259                 break;
    260         case FIND_ANY:
    261                 while ( 1 )
    262                 {
    263                         if ( !(pIndexEntry[lCur].dwFlags & AVIIF_NOTIME) )
    264                                 break;
    265                         if ( lCur == lEnd )
    266                                 return -1L;
    267                         lCur += lAdd;
    268                 }
    269                 break;
    270         case FIND_FORMAT:
    271                 FIXME( "FIND_FORMAT is not implemented.\n" );
    272                 return -1L;
    273         default:
    274                 FIXME( "unknown type flag %08lx\n", (flags & FIND_TYPE) );
    275                 return -1L;
    276         }
    277 
    278         switch ( flags & FIND_RET )
    279         {
    280         case FIND_POS:
    281                 return lCur;
    282         case FIND_LENGTH:
    283                 FIXME( "FIND_LENGTH is not implemented.\n" );
    284                 return -1L;
    285         case FIND_OFFSET:
    286                 return pIndexEntry[lCur].dwChunkOffset;
    287         case FIND_SIZE:
    288                 return pIndexEntry[lCur].dwChunkLength;
    289         case FIND_INDEX:
    290                 FIXME( "FIND_INDEX is not implemented.\n" );
    291                 return -1L;
    292         default:
    293                 FIXME( "unknown return type flag %08lx\n", (flags & FIND_RET) );
    294                 break;
    295         }
    296 
    297         return -1L;
     203    ICOM_THIS(IAVIStreamImpl,iface);
     204    HRESULT hr;
     205    AVIINDEXENTRY*  pIndexEntry;
     206    DWORD       dwCountOfIndexEntry;
     207    LONG        lCur, lAdd, lEnd;
     208
     209    FIXME("(%p)->FindSample(%ld,0x%08lx)\n",This,pos,flags);
     210
     211    hr = AVIFILE_IAVIFile_GetIndexTable(
     212        This->paf, This->pData->dwStreamIndex,
     213        &pIndexEntry, &dwCountOfIndexEntry );
     214    if ( hr != S_OK )
     215        return -1L;
     216
     217    if ( flags & (~(FIND_DIR|FIND_TYPE|FIND_RET)) )
     218    {
     219        FIXME( "unknown flag %08lx\n", flags );
     220        return -1L;
     221    }
     222
     223    switch ( flags & FIND_DIR )
     224    {
     225    case FIND_NEXT:
     226        lCur = pos;
     227        lAdd = 1;
     228        lEnd = dwCountOfIndexEntry;
     229        if ( lCur > dwCountOfIndexEntry )
     230            return -1L;
     231        break;
     232    case FIND_PREV:
     233        lCur = pos;
     234        if ( lCur > dwCountOfIndexEntry )
     235            lCur = dwCountOfIndexEntry;
     236        lAdd = -1;
     237        lEnd = 0;
     238        break;
     239    case FIND_FROM_START:
     240        lCur = 0;
     241        lAdd = 1;
     242        lEnd = dwCountOfIndexEntry;
     243        break;
     244    default:
     245        FIXME( "unknown direction flag %08lx\n", (flags & FIND_DIR) );
     246        return -1L;
     247    }
     248
     249    switch ( flags & FIND_TYPE )
     250    {
     251    case FIND_KEY:
     252        while ( 1 )
     253        {
     254            if ( pIndexEntry[lCur].dwFlags & AVIIF_KEYFRAME )
     255                break;
     256            if ( lCur == lEnd )
     257                return -1L;
     258            lCur += lAdd;
     259        }
     260        break;
     261    case FIND_ANY:
     262        while ( 1 )
     263        {
     264            if ( !(pIndexEntry[lCur].dwFlags & AVIIF_NOTIME) )
     265                break;
     266            if ( lCur == lEnd )
     267                return -1L;
     268            lCur += lAdd;
     269        }
     270        break;
     271    case FIND_FORMAT:
     272        FIXME( "FIND_FORMAT is not implemented.\n" );
     273        return -1L;
     274    default:
     275        FIXME( "unknown type flag %08lx\n", (flags & FIND_TYPE) );
     276        return -1L;
     277    }
     278
     279    switch ( flags & FIND_RET )
     280    {
     281    case FIND_POS:
     282        return lCur;
     283    case FIND_LENGTH:
     284        FIXME( "FIND_LENGTH is not implemented.\n" );
     285        return -1L;
     286    case FIND_OFFSET:
     287        return pIndexEntry[lCur].dwChunkOffset;
     288    case FIND_SIZE:
     289        return pIndexEntry[lCur].dwChunkLength;
     290    case FIND_INDEX:
     291        FIXME( "FIND_INDEX is not implemented.\n" );
     292        return -1L;
     293    default:
     294        FIXME( "unknown return type flag %08lx\n", (flags & FIND_RET) );
     295        break;
     296    }
     297
     298    return -1L;
    298299}
    299300
    300301static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize) {
    301         ICOM_THIS(IAVIStreamImpl,iface);
    302 
    303         TRACE("(%p)->ReadFormat(%ld,%p,%p)\n",This,pos,format,formatsize);
    304         if ( This->pData == NULL )
    305                 return E_UNEXPECTED;
    306 
    307         /* FIXME - check pos. */
    308         if ( format == NULL )
    309         {
    310                 *formatsize = This->pData->dwFmtLen;
    311                 return S_OK;
    312         }
    313         if ( (*formatsize) < This->pData->dwFmtLen )
    314                 return AVIERR_BUFFERTOOSMALL;
    315 
    316         memcpy( format, This->pData->pbFmt, This->pData->dwFmtLen );
    317         *formatsize = This->pData->dwFmtLen;
    318 
    319         return S_OK;
     302    ICOM_THIS(IAVIStreamImpl,iface);
     303
     304    TRACE("(%p)->ReadFormat(%ld,%p,%p)\n",This,pos,format,formatsize);
     305    if ( This->pData == NULL )
     306        return E_UNEXPECTED;
     307
     308    /* FIXME - check pos. */
     309    if ( format == NULL )
     310    {
     311        *formatsize = This->pData->dwFmtLen;
     312        return S_OK;
     313    }
     314    if ( (*formatsize) < This->pData->dwFmtLen )
     315        return AVIERR_BUFFERTOOSMALL;
     316
     317    memcpy( format, This->pData->pbFmt, This->pData->dwFmtLen );
     318    *formatsize = This->pData->dwFmtLen;
     319
     320    return S_OK;
    320321}
    321322
    322323static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize) {
    323         ICOM_THIS(IAVIStreamImpl,iface);
    324 
    325         FIXME("(%p)->SetFormat(%ld,%p,%ld)\n",This,pos,format,formatsize);
    326         return E_FAIL;
     324    ICOM_THIS(IAVIStreamImpl,iface);
     325
     326    FIXME("(%p)->SetFormat(%ld,%p,%ld)\n",This,pos,format,formatsize);
     327    return E_FAIL;
    327328}
    328329
    329330static HRESULT WINAPI IAVIStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread) {
    330         ICOM_THIS(IAVIStreamImpl,iface);
    331         HRESULT hr;
    332         AVIINDEXENTRY*  pIndexEntry;
    333         DWORD           dwCountOfIndexEntry;
    334         DWORD           dwFrameLength;
    335 
    336         FIXME("(%p)->Read(%ld,%ld,%p,%ld,%p,%p)\n",This,start,samples,buffer,buffersize,bytesread,samplesread);
    337 
    338         *bytesread = 0;
    339         *samplesread = 0;
    340 
    341         hr = AVIFILE_IAVIFile_GetIndexTable(
    342                 This->paf, This->pData->dwStreamIndex,
    343                 &pIndexEntry, &dwCountOfIndexEntry );
    344         if ( hr != S_OK )
    345                 return hr;
    346         if ( start < 0 )
    347                 return E_FAIL;
    348         if ( start >= dwCountOfIndexEntry || samples <= 0 )
    349         {
    350                 FIXME("start %ld,samples %ld,total %ld\n",start,samples,dwCountOfIndexEntry);
    351                 return S_OK;
    352         }
    353 
    354         /* FIXME - is this data valid??? */
    355         dwFrameLength = pIndexEntry[start].dwChunkLength + sizeof(DWORD)*2;
    356 
    357         if ( buffer == NULL )
    358         {
    359                 *bytesread = dwFrameLength;
    360                 *samplesread = 1;
    361                 return S_OK;
    362         }
    363         if ( buffersize < dwFrameLength )
    364         {
    365                 FIXME( "buffer is too small!\n" );
    366                 return AVIERR_BUFFERTOOSMALL;
    367         }
    368 
    369         hr = AVIFILE_IAVIFile_ReadMovieData(
    370                         This->paf,
    371                         pIndexEntry[start].dwChunkOffset,
    372                         dwFrameLength, buffer );
    373         if ( hr != S_OK )
    374         {
    375                 FIXME( "ReadMovieData failed!\n");
    376                 return hr;
    377         }
    378         *bytesread = dwFrameLength;
    379         *samplesread = 1;
    380 
    381         return S_OK;
     331    ICOM_THIS(IAVIStreamImpl,iface);
     332    HRESULT hr;
     333    AVIINDEXENTRY*  pIndexEntry;
     334    DWORD       dwCountOfIndexEntry;
     335    DWORD       dwFrameLength;
     336
     337    FIXME("(%p)->Read(%ld,%ld,%p,%ld,%p,%p)\n",This,start,samples,buffer,buffersize,bytesread,samplesread);
     338
     339    *bytesread = 0;
     340    *samplesread = 0;
     341
     342    hr = AVIFILE_IAVIFile_GetIndexTable(
     343        This->paf, This->pData->dwStreamIndex,
     344        &pIndexEntry, &dwCountOfIndexEntry );
     345    if ( hr != S_OK )
     346        return hr;
     347    if ( start < 0 )
     348        return E_FAIL;
     349    if ( start >= dwCountOfIndexEntry || samples <= 0 )
     350    {
     351        FIXME("start %ld,samples %ld,total %ld\n",start,samples,dwCountOfIndexEntry);
     352        return S_OK;
     353    }
     354
     355    /* FIXME - is this data valid??? */
     356    dwFrameLength = pIndexEntry[start].dwChunkLength + sizeof(DWORD)*2;
     357
     358    if ( buffer == NULL )
     359    {
     360        *bytesread = dwFrameLength;
     361        *samplesread = 1;
     362        return S_OK;
     363    }
     364    if ( buffersize < dwFrameLength )
     365    {
     366        FIXME( "buffer is too small!\n" );
     367        return AVIERR_BUFFERTOOSMALL;
     368    }
     369
     370    hr = AVIFILE_IAVIFile_ReadMovieData(
     371            This->paf,
     372            pIndexEntry[start].dwChunkOffset,
     373            dwFrameLength, buffer );
     374    if ( hr != S_OK )
     375    {
     376        FIXME( "ReadMovieData failed!\n");
     377        return hr;
     378    }
     379    *bytesread = dwFrameLength;
     380    *samplesread = 1;
     381
     382    return S_OK;
    382383}
    383384
    384385static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
    385         ICOM_THIS(IAVIStreamImpl,iface);
    386 
    387 
    388         FIXME("(%p)->Write(%ld,%ld,%p,%ld,0x%08lx,%p,%p)\n",This,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
    389         return E_FAIL;
     386    ICOM_THIS(IAVIStreamImpl,iface);
     387
     388
     389    FIXME("(%p)->Write(%ld,%ld,%p,%ld,0x%08lx,%p,%p)\n",This,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
     390    return E_FAIL;
    390391}
    391392
    392393static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples) {
    393         ICOM_THIS(IAVIStreamImpl,iface);
    394 
    395         FIXME("(%p)->Delete(%ld,%ld)\n",This,start,samples);
    396         return E_FAIL;
     394    ICOM_THIS(IAVIStreamImpl,iface);
     395
     396    FIXME("(%p)->Delete(%ld,%ld)\n",This,start,samples);
     397    return E_FAIL;
    397398}
    398399static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread) {
    399         ICOM_THIS(IAVIStreamImpl,iface);
    400 
    401         FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,fcc,lp,lpread);
    402         return E_FAIL;
     400    ICOM_THIS(IAVIStreamImpl,iface);
     401
     402    FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,fcc,lp,lpread);
     403    return E_FAIL;
    403404}
    404405
    405406static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size) {
    406         ICOM_THIS(IAVIStreamImpl,iface);
    407 
    408         FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,fcc,lp,size);
    409         return E_FAIL;
     407    ICOM_THIS(IAVIStreamImpl,iface);
     408
     409    FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,fcc,lp,size);
     410    return E_FAIL;
    410411}
    411412
    412413static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen) {
    413         ICOM_THIS(IAVIStreamImpl,iface);
    414 
    415         FIXME("(%p)->SetInfo(%p,%ld)\n",This,info,infolen);
    416 
    417         return E_FAIL;
    418 }
    419 
     414    ICOM_THIS(IAVIStreamImpl,iface);
     415
     416    FIXME("(%p)->SetInfo(%p,%ld)\n",This,info,infolen);
     417
     418    return E_FAIL;
     419}
     420

  • trunk/src/avifil32/igframe.c

    r6386 r6652  
     1/* $Id: igframe.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
    12/*
    23 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    2930struct ICOM_VTABLE(IGetFrame) igetfrm = {
    3031    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    31         IGetFrame_fnQueryInterface,
    32         IGetFrame_fnAddRef,
    33         IGetFrame_fnRelease,
    34         IGetFrame_fnGetFrame,
    35         IGetFrame_fnBegin,
    36         IGetFrame_fnEnd,
    37         IGetFrame_fnSetFormat,
     32    IGetFrame_fnQueryInterface,
     33    IGetFrame_fnAddRef,
     34    IGetFrame_fnRelease,
     35    IGetFrame_fnGetFrame,
     36    IGetFrame_fnBegin,
     37    IGetFrame_fnEnd,
     38    IGetFrame_fnSetFormat,
    3839};
    3940
    4041typedef struct IGetFrameImpl
    4142{
    42         ICOM_VFIELD(IGetFrame);
    43         /* IUnknown stuff */
    44         DWORD                   ref;
    45         /* IGetFrame stuff */
    46         IAVIStream*             pas;
    47         HIC                     hIC;
    48         LONG                    lCachedFrame;
    49         BITMAPINFO*             pbiICIn;
    50         BITMAPINFO*             pbiICOut;
    51         LPVOID                  pvICOutBits;
    52         LPVOID                  pvICInFmtBuf;
    53         DWORD                   dwICInDataBufSize;
    54         LPVOID                  pvICInDataBuf;
    55         LPVOID                  pvICOutBuf;
     43    ICOM_VFIELD(IGetFrame);
     44    /* IUnknown stuff */
     45    DWORD           ref;
     46    /* IGetFrame stuff */
     47    IAVIStream*     pas;
     48    HIC         hIC;
     49    LONG            lCachedFrame;
     50    BITMAPINFO*     pbiICIn;
     51    BITMAPINFO*     pbiICOut;
     52    LPVOID          pvICOutBits;
     53    LPVOID          pvICInFmtBuf;
     54    DWORD           dwICInDataBufSize;
     55    LPVOID          pvICInDataBuf;
     56    LPVOID          pvICOutBuf;
    5657} IGetFrameImpl;
    5758
    5859static HRESULT IGetFrame_Construct( IGetFrameImpl* This,
    59                                     IAVIStream* pstr,
    60                                     LPBITMAPINFOHEADER lpbi );
     60                    IAVIStream* pstr,
     61                    LPBITMAPINFOHEADER lpbi );
    6162static void IGetFrame_Destruct( IGetFrameImpl* This );
    6263
    … …  
    6667static LPVOID AVIFILE_IGetFrame_DecodeFrame(IGetFrameImpl* This,LONG lPos)
    6768{
    68         HRESULT hr;
    69         DWORD   dwRes;
    70         LONG    lFrameLength;
    71         LONG    lSampleCount;
    72         ICDECOMPRESS    icd;
    73 
    74         if ( This->hIC == (HIC)NULL )
    75                 return NULL;
    76 
    77         hr = IAVIStream_Read(This->pas,lPos,1,NULL,0,
    78                              &lFrameLength,&lSampleCount);
    79         if ( hr != S_OK || lSampleCount <= 0 )
    80         {
    81                 FIXME( "IAVIStream_Read failed! res = %08lx\n", hr );
    82                 return NULL;
    83         }
    84         TRACE( "frame length = %ld\n", lFrameLength );
    85 
    86         if ( This->dwICInDataBufSize < lFrameLength )
    87         {
    88                 LPVOID  lpv;
    89 
    90                 if ( This->pvICInDataBuf == NULL )
    91                 {
    92                         lpv = HeapAlloc(
    93                                 AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    94                                 lFrameLength );
    95                 }
    96                 else
    97                 {
    98                         lpv = HeapReAlloc(
    99                                 AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    100                                 This->pvICInDataBuf,lFrameLength );
    101                 }
    102                 if ( lpv == NULL )
    103                 {
    104                         ERR( "out of memory!\n" );
    105                         return NULL;
    106                 }
    107                 This->pvICInDataBuf = lpv;
    108                 This->dwICInDataBufSize = lFrameLength;
    109         }
    110 
    111         hr = IAVIStream_Read(This->pas,lPos,1,
    112                              This->pvICInDataBuf,This->dwICInDataBufSize,
    113                              &lFrameLength,&lSampleCount);
    114         if ( hr != S_OK || lSampleCount <= 0 )
    115         {
    116                 FIXME( "IAVIStream_Read to buffer failed! res = %08lx\n", hr );
    117                 return NULL;
    118         }
    119 
    120         This->pbiICIn->bmiHeader.biSizeImage = lFrameLength;
    121 
    122         TRACE( "call ICM_DECOMPRESS\n" );
    123         icd.dwFlags = (*(BYTE*)This->pvICInDataBuf) == 'c' ?
    124                                       ICDECOMPRESS_NOTKEYFRAME : 0;
    125         icd.lpbiInput = &This->pbiICIn->bmiHeader;
    126         icd.lpInput = (BYTE*)This->pvICInDataBuf + 8;
    127         icd.lpbiOutput = &This->pbiICOut->bmiHeader;
    128         icd.lpOutput = This->pvICOutBits;
    129         icd.ckid = *((DWORD*)This->pvICInDataBuf);
    130         dwRes = ICSendMessage(This->hIC,ICM_DECOMPRESS,
    131                               (DWORD)(&icd),sizeof(ICDECOMPRESS) );
    132         TRACE( "returned from ICM_DECOMPRESS\n" );
    133         if ( dwRes != ICERR_OK )
    134         {
    135                 ERR( "ICDecompress failed!\n" );
    136                 return NULL;
    137         }
    138 
    139         This->lCachedFrame = lPos;
    140 
    141         return This->pvICOutBits;
     69    HRESULT hr;
     70    DWORD   dwRes;
     71    LONG    lFrameLength;
     72    LONG    lSampleCount;
     73    ICDECOMPRESS    icd;
     74
     75    if ( This->hIC == (HIC)NULL )
     76        return NULL;
     77
     78    hr = IAVIStream_Read(This->pas,lPos,1,NULL,0,
     79                 &lFrameLength,&lSampleCount);
     80    if ( hr != S_OK || lSampleCount <= 0 )
     81    {
     82        FIXME( "IAVIStream_Read failed! res = %08lx\n", hr );
     83        return NULL;
     84    }
     85    TRACE( "frame length = %ld\n", lFrameLength );
     86
     87    if ( This->dwICInDataBufSize < lFrameLength )
     88    {
     89        LPVOID  lpv;
     90
     91        if ( This->pvICInDataBuf == NULL )
     92        {
     93            lpv = HeapAlloc(
     94                AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     95                lFrameLength );
     96        }
     97        else
     98        {
     99            lpv = HeapReAlloc(
     100                AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     101                This->pvICInDataBuf,lFrameLength );
     102        }
     103        if ( lpv == NULL )
     104        {
     105            ERR( "out of memory!\n" );
     106            return NULL;
     107        }
     108        This->pvICInDataBuf = lpv;
     109        This->dwICInDataBufSize = lFrameLength;
     110    }
     111
     112    hr = IAVIStream_Read(This->pas,lPos,1,
     113                 This->pvICInDataBuf,This->dwICInDataBufSize,
     114                 &lFrameLength,&lSampleCount);
     115    if ( hr != S_OK || lSampleCount <= 0 )
     116    {
     117        FIXME( "IAVIStream_Read to buffer failed! res = %08lx\n", hr );
     118        return NULL;
     119    }
     120
     121    This->pbiICIn->bmiHeader.biSizeImage = lFrameLength;
     122
     123    TRACE( "call ICM_DECOMPRESS\n" );
     124    icd.dwFlags = (*(BYTE*)This->pvICInDataBuf) == 'c' ?
     125                      ICDECOMPRESS_NOTKEYFRAME : 0;
     126    icd.lpbiInput = &This->pbiICIn->bmiHeader;
     127    icd.lpInput = (BYTE*)This->pvICInDataBuf + 8;
     128    icd.lpbiOutput = &This->pbiICOut->bmiHeader;
     129    icd.lpOutput = This->pvICOutBits;
     130    icd.ckid = *((DWORD*)This->pvICInDataBuf);
     131    dwRes = ICSendMessage(This->hIC,ICM_DECOMPRESS,
     132                  (DWORD)(&icd),sizeof(ICDECOMPRESS) );
     133    TRACE( "returned from ICM_DECOMPRESS\n" );
     134    if ( dwRes != ICERR_OK )
     135    {
     136        ERR( "ICDecompress failed!\n" );
     137        return NULL;
     138    }
     139
     140    This->lCachedFrame = lPos;
     141
     142    return This->pvICOutBits;
    142143}
    143144
    … …  
    145146
    146147HRESULT AVIFILE_CreateIGetFrame(void** ppobj,
    147                                 IAVIStream* pstr,LPBITMAPINFOHEADER lpbi)
    148 {
    149         IGetFrameImpl   *This;
    150         HRESULT         hr;
    151 
    152         *ppobj = NULL;
    153         This = (IGetFrameImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    154                                           sizeof(IGetFrameImpl));
    155         This->ref = 1;
    156         ICOM_VTBL(This) = &igetfrm;
    157         hr = IGetFrame_Construct( This, pstr, lpbi );
    158         if ( hr != S_OK )
    159         {
    160                 IGetFrame_Destruct( This );
    161                 return hr;
    162         }
    163 
    164         *ppobj = (LPVOID)This;
    165 
    166         return S_OK;
     148                IAVIStream* pstr,LPBITMAPINFOHEADER lpbi)
     149{
     150    IGetFrameImpl   *This;
     151    HRESULT     hr;
     152
     153    *ppobj = NULL;
     154    This = (IGetFrameImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     155                      sizeof(IGetFrameImpl));
     156    This->ref = 1;
     157    ICOM_VTBL(This) = &igetfrm;
     158    hr = IGetFrame_Construct( This, pstr, lpbi );
     159    if ( hr != S_OK )
     160    {
     161        IGetFrame_Destruct( This );
     162        return hr;
     163    }
     164
     165    *ppobj = (LPVOID)This;
     166
     167    return S_OK;
    167168}
    168169
    … …  
    173174static HRESULT WINAPI IGetFrame_fnQueryInterface(IGetFrame* iface,REFIID refiid,LPVOID *obj)
    174175{
    175         ICOM_THIS(IGetFrameImpl,iface);
    176 
    177         TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
    178         if ( IsEqualGUID(&IID_IUnknown,refiid) ||
    179              IsEqualGUID(&IID_IGetFrame,refiid) )
    180         {
    181                 IGetFrame_AddRef(iface);
    182                 *obj = iface;
    183                 return S_OK;
    184         }
    185 
    186         return OLE_E_ENUM_NOMORE;
     176    ICOM_THIS(IGetFrameImpl,iface);
     177
     178    TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
     179    if ( IsEqualGUID(&IID_IUnknown,refiid) ||
     180         IsEqualGUID(&IID_IGetFrame,refiid) )
     181    {
     182        IGetFrame_AddRef(iface);
     183        *obj = iface;
     184        return S_OK;
     185    }
     186
     187    return OLE_E_ENUM_NOMORE;
    187188}
    188189
    189190static ULONG WINAPI IGetFrame_fnAddRef(IGetFrame* iface)
    190191{
    191         ICOM_THIS(IGetFrameImpl,iface);
    192 
    193         TRACE("(%p)->AddRef()\n",iface);
    194         return ++(This->ref);
     192    ICOM_THIS(IGetFrameImpl,iface);
     193
     194    TRACE("(%p)->AddRef()\n",iface);
     195    return ++(This->ref);
    195196}
    196197
    197198static ULONG WINAPI IGetFrame_fnRelease(IGetFrame* iface)
    198199{
    199         ICOM_THIS(IGetFrameImpl,iface);
    200 
    201         TRACE("(%p)->Release()\n",iface);
    202         if ((--(This->ref)) > 0 )
    203                 return This->ref;
    204         IGetFrame_Destruct(This);
    205         if ( This->pas != NULL )
    206                 IAVIStream_Release( This->pas );
    207 
    208         HeapFree(AVIFILE_data.hHeap,0,iface);
    209         return 0;
     200    ICOM_THIS(IGetFrameImpl,iface);
     201
     202    TRACE("(%p)->Release()\n",iface);
     203    if ((--(This->ref)) > 0 )
     204        return This->ref;
     205    IGetFrame_Destruct(This);
     206    if ( This->pas != NULL )
     207        IAVIStream_Release( This->pas );
     208
     209    HeapFree(AVIFILE_data.hHeap,0,iface);
     210    return 0;
    210211}
    211212
    … …  
    216217static LPVOID WINAPI IGetFrame_fnGetFrame(IGetFrame* iface,LONG lPos)
    217218{
    218         ICOM_THIS(IGetFrameImpl,iface);
    219         LPVOID  lpv;
    220         LONG    lKeyFrame;
    221 
    222         TRACE( "(%p)->(%ld)\n", This, lPos );
    223 
    224         if ( lPos < 0 )
    225                 return NULL;
    226 
    227         if ( This->lCachedFrame == lPos )
    228                 return This->pvICOutBits;
    229         if ( (This->lCachedFrame+1) != lPos )
    230         {
    231                 lKeyFrame = IAVIStream_FindSample( This->pas, lPos,
    232                                                    FIND_KEY | FIND_PREV );
    233                 if ( lKeyFrame < 0 || lKeyFrame > lPos )
    234                         return NULL;
    235                 while ( ++lKeyFrame < lPos )
    236                 {
    237                         lpv = AVIFILE_IGetFrame_DecodeFrame(This, lKeyFrame);
    238                         if ( lpv == NULL )
    239                                 return NULL;
    240                 }
    241         }
    242 
    243         lpv = AVIFILE_IGetFrame_DecodeFrame(This, lPos);
    244         TRACE( "lpv = %p\n",lpv );
    245         if ( lpv == NULL )
    246                 return NULL;
    247 
    248         return lpv;
     219    ICOM_THIS(IGetFrameImpl,iface);
     220    LPVOID  lpv;
     221    LONG    lKeyFrame;
     222
     223    TRACE( "(%p)->(%ld)\n", This, lPos );
     224
     225    if ( lPos < 0 )
     226        return NULL;
     227
     228    if ( This->lCachedFrame == lPos )
     229        return This->pvICOutBits;
     230    if ( (This->lCachedFrame+1) != lPos )
     231    {
     232        lKeyFrame = IAVIStream_FindSample( This->pas, lPos,
     233                           FIND_KEY | FIND_PREV );
     234        if ( lKeyFrame < 0 || lKeyFrame > lPos )
     235            return NULL;
     236        while ( ++lKeyFrame < lPos )
     237        {
     238            lpv = AVIFILE_IGetFrame_DecodeFrame(This, lKeyFrame);
     239            if ( lpv == NULL )
     240                return NULL;
     241        }
     242    }
     243
     244    lpv = AVIFILE_IGetFrame_DecodeFrame(This, lPos);
     245    TRACE( "lpv = %p\n",lpv );
     246    if ( lpv == NULL )
     247        return NULL;
     248
     249    return lpv;
    249250}
    250251
    251252static HRESULT WINAPI IGetFrame_fnBegin(IGetFrame* iface,LONG lStart,LONG lEnd,LONG lRate)
    252253{
    253         ICOM_THIS(IGetFrameImpl,iface);
    254 
    255         TRACE( "(%p)->(%ld,%ld,%ld)\n", This, lStart, lEnd, lRate );
    256 
    257         if ( This->hIC == (HIC)NULL )
    258                 return E_UNEXPECTED;
    259 
    260         if ( ICDecompressBegin( This->hIC,
    261                                 This->pbiICIn,
    262                                 This->pbiICOut ) != ICERR_OK )
    263                 return E_FAIL;
    264 
    265         return S_OK;
     254    ICOM_THIS(IGetFrameImpl,iface);
     255
     256    TRACE( "(%p)->(%ld,%ld,%ld)\n", This, lStart, lEnd, lRate );
     257
     258    if ( This->hIC == (HIC)NULL )
     259        return E_UNEXPECTED;
     260
     261    if ( ICDecompressBegin( This->hIC,
     262                This->pbiICIn,
     263                This->pbiICOut ) != ICERR_OK )
     264        return E_FAIL;
     265
     266    return S_OK;
    266267}
    267268
    268269static HRESULT WINAPI IGetFrame_fnEnd(IGetFrame* iface)
    269270{
    270         ICOM_THIS(IGetFrameImpl,iface);
    271 
    272         TRACE( "(%p)->()\n", This );
    273 
    274         if ( This->hIC == (HIC)NULL )
    275                 return E_UNEXPECTED;
    276 
    277         if ( ICDecompressEnd( This->hIC ) != ICERR_OK )
    278                 return E_FAIL;
    279 
    280         return S_OK;
     271    ICOM_THIS(IGetFrameImpl,iface);
     272
     273    TRACE( "(%p)->()\n", This );
     274
     275    if ( This->hIC == (HIC)NULL )
     276        return E_UNEXPECTED;
     277
     278    if ( ICDecompressEnd( This->hIC ) != ICERR_OK )
     279        return E_FAIL;
     280
     281    return S_OK;
    281282}
    282283
    283284static HRESULT WINAPI IGetFrame_fnSetFormat(IGetFrame* iface,LPBITMAPINFOHEADER lpbi,LPVOID lpBits,INT x,INT y,INT dx,INT dy)
    284285{
    285         ICOM_THIS(IGetFrameImpl,iface);
    286         HRESULT hr;
    287         LONG    fmtlen;
    288         BITMAPINFOHEADER        biTemp;
    289         DWORD   dwSizeImage;
    290 
    291         FIXME( "(%p)->(%p,%p,%d,%d,%d,%d)\n",This,lpbi,lpBits,x,y,dx,dy );
    292 
    293         IGetFrame_Destruct(This);
    294 
    295         hr = IAVIStream_ReadFormat(This->pas,0,NULL,&fmtlen);
    296         if ( hr != S_OK )
    297                 return hr;
    298         This->pvICInFmtBuf = HeapAlloc(
    299                 AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,fmtlen);
    300         if ( This->pvICInFmtBuf == NULL )
    301                 return AVIERR_MEMORY;
    302         hr = IAVIStream_ReadFormat(This->pas,0,This->pvICInFmtBuf,&fmtlen);
    303         if ( hr != S_OK )
    304                 return hr;
    305         This->pbiICIn = (LPBITMAPINFO)This->pvICInFmtBuf;
    306 
    307         This->hIC = (HIC)ICOpen( ICTYPE_VIDEO,
    308                                 This->pbiICIn->bmiHeader.biCompression,
    309                                 ICMODE_DECOMPRESS );
    310         if ( This->hIC == (HIC)NULL )
    311         {
    312                 ERR( "no AVI decompressor for %c%c%c%c.\n",
    313                      (int)(This->pbiICIn->bmiHeader.biCompression>> 0)&0xff,
    314                      (int)(This->pbiICIn->bmiHeader.biCompression>> 8)&0xff,
    315                      (int)(This->pbiICIn->bmiHeader.biCompression>>16)&0xff,
    316                      (int)(This->pbiICIn->bmiHeader.biCompression>>24)&0xff );
    317                 return E_FAIL;
    318         }
    319 
    320         if ( lpbi == NULL || lpbi == ((LPBITMAPINFOHEADER)1) )
    321         {
    322                 memset( &biTemp, 0, sizeof(biTemp) );
    323                 biTemp.biSize = sizeof(BITMAPINFOHEADER);
    324                 biTemp.biWidth = This->pbiICIn->bmiHeader.biWidth;
    325                 biTemp.biHeight = This->pbiICIn->bmiHeader.biHeight;
    326                 biTemp.biPlanes = 1;
    327                 biTemp.biBitCount = 24;
    328                 biTemp.biCompression = 0;
    329                 lpbi = &biTemp;
    330         }
    331 
    332         if ( lpbi->biPlanes != 1 || lpbi->biCompression != 0 )
    333                 return E_FAIL;
    334 
    335         dwSizeImage =
    336                 ((This->pbiICIn->bmiHeader.biWidth*lpbi->biBitCount+7)/8)*
    337                                         This->pbiICIn->bmiHeader.biHeight;
    338         This->pvICOutBuf = HeapAlloc(
    339                 AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
    340                 (sizeof(BITMAPINFO)+sizeof(RGBQUAD)*256)*2+
    341                 dwSizeImage );
    342         if ( This->pvICOutBuf == NULL )
    343                 return AVIERR_MEMORY;
    344 
    345         This->pbiICOut = (BITMAPINFO*)This->pvICOutBuf;
    346         This->pvICOutBits = (LPVOID)( (BYTE*)This->pvICOutBuf +
    347                                 sizeof(BITMAPINFO) + sizeof(RGBQUAD)*256 );
    348 
    349         This->pbiICOut->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    350         This->pbiICOut->bmiHeader.biWidth = This->pbiICIn->bmiHeader.biWidth;
    351         This->pbiICOut->bmiHeader.biHeight = This->pbiICIn->bmiHeader.biHeight;
    352         This->pbiICOut->bmiHeader.biPlanes = 1;
    353         This->pbiICOut->bmiHeader.biBitCount = lpbi->biBitCount;
    354         This->pbiICOut->bmiHeader.biSizeImage = dwSizeImage;
    355         memcpy( This->pvICOutBits, This->pbiICOut, sizeof(BITMAPINFOHEADER) );
    356 
    357         return S_OK;
     286    ICOM_THIS(IGetFrameImpl,iface);
     287    HRESULT hr;
     288    LONG    fmtlen;
     289    BITMAPINFOHEADER    biTemp;
     290    DWORD   dwSizeImage;
     291
     292    FIXME( "(%p)->(%p,%p,%d,%d,%d,%d)\n",This,lpbi,lpBits,x,y,dx,dy );
     293
     294    IGetFrame_Destruct(This);
     295
     296    hr = IAVIStream_ReadFormat(This->pas,0,NULL,&fmtlen);
     297    if ( hr != S_OK )
     298        return hr;
     299    This->pvICInFmtBuf = HeapAlloc(
     300        AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,fmtlen);
     301    if ( This->pvICInFmtBuf == NULL )
     302        return AVIERR_MEMORY;
     303    hr = IAVIStream_ReadFormat(This->pas,0,This->pvICInFmtBuf,&fmtlen);
     304    if ( hr != S_OK )
     305        return hr;
     306    This->pbiICIn = (LPBITMAPINFO)This->pvICInFmtBuf;
     307
     308    This->hIC = (HIC)ICOpen( ICTYPE_VIDEO,
     309                This->pbiICIn->bmiHeader.biCompression,
     310                ICMODE_DECOMPRESS );
     311    if ( This->hIC == (HIC)NULL )
     312    {
     313        ERR( "no AVI decompressor for %c%c%c%c.\n",
     314             (int)(This->pbiICIn->bmiHeader.biCompression>> 0)&0xff,
     315             (int)(This->pbiICIn->bmiHeader.biCompression>> 8)&0xff,
     316             (int)(This->pbiICIn->bmiHeader.biCompression>>16)&0xff,
     317             (int)(This->pbiICIn->bmiHeader.biCompression>>24)&0xff );
     318        return E_FAIL;
     319    }
     320
     321    if ( lpbi == NULL || lpbi == ((LPBITMAPINFOHEADER)1) )
     322    {
     323        memset( &biTemp, 0, sizeof(biTemp) );
     324        biTemp.biSize = sizeof(BITMAPINFOHEADER);
     325        biTemp.biWidth = This->pbiICIn->bmiHeader.biWidth;
     326        biTemp.biHeight = This->pbiICIn->bmiHeader.biHeight;
     327        biTemp.biPlanes = 1;
     328        biTemp.biBitCount = 24;
     329        biTemp.biCompression = 0;
     330        lpbi = &biTemp;
     331    }
     332
     333    if ( lpbi->biPlanes != 1 || lpbi->biCompression != 0 )
     334        return E_FAIL;
     335
     336    dwSizeImage =
     337        ((This->pbiICIn->bmiHeader.biWidth*lpbi->biBitCount+7)/8)*
     338                    This->pbiICIn->bmiHeader.biHeight;
     339    This->pvICOutBuf = HeapAlloc(
     340        AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
     341        (sizeof(BITMAPINFO)+sizeof(RGBQUAD)*256)*2+
     342        dwSizeImage );
     343    if ( This->pvICOutBuf == NULL )
     344        return AVIERR_MEMORY;
     345
     346    This->pbiICOut = (BITMAPINFO*)This->pvICOutBuf;
     347    This->pvICOutBits = (LPVOID)( (BYTE*)This->pvICOutBuf +
     348                sizeof(BITMAPINFO) + sizeof(RGBQUAD)*256 );
     349
     350    This->pbiICOut->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
     351    This->pbiICOut->bmiHeader.biWidth = This->pbiICIn->bmiHeader.biWidth;
     352    This->pbiICOut->bmiHeader.biHeight = This->pbiICIn->bmiHeader.biHeight;
     353    This->pbiICOut->bmiHeader.biPlanes = 1;
     354    This->pbiICOut->bmiHeader.biBitCount = lpbi->biBitCount;
     355    This->pbiICOut->bmiHeader.biSizeImage = dwSizeImage;
     356    memcpy( This->pvICOutBits, This->pbiICOut, sizeof(BITMAPINFOHEADER) );
     357
     358    return S_OK;
    358359}
    359360
    360361static HRESULT IGetFrame_Construct( IGetFrameImpl* This,
    361                                     IAVIStream* pstr,
    362                                     LPBITMAPINFOHEADER lpbi )
    363 {
    364         HRESULT hr;
    365 
    366         TRACE( "(%p)->(%p,%p)\n",This,pstr,lpbi );
    367 
    368         IAVIStream_AddRef( pstr );
    369         This->pas = pstr;
    370         This->hIC = (HIC)NULL;
    371         This->lCachedFrame = -1L;
    372         This->pbiICIn = NULL;
    373         This->pbiICOut = NULL;
    374         This->pvICInFmtBuf = NULL;
    375         This->pvICInDataBuf = NULL;
    376         This->dwICInDataBufSize = 0;
    377         This->pvICOutBuf = NULL;
    378 
    379         hr = IGetFrame_SetFormat((IGetFrame*)This,lpbi,NULL,0,0,0,0);
    380         if ( hr != S_OK )
    381                 return hr;
    382 
    383         return S_OK;
     362                    IAVIStream* pstr,
     363                    LPBITMAPINFOHEADER lpbi )
     364{
     365    HRESULT hr;
     366
     367    TRACE( "(%p)->(%p,%p)\n",This,pstr,lpbi );
     368
     369    IAVIStream_AddRef( pstr );
     370    This->pas = pstr;
     371    This->hIC = (HIC)NULL;
     372    This->lCachedFrame = -1L;
     373    This->pbiICIn = NULL;
     374    This->pbiICOut = NULL;
     375    This->pvICInFmtBuf = NULL;
     376    This->pvICInDataBuf = NULL;
     377    This->dwICInDataBufSize = 0;
     378    This->pvICOutBuf = NULL;
     379
     380    hr = IGetFrame_SetFormat((IGetFrame*)This,lpbi,NULL,0,0,0,0);
     381    if ( hr != S_OK )
     382        return hr;
     383
     384    return S_OK;
    384385}
    385386
    386387static void IGetFrame_Destruct( IGetFrameImpl* This )
    387388{
    388         if ( This->hIC != (HIC)NULL )
    389         {
    390                 ICClose( This->hIC );
    391                 This->hIC = (HIC)NULL;
    392         }
    393         if ( This->pvICInFmtBuf != NULL )
    394         {
    395                 HeapFree( AVIFILE_data.hHeap, 0, This->pvICInFmtBuf );
    396                 This->pvICInFmtBuf = NULL;
    397         }
    398         if ( This->pvICInDataBuf != NULL )
    399         {
    400                 HeapFree( AVIFILE_data.hHeap, 0, This->pvICInDataBuf );
    401                 This->pvICInDataBuf = NULL;
    402         }
    403         if ( This->pvICOutBuf != NULL )
    404         {
    405                 HeapFree( AVIFILE_data.hHeap, 0, This->pvICOutBuf );
    406                 This->pvICOutBuf = NULL;
    407         }
    408 
    409         This->lCachedFrame = -1L;
    410         This->pbiICIn = NULL;
    411         This->pbiICOut = NULL;
    412         This->dwICInDataBufSize = 0;
    413 }
     389    if ( This->hIC != (HIC)NULL )
     390    {
     391        ICClose( This->hIC );
     392        This->hIC = (HIC)NULL;
     393    }
     394    if ( This->pvICInFmtBuf != NULL )
     395    {
     396        HeapFree( AVIFILE_data.hHeap, 0, This->pvICInFmtBuf );
     397        This->pvICInFmtBuf = NULL;
     398    }
     399    if ( This->pvICInDataBuf != NULL )
     400    {
     401        HeapFree( AVIFILE_data.hHeap, 0, This->pvICInDataBuf );
     402        This->pvICInDataBuf = NULL;
     403    }
     404    if ( This->pvICOutBuf != NULL )
     405    {
     406        HeapFree( AVIFILE_data.hHeap, 0, This->pvICOutBuf );
     407        This->pvICOutBuf = NULL;
     408    }
     409
     410    This->lCachedFrame = -1L;
     411    This->pbiICIn = NULL;
     412    This->pbiICOut = NULL;
     413    This->dwICInDataBufSize = 0;
     414}

  • trunk/src/avifil32/initavifil32.cpp

    r6386 r6652  
     1/* $Id: initavifil32.cpp,v 1.2 2001-09-05 14:16:45 bird Exp $ */
    12/*
    23 * WINMM DLL entry point
    … …  
    4546static HMODULE dllHandle = 0;
    4647
    47 BOOL WINAPI AVIFILE_DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved );
     48BOOL WINAPI AVIFILE_DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved );
    4849
    4950/****************************************************************************/

  • trunk/src/avifil32/initterm.cpp

    r6386 r6652  
     1/* $Id: initterm.cpp,v 1.5 2001-09-05 14:16:45 bird Exp $ */
    12/*
    23 * WINMM DLL entry point

  • trunk/src/avifil32/main.c

    r6386 r6652  
     1/* $Id: main.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
    12/*
    23 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    2122
    2223/***********************************************************************
    23  *              AVIFILE_InitProcess (internal)
     24 *      AVIFILE_InitProcess (internal)
    2425 */
    2526static BOOL AVIFILE_InitProcess( void )
    2627{
    27         TRACE("()\n");
     28    TRACE("()\n");
    2829
    29         AVIFILE_data.dwAVIFileRef = 0;
    30         AVIFILE_data.dwClassObjRef = 0;
    31         AVIFILE_data.hHeap = (HANDLE)NULL;
     30    AVIFILE_data.dwAVIFileRef = 0;
     31    AVIFILE_data.dwClassObjRef = 0;
     32    AVIFILE_data.hHeap = (HANDLE)NULL;
    3233
    33         AVIFILE_data.hHeap = HeapCreate( 0, 0x10000, 0 );
    34         if ( AVIFILE_data.hHeap  == (HANDLE)NULL )
    35         {
    36                 ERR( "cannot allocate heap for AVIFILE.\n" );
    37                 return FALSE;
    38         }
     34    AVIFILE_data.hHeap = HeapCreate( 0, 0x10000, 0 );
     35    if ( AVIFILE_data.hHeap  == (HANDLE)NULL )
     36    {
     37        ERR( "cannot allocate heap for AVIFILE.\n" );
     38        return FALSE;
     39    }
    3940
    40         return TRUE;
     41    return TRUE;
    4142}
    4243
    4344/***********************************************************************
    44  *              AVIFILE_UninitProcess (internal)
     45 *      AVIFILE_UninitProcess (internal)
    4546 */
    4647static void AVIFILE_UninitProcess( void )
    4748{
    48         TRACE("()\n");
     49    TRACE("()\n");
    4950
    50         if ( AVIFILE_data.dwAVIFileRef != 0 )
    51                 ERR( "you must call AVIFileExit()\n" );
     51    if ( AVIFILE_data.dwAVIFileRef != 0 )
     52        ERR( "you must call AVIFileExit()\n" );
    5253
    53         if ( AVIFILE_data.dwClassObjRef != 0 )
    54                 ERR( "you must release some objects allocated from AVIFile.\n" );
     54    if ( AVIFILE_data.dwClassObjRef != 0 )
     55        ERR( "you must release some objects allocated from AVIFile.\n" );
    5556
    56         if ( AVIFILE_data.hHeap != (HANDLE)NULL )
    57         {
    58                 HeapDestroy( AVIFILE_data.hHeap );
    59                 AVIFILE_data.hHeap = (HANDLE)NULL;
    60         }
     57    if ( AVIFILE_data.hHeap != (HANDLE)NULL )
     58    {
     59        HeapDestroy( AVIFILE_data.hHeap );
     60        AVIFILE_data.hHeap = (HANDLE)NULL;
     61    }
    6162}
    6263
    6364/***********************************************************************
    64  *              AVIFILE_DllMain
     65 *      AVIFILE_DllMain
    6566 */
    6667BOOL WINAPI AVIFILE_DllMain(
    67         HINSTANCE hInstDLL,
    68         DWORD fdwReason,
    69         LPVOID lpvReserved )
     68    HINSTANCE hInstDLL,
     69    DWORD fdwReason,
     70    LPVOID lpvReserved )
    7071{
    71         switch ( fdwReason )
    72         {
    73         case DLL_PROCESS_ATTACH:
    74                 if ( !AVIFILE_InitProcess() )
    75                         return FALSE;
    76                 break;
    77         case DLL_PROCESS_DETACH:
    78                 AVIFILE_UninitProcess();
    79                 break;
    80         case DLL_THREAD_ATTACH:
    81                 break;
    82         case DLL_THREAD_DETACH:
    83                 break;
    84         }
     72    switch ( fdwReason )
     73    {
     74    case DLL_PROCESS_ATTACH:
     75        if ( !AVIFILE_InitProcess() )
     76            return FALSE;
     77        break;
     78    case DLL_PROCESS_DETACH:
     79        AVIFILE_UninitProcess();
     80        break;
     81    case DLL_THREAD_ATTACH:
     82        break;
     83    case DLL_THREAD_DETACH:
     84        break;
     85    }
    8586
    86         return TRUE;
     87    return TRUE;
    8788}
    8889

  • trunk/src/avifil32/string.c

    r6386 r6652  
     1/* $Id: string.c,v 1.2 2001-09-05 14:16:46 bird Exp $ */
    12/*
    23 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    2425INT AVIFILE_strlenAtoW( LPCSTR lpstr )
    2526{
    26         INT     len;
     27    INT len;
    2728
    28         len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, NULL, 0 );
    29         return ( len > 0 ) ? (len-1) : 0;
     29    len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, NULL, 0 );
     30    return ( len > 0 ) ? (len-1) : 0;
    3031}
    3132
    3233INT AVIFILE_strlenWtoA( LPCWSTR lpwstr )
    3334{
    34         INT     len;
     35    INT len;
    3536
    36         len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
    37                                    NULL, 0, NULL, NULL );
    38         return ( len > 0 ) ? (len-1) : 0;
     37    len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
     38                   NULL, 0, NULL, NULL );
     39    return ( len > 0 ) ? (len-1) : 0;
    3940}
    4041
    4142LPWSTR AVIFILE_strncpyAtoW( LPWSTR lpwstr, LPCSTR lpstr, INT wbuflen )
    4243{
    43         INT     len;
     44    INT len;
    4445
    45         len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, lpwstr, wbuflen );
    46         if ( len == 0 )
    47                 *lpwstr = 0;
    48         return lpwstr;
     46    len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, lpwstr, wbuflen );
     47    if ( len == 0 )
     48        *lpwstr = 0;
     49    return lpwstr;
    4950}
    5051
    5152LPSTR AVIFILE_strncpyWtoA( LPSTR lpstr, LPCWSTR lpwstr, INT abuflen )
    5253{
    53         INT     len;
     54    INT len;
    5455
    55         len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
    56                                    lpstr, abuflen, NULL, NULL );
    57         if ( len == 0 )
    58                 *lpstr = 0;
    59         return lpstr;
     56    len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
     57                   lpstr, abuflen, NULL, NULL );
     58    if ( len == 0 )
     59        *lpstr = 0;
     60    return lpstr;
    6061}
    6162
    6263LPWSTR AVIFILE_strdupAtoW( LPCSTR lpstr )
    6364{
    64         INT len;
    65         LPWSTR lpwstr = NULL;
     65    INT len;
     66    LPWSTR lpwstr = NULL;
    6667
    67         len = AVIFILE_strlenAtoW( lpstr );
    68         if ( len > 0 )
    69         {
    70                 lpwstr = (LPWSTR)HeapAlloc( AVIFILE_data.hHeap, 0, sizeof(WCHAR)*(len+1) );
    71                 if ( lpwstr != NULL )
    72                         (void)AVIFILE_strncpyAtoW( lpwstr, lpstr, len+1 );
    73         }
     68    len = AVIFILE_strlenAtoW( lpstr );
     69    if ( len > 0 )
     70    {
     71        lpwstr = (LPWSTR)HeapAlloc( AVIFILE_data.hHeap, 0, sizeof(WCHAR)*(len+1) );
     72        if ( lpwstr != NULL )
     73            (void)AVIFILE_strncpyAtoW( lpwstr, lpstr, len+1 );
     74    }
    7475
    75         return lpwstr;
     76    return lpwstr;
    7677}
    7778
    7879LPSTR AVIFILE_strdupWtoA( LPCWSTR lpwstr )
    7980{
    80         INT len;
    81         LPSTR lpstr = NULL;
     81    INT len;
     82    LPSTR lpstr = NULL;
    8283
    83         len = AVIFILE_strlenWtoA( lpwstr );
    84         if ( len > 0 )
    85         {
    86                 lpstr = (LPSTR)HeapAlloc( AVIFILE_data.hHeap, 0, sizeof(CHAR)*(len+1) );
    87                 if ( lpstr != NULL )
    88                         (void)AVIFILE_strncpyWtoA( lpstr, lpwstr, len+1 );
    89         }
     84    len = AVIFILE_strlenWtoA( lpwstr );
     85    if ( len > 0 )
     86    {
     87        lpstr = (LPSTR)HeapAlloc( AVIFILE_data.hHeap, 0, sizeof(CHAR)*(len+1) );
     88        if ( lpstr != NULL )
     89            (void)AVIFILE_strncpyWtoA( lpstr, lpwstr, len+1 );
     90    }
    9091
    91         return lpstr;
     92    return lpstr;
    9293}
    9394
Note: See TracChangeset for help on using the changeset viewer.