Changeset 6712 for trunk/src/avifil32


Ignore:
Timestamp:
Sep 15, 2001, 11:47:44 AM (24 years ago)
Author:
sandervl
Message:

restored old version

Location:
trunk/src/avifil32
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/avifil32/api.c

    r6644 r6712  
    1 /* $Id: api.c,v 1.2 2001-09-05 12:00:53 bird Exp $
    2  *
     1/*
    32 * Copyright 1999 Marcus Meissner
    43 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    2322
    2423/***********************************************************************
    25  *      AVIFileInit (AVIFILE.100)
    26  *      AVIFileInit (AVIFIL32.@)
     24 *              AVIFileInit (AVIFILE.100)
     25 *              AVIFileInit (AVIFIL32.@)
    2726 */
    2827void WINAPI AVIFileInit(void)
    2928{
    30     TRACE("()\n");
    31     if ( AVIFILE_data.dwAVIFileRef == 0 )
    32     {
    33         if ( FAILED(CoInitialize(NULL)) )
    34             AVIFILE_data.fInitCOM = FALSE;
    35         else
    36             AVIFILE_data.fInitCOM = TRUE;
    37     }
    38     AVIFILE_data.dwAVIFileRef ++;
    39 }
    40 
    41 /***********************************************************************
    42  *      AVIFileExit (AVIFILE.101)
    43  *      AVIFileExit (AVIFIL32.@)
     29        TRACE("()\n");
     30        if ( AVIFILE_data.dwAVIFileRef == 0 )
     31        {
     32                if ( FAILED(CoInitialize(NULL)) )
     33                        AVIFILE_data.fInitCOM = FALSE;
     34                else
     35                        AVIFILE_data.fInitCOM = TRUE;
     36        }
     37        AVIFILE_data.dwAVIFileRef ++;
     38}
     39
     40/***********************************************************************
     41 *              AVIFileExit (AVIFILE.101)
     42 *              AVIFileExit (AVIFIL32.@)
    4443 */
    4544void WINAPI AVIFileExit(void)
    4645{
    47     TRACE("()\n");
    48     if ( AVIFILE_data.dwAVIFileRef == 0 )
    49     {
    50         ERR( "unexpected AVIFileExit()\n" );
    51         return;
    52     }
    53 
    54     AVIFILE_data.dwAVIFileRef --;
    55     if ( AVIFILE_data.dwAVIFileRef == 0 )
    56     {
    57         if ( AVIFILE_data.fInitCOM )
    58         {
    59             CoUninitialize();
    60             AVIFILE_data.fInitCOM = FALSE;
    61         }
    62     }
    63 }
    64 
    65 /***********************************************************************
    66  *      AVIFileAddRef (AVIFIL32.@)
     46        TRACE("()\n");
     47        if ( AVIFILE_data.dwAVIFileRef == 0 )
     48        {
     49                ERR( "unexpected AVIFileExit()\n" );
     50                return;
     51        }
     52
     53        AVIFILE_data.dwAVIFileRef --;
     54        if ( AVIFILE_data.dwAVIFileRef == 0 )
     55        {
     56                if ( AVIFILE_data.fInitCOM )
     57                {
     58                        CoUninitialize();
     59                        AVIFILE_data.fInitCOM = FALSE;
     60                }
     61        }
     62}
     63
     64/***********************************************************************
     65 *              AVIFileAddRef (AVIFIL32.@)
    6766 */
    6867ULONG WINAPI AVIFileAddRef(PAVIFILE pfile)
    6968{
    70     return IAVIFile_AddRef( pfile );
    71 }
    72 
    73 /***********************************************************************
    74  *      AVIFileRelease (AVIFILE.141)
    75  *      AVIFileRelease (AVIFIL32.@)
     69        return IAVIFile_AddRef( pfile );
     70}
     71
     72/***********************************************************************
     73 *              AVIFileRelease (AVIFILE.141)
     74 *              AVIFileRelease (AVIFIL32.@)
    7675 */
    7776ULONG WINAPI AVIFileRelease(PAVIFILE pfile)
    7877{
    79     return IAVIFile_Release( pfile );
    80 }
    81 
    82 /***********************************************************************
    83  *      AVIFileOpen  (AVIFILE.102)
    84  *      AVIFileOpenA (AVIFIL32.@)
     78        return IAVIFile_Release( pfile );
     79}
     80
     81/***********************************************************************
     82 *              AVIFileOpen  (AVIFILE.102)
     83 *              AVIFileOpenA (AVIFIL32.@)
    8584 */
    8685HRESULT WINAPI AVIFileOpenA(
    87     PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler )
    88 {
    89     WCHAR*  pwsz;
    90     HRESULT hr;
    91 
    92     TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
    93     pwsz = AVIFILE_strdupAtoW( szFile );
    94     if ( pwsz == NULL )
    95         return AVIERR_MEMORY;
    96     hr = AVIFileOpenW(ppfile,pwsz,uMode,lpHandler);
    97     HeapFree( AVIFILE_data.hHeap, 0, pwsz );
    98     return hr;
    99 }
    100 
    101 /***********************************************************************
    102  *      AVIFileOpenW (AVIFIL32.@)
     86        PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler )
     87{
     88        WCHAR*  pwsz;
     89        HRESULT hr;
     90
     91        TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
     92        pwsz = AVIFILE_strdupAtoW( szFile );
     93        if ( pwsz == NULL )
     94                return AVIERR_MEMORY;
     95        hr = AVIFileOpenW(ppfile,pwsz,uMode,lpHandler);
     96        HeapFree( AVIFILE_data.hHeap, 0, pwsz );
     97        return hr;
     98}
     99
     100/***********************************************************************
     101 *              AVIFileOpenW (AVIFIL32.@)
    103102 */
    104103HRESULT WINAPI AVIFileOpenW(
    105     PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler )
    106 {
    107     HRESULT hr;
    108     IClassFactory*  pcf;
    109     CLSID   clsRIFF;
    110 
    111     TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
    112     *ppfile = (PAVIFILE)NULL;
    113 
    114     if ( lpHandler == NULL )
    115     {
    116         /* FIXME - check RIFF type and get a handler from registry
    117         *         if IAVIFile::Open is worked...
    118         */
    119         memcpy( &clsRIFF, &CLSID_AVIFile, sizeof(CLSID) );
    120         lpHandler = &clsRIFF;
    121     }
    122 
    123     /*
    124     * FIXME - MS says IAVIFile::Open will be called,
    125     *         but no such method in vfw.h... why????
    126     */
    127     if ( !IsEqualGUID( lpHandler, &CLSID_AVIFile ) )
    128         return REGDB_E_CLASSNOTREG;
    129 
    130     hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
    131                        &IID_IClassFactory,(void**)&pcf);
    132     if ( hr != S_OK )
    133         return hr;
    134 
    135     hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIFile,
    136                        (void**)ppfile );
    137     IClassFactory_Release( pcf );
    138 
    139     if ( hr == S_OK )
    140     {
    141         /* FIXME??? */
    142         hr = AVIFILE_IAVIFile_Open( *ppfile, szFile, uMode );
    143         if ( hr != S_OK )
    144         {
    145             IAVIFile_Release( (*ppfile) );
    146             *ppfile = NULL;
    147         }
    148     }
    149 
    150     return hr;
    151 }
    152 
    153 /***********************************************************************
    154  *      AVIFileInfoW (AVIFIL32.@)
     104        PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler )
     105{
     106        HRESULT hr;
     107        IClassFactory*  pcf;
     108        CLSID   clsRIFF;
     109
     110        TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
     111        *ppfile = (PAVIFILE)NULL;
     112
     113        if ( lpHandler == NULL )
     114        {
     115                /* FIXME - check RIFF type and get a handler from registry
     116                *         if IAVIFile::Open is worked...
     117                */
     118                memcpy( &clsRIFF, &CLSID_AVIFile, sizeof(CLSID) );
     119                lpHandler = &clsRIFF;
     120        }
     121
     122        /*
     123        * FIXME - MS says IAVIFile::Open will be called,
     124        *         but no such method in vfw.h... why????
     125        */
     126        if ( !IsEqualGUID( lpHandler, &CLSID_AVIFile ) )
     127                return REGDB_E_CLASSNOTREG;
     128
     129        hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
     130                                       &IID_IClassFactory,(void**)&pcf);
     131        if ( hr != S_OK )
     132                return hr;
     133
     134        hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIFile,
     135                                           (void**)ppfile );
     136        IClassFactory_Release( pcf );
     137
     138        if ( hr == S_OK )
     139        {
     140                /* FIXME??? */
     141                hr = AVIFILE_IAVIFile_Open( *ppfile, szFile, uMode );
     142                if ( hr != S_OK )
     143                {
     144                        IAVIFile_Release( (*ppfile) );
     145                        *ppfile = NULL;
     146                }
     147        }
     148
     149        return hr;
     150}
     151
     152/***********************************************************************
     153 *              AVIFileInfoW (AVIFIL32.@)
    155154 */
    156155HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile,AVIFILEINFOW* pfi,LONG lSize)
    157156{
    158     return IAVIFile_Info( pfile, pfi, lSize );
    159 }
    160 
    161 /***********************************************************************
    162  *      AVIFileInfo  (AVIFIL32.@)
    163  *      AVIFileInfoA (AVIFIL32.@)
     157        return IAVIFile_Info( pfile, pfi, lSize );
     158}
     159
     160/***********************************************************************
     161 *              AVIFileInfo  (AVIFIL32.@)
     162 *              AVIFileInfoA (AVIFIL32.@)
    164163 */
    165164HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile,AVIFILEINFOA* pfi,LONG lSize)
    166165{
    167     AVIFILEINFOW    fiw;
    168     HRESULT     hr;
    169 
    170     if ( lSize < sizeof(AVIFILEINFOA) )
    171         return AVIERR_BADSIZE;
    172     hr = AVIFileInfoW( pfile, &fiw, sizeof(AVIFILEINFOW) );
    173     if ( hr != S_OK )
    174         return hr;
    175     memcpy( pfi,&fiw,sizeof(AVIFILEINFOA) );
    176     AVIFILE_strncpyWtoA( pfi->szFileType, fiw.szFileType,
    177                  sizeof(pfi->szFileType) );
    178     pfi->szFileType[sizeof(pfi->szFileType)-1] = 0;
    179 
    180     return S_OK;
    181 }
    182 
    183 /***********************************************************************
    184  *      AVIFileGetStream (AVIFILE.143)
    185  *      AVIFileGetStream (AVIFIL32.@)
     166        AVIFILEINFOW    fiw;
     167        HRESULT         hr;
     168
     169        if ( lSize < sizeof(AVIFILEINFOA) )
     170                return AVIERR_BADSIZE;
     171        hr = AVIFileInfoW( pfile, &fiw, sizeof(AVIFILEINFOW) );
     172        if ( hr != S_OK )
     173                return hr;
     174        memcpy( pfi,&fiw,sizeof(AVIFILEINFOA) );
     175        AVIFILE_strncpyWtoA( pfi->szFileType, fiw.szFileType,
     176                             sizeof(pfi->szFileType) );
     177        pfi->szFileType[sizeof(pfi->szFileType)-1] = 0;
     178
     179        return S_OK;
     180}
     181
     182/***********************************************************************
     183 *              AVIFileGetStream (AVIFILE.143)
     184 *              AVIFileGetStream (AVIFIL32.@)
    186185 */
    187186HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile,PAVISTREAM* pas,DWORD fccType,LONG lParam)
    188187{
    189     return IAVIFile_GetStream(pfile,pas,fccType,lParam);
    190 }
    191 
    192 /***********************************************************************
    193  *      AVIFileCreateStreamW (AVIFIL32.@)
     188        return IAVIFile_GetStream(pfile,pas,fccType,lParam);
     189}
     190
     191/***********************************************************************
     192 *              AVIFileCreateStreamW (AVIFIL32.@)
    194193 */
    195194HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile,PAVISTREAM* ppas,AVISTREAMINFOW* pasi)
    196195{
    197     return IAVIFile_CreateStream(pfile,ppas,pasi);
    198 }
    199 
    200 /***********************************************************************
    201  *      AVIFileCreateStreamA (AVIFIL32.@)
     196        return IAVIFile_CreateStream(pfile,ppas,pasi);
     197}
     198
     199/***********************************************************************
     200 *              AVIFileCreateStreamA (AVIFIL32.@)
    202201 */
    203202HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile,PAVISTREAM* ppas,AVISTREAMINFOA* pasi)
    204203{
    205     AVISTREAMINFOW  siw;
    206     HRESULT     hr;
    207 
    208     memcpy( &siw,pasi,sizeof(AVISTREAMINFOA) );
    209     AVIFILE_strncpyAtoW( siw.szName, pasi->szName,
    210         sizeof(siw.szName)/sizeof(siw.szName[0]) );
    211     siw.szName[sizeof(siw.szName)/sizeof(siw.szName[0])-1] = 0;
    212 
    213     hr = AVIFileCreateStreamW(pfile,ppas,&siw);
    214 
    215     return hr;
    216 }
    217 
    218 /***********************************************************************
    219  *      AVIFileWriteData (AVIFIL32.@)
     204        AVISTREAMINFOW  siw;
     205        HRESULT         hr;
     206
     207        memcpy( &siw,pasi,sizeof(AVISTREAMINFOA) );
     208        AVIFILE_strncpyAtoW( siw.szName, pasi->szName,
     209                sizeof(siw.szName)/sizeof(siw.szName[0]) );
     210        siw.szName[sizeof(siw.szName)/sizeof(siw.szName[0])-1] = 0;
     211
     212        hr = AVIFileCreateStreamW(pfile,ppas,&siw);
     213
     214        return hr;
     215}
     216
     217/***********************************************************************
     218 *              AVIFileWriteData (AVIFIL32.@)
    220219 */
    221220HRESULT WINAPI AVIFileWriteData(
    222     PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LONG cbData )
    223 {
    224     return IAVIFile_WriteData( pfile,dwChunkId,lpvData,cbData );
    225 }
    226 
    227 /***********************************************************************
    228  *      AVIFileReadData (AVIFIL32.@)
     221        PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LONG cbData )
     222{
     223        return IAVIFile_WriteData( pfile,dwChunkId,lpvData,cbData );
     224}
     225
     226/***********************************************************************
     227 *              AVIFileReadData (AVIFIL32.@)
    229228 */
    230229HRESULT WINAPI AVIFileReadData(
    231     PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LPLONG pcbData )
    232 {
    233     return IAVIFile_ReadData( pfile,dwChunkId,lpvData,pcbData );
    234 }
    235 
    236 /***********************************************************************
    237  *      AVIFileEndRecord (AVIFIL32.@)
     230        PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LPLONG pcbData )
     231{
     232        return IAVIFile_ReadData( pfile,dwChunkId,lpvData,pcbData );
     233}
     234
     235/***********************************************************************
     236 *              AVIFileEndRecord (AVIFIL32.@)
    238237 */
    239238HRESULT WINAPI AVIFileEndRecord( PAVIFILE pfile )
    240239{
    241     return IAVIFile_EndRecord( pfile );
    242 }
    243 
    244 /***********************************************************************
    245  *      AVIStreamAddRef (AVIFIL32.@)
     240        return IAVIFile_EndRecord( pfile );
     241}
     242
     243/***********************************************************************
     244 *              AVIStreamAddRef (AVIFIL32.@)
    246245 */
    247246ULONG WINAPI AVIStreamAddRef(PAVISTREAM pas)
    248247{
    249     return IAVIStream_Release(pas);
    250 }
    251 
    252 /***********************************************************************
    253  *      AVIStreamRelease (AVIFIL32.@)
     248        return IAVIStream_Release(pas);
     249}
     250
     251/***********************************************************************
     252 *              AVIStreamRelease (AVIFIL32.@)
    254253 */
    255254ULONG WINAPI AVIStreamRelease(PAVISTREAM pas)
    256255{
    257     return IAVIStream_Release(pas);
    258 }
    259 
    260 /***********************************************************************
    261  *      AVIStreamInfoW (AVIFIL32.@)
     256        return IAVIStream_Release(pas);
     257}
     258
     259/***********************************************************************
     260 *              AVIStreamInfoW (AVIFIL32.@)
    262261 */
    263262HRESULT WINAPI AVIStreamInfoW(PAVISTREAM pas,AVISTREAMINFOW* psi,LONG lSize)
    264263{
    265     return IAVIStream_Info(pas,psi,lSize);
    266 }
    267 
    268 /***********************************************************************
    269  *      AVIStreamInfo  (AVIFIL32.@)
    270  *      AVIStreamInfoA (AVIFIL32.@)
     264        return IAVIStream_Info(pas,psi,lSize);
     265}
     266
     267/***********************************************************************
     268 *              AVIStreamInfo  (AVIFIL32.@)
     269 *              AVIStreamInfoA (AVIFIL32.@)
    271270 */
    272271HRESULT WINAPI AVIStreamInfoA(PAVISTREAM pas,AVISTREAMINFOA* psi,LONG lSize)
    273272{
    274     AVISTREAMINFOW  siw;
    275     HRESULT     hr;
    276 
    277     if (lSize < sizeof(AVISTREAMINFOA))
    278         return AVIERR_BADSIZE;
    279     hr = AVIStreamInfoW(pas,&siw,sizeof(AVISTREAMINFOW));
    280     if ( hr != S_OK )
    281         return hr;
    282     memcpy( psi,&siw,sizeof(AVIFILEINFOA) );
    283     AVIFILE_strncpyWtoA( psi->szName, siw.szName, sizeof(psi->szName) );
    284     psi->szName[sizeof(psi->szName)-1] = 0;
    285 
    286     return hr;
    287 }
    288 
    289 /***********************************************************************
    290  *      AVIStreamFindSample (AVIFIL32.@)
     273        AVISTREAMINFOW  siw;
     274        HRESULT         hr;
     275
     276        if (lSize < sizeof(AVISTREAMINFOA))
     277                return AVIERR_BADSIZE;
     278        hr = AVIStreamInfoW(pas,&siw,sizeof(AVISTREAMINFOW));
     279        if ( hr != S_OK )
     280                return hr;
     281        memcpy( psi,&siw,sizeof(AVIFILEINFOA) );
     282        AVIFILE_strncpyWtoA( psi->szName, siw.szName, sizeof(psi->szName) );
     283        psi->szName[sizeof(psi->szName)-1] = 0;
     284
     285        return hr;
     286}
     287
     288/***********************************************************************
     289 *              AVIStreamFindSample (AVIFIL32.@)
    291290 */
    292291LONG WINAPI AVIStreamFindSample(PAVISTREAM pas,LONG lPos,LONG lFlags)
    293292{
    294     return IAVIStream_FindSample(pas,lPos,lFlags);
    295 }
    296 
    297 /***********************************************************************
    298  *      AVIStreamReadFormat (AVIFIL32.@)
     293        return IAVIStream_FindSample(pas,lPos,lFlags);
     294}
     295
     296/***********************************************************************
     297 *              AVIStreamReadFormat (AVIFIL32.@)
    299298 */
    300299HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM pas,LONG pos,LPVOID format,LONG *formatsize) {
    301     return IAVIStream_ReadFormat(pas,pos,format,formatsize);
    302 }
    303 
    304 /***********************************************************************
    305  *      AVIStreamSetFormat (AVIFIL32.@)
     300        return IAVIStream_ReadFormat(pas,pos,format,formatsize);
     301}
     302
     303/***********************************************************************
     304 *              AVIStreamSetFormat (AVIFIL32.@)
    306305 */
    307306HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM pas,LONG pos,LPVOID format,LONG formatsize) {
    308     return IAVIStream_SetFormat(pas,pos,format,formatsize);
    309 }
    310 
    311 /***********************************************************************
    312  *      AVIStreamReadData (AVIFIL32.@)
     307        return IAVIStream_SetFormat(pas,pos,format,formatsize);
     308}
     309
     310/***********************************************************************
     311 *              AVIStreamReadData (AVIFIL32.@)
    313312 */
    314313HRESULT WINAPI AVIStreamReadData(PAVISTREAM pas,DWORD fcc,LPVOID lp,LONG *lpread) {
    315     return IAVIStream_ReadData(pas,fcc,lp,lpread);
    316 }
    317 
    318 /***********************************************************************
    319  *      AVIStreamWriteData (AVIFIL32.@)
     314        return IAVIStream_ReadData(pas,fcc,lp,lpread);
     315}
     316
     317/***********************************************************************
     318 *              AVIStreamWriteData (AVIFIL32.@)
    320319 */
    321320HRESULT WINAPI AVIStreamWriteData(PAVISTREAM pas,DWORD fcc,LPVOID lp,LONG size) {
    322     return IAVIStream_WriteData(pas,fcc,lp,size);
    323 }
    324 
    325 /***********************************************************************
    326  *      AVIStreamRead (AVIFIL32.@)
     321        return IAVIStream_WriteData(pas,fcc,lp,size);
     322}
     323
     324/***********************************************************************
     325 *              AVIStreamRead (AVIFIL32.@)
    327326 */
    328327HRESULT WINAPI AVIStreamRead(PAVISTREAM pas,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread)
    329328{
    330     return IAVIStream_Read(pas,start,samples,buffer,buffersize,bytesread,samplesread);
    331 }
    332 
    333 /***********************************************************************
    334  *      AVIStreamWrite (AVIFIL32.@)
     329        return IAVIStream_Read(pas,start,samples,buffer,buffersize,bytesread,samplesread);
     330}
     331
     332/***********************************************************************
     333 *              AVIStreamWrite (AVIFIL32.@)
    335334 */
    336335HRESULT WINAPI AVIStreamWrite(PAVISTREAM pas,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
    337     return IAVIStream_Write(pas,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
    338 }
    339 
    340 
    341 /***********************************************************************
    342  *      AVIStreamStart (AVIFIL32.@)
     336        return IAVIStream_Write(pas,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
     337}
     338
     339
     340/***********************************************************************
     341 *              AVIStreamStart (AVIFIL32.@)
    343342 */
    344343LONG WINAPI AVIStreamStart(PAVISTREAM pas)
    345344{
    346     AVISTREAMINFOW  si;
    347     HRESULT         hr;
    348 
    349     hr = IAVIStream_Info(pas,&si,sizeof(si));
    350     if (hr != S_OK)
    351         return -1;
    352     return (LONG)si.dwStart;
    353 }
    354 
    355 /***********************************************************************
    356  *      AVIStreamLength (AVIFIL32.@)
     345        AVISTREAMINFOW  si;
     346        HRESULT                 hr;
     347
     348        hr = IAVIStream_Info(pas,&si,sizeof(si));
     349        if (hr != S_OK)
     350                return -1;
     351        return (LONG)si.dwStart;
     352}
     353
     354/***********************************************************************
     355 *              AVIStreamLength (AVIFIL32.@)
    357356 */
    358357LONG WINAPI AVIStreamLength(PAVISTREAM pas)
    359358{
    360     AVISTREAMINFOW  si;
    361     HRESULT         hr;
    362 
    363     hr = IAVIStream_Info(pas,&si,sizeof(si));
    364     if (hr != S_OK)
    365         return -1;
    366     return (LONG)si.dwLength;
    367 }
    368 
    369 /***********************************************************************
    370  *      AVIStreamTimeToSample (AVIFIL32.@)
     359        AVISTREAMINFOW  si;
     360        HRESULT                 hr;
     361
     362        hr = IAVIStream_Info(pas,&si,sizeof(si));
     363        if (hr != S_OK)
     364                return -1;
     365        return (LONG)si.dwLength;
     366}
     367
     368/***********************************************************************
     369 *              AVIStreamTimeToSample (AVIFIL32.@)
    371370 */
    372371LONG WINAPI AVIStreamTimeToSample(PAVISTREAM pas,LONG lTime)
    373372{
    374     AVISTREAMINFOW  si;
    375     HRESULT         hr;
    376 
    377     hr = IAVIStream_Info(pas,&si,sizeof(si));
    378     if (hr != S_OK)
    379         return -1;
    380 
    381     /* I am too lazy... */
    382     FIXME("(%p,%ld)",pas,lTime);
    383     return (LONG)-1L;
    384 }
    385 
    386 /***********************************************************************
    387  *      AVIStreamSampleToTime (AVIFIL32.@)
     373        AVISTREAMINFOW  si;
     374        HRESULT                 hr;
     375
     376        hr = IAVIStream_Info(pas,&si,sizeof(si));
     377        if (hr != S_OK)
     378                return -1;
     379
     380        /* I am too lazy... */
     381        FIXME("(%p,%ld)",pas,lTime);
     382        return (LONG)-1L;
     383}
     384
     385/***********************************************************************
     386 *              AVIStreamSampleToTime (AVIFIL32.@)
    388387 */
    389388LONG WINAPI AVIStreamSampleToTime(PAVISTREAM pas,LONG lSample)
    390389{
    391     AVISTREAMINFOW  si;
    392     HRESULT         hr;
    393 
    394     hr = IAVIStream_Info(pas,&si,sizeof(si));
    395     if (hr != S_OK)
    396         return -1;
    397 
    398     /* I am too lazy... */
    399     FIXME("(%p,%ld)",pas,lSample);
    400     return (LONG)-1L;
    401 }
    402 
    403 /***********************************************************************
    404  *      AVIStreamBeginStreaming (AVIFIL32.@)
     390        AVISTREAMINFOW  si;
     391        HRESULT                 hr;
     392
     393        hr = IAVIStream_Info(pas,&si,sizeof(si));
     394        if (hr != S_OK)
     395                return -1;
     396
     397        /* I am too lazy... */
     398        FIXME("(%p,%ld)",pas,lSample);
     399        return (LONG)-1L;
     400}
     401
     402/***********************************************************************
     403 *              AVIStreamBeginStreaming (AVIFIL32.@)
    405404 */
    406405HRESULT WINAPI AVIStreamBeginStreaming(PAVISTREAM pas,LONG lStart,LONG lEnd,LONG lRate)
    407406{
    408     FIXME("(%p)->(%ld,%ld,%ld),stub!\n",pas,lStart,lEnd,lRate);
    409     return E_FAIL;
    410 }
    411 
    412 /***********************************************************************
    413  *      AVIStreamEndStreaming (AVIFIL32.@)
     407        FIXME("(%p)->(%ld,%ld,%ld),stub!\n",pas,lStart,lEnd,lRate);
     408        return E_FAIL;
     409}
     410
     411/***********************************************************************
     412 *              AVIStreamEndStreaming (AVIFIL32.@)
    414413 */
    415414HRESULT WINAPI AVIStreamEndStreaming(PAVISTREAM pas)
    416415{
    417     FIXME("(%p)->(),stub!\n",pas);
    418     return E_FAIL;
    419 }
    420 
    421 /***********************************************************************
    422  *      AVIStreamGetFrameOpen (AVIFIL32.@)
     416        FIXME("(%p)->(),stub!\n",pas);
     417        return E_FAIL;
     418}
     419
     420/***********************************************************************
     421 *              AVIStreamGetFrameOpen (AVIFIL32.@)
    423422 */
    424423PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pas,LPBITMAPINFOHEADER pbi)
    425424{
    426     IGetFrame*  pgf;
    427     HRESULT     hr;
    428     AVISTREAMINFOW  si;
    429 
    430     FIXME("(%p,%p)\n",pas,pbi);
    431 
    432     hr = IAVIStream_Info(pas,&si,sizeof(si));
    433     if (hr != S_OK)
    434         return NULL;
    435 
    436     hr = AVIFILE_CreateIGetFrame((void**)&pgf,pas,pbi);
    437     if ( hr != S_OK )
    438         return NULL;
    439     hr = IGetFrame_Begin( pgf, si.dwStart, si.dwLength, 1000 );
    440     if ( hr != S_OK )
    441     {
    442         IGetFrame_Release( pgf );
    443         return NULL;
    444     }
    445 
    446     return pgf;
    447 }
    448 
    449 /***********************************************************************
    450  *      AVIStreamGetFrame (AVIFIL32.@)
     425        IGetFrame*      pgf;
     426        HRESULT         hr;
     427        AVISTREAMINFOW  si;
     428
     429        FIXME("(%p,%p)\n",pas,pbi);
     430
     431        hr = IAVIStream_Info(pas,&si,sizeof(si));
     432        if (hr != S_OK)
     433                return NULL;
     434
     435        hr = AVIFILE_CreateIGetFrame((void**)&pgf,pas,pbi);
     436        if ( hr != S_OK )
     437                return NULL;
     438        hr = IGetFrame_Begin( pgf, si.dwStart, si.dwLength, 1000 );
     439        if ( hr != S_OK )
     440        {
     441                IGetFrame_Release( pgf );
     442                return NULL;
     443        }
     444
     445        return pgf;
     446}
     447
     448/***********************************************************************
     449 *              AVIStreamGetFrame (AVIFIL32.@)
    451450 */
    452451LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pgf, LONG lPos)
    453452{
    454     return IGetFrame_GetFrame(pgf,lPos);
    455 }
    456 
    457 /***********************************************************************
    458  *      AVIStreamGetFrameClose (AVIFIL32.@)
     453        return IGetFrame_GetFrame(pgf,lPos);
     454}
     455
     456/***********************************************************************
     457 *              AVIStreamGetFrameClose (AVIFIL32.@)
    459458 */
    460459HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pgf)
    461460{
    462     return IGetFrame_End(pgf);
    463 }
    464 
    465 /***********************************************************************
    466  *      AVIStreamOpenFromFileA (AVIFIL32.@)
     461        return IGetFrame_End(pgf);
     462}
     463
     464/***********************************************************************
     465 *              AVIStreamOpenFromFileA (AVIFIL32.@)
    467466 */
    468467HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM* ppas, LPCSTR szFile, DWORD fccType, LONG lParam, UINT uMode, CLSID* lpHandler)
    469468{
    470     WCHAR*  pwsz;
    471     HRESULT hr;
    472 
    473     pwsz = AVIFILE_strdupAtoW( szFile );
    474     if ( pwsz == NULL )
    475         return AVIERR_MEMORY;
    476     hr = AVIStreamOpenFromFileW(ppas,pwsz,fccType,lParam,uMode,lpHandler);
    477     HeapFree( AVIFILE_data.hHeap, 0, pwsz );
    478     return hr;
    479 }
    480 
    481 /***********************************************************************
    482  *      AVIStreamOpenFromFileW (AVIFIL32.@)
     469        WCHAR*  pwsz;
     470        HRESULT hr;
     471
     472        pwsz = AVIFILE_strdupAtoW( szFile );
     473        if ( pwsz == NULL )
     474                return AVIERR_MEMORY;
     475        hr = AVIStreamOpenFromFileW(ppas,pwsz,fccType,lParam,uMode,lpHandler);
     476        HeapFree( AVIFILE_data.hHeap, 0, pwsz );
     477        return hr;
     478}
     479
     480/***********************************************************************
     481 *              AVIStreamOpenFromFileW (AVIFIL32.@)
    483482 */
    484483HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM* ppas, LPCWSTR szFile, DWORD fccType, LONG lParam, UINT uMode, CLSID* lpHandler)
    485484{
    486     HRESULT hr;
    487     PAVIFILE    paf;
    488     AVIFILEINFOW    fi;
    489 
    490     *ppas = NULL;
    491     hr = AVIFileOpenW(&paf,szFile,uMode,lpHandler);
    492     if ( hr != S_OK )
    493         return hr;
    494     hr = AVIFileInfoW(paf,&fi,sizeof(AVIFILEINFOW));
    495     if ( hr == S_OK )
    496         hr = AVIFileGetStream(paf,ppas,fccType,lParam);
    497 
    498     IAVIFile_Release(paf);
    499 
    500     return hr;
    501 }
    502 
    503 /***********************************************************************
    504  *      AVIStreamCreate (AVIFIL32.@)
     485        HRESULT hr;
     486        PAVIFILE        paf;
     487        AVIFILEINFOW    fi;
     488
     489        *ppas = NULL;
     490        hr = AVIFileOpenW(&paf,szFile,uMode,lpHandler);
     491        if ( hr != S_OK )
     492                return hr;
     493        hr = AVIFileInfoW(paf,&fi,sizeof(AVIFILEINFOW));
     494        if ( hr == S_OK )
     495                hr = AVIFileGetStream(paf,ppas,fccType,lParam);
     496
     497        IAVIFile_Release(paf);
     498
     499        return hr;
     500}
     501
     502/***********************************************************************
     503 *              AVIStreamCreate (AVIFIL32.@)
    505504 */
    506505HRESULT WINAPI AVIStreamCreate(PAVISTREAM* ppas, LONG lParam1, LONG lParam2, CLSID* lpHandler)
    507506{
    508     HRESULT hr;
    509     IClassFactory*  pcf;
    510 
    511     *ppas = NULL;
    512 
    513     if ( lpHandler == NULL )
    514     {
    515         hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
    516                            &IID_IClassFactory,(void**)&pcf);
    517     }
    518     else
    519     {
    520         if ( !AVIFILE_data.fInitCOM )
    521             return E_UNEXPECTED;
    522         hr = CoGetClassObject(lpHandler,CLSCTX_INPROC_SERVER,
    523                       NULL,&IID_IClassFactory,(void**)&pcf);
    524     }
    525     if ( hr != S_OK )
    526         return hr;
    527 
    528     hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIStream,
    529                        (void**)ppas );
    530     IClassFactory_Release( pcf );
    531 
    532     if ( hr == S_OK )
    533     {
    534         hr = IAVIStream_Create((*ppas),lParam1,lParam2);
    535         if ( hr != S_OK )
    536         {
    537             IAVIStream_Release((*ppas));
    538             *ppas = NULL;
    539         }
    540     }
    541 
    542     return hr;
    543 }
    544 
    545 /***********************************************************************
    546  *      AVIMakeCompressedStream (AVIFIL32.@)
     507        HRESULT hr;
     508        IClassFactory*  pcf;
     509
     510        *ppas = NULL;
     511
     512        if ( lpHandler == NULL )
     513        {
     514                hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
     515                                               &IID_IClassFactory,(void**)&pcf);
     516        }
     517        else
     518        {
     519                if ( !AVIFILE_data.fInitCOM )
     520                        return E_UNEXPECTED;
     521                hr = CoGetClassObject(lpHandler,CLSCTX_INPROC_SERVER,
     522                                      NULL,&IID_IClassFactory,(void**)&pcf);
     523        }
     524        if ( hr != S_OK )
     525                return hr;
     526
     527        hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIStream,
     528                                           (void**)ppas );
     529        IClassFactory_Release( pcf );
     530
     531        if ( hr == S_OK )
     532        {
     533                hr = IAVIStream_Create((*ppas),lParam1,lParam2);
     534                if ( hr != S_OK )
     535                {
     536                        IAVIStream_Release((*ppas));
     537                        *ppas = NULL;
     538                }
     539        }
     540
     541        return hr;
     542}
     543
     544/***********************************************************************
     545 *              AVIMakeCompressedStream (AVIFIL32.@)
    547546 */
    548547HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *aco,CLSID *pclsidHandler)
    549548{
    550     FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
    551     return E_FAIL;
    552 }
    553 
     549        FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
     550        return E_FAIL;
     551}
     552

  • trunk/src/avifil32/comentry.c

    r6644 r6712  
    1 /* $Id: comentry.c,v 1.2 2001-09-05 12:00:53 bird Exp $
    2  *
     1/*
    32 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    43 */
    … …  
    2827static ICOM_VTABLE(IClassFactory) iclassfact =
    2928{
    30     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    31     IClassFactory_fnQueryInterface,
    32     IClassFactory_fnAddRef,
    33     IClassFactory_fnRelease,
    34     IClassFactory_fnCreateInstance,
    35     IClassFactory_fnLockServer
     29        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
     30        IClassFactory_fnQueryInterface,
     31        IClassFactory_fnAddRef,
     32        IClassFactory_fnRelease,
     33        IClassFactory_fnCreateInstance,
     34        IClassFactory_fnLockServer
    3635};
    3736
    3837typedef struct
    3938{
    40     /* IUnknown fields */
    41     ICOM_VFIELD(IClassFactory);
    42     DWORD   ref;
     39        /* IUnknown fields */
     40        ICOM_VFIELD(IClassFactory);
     41        DWORD   ref;
    4342} IClassFactoryImpl;
    4443
    … …  
    5049IClassFactory_fnQueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
    5150{
    52     ICOM_THIS(IClassFactoryImpl,iface);
     51        ICOM_THIS(IClassFactoryImpl,iface);
    5352
    54     TRACE("(%p)->(%p,%p)\n",This,riid,ppobj);
    55     if ( ( IsEqualGUID( &IID_IUnknown, riid ) ) ||
    56          ( IsEqualGUID( &IID_IClassFactory, riid ) ) )
    57     {
    58         *ppobj = iface;
    59         IClassFactory_AddRef(iface);
    60         return S_OK;
    61     }
     53        TRACE("(%p)->(%p,%p)\n",This,riid,ppobj);
     54        if ( ( IsEqualGUID( &IID_IUnknown, riid ) ) ||
     55             ( IsEqualGUID( &IID_IClassFactory, riid ) ) )
     56        {
     57                *ppobj = iface;
     58                IClassFactory_AddRef(iface);
     59                return S_OK;
     60        }
    6261
    63     return E_NOINTERFACE;
     62        return E_NOINTERFACE;
    6463}
    6564
    6665static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface)
    6766{
    68     ICOM_THIS(IClassFactoryImpl,iface);
     67        ICOM_THIS(IClassFactoryImpl,iface);
    6968
    70     TRACE("(%p)->()\n",This);
    71     if ( (This->ref) == 0 )
    72         AVIFILE_data.dwClassObjRef ++;
     69        TRACE("(%p)->()\n",This);
     70        if ( (This->ref) == 0 )
     71                AVIFILE_data.dwClassObjRef ++;
    7372
    74     return ++(This->ref);
     73        return ++(This->ref);
    7574}
    7675
    7776static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface)
    7877{
    79     ICOM_THIS(IClassFactoryImpl,iface);
     78        ICOM_THIS(IClassFactoryImpl,iface);
    8079
    81     TRACE("(%p)->()\n",This);
    82     if ( (--(This->ref)) > 0 )
    83         return This->ref;
     80        TRACE("(%p)->()\n",This);
     81        if ( (--(This->ref)) > 0 )
     82                return This->ref;
    8483
    85     AVIFILE_data.dwClassObjRef --;
    86     return 0;
     84        AVIFILE_data.dwClassObjRef --;
     85        return 0;
    8786}
    8887
    … …  
    9190    /*ICOM_THIS(IClassFactoryImpl,iface);*/
    9291
    93     *ppobj = NULL;
    94     if ( pOuter != NULL )
    95         return E_FAIL;
     92        *ppobj = NULL;
     93        if ( pOuter != NULL )
     94                return E_FAIL;
    9695
    97     if ( IsEqualGUID( &IID_IAVIFile, riid ) )
    98         return AVIFILE_CreateIAVIFile(ppobj);
    99     if ( IsEqualGUID( &IID_IAVIStream, riid ) )
    100         return AVIFILE_CreateIAVIStream(ppobj);
     96        if ( IsEqualGUID( &IID_IAVIFile, riid ) )
     97                return AVIFILE_CreateIAVIFile(ppobj);
     98        if ( IsEqualGUID( &IID_IAVIStream, riid ) )
     99                return AVIFILE_CreateIAVIStream(ppobj);
    101100
    102     return E_NOINTERFACE;
     101        return E_NOINTERFACE;
    103102}
    104103
    105104static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface,BOOL dolock)
    106105{
    107     ICOM_THIS(IClassFactoryImpl,iface);
    108     HRESULT hr;
     106        ICOM_THIS(IClassFactoryImpl,iface);
     107        HRESULT hr;
    109108
    110     FIXME("(%p)->(%d),stub!\n",This,dolock);
    111     if (dolock)
    112         hr = IClassFactory_AddRef(iface);
    113     else
    114         hr = IClassFactory_Release(iface);
     109        FIXME("(%p)->(%d),stub!\n",This,dolock);
     110        if (dolock)
     111                hr = IClassFactory_AddRef(iface);
     112        else
     113                hr = IClassFactory_Release(iface);
    115114
    116     return hr;
     115        return hr;
    117116}
    118117
    119118
    120119/***********************************************************************
    121  *      DllGetClassObject (AVIFIL32.@)
     120 *              DllGetClassObject (AVIFIL32.@)
    122121 */
    123122HRESULT WINAPI AVIFILE_DllGetClassObject(const CLSID* pclsid,const IID* piid,void** ppv)
    124123{
    125     *ppv = NULL;
    126     if ( IsEqualCLSID( &IID_IClassFactory, piid ) )
    127     {
    128         *ppv = (LPVOID)&AVIFILE_GlobalCF;
    129         IClassFactory_AddRef((IClassFactory*)*ppv);
    130         return S_OK;
    131     }
     124        *ppv = NULL;
     125        if ( IsEqualCLSID( &IID_IClassFactory, piid ) )
     126        {
     127                *ppv = (LPVOID)&AVIFILE_GlobalCF;
     128                IClassFactory_AddRef((IClassFactory*)*ppv);
     129                return S_OK;
     130        }
    132131
    133     return CLASS_E_CLASSNOTAVAILABLE;
     132        return CLASS_E_CLASSNOTAVAILABLE;
    134133}
    135134
    136135/*****************************************************************************
    137  *      DllCanUnloadNow (AVIFIL32.@)
     136 *              DllCanUnloadNow (AVIFIL32.@)
    138137 */
    139138DWORD WINAPI AVIFILE_DllCanUnloadNow(void)
    140139{
    141     return ( AVIFILE_data.dwClassObjRef == 0 ) ? S_OK : S_FALSE;
     140        return ( AVIFILE_data.dwClassObjRef == 0 ) ? S_OK : S_FALSE;
    142141}
    143142

  • trunk/src/avifil32/guid.c

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

  • trunk/src/avifil32/iafile.c

    r6652 r6712  
    1 /* $Id: iafile.c,v 1.2 2001-09-05 14:16:44 bird Exp $ */
    21/*
    32 * Copyright 1999 Marcus Meissner
    … …  
    2120DEFAULT_DEBUG_CHANNEL(avifile);
    2221
    23 #define AVIFILE_STREAMS_MAX 4
     22#define AVIFILE_STREAMS_MAX     4
    2423
    2524
    … …  
    5352typedef struct IAVIFileImpl
    5453{
    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];
     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];
    7271} IAVIFileImpl;
    7372
    … …  
    7877
    7978static HRESULT AVIFILE_IAVIFile_ReadNextChunkHeader(
    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;
     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;
    9594}
    9695
    9796static HRESULT AVIFILE_IAVIFile_SkipChunkData(
    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;
     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;
    113112}
    114113
    115114static HRESULT AVIFILE_IAVIFile_ReadChunkData(
    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 );
     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 );
    126125}
    127126
    128127static HRESULT AVIFILE_IAVIFile_SeekToSpecifiedChunk(
    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     }
     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        }
    159158}
    160159
    … …  
    162161WINE_AVISTREAM_DATA* AVIFILE_Alloc_IAVIStreamData( DWORD dwFmtLen )
    163162{
    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;
     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;
    185184}
    186185
    187186void AVIFILE_Free_IAVIStreamData( WINE_AVISTREAM_DATA* pData )
    188187{
    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     }
     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        }
    195194}
    196195
    197196static void AVIFILE_IAVIFile_InitIndexTable(
    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,
     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,
    226225                            (int)(pIndexData[dwIndex].ckid>> 8)&0xff,
    227226                            (int)(pIndexData[dwIndex].ckid>>16)&0xff,
    228227                            (int)(pIndexData[dwIndex].ckid>>24)&0xff );
    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         }
     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                }
    238237                FIXME( "pIndexBuf = %p\n", pIndexBuf );
    239     }
    240     This->pStreamIndexEntry[This->hdr.dwStreams] = pIndexBuf;
     238        }
     239        This->pStreamIndexEntry[This->hdr.dwStreams] = pIndexBuf;
    241240}
    242241
    … …  
    251250HRESULT AVIFILE_CreateIAVIFile(void** ppobj)
    252251{
    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;
     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;
    275274}
    276275
    … …  
    280279
    281280static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile* iface,REFIID refiid,LPVOID *obj) {
    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;
     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;
    293292}
    294293
    295294static ULONG WINAPI IAVIFile_fnAddRef(IAVIFile* iface) {
    296     ICOM_THIS(IAVIFileImpl,iface);
    297 
    298     TRACE("(%p)->AddRef()\n",iface);
    299     return ++(This->ref);
     295        ICOM_THIS(IAVIFileImpl,iface);
     296
     297        TRACE("(%p)->AddRef()\n",iface);
     298        return ++(This->ref);
    300299}
    301300
    302301static ULONG WINAPI IAVIFile_fnRelease(IAVIFile* iface) {
    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;
     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;
    312311}
    313312
    … …  
    318317static HRESULT AVIFILE_IAVIFile_Construct( IAVIFileImpl* This )
    319318{
    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;
     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;
    336335}
    337336
    338337static void AVIFILE_IAVIFile_Destruct( IAVIFileImpl* This )
    339338{
    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 --;
     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 --;
    361360}
    362361
    363362static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile*iface,AVIFILEINFOW*afi,LONG size)
    364363{
    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;
     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;
    389388}
    390389
    391390static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam)
    392391{
    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;
     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;
    404403}
    405404
    406405static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi)
    407406{
    408     ICOM_THIS(IAVIFileImpl,iface);
    409 
    410     FIXME("(%p,%p,%p)\n",This,avis,asi);
    411     return E_FAIL;
     407        ICOM_THIS(IAVIFileImpl,iface);
     408
     409        FIXME("(%p,%p,%p)\n",This,avis,asi);
     410        return E_FAIL;
    412411}
    413412
    414413static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG size)
    415414{
    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;
     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;
    421420}
    422421
    423422static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG *size)
    424423{
    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;
     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;
    431430}
    432431
    433432static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile*iface)
    434433{
    435     ICOM_THIS(IAVIFileImpl,iface);
    436 
    437     FIXME("(%p)->EndRecord()\n",This);
    438     /* FIXME: end record? */
    439     return E_FAIL;
     434        ICOM_THIS(IAVIFileImpl,iface);
     435
     436        FIXME("(%p)->EndRecord()\n",This);
     437        /* FIXME: end record? */
     438        return E_FAIL;
    440439}
    441440
    442441static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG lParam)
    443442{
    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;
     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;
    449448}
    450449
    451450/*****************************************************************************
    452  *  AVIFILE_IAVIFile_Open (internal)
     451 *      AVIFILE_IAVIFile_Open (internal)
    453452 */
    454453HRESULT AVIFILE_IAVIFile_Open( PAVIFILE paf, LPCWSTR szFile, UINT uMode )
    455454{
    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;
     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;
    691690}
    692691
    693692/*****************************************************************************
    694  *  AVIFILE_IAVIFile_GetIndexTable (internal)
     693 *      AVIFILE_IAVIFile_GetIndexTable (internal)
    695694 */
    696695HRESULT AVIFILE_IAVIFile_GetIndexTable( PAVIFILE paf, DWORD dwStreamIndex,
    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;
     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;
    716715}
    717716
    718717/*****************************************************************************
    719  *  AVIFILE_IAVIFile_ReadMovieData (internal)
     718 *      AVIFILE_IAVIFile_ReadMovieData (internal)
    720719 */
    721720HRESULT AVIFILE_IAVIFile_ReadMovieData( PAVIFILE paf, DWORD dwOffset,
    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 
     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

  • trunk/src/avifil32/iastream.c

    r6652 r6712  
    1 /* $Id: iastream.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
    21/*
    32 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    5655typedef struct IAVIStreamImpl
    5756{
    58     ICOM_VFIELD(IAVIStream);
    59     /* IUnknown stuff */
    60     DWORD       ref;
    61     /* IAVIStream stuff */
    62     IAVIFile*       paf;
    63     WINE_AVISTREAM_DATA*    pData;
     57        ICOM_VFIELD(IAVIStream);
     58        /* IUnknown stuff */
     59        DWORD           ref;
     60        /* IAVIStream stuff */
     61        IAVIFile*               paf;
     62        WINE_AVISTREAM_DATA*    pData;
    6463} IAVIStreamImpl;
    6564
    … …  
    6968HRESULT AVIFILE_CreateIAVIStream(void** ppobj)
    7069{
    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;
     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;
    8988}
    9089
    … …  
    9594
    9695static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj) {
    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;
     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;
    110109}
    111110
    112111static ULONG WINAPI IAVIStream_fnAddRef(IAVIStream*iface) {
    113     ICOM_THIS(IAVIStreamImpl,iface);
    114 
    115     TRACE("(%p)->AddRef()\n",iface);
    116     return ++(This->ref);
     112        ICOM_THIS(IAVIStreamImpl,iface);
     113
     114        TRACE("(%p)->AddRef()\n",iface);
     115        return ++(This->ref);
    117116}
    118117
    119118static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface) {
    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;
     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;
    129128}
    130129
    … …  
    135134static HRESULT IAVIStream_Construct( IAVIStreamImpl* This )
    136135{
    137     This->paf = NULL;
    138     This->pData = NULL;
    139 
    140     AVIFILE_data.dwClassObjRef ++;
    141 
    142     return S_OK;
     136        This->paf = NULL;
     137        This->pData = NULL;
     138
     139        AVIFILE_data.dwClassObjRef ++;
     140
     141        return S_OK;
    143142}
    144143
    145144static void IAVIStream_Destruct( IAVIStreamImpl* This )
    146145{
    147     AVIFILE_data.dwClassObjRef --;
     146        AVIFILE_data.dwClassObjRef --;
    148147}
    149148
    150149static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2)
    151150{
    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;
     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;
    160159}
    161160
    162161static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size)
    163162{
    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;
     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;
    199198}
    200199
    201200static LONG WINAPI IAVIStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags)
    202201{
    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;
     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;
    299298}
    300299
    301300static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize) {
    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;
     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;
    321320}
    322321
    323322static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize) {
    324     ICOM_THIS(IAVIStreamImpl,iface);
    325 
    326     FIXME("(%p)->SetFormat(%ld,%p,%ld)\n",This,pos,format,formatsize);
    327     return E_FAIL;
     323        ICOM_THIS(IAVIStreamImpl,iface);
     324
     325        FIXME("(%p)->SetFormat(%ld,%p,%ld)\n",This,pos,format,formatsize);
     326        return E_FAIL;
    328327}
    329328
    330329static HRESULT WINAPI IAVIStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread) {
    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;
     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;
    383382}
    384383
    385384static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
    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;
     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;
    391390}
    392391
    393392static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples) {
    394     ICOM_THIS(IAVIStreamImpl,iface);
    395 
    396     FIXME("(%p)->Delete(%ld,%ld)\n",This,start,samples);
    397     return E_FAIL;
     393        ICOM_THIS(IAVIStreamImpl,iface);
     394
     395        FIXME("(%p)->Delete(%ld,%ld)\n",This,start,samples);
     396        return E_FAIL;
    398397}
    399398static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread) {
    400     ICOM_THIS(IAVIStreamImpl,iface);
    401 
    402     FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,fcc,lp,lpread);
    403     return E_FAIL;
     399        ICOM_THIS(IAVIStreamImpl,iface);
     400
     401        FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,fcc,lp,lpread);
     402        return E_FAIL;
    404403}
    405404
    406405static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size) {
    407     ICOM_THIS(IAVIStreamImpl,iface);
    408 
    409     FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,fcc,lp,size);
    410     return E_FAIL;
     406        ICOM_THIS(IAVIStreamImpl,iface);
     407
     408        FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,fcc,lp,size);
     409        return E_FAIL;
    411410}
    412411
    413412static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen) {
    414     ICOM_THIS(IAVIStreamImpl,iface);
    415 
    416     FIXME("(%p)->SetInfo(%p,%ld)\n",This,info,infolen);
    417 
    418     return E_FAIL;
    419 }
    420 
     413        ICOM_THIS(IAVIStreamImpl,iface);
     414
     415        FIXME("(%p)->SetInfo(%p,%ld)\n",This,info,infolen);
     416
     417        return E_FAIL;
     418}
     419

  • trunk/src/avifil32/igframe.c

    r6652 r6712  
    1 /* $Id: igframe.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
    21/*
    32 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    3029struct ICOM_VTABLE(IGetFrame) igetfrm = {
    3130    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    32     IGetFrame_fnQueryInterface,
    33     IGetFrame_fnAddRef,
    34     IGetFrame_fnRelease,
    35     IGetFrame_fnGetFrame,
    36     IGetFrame_fnBegin,
    37     IGetFrame_fnEnd,
    38     IGetFrame_fnSetFormat,
     31        IGetFrame_fnQueryInterface,
     32        IGetFrame_fnAddRef,
     33        IGetFrame_fnRelease,
     34        IGetFrame_fnGetFrame,
     35        IGetFrame_fnBegin,
     36        IGetFrame_fnEnd,
     37        IGetFrame_fnSetFormat,
    3938};
    4039
    4140typedef struct IGetFrameImpl
    4241{
    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;
     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;
    5756} IGetFrameImpl;
    5857
    5958static HRESULT IGetFrame_Construct( IGetFrameImpl* This,
    60                     IAVIStream* pstr,
    61                     LPBITMAPINFOHEADER lpbi );
     59                                    IAVIStream* pstr,
     60                                    LPBITMAPINFOHEADER lpbi );
    6261static void IGetFrame_Destruct( IGetFrameImpl* This );
    6362
    … …  
    6766static LPVOID AVIFILE_IGetFrame_DecodeFrame(IGetFrameImpl* This,LONG lPos)
    6867{
    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;
     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;
    143142}
    144143
    … …  
    146145
    147146HRESULT AVIFILE_CreateIGetFrame(void** ppobj,
    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;
     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;
    168167}
    169168
    … …  
    174173static HRESULT WINAPI IGetFrame_fnQueryInterface(IGetFrame* iface,REFIID refiid,LPVOID *obj)
    175174{
    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;
     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;
    188187}
    189188
    190189static ULONG WINAPI IGetFrame_fnAddRef(IGetFrame* iface)
    191190{
    192     ICOM_THIS(IGetFrameImpl,iface);
    193 
    194     TRACE("(%p)->AddRef()\n",iface);
    195     return ++(This->ref);
     191        ICOM_THIS(IGetFrameImpl,iface);
     192
     193        TRACE("(%p)->AddRef()\n",iface);
     194        return ++(This->ref);
    196195}
    197196
    198197static ULONG WINAPI IGetFrame_fnRelease(IGetFrame* iface)
    199198{
    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;
     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;
    211210}
    212211
    … …  
    217216static LPVOID WINAPI IGetFrame_fnGetFrame(IGetFrame* iface,LONG lPos)
    218217{
    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;
     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;
    250249}
    251250
    252251static HRESULT WINAPI IGetFrame_fnBegin(IGetFrame* iface,LONG lStart,LONG lEnd,LONG lRate)
    253252{
    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;
     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;
    267266}
    268267
    269268static HRESULT WINAPI IGetFrame_fnEnd(IGetFrame* iface)
    270269{
    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;
     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;
    282281}
    283282
    284283static HRESULT WINAPI IGetFrame_fnSetFormat(IGetFrame* iface,LPBITMAPINFOHEADER lpbi,LPVOID lpBits,INT x,INT y,INT dx,INT dy)
    285284{
    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;
     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;
    359358}
    360359
    361360static HRESULT IGetFrame_Construct( IGetFrameImpl* This,
    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;
     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;
    385384}
    386385
    387386static void IGetFrame_Destruct( IGetFrameImpl* This )
    388387{
    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 }
     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}

  • trunk/src/avifil32/main.c

    r6652 r6712  
    1 /* $Id: main.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
    21/*
    32 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    2221
    2322/***********************************************************************
    24  *      AVIFILE_InitProcess (internal)
     23 *              AVIFILE_InitProcess (internal)
    2524 */
    2625static BOOL AVIFILE_InitProcess( void )
    2726{
    28     TRACE("()\n");
     27        TRACE("()\n");
    2928
    30     AVIFILE_data.dwAVIFileRef = 0;
    31     AVIFILE_data.dwClassObjRef = 0;
    32     AVIFILE_data.hHeap = (HANDLE)NULL;
     29        AVIFILE_data.dwAVIFileRef = 0;
     30        AVIFILE_data.dwClassObjRef = 0;
     31        AVIFILE_data.hHeap = (HANDLE)NULL;
    3332
    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     }
     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        }
    4039
    41     return TRUE;
     40        return TRUE;
    4241}
    4342
    4443/***********************************************************************
    45  *      AVIFILE_UninitProcess (internal)
     44 *              AVIFILE_UninitProcess (internal)
    4645 */
    4746static void AVIFILE_UninitProcess( void )
    4847{
    49     TRACE("()\n");
     48        TRACE("()\n");
    5049
    51     if ( AVIFILE_data.dwAVIFileRef != 0 )
    52         ERR( "you must call AVIFileExit()\n" );
     50        if ( AVIFILE_data.dwAVIFileRef != 0 )
     51                ERR( "you must call AVIFileExit()\n" );
    5352
    54     if ( AVIFILE_data.dwClassObjRef != 0 )
    55         ERR( "you must release some objects allocated from AVIFile.\n" );
     53        if ( AVIFILE_data.dwClassObjRef != 0 )
     54                ERR( "you must release some objects allocated from AVIFile.\n" );
    5655
    57     if ( AVIFILE_data.hHeap != (HANDLE)NULL )
    58     {
    59         HeapDestroy( AVIFILE_data.hHeap );
    60         AVIFILE_data.hHeap = (HANDLE)NULL;
    61     }
     56        if ( AVIFILE_data.hHeap != (HANDLE)NULL )
     57        {
     58                HeapDestroy( AVIFILE_data.hHeap );
     59                AVIFILE_data.hHeap = (HANDLE)NULL;
     60        }
    6261}
    6362
    6463/***********************************************************************
    65  *      AVIFILE_DllMain
     64 *              AVIFILE_DllMain
    6665 */
    6766BOOL WINAPI AVIFILE_DllMain(
    68     HINSTANCE hInstDLL,
    69     DWORD fdwReason,
    70     LPVOID lpvReserved )
     67        HINSTANCE hInstDLL,
     68        DWORD fdwReason,
     69        LPVOID lpvReserved )
    7170{
    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     }
     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        }
    8685
    87     return TRUE;
     86        return TRUE;
    8887}
    8988

  • trunk/src/avifil32/string.c

    r6652 r6712  
    1 /* $Id: string.c,v 1.2 2001-09-05 14:16:46 bird Exp $ */
    21/*
    32 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    2524INT AVIFILE_strlenAtoW( LPCSTR lpstr )
    2625{
    27     INT len;
     26        INT     len;
    2827
    29     len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, NULL, 0 );
    30     return ( len > 0 ) ? (len-1) : 0;
     28        len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, NULL, 0 );
     29        return ( len > 0 ) ? (len-1) : 0;
    3130}
    3231
    3332INT AVIFILE_strlenWtoA( LPCWSTR lpwstr )
    3433{
    35     INT len;
     34        INT     len;
    3635
    37     len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
    38                    NULL, 0, NULL, NULL );
    39     return ( len > 0 ) ? (len-1) : 0;
     36        len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
     37                                   NULL, 0, NULL, NULL );
     38        return ( len > 0 ) ? (len-1) : 0;
    4039}
    4140
    4241LPWSTR AVIFILE_strncpyAtoW( LPWSTR lpwstr, LPCSTR lpstr, INT wbuflen )
    4342{
    44     INT len;
     43        INT     len;
    4544
    46     len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, lpwstr, wbuflen );
    47     if ( len == 0 )
    48         *lpwstr = 0;
    49     return lpwstr;
     45        len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, lpwstr, wbuflen );
     46        if ( len == 0 )
     47                *lpwstr = 0;
     48        return lpwstr;
    5049}
    5150
    5251LPSTR AVIFILE_strncpyWtoA( LPSTR lpstr, LPCWSTR lpwstr, INT abuflen )
    5352{
    54     INT len;
     53        INT     len;
    5554
    56     len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
    57                    lpstr, abuflen, NULL, NULL );
    58     if ( len == 0 )
    59         *lpstr = 0;
    60     return lpstr;
     55        len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
     56                                   lpstr, abuflen, NULL, NULL );
     57        if ( len == 0 )
     58                *lpstr = 0;
     59        return lpstr;
    6160}
    6261
    6362LPWSTR AVIFILE_strdupAtoW( LPCSTR lpstr )
    6463{
    65     INT len;
    66     LPWSTR lpwstr = NULL;
     64        INT len;
     65        LPWSTR lpwstr = NULL;
    6766
    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     }
     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        }
    7574
    76     return lpwstr;
     75        return lpwstr;
    7776}
    7877
    7978LPSTR AVIFILE_strdupWtoA( LPCWSTR lpwstr )
    8079{
    81     INT len;
    82     LPSTR lpstr = NULL;
     80        INT len;
     81        LPSTR lpstr = NULL;
    8382
    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     }
     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        }
    9190
    92     return lpstr;
     91        return lpstr;
    9392}
    9493
Note: See TracChangeset for help on using the changeset viewer.