Ignore:
Timestamp:
Sep 5, 2001, 2:05:03 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/avifil32/api.c

    r6386 r6644  
    1 /*
     1/* $Id: api.c,v 1.2 2001-09-05 12:00:53 bird Exp $
     2 *
    23 * Copyright 1999 Marcus Meissner
    34 * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
    … …  
    2223
    2324/***********************************************************************
    24  *              AVIFileInit (AVIFILE.100)
    25  *              AVIFileInit (AVIFIL32.@)
     25 *      AVIFileInit (AVIFILE.100)
     26 *      AVIFileInit (AVIFIL32.@)
    2627 */
    2728void WINAPI AVIFileInit(void)
    2829{
    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.@)
     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.@)
    4344 */
    4445void WINAPI AVIFileExit(void)
    4546{
    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.@)
     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.@)
    6667 */
    6768ULONG WINAPI AVIFileAddRef(PAVIFILE pfile)
    6869{
    69         return IAVIFile_AddRef( pfile );
    70 }
    71 
    72 /***********************************************************************
    73  *              AVIFileRelease (AVIFILE.141)
    74  *              AVIFileRelease (AVIFIL32.@)
     70    return IAVIFile_AddRef( pfile );
     71}
     72
     73/***********************************************************************
     74 *      AVIFileRelease (AVIFILE.141)
     75 *      AVIFileRelease (AVIFIL32.@)
    7576 */
    7677ULONG WINAPI AVIFileRelease(PAVIFILE pfile)
    7778{
    78         return IAVIFile_Release( pfile );
    79 }
    80 
    81 /***********************************************************************
    82  *              AVIFileOpen  (AVIFILE.102)
    83  *              AVIFileOpenA (AVIFIL32.@)
     79    return IAVIFile_Release( pfile );
     80}
     81
     82/***********************************************************************
     83 *      AVIFileOpen  (AVIFILE.102)
     84 *      AVIFileOpenA (AVIFIL32.@)
    8485 */
    8586HRESULT WINAPI AVIFileOpenA(
    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.@)
     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.@)
    102103 */
    103104HRESULT WINAPI AVIFileOpenW(
    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.@)
     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.@)
    154155 */
    155156HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile,AVIFILEINFOW* pfi,LONG lSize)
    156157{
    157         return IAVIFile_Info( pfile, pfi, lSize );
    158 }
    159 
    160 /***********************************************************************
    161  *              AVIFileInfo  (AVIFIL32.@)
    162  *              AVIFileInfoA (AVIFIL32.@)
     158    return IAVIFile_Info( pfile, pfi, lSize );
     159}
     160
     161/***********************************************************************
     162 *      AVIFileInfo  (AVIFIL32.@)
     163 *      AVIFileInfoA (AVIFIL32.@)
    163164 */
    164165HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile,AVIFILEINFOA* pfi,LONG lSize)
    165166{
    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.@)
     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.@)
    185186 */
    186187HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile,PAVISTREAM* pas,DWORD fccType,LONG lParam)
    187188{
    188         return IAVIFile_GetStream(pfile,pas,fccType,lParam);
    189 }
    190 
    191 /***********************************************************************
    192  *              AVIFileCreateStreamW (AVIFIL32.@)
     189    return IAVIFile_GetStream(pfile,pas,fccType,lParam);
     190}
     191
     192/***********************************************************************
     193 *      AVIFileCreateStreamW (AVIFIL32.@)
    193194 */
    194195HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile,PAVISTREAM* ppas,AVISTREAMINFOW* pasi)
    195196{
    196         return IAVIFile_CreateStream(pfile,ppas,pasi);
    197 }
    198 
    199 /***********************************************************************
    200  *              AVIFileCreateStreamA (AVIFIL32.@)
     197    return IAVIFile_CreateStream(pfile,ppas,pasi);
     198}
     199
     200/***********************************************************************
     201 *      AVIFileCreateStreamA (AVIFIL32.@)
    201202 */
    202203HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile,PAVISTREAM* ppas,AVISTREAMINFOA* pasi)
    203204{
    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.@)
     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.@)
    219220 */
    220221HRESULT WINAPI AVIFileWriteData(
    221         PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LONG cbData )
    222 {
    223         return IAVIFile_WriteData( pfile,dwChunkId,lpvData,cbData );
    224 }
    225 
    226 /***********************************************************************
    227  *              AVIFileReadData (AVIFIL32.@)
     222    PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LONG cbData )
     223{
     224    return IAVIFile_WriteData( pfile,dwChunkId,lpvData,cbData );
     225}
     226
     227/***********************************************************************
     228 *      AVIFileReadData (AVIFIL32.@)
    228229 */
    229230HRESULT WINAPI AVIFileReadData(
    230         PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LPLONG pcbData )
    231 {
    232         return IAVIFile_ReadData( pfile,dwChunkId,lpvData,pcbData );
    233 }
    234 
    235 /***********************************************************************
    236  *              AVIFileEndRecord (AVIFIL32.@)
     231    PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LPLONG pcbData )
     232{
     233    return IAVIFile_ReadData( pfile,dwChunkId,lpvData,pcbData );
     234}
     235
     236/***********************************************************************
     237 *      AVIFileEndRecord (AVIFIL32.@)
    237238 */
    238239HRESULT WINAPI AVIFileEndRecord( PAVIFILE pfile )
    239240{
    240         return IAVIFile_EndRecord( pfile );
    241 }
    242 
    243 /***********************************************************************
    244  *              AVIStreamAddRef (AVIFIL32.@)
     241    return IAVIFile_EndRecord( pfile );
     242}
     243
     244/***********************************************************************
     245 *      AVIStreamAddRef (AVIFIL32.@)
    245246 */
    246247ULONG WINAPI AVIStreamAddRef(PAVISTREAM pas)
    247248{
    248         return IAVIStream_Release(pas);
    249 }
    250 
    251 /***********************************************************************
    252  *              AVIStreamRelease (AVIFIL32.@)
     249    return IAVIStream_Release(pas);
     250}
     251
     252/***********************************************************************
     253 *      AVIStreamRelease (AVIFIL32.@)
    253254 */
    254255ULONG WINAPI AVIStreamRelease(PAVISTREAM pas)
    255256{
    256         return IAVIStream_Release(pas);
    257 }
    258 
    259 /***********************************************************************
    260  *              AVIStreamInfoW (AVIFIL32.@)
     257    return IAVIStream_Release(pas);
     258}
     259
     260/***********************************************************************
     261 *      AVIStreamInfoW (AVIFIL32.@)
    261262 */
    262263HRESULT WINAPI AVIStreamInfoW(PAVISTREAM pas,AVISTREAMINFOW* psi,LONG lSize)
    263264{
    264         return IAVIStream_Info(pas,psi,lSize);
    265 }
    266 
    267 /***********************************************************************
    268  *              AVIStreamInfo  (AVIFIL32.@)
    269  *              AVIStreamInfoA (AVIFIL32.@)
     265    return IAVIStream_Info(pas,psi,lSize);
     266}
     267
     268/***********************************************************************
     269 *      AVIStreamInfo  (AVIFIL32.@)
     270 *      AVIStreamInfoA (AVIFIL32.@)
    270271 */
    271272HRESULT WINAPI AVIStreamInfoA(PAVISTREAM pas,AVISTREAMINFOA* psi,LONG lSize)
    272273{
    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.@)
     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.@)
    290291 */
    291292LONG WINAPI AVIStreamFindSample(PAVISTREAM pas,LONG lPos,LONG lFlags)
    292293{
    293         return IAVIStream_FindSample(pas,lPos,lFlags);
    294 }
    295 
    296 /***********************************************************************
    297  *              AVIStreamReadFormat (AVIFIL32.@)
     294    return IAVIStream_FindSample(pas,lPos,lFlags);
     295}
     296
     297/***********************************************************************
     298 *      AVIStreamReadFormat (AVIFIL32.@)
    298299 */
    299300HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM pas,LONG pos,LPVOID format,LONG *formatsize) {
    300         return IAVIStream_ReadFormat(pas,pos,format,formatsize);
    301 }
    302 
    303 /***********************************************************************
    304  *              AVIStreamSetFormat (AVIFIL32.@)
     301    return IAVIStream_ReadFormat(pas,pos,format,formatsize);
     302}
     303
     304/***********************************************************************
     305 *      AVIStreamSetFormat (AVIFIL32.@)
    305306 */
    306307HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM pas,LONG pos,LPVOID format,LONG formatsize) {
    307         return IAVIStream_SetFormat(pas,pos,format,formatsize);
    308 }
    309 
    310 /***********************************************************************
    311  *              AVIStreamReadData (AVIFIL32.@)
     308    return IAVIStream_SetFormat(pas,pos,format,formatsize);
     309}
     310
     311/***********************************************************************
     312 *      AVIStreamReadData (AVIFIL32.@)
    312313 */
    313314HRESULT WINAPI AVIStreamReadData(PAVISTREAM pas,DWORD fcc,LPVOID lp,LONG *lpread) {
    314         return IAVIStream_ReadData(pas,fcc,lp,lpread);
    315 }
    316 
    317 /***********************************************************************
    318  *              AVIStreamWriteData (AVIFIL32.@)
     315    return IAVIStream_ReadData(pas,fcc,lp,lpread);
     316}
     317
     318/***********************************************************************
     319 *      AVIStreamWriteData (AVIFIL32.@)
    319320 */
    320321HRESULT WINAPI AVIStreamWriteData(PAVISTREAM pas,DWORD fcc,LPVOID lp,LONG size) {
    321         return IAVIStream_WriteData(pas,fcc,lp,size);
    322 }
    323 
    324 /***********************************************************************
    325  *              AVIStreamRead (AVIFIL32.@)
     322    return IAVIStream_WriteData(pas,fcc,lp,size);
     323}
     324
     325/***********************************************************************
     326 *      AVIStreamRead (AVIFIL32.@)
    326327 */
    327328HRESULT WINAPI AVIStreamRead(PAVISTREAM pas,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread)
    328329{
    329         return IAVIStream_Read(pas,start,samples,buffer,buffersize,bytesread,samplesread);
    330 }
    331 
    332 /***********************************************************************
    333  *              AVIStreamWrite (AVIFIL32.@)
     330    return IAVIStream_Read(pas,start,samples,buffer,buffersize,bytesread,samplesread);
     331}
     332
     333/***********************************************************************
     334 *      AVIStreamWrite (AVIFIL32.@)
    334335 */
    335336HRESULT WINAPI AVIStreamWrite(PAVISTREAM pas,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
    336         return IAVIStream_Write(pas,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
    337 }
    338 
    339 
    340 /***********************************************************************
    341  *              AVIStreamStart (AVIFIL32.@)
     337    return IAVIStream_Write(pas,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
     338}
     339
     340
     341/***********************************************************************
     342 *      AVIStreamStart (AVIFIL32.@)
    342343 */
    343344LONG WINAPI AVIStreamStart(PAVISTREAM pas)
    344345{
    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.@)
     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.@)
    356357 */
    357358LONG WINAPI AVIStreamLength(PAVISTREAM pas)
    358359{
    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.@)
     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.@)
    370371 */
    371372LONG WINAPI AVIStreamTimeToSample(PAVISTREAM pas,LONG lTime)
    372373{
    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.@)
     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.@)
    387388 */
    388389LONG WINAPI AVIStreamSampleToTime(PAVISTREAM pas,LONG lSample)
    389390{
    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.@)
     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.@)
    404405 */
    405406HRESULT WINAPI AVIStreamBeginStreaming(PAVISTREAM pas,LONG lStart,LONG lEnd,LONG lRate)
    406407{
    407         FIXME("(%p)->(%ld,%ld,%ld),stub!\n",pas,lStart,lEnd,lRate);
    408         return E_FAIL;
    409 }
    410 
    411 /***********************************************************************
    412  *              AVIStreamEndStreaming (AVIFIL32.@)
     408    FIXME("(%p)->(%ld,%ld,%ld),stub!\n",pas,lStart,lEnd,lRate);
     409    return E_FAIL;
     410}
     411
     412/***********************************************************************
     413 *      AVIStreamEndStreaming (AVIFIL32.@)
    413414 */
    414415HRESULT WINAPI AVIStreamEndStreaming(PAVISTREAM pas)
    415416{
    416         FIXME("(%p)->(),stub!\n",pas);
    417         return E_FAIL;
    418 }
    419 
    420 /***********************************************************************
    421  *              AVIStreamGetFrameOpen (AVIFIL32.@)
     417    FIXME("(%p)->(),stub!\n",pas);
     418    return E_FAIL;
     419}
     420
     421/***********************************************************************
     422 *      AVIStreamGetFrameOpen (AVIFIL32.@)
    422423 */
    423424PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pas,LPBITMAPINFOHEADER pbi)
    424425{
    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.@)
     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.@)
    450451 */
    451452LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pgf, LONG lPos)
    452453{
    453         return IGetFrame_GetFrame(pgf,lPos);
    454 }
    455 
    456 /***********************************************************************
    457  *              AVIStreamGetFrameClose (AVIFIL32.@)
     454    return IGetFrame_GetFrame(pgf,lPos);
     455}
     456
     457/***********************************************************************
     458 *      AVIStreamGetFrameClose (AVIFIL32.@)
    458459 */
    459460HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pgf)
    460461{
    461         return IGetFrame_End(pgf);
    462 }
    463 
    464 /***********************************************************************
    465  *              AVIStreamOpenFromFileA (AVIFIL32.@)
     462    return IGetFrame_End(pgf);
     463}
     464
     465/***********************************************************************
     466 *      AVIStreamOpenFromFileA (AVIFIL32.@)
    466467 */
    467468HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM* ppas, LPCSTR szFile, DWORD fccType, LONG lParam, UINT uMode, CLSID* lpHandler)
    468469{
    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.@)
     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.@)
    482483 */
    483484HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM* ppas, LPCWSTR szFile, DWORD fccType, LONG lParam, UINT uMode, CLSID* lpHandler)
    484485{
    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.@)
     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.@)
    504505 */
    505506HRESULT WINAPI AVIStreamCreate(PAVISTREAM* ppas, LONG lParam1, LONG lParam2, CLSID* lpHandler)
    506507{
    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.@)
     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.@)
    546547 */
    547548HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *aco,CLSID *pclsidHandler)
    548549{
    549         FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
    550         return E_FAIL;
    551 }
    552 
     550    FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
     551    return E_FAIL;
     552}
     553
Note: See TracChangeset for help on using the changeset viewer.