git.oblomov.eu Git - wine/blob - dlls/avifil32/avifile.c

   1 /*
   2  * Copyright 1999 Marcus Meissner
   3  */
   4 #include <string.h>
   5 #include <stdio.h>
   6 #include <assert.h>
   7
   8 #include "winbase.h"
   9 #include "vfw.h"
  10 #include "wine/winestring.h"
  11 #include "driver.h"
  12 #include "mmsystem.h"
  13 #include "winerror.h"
  14 #include "debugstr.h"
  15 #include "debugtools.h"
  16
  17 DEFAULT_DEBUG_CHANNEL(avifile)
  18 DECLARE_DEBUG_CHANNEL(msvideo)
  19 DECLARE_DEBUG_CHANNEL(relay)
  20
  21 static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile* iface,REFIID refiid,LPVOID *obj);
  22 static ULONG WINAPI IAVIFile_fnAddRef(IAVIFile* iface);
  23 static ULONG WINAPI IAVIFile_fnRelease(IAVIFile* iface);
  24 static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile*iface,AVIFILEINFOW*afi,LONG size);
  25 static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam);
  26 static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi);
  27 static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG size);
  28 static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG *size);
  29 static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile*iface);
  30 static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG lParam);
  31
  32 struct ICOM_VTABLE(IAVIFile) iavift = {
  33     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
  34     IAVIFile_fnQueryInterface,
  35     IAVIFile_fnAddRef,
  36     IAVIFile_fnRelease,
  37     IAVIFile_fnInfo,
  38     IAVIFile_fnGetStream,
  39     IAVIFile_fnCreateStream,
  40     IAVIFile_fnWriteData,
  41     IAVIFile_fnReadData,
  42     IAVIFile_fnEndRecord,
  43     IAVIFile_fnDeleteStream
  44 };
  45
  46 static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj);
  47 static ULONG WINAPI IAVIStream_fnAddRef(IAVIStream*iface);
  48 static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface);
  49 static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2);
  50 static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size);
  51 static LONG WINAPI IAVIStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags);
  52 static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize);
  53 static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize);
  54 static HRESULT WINAPI IAVIStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread);
  55 static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
  56 static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples);
  57 static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread);
  58 static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size);
  59 static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen);
  60
  61 struct ICOM_VTABLE(IAVIStream) iavist = {
  62     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
  63     IAVIStream_fnQueryInterface,
  64     IAVIStream_fnAddRef,
  65     IAVIStream_fnRelease,
  66     IAVIStream_fnCreate,
  67     IAVIStream_fnInfo,
  68     IAVIStream_fnFindSample,
  69     IAVIStream_fnReadFormat,
  70     IAVIStream_fnSetFormat,
  71     IAVIStream_fnRead,
  72     IAVIStream_fnWrite,
  73     IAVIStream_fnDelete,
  74     IAVIStream_fnReadData,
  75     IAVIStream_fnWriteData,
  76     IAVIStream_fnSetInfo
  77 };
  78
  79 typedef struct IAVIStreamImpl {
  80         /* IUnknown stuff */
  81         ICOM_VFIELD(IAVIStream);
  82         DWORD           ref;
  83         /* IAVIStream stuff */
  84         LPVOID          lpInputFormat;
  85         DWORD           inputformatsize;
  86         BOOL            iscompressing;
  87         DWORD           curframe;
  88
  89             /* Compressor stuff */
  90             HIC hic;
  91             LPVOID      lpCompressFormat;
  92             ICINFO      icinfo;
  93             DWORD       compbufsize;
  94             LPVOID      compbuffer;
  95
  96             DWORD       decompbufsize;
  97             LPVOID      decompbuffer;
  98             LPVOID      decompformat;
  99             AVICOMPRESSOPTIONS  aco;
 100
 101             LPVOID      lpPrev; /* pointer to decompressed frame later */
 102             LPVOID      lpPrevFormat; /* pointer to decompressed info later */
 103 } IAVIStreamImpl;
 104
 105 void WINAPI
 106 AVIFileInit(void) {
 107         FIXME("(),stub!\n");
 108 }
 109
 110 typedef struct IAVIFileImpl {
 111         /* IUnknown stuff */
 112         ICOM_VFIELD(IAVIFile);
 113         DWORD                           ref;
 114         /* IAVIFile stuff... */
 115 } IAVIFileImpl;
 116
 117 static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile* iface,REFIID refiid,LPVOID *obj) {
 118         ICOM_THIS(IAVIFileImpl,iface);
 119         char    xrefiid[50];
 120
 121         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
 122         TRACE_(relay)("(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
 123         if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
 124                 !memcmp(&IID_IAVIFile,refiid,sizeof(IID_IAVIFile))
 125         ) {
 126                 *obj = iface;
 127                 return S_OK;
 128         }
 129         return OLE_E_ENUM_NOMORE;
 130 }
 131
 132 static ULONG WINAPI IAVIFile_fnAddRef(IAVIFile* iface) {
 133         ICOM_THIS(IAVIFileImpl,iface);
 134
 135         FIXME_(relay)("(%p)->AddRef()\n",iface);
 136         return ++(This->ref);
 137 }
 138
 139 static ULONG WINAPI IAVIFile_fnRelease(IAVIFile* iface) {
 140         ICOM_THIS(IAVIFileImpl,iface);
 141
 142         FIXME_(relay)("(%p)->Release()\n",iface);
 143         if (!--(This->ref)) {
 144                 HeapFree(GetProcessHeap(),0,iface);
 145                 return 0;
 146         }
 147         return This->ref;
 148 }
 149
 150 static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile*iface,AVIFILEINFOW*afi,LONG size) {
 151         FIXME("(%p)->Info(%p,%ld)\n",iface,afi,size);
 152
 153         /* FIXME: fill out struct? */
 154         return E_FAIL;
 155 }
 156
 157 static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam) {
 158         FIXME("(%p)->GetStream(%p,0x%08lx,%ld)\n",iface,avis,fccType,lParam);
 159         /* FIXME: create interface etc. */
 160         return E_FAIL;
 161 }
 162
 163 static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi) {
 164         ICOM_THIS(IAVIStreamImpl,iface);
 165         char            fcc[5];
 166         IAVIStreamImpl  *istream;
 167
 168         FIXME("(%p,%p,%p)\n",This,avis,asi);
 169         istream = (IAVIStreamImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IAVIStreamImpl));
 170         istream->ref = 1;
 171         ICOM_VTBL(istream) = &iavist;
 172         fcc[4]='\0';
 173         memcpy(fcc,(char*)&(asi->fccType),4);
 174         FIXME("\tfccType '%s'\n",fcc);
 175         memcpy(fcc,(char*)&(asi->fccHandler),4);
 176         FIXME("\tfccHandler '%s'\n",fcc);
 177         FIXME("\tdwFlags 0x%08lx\n",asi->dwFlags);
 178         FIXME("\tdwCaps 0x%08lx\n",asi->dwCaps);
 179         FIXME("\tname '%s'\n",debugstr_w(asi->szName));
 180
 181         istream->curframe = 0;
 182         *avis = (PAVISTREAM)istream;
 183         return S_OK;
 184 }
 185
 186 static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG size) {
 187         FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",iface,ckid,lpData,size);
 188         /* FIXME: write data to file */
 189         return E_FAIL;
 190 }
 191
 192 static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG *size) {
 193         FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",iface,ckid,lpData,size);
 194         /* FIXME: read at most size bytes from file */
 195         return E_FAIL;
 196 }
 197
 198 static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile*iface) {
 199         FIXME("(%p)->EndRecord()\n",iface);
 200         /* FIXME: end record? */
 201         return E_FAIL;
 202 }
 203
 204 static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG lParam) {
 205         FIXME("(%p)->DeleteStream(0x%08lx,%ld)\n",iface,fccType,lParam);
 206         /* FIXME: delete stream? */
 207         return E_FAIL;
 208 }
 209
 210 HRESULT WINAPI AVIFileOpenA(
 211         PAVIFILE * ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler
 212 ) {
 213         char    buf[80];
 214         IAVIFileImpl    *iavi;
 215
 216
 217         if (HIWORD(lpHandler))
 218                 WINE_StringFromCLSID(lpHandler,buf);
 219         else
 220                 sprintf(buf,"<clsid-0x%04lx>",(DWORD)lpHandler);
 221
 222         FIXME("(%p,%s,0x%08lx,%s),stub!\n",ppfile,szFile,(DWORD)uMode,buf);
 223         iavi = (IAVIFileImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IAVIFileImpl));
 224         iavi->ref = 1;
 225         ICOM_VTBL(iavi) = &iavift;
 226         *ppfile = (LPVOID)iavi;
 227         return S_OK;
 228 }
 229
 230 static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj) {
 231         ICOM_THIS(IAVIStreamImpl,iface);
 232         char    xrefiid[50];
 233
 234         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
 235         TRACE_(relay)("(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
 236         if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
 237                 !memcmp(&IID_IAVIStream,refiid,sizeof(IID_IAVIStream))
 238         ) {
 239                 *obj = This;
 240                 return S_OK;
 241         }
 242         /* can return IGetFrame interface too */
 243         return OLE_E_ENUM_NOMORE;
 244 }
 245
 246 static ULONG WINAPI IAVIStream_fnAddRef(IAVIStream*iface) {
 247         ICOM_THIS(IAVIStreamImpl,iface);
 248
 249         FIXME_(relay)("(%p)->AddRef()\n",iface);
 250         return ++(This->ref);
 251 }
 252
 253 static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface) {
 254         ICOM_THIS(IAVIStreamImpl,iface);
 255
 256         FIXME_(relay)("(%p)->Release()\n",iface);
 257         if (!--(This->ref)) {
 258                 HeapFree(GetProcessHeap(),0,This);
 259                 return 0;
 260         }
 261         return This->ref;
 262 }
 263
 264 static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2) {
 265         FIXME("(%p)->Create(0x%08lx,0x%08lx)\n",iface,lParam1,lParam2);
 266         return E_FAIL;
 267 }
 268
 269 static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size) {
 270         FIXME("(%p)->Info(%p,%ld)\n",iface,psi,size);
 271         return E_FAIL;
 272 }
 273
 274 static LONG WINAPI IAVIStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags) {
 275         FIXME("(%p)->FindSample(%ld,0x%08lx)\n",iface,pos,flags);
 276         return E_FAIL;
 277 }
 278
 279 static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize) {
 280         FIXME("(%p)->ReadFormat(%ld,%p,%p)\n",iface,pos,format,formatsize);
 281         return E_FAIL;
 282 }
 283
 284 /*****************************************************************************
 285  *                                              [IAVIStream::SetFormat]
 286  */
 287 static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize) {
 288         IAVIStreamImpl  *as = (IAVIStreamImpl*)iface;
 289
 290         FIXME("(%p)->SetFormat(%ld,%p,%ld)\n",iface,pos,format,formatsize);
 291         if (as->lpInputFormat) HeapFree(GetProcessHeap(),0,as->lpInputFormat);
 292         as->inputformatsize = formatsize;
 293         as->lpInputFormat = HeapAlloc(GetProcessHeap(),0,formatsize);
 294         memcpy(as->lpInputFormat,format,formatsize);
 295         if (as->iscompressing) {
 296                 int     xsize;
 297                 /* Set up the Compressor part */
 298                 xsize = ICCompressGetFormatSize(as->hic,as->lpInputFormat);
 299                 as->lpCompressFormat = HeapAlloc(GetProcessHeap(),0,xsize);
 300                 ICCompressGetFormat(as->hic,as->lpInputFormat,as->lpCompressFormat);
 301                 ICCompressBegin(as->hic,as->lpInputFormat,as->lpCompressFormat);
 302                 as->compbufsize = ICCompressGetSize(as->hic,as->lpInputFormat,as->lpCompressFormat);
 303                 as->compbuffer = HeapAlloc(GetProcessHeap(),0,as->compbufsize);
 304
 305                 /* Set up the Decompressor part (for prev frames?) */
 306                 xsize=ICDecompressGetFormatSize(as->hic,as->lpCompressFormat);
 307                 as->decompformat = HeapAlloc(GetProcessHeap(),0,xsize);
 308                 ICDecompressGetFormat(as->hic,as->lpCompressFormat,as->decompformat);
 309                 as->decompbufsize=((LPBITMAPINFOHEADER)as->decompbuffer)->biSizeImage;
 310                 as->decompbuffer = HeapReAlloc(GetProcessHeap(),0,as->decompbuffer,as->decompbufsize);
 311                 memset(as->decompbuffer,0xff,as->decompbufsize);
 312                 assert(HeapValidate(GetProcessHeap(),0,NULL));
 313
 314                 ICDecompressGetFormat(as->hic,as->lpCompressFormat,as->decompformat);
 315                 ICDecompressBegin(as->hic,as->lpCompressFormat,as->decompformat);
 316                 as->lpPrev = as->lpPrevFormat = NULL;
 317         }
 318         return S_OK;
 319 }
 320
 321 static HRESULT WINAPI IAVIStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread) {
 322         FIXME("(%p)->Read(%ld,%ld,%p,%ld,%p,%p)\n",iface,start,samples,buffer,buffersize,bytesread,samplesread);
 323         return E_FAIL;
 324 }
 325
 326 static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
 327         IAVIStreamImpl  *as = (IAVIStreamImpl*)iface;
 328         DWORD           ckid,xflags;
 329
 330         FIXME("(%p)->Write(%ld,%ld,%p,%ld,0x%08lx,%p,%p)\n",iface,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
 331
 332         ICCompress(
 333                 as->hic,flags,
 334                 as->lpCompressFormat,
 335                 as->compbuffer,
 336                 as->lpInputFormat,buffer,
 337                 &ckid,&xflags,
 338                 as->curframe,0xffffff/*framesize*/,as->aco.dwQuality,
 339                 as->lpPrevFormat,as->lpPrev
 340         );
 341         ICDecompress(
 342                 as->hic,
 343                 flags,  /* FIXME: check */
 344                 as->lpCompressFormat,
 345                 as->compbuffer,
 346                 as->decompformat,
 347                 as->decompbuffer
 348         );
 349         /* We now have a prev format for the next compress ... */
 350         as->lpPrevFormat = as->decompformat;
 351         as->lpPrev = as->decompbuffer;
 352         return S_OK;
 353 }
 354
 355 static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples) {
 356         FIXME("(%p)->Delete(%ld,%ld)\n",iface,start,samples);
 357         return E_FAIL;
 358 }
 359 static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread) {
 360         FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",iface,fcc,lp,lpread);
 361         return E_FAIL;
 362 }
 363
 364 static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size) {
 365         FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",iface,fcc,lp,size);
 366         return E_FAIL;
 367 }
 368
 369 static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen) {
 370         FIXME("(%p)->SetInfo(%p,%ld)\n",iface,info,infolen);
 371         return E_FAIL;
 372 }
 373
 374 HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE iface,PAVISTREAM *ppavi,AVISTREAMINFOA * psi) {
 375         AVISTREAMINFOW  psiw;
 376
 377         /* Only the szName at the end is different */
 378         memcpy(&psiw,psi,sizeof(*psi)-sizeof(psi->szName));
 379         lstrcpynAtoW(psiw.szName,psi->szName,sizeof(psi->szName));
 380         return IAVIFile_CreateStream(iface,ppavi,&psiw);
 381 }
 382
 383 HRESULT WINAPI AVIFileCreateStreamW(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi) {
 384         return IAVIFile_CreateStream(iface,avis,asi);
 385 }
 386
 387
 388 HRESULT WINAPI AVIFileGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam) {
 389         return IAVIFile_GetStream(iface,avis,fccType,lParam);
 390 }
 391
 392 HRESULT WINAPI AVIFileInfoA(PAVIFILE iface,LPAVIFILEINFOA afi,LONG size) {
 393         AVIFILEINFOW    afiw;
 394         HRESULT         hres;
 395
 396         if (size < sizeof(AVIFILEINFOA))
 397                 return AVIERR_BADSIZE;
 398         hres = IAVIFile_Info(iface,&afiw,sizeof(afiw));
 399         memcpy(afi,&afiw,sizeof(*afi)-sizeof(afi->szFileType));
 400         lstrcpynWtoA(afi->szFileType,afiw.szFileType,sizeof(afi->szFileType));
 401         return hres;
 402 }
 403
 404 HRESULT WINAPI AVIStreamInfoW(PAVISTREAM iface,AVISTREAMINFOW *asi,LONG
 405  size) {
 406         return IAVIFile_Info(iface,asi,size);
 407 }
 408
 409 HRESULT WINAPI AVIStreamInfoA(PAVISTREAM iface,AVISTREAMINFOA *asi,LONG
 410  size) {
 411         AVISTREAMINFOW  asiw;
 412         HRESULT                 hres;
 413
 414         if (size<sizeof(AVISTREAMINFOA))
 415                 return AVIERR_BADSIZE;
 416         hres = IAVIFile_Info(iface,&asiw,sizeof(asiw));
 417         memcpy(asi,&asiw,sizeof(asiw)-sizeof(asiw.szName));
 418         lstrcpynWtoA(asi->szName,asiw.szName,sizeof(asi->szName));
 419         return hres;
 420 }
 421
 422 HRESULT WINAPI AVIFileInfoW(PAVIFILE iface,LPAVIFILEINFOW afi,LONG size) {
 423         return IAVIFile_Info(iface,afi,size);
 424 }
 425
 426 HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *aco,CLSID *pclsidHandler) {
 427         char                    fcc[5];
 428         IAVIStreamImpl  *as;
 429         FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
 430         fcc[4]='\0';
 431         memcpy(fcc,&(aco->fccType),4);
 432         FIXME("\tfccType: '%s'\n",fcc);
 433         memcpy(fcc,&(aco->fccHandler),4);
 434         FIXME("\tfccHandler: '%s'\n",fcc);
 435         FIXME("\tdwFlags: 0x%08lx\n",aco->dwFlags);
 436
 437         /* we just create a duplicate for now */
 438         IAVIStream_AddRef(ppsSource);
 439         *ppsCompressed = ppsSource;
 440         as = (IAVIStreamImpl*)ppsSource;
 441
 442         /* this is where the fun begins. Open a compressor and prepare it. */
 443         as->hic = ICOpen(aco->fccType,aco->fccHandler,ICMODE_COMPRESS);
 444
 445         /* May happen. for instance if the codec is not able to compress */
 446         if (!as->hic)
 447                 return AVIERR_UNSUPPORTED;
 448
 449         ICGetInfo(as->hic,&(as->icinfo),sizeof(ICINFO));
 450         FIXME("Opened compressor: '%s' '%s'\n",debugstr_w(as->icinfo.szName),debugstr_w(as->icinfo.szDescription));
 451         as->iscompressing = TRUE;
 452         memcpy(&(as->aco),aco,sizeof(*aco));
 453         if (as->icinfo.dwFlags & VIDCF_COMPRESSFRAMES) {
 454                 ICCOMPRESSFRAMES        icf;
 455
 456                 /* now what to fill in there ... Hmm */
 457                 memset(&icf,0,sizeof(icf));
 458                 icf.lDataRate   = aco->dwBytesPerSecond;
 459                 icf.lQuality    = aco->dwQuality;
 460                 icf.lKeyRate    = aco->dwKeyFrameEvery;
 461
 462                 icf.GetData = (LONG (*)(LPARAM,LONG,LPVOID,LONG)) 0xdead4242;
 463                 icf.PutData = (LONG (*)(LPARAM,LONG,LPVOID,LONG)) 0xdead4243;
 464                 ICSendMessage(as->hic,ICM_COMPRESS_FRAMES_INFO,(LPARAM)&icf,sizeof(icf));
 465         }
 466         return S_OK;
 467 }
 468
 469 HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG formatsize) {
 470         return IAVIStream_SetFormat(iface,pos,format,formatsize);
 471 }
 472
 473 HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG *formatsize) {
 474         return IAVIStream_ReadFormat(iface,pos,format,formatsize);
 475 }
 476
 477 HRESULT WINAPI AVIStreamWrite(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
 478         return IAVIStream_Write(iface,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
 479 }
 480
 481 HRESULT WINAPI AVIStreamRead(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread) {
 482         return IAVIStream_Read(iface,start,samples,buffer,buffersize,bytesread,samplesread);
 483 }
 484
 485 HRESULT WINAPI AVIStreamWriteData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG size) {
 486         return IAVIStream_WriteData(iface,fcc,lp,size);
 487 }
 488
 489 HRESULT WINAPI AVIStreamReadData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG *lpread) {
 490         return IAVIStream_ReadData(iface,fcc,lp,lpread);
 491 }
 492
 493 LONG WINAPI AVIStreamStart(PAVISTREAM iface) {
 494         AVISTREAMINFOW  si;
 495
 496         IAVIStream_Info(iface,&si,sizeof(si));
 497         return si.dwStart;
 498 }
 499
 500 LONG WINAPI AVIStreamLength(PAVISTREAM iface) {
 501         AVISTREAMINFOW  si;
 502         HRESULT                 ret;
 503
 504         ret = IAVIStream_Info(iface,&si,sizeof(si));
 505         if (ret) /* error */
 506                 return 1;
 507         return si.dwLength;
 508 }
 509
 510 ULONG WINAPI AVIStreamRelease(PAVISTREAM iface) {
 511         return IAVIStream_Release(iface);
 512 }
 513
 514 PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM iface,LPBITMAPINFOHEADER bmi) {
 515         FIXME_(msvideo)("(%p)->(%p),stub!\n",iface,bmi);
 516         return NULL;
 517 }
 518
 519 LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pg,LONG pos) {
 520         return IGetFrame_GetFrame(pg,pos);
 521 }
 522
 523 HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pg) {
 524         if (pg) IGetFrame_Release(pg);
 525         return 0;
 526 }
 527
 528 ULONG WINAPI AVIFileRelease(PAVIFILE iface) {
 529         return IAVIFile_Release(iface);
 530 }
 531
 532 void WINAPI AVIFileExit(void) {
 533         FIXME("(), stub.\n");
 534 }