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

restored old version

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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}
Note: See TracChangeset for help on using the changeset viewer.