dlls/avifil32/icmstream.c

   1 /*
   2  * Copyright 2002 Michael Günnewig
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <assert.h>
  20 #include <stdarg.h>
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "wingdi.h"
  25 #include "winuser.h"
  26 #include "winerror.h"
  27 #include "mmsystem.h"
  28 #include "vfw.h"
  29
  30 #include "avifile_private.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(avifile);
  35
  36 #define MAX_FRAMESIZE       (16 * 1024 * 1024)
  37 #define MAX_FRAMESIZE_DIFF  512
  38
  39 /***********************************************************************/
  40
  41 static HRESULT WINAPI ICMStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj);
  42 static ULONG   WINAPI ICMStream_fnAddRef(IAVIStream*iface);
  43 static ULONG   WINAPI ICMStream_fnRelease(IAVIStream* iface);
  44 static HRESULT WINAPI ICMStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2);
  45 static HRESULT WINAPI ICMStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size);
  46 static LONG    WINAPI ICMStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags);
  47 static HRESULT WINAPI ICMStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize);
  48 static HRESULT WINAPI ICMStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize);
  49 static HRESULT WINAPI ICMStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread);
  50 static HRESULT WINAPI ICMStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
  51 static HRESULT WINAPI ICMStream_fnDelete(IAVIStream*iface,LONG start,LONG samples);
  52 static HRESULT WINAPI ICMStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread);
  53 static HRESULT WINAPI ICMStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size);
  54 static HRESULT WINAPI ICMStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen);
  55
  56 static const struct IAVIStreamVtbl iicmst = {
  57   ICMStream_fnQueryInterface,
  58   ICMStream_fnAddRef,
  59   ICMStream_fnRelease,
  60   ICMStream_fnCreate,
  61   ICMStream_fnInfo,
  62   ICMStream_fnFindSample,
  63   ICMStream_fnReadFormat,
  64   ICMStream_fnSetFormat,
  65   ICMStream_fnRead,
  66   ICMStream_fnWrite,
  67   ICMStream_fnDelete,
  68   ICMStream_fnReadData,
  69   ICMStream_fnWriteData,
  70   ICMStream_fnSetInfo
  71 };
  72
  73 typedef struct _IAVIStreamImpl {
  74   /* IUnknown stuff */
  75   const IAVIStreamVtbl *lpVtbl;
  76   LONG               ref;
  77
  78   /* IAVIStream stuff */
  79   PAVISTREAM         pStream;
  80   AVISTREAMINFOW     sInfo;
  81
  82   PGETFRAME          pg;
  83   HIC                hic;
  84   DWORD              dwICMFlags;
  85
  86   LONG               lCurrent;
  87   LONG               lLastKey;
  88   LONG               lKeyFrameEvery;
  89   DWORD              dwLastQuality;
  90   DWORD              dwBytesPerFrame;
  91   DWORD              dwUnusedBytes;
  92
  93   LPBITMAPINFOHEADER lpbiCur;  /* current frame */
  94   LPVOID             lpCur;
  95   LPBITMAPINFOHEADER lpbiPrev; /* previous frame */
  96   LPVOID             lpPrev;
  97
  98   LPBITMAPINFOHEADER lpbiOutput; /* output format of codec */
  99   LONG               cbOutput;
 100   LPBITMAPINFOHEADER lpbiInput;  /* input format for codec */
 101   LONG               cbInput;
 102 } IAVIStreamImpl;
 103
 104 /***********************************************************************/
 105
 106 static HRESULT AVIFILE_EncodeFrame(IAVIStreamImpl *This,
 107                                    LPBITMAPINFOHEADER lpbi, LPVOID lpBits);
 108 static HRESULT AVIFILE_OpenGetFrame(IAVIStreamImpl *This);
 109
 110 static inline void AVIFILE_Reset(IAVIStreamImpl *This)
 111 {
 112   This->lCurrent      = -1;
 113   This->lLastKey      = 0;
 114   This->dwLastQuality = ICQUALITY_HIGH;
 115   This->dwUnusedBytes = 0;
 116 }
 117
 118 HRESULT AVIFILE_CreateICMStream(REFIID riid, LPVOID *ppv)
 119 {
 120   IAVIStreamImpl *pstream;
 121   HRESULT         hr;
 122
 123   assert(riid != NULL && ppv != NULL);
 124
 125   *ppv = NULL;
 126
 127   pstream = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAVIStreamImpl));
 128   if (pstream == NULL)
 129     return AVIERR_MEMORY;
 130
 131   pstream->lpVtbl  = &iicmst;
 132   AVIFILE_Reset(pstream);
 133
 134   hr = IAVIStream_QueryInterface((IAVIStream*)pstream, riid, ppv);
 135   if (FAILED(hr))
 136     HeapFree(GetProcessHeap(), 0, pstream);
 137
 138   return hr;
 139 }
 140
 141 static HRESULT WINAPI ICMStream_fnQueryInterface(IAVIStream *iface,
 142                                                   REFIID refiid, LPVOID *obj)
 143 {
 144   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 145
 146   TRACE("(%p,%s,%p)\n", iface, debugstr_guid(refiid), obj);
 147
 148   if (IsEqualGUID(&IID_IUnknown, refiid) ||
 149       IsEqualGUID(&IID_IAVIStream, refiid)) {
 150     *obj = This;
 151     IAVIStream_AddRef(iface);
 152
 153     return S_OK;
 154   }
 155
 156   return OLE_E_ENUM_NOMORE;
 157 }
 158
 159 static ULONG WINAPI ICMStream_fnAddRef(IAVIStream *iface)
 160 {
 161   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 162   ULONG ref = InterlockedIncrement(&This->ref);
 163
 164   TRACE("(%p) -> %d\n", iface, ref);
 165
 166   /* also add reference to the nested stream */
 167   if (This->pStream != NULL)
 168     IAVIStream_AddRef(This->pStream);
 169
 170   return ref;
 171 }
 172
 173 static ULONG WINAPI ICMStream_fnRelease(IAVIStream* iface)
 174 {
 175   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 176   ULONG ref = InterlockedDecrement(&This->ref);
 177
 178   TRACE("(%p) -> %d\n", iface, ref);
 179
 180   if (ref == 0) {
 181     /* destruct */
 182     if (This->pg != NULL) {
 183       AVIStreamGetFrameClose(This->pg);
 184       This->pg = NULL;
 185     }
 186     if (This->pStream != NULL) {
 187       IAVIStream_Release(This->pStream);
 188       This->pStream = NULL;
 189     }
 190     if (This->hic != NULL) {
 191       if (This->lpbiPrev != NULL) {
 192         ICDecompressEnd(This->hic);
 193         HeapFree(GetProcessHeap(), 0, This->lpbiPrev);
 194         This->lpbiPrev = NULL;
 195         This->lpPrev   = NULL;
 196       }
 197       ICCompressEnd(This->hic);
 198       This->hic = NULL;
 199     }
 200     if (This->lpbiCur != NULL) {
 201       HeapFree(GetProcessHeap(), 0, This->lpbiCur);
 202       This->lpbiCur = NULL;
 203       This->lpCur   = NULL;
 204     }
 205     if (This->lpbiOutput != NULL) {
 206       HeapFree(GetProcessHeap(), 0, This->lpbiOutput);
 207       This->lpbiOutput = NULL;
 208       This->cbOutput   = 0;
 209     }
 210     if (This->lpbiInput != NULL) {
 211       HeapFree(GetProcessHeap(), 0, This->lpbiInput);
 212       This->lpbiInput = NULL;
 213       This->cbInput   = 0;
 214     }
 215
 216     HeapFree(GetProcessHeap(), 0, This);
 217
 218     return 0;
 219   }
 220
 221   /* also release reference to the nested stream */
 222   if (This->pStream != NULL)
 223     IAVIStream_Release(This->pStream);
 224
 225   return ref;
 226 }
 227
 228 /* lParam1: PAVISTREAM
 229  * lParam2: LPAVICOMPRESSOPTIONS
 230  */
 231 static HRESULT WINAPI ICMStream_fnCreate(IAVIStream *iface, LPARAM lParam1,
 232                                           LPARAM lParam2)
 233 {
 234   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 235
 236   ICINFO               icinfo;
 237   ICCOMPRESSFRAMES     icFrames;
 238   LPAVICOMPRESSOPTIONS pco = (LPAVICOMPRESSOPTIONS)lParam2;
 239
 240   TRACE("(%p,0x%08lX,0x%08lX)\n", iface, lParam1, lParam2);
 241
 242   /* check parameter */
 243   if ((LPVOID)lParam1 == NULL)
 244     return AVIERR_BADPARAM;
 245
 246   /* get infos from stream */
 247   IAVIStream_Info((PAVISTREAM)lParam1, &This->sInfo, sizeof(This->sInfo));
 248   if (This->sInfo.fccType != streamtypeVIDEO)
 249     return AVIERR_ERROR; /* error in registry or AVIMakeCompressedStream */
 250
 251   /* add reference to the stream */
 252   This->pStream = (PAVISTREAM)lParam1;
 253   IAVIStream_AddRef(This->pStream);
 254
 255   AVIFILE_Reset(This);
 256
 257   if (pco != NULL && pco->fccHandler != comptypeDIB) {
 258     /* we should compress */
 259     This->sInfo.fccHandler = pco->fccHandler;
 260
 261     This->hic = ICOpen(ICTYPE_VIDEO, pco->fccHandler, ICMODE_COMPRESS);
 262     if (This->hic == NULL)
 263       return AVIERR_NOCOMPRESSOR;
 264
 265     /* restore saved state of codec */
 266     if (pco->cbParms > 0 && pco->lpParms != NULL) {
 267       ICSetState(This->hic, pco->lpParms, pco->cbParms);
 268     }
 269
 270     /* set quality -- resolve default quality */
 271     This->sInfo.dwQuality = pco->dwQuality;
 272     if (pco->dwQuality == ICQUALITY_DEFAULT)
 273       This->sInfo.dwQuality = ICGetDefaultQuality(This->hic);
 274
 275     /* get capabilities of codec */
 276     ICGetInfo(This->hic, &icinfo, sizeof(icinfo));
 277     This->dwICMFlags = icinfo.dwFlags;
 278
 279     /* use keyframes? */
 280     if ((pco->dwFlags & AVICOMPRESSF_KEYFRAMES) &&
 281         (icinfo.dwFlags & (VIDCF_TEMPORAL|VIDCF_FASTTEMPORALC))) {
 282       This->lKeyFrameEvery = pco->dwKeyFrameEvery;
 283     } else
 284       This->lKeyFrameEvery = 1;
 285
 286     /* use datarate? */
 287     if ((pco->dwFlags & AVICOMPRESSF_DATARATE)) {
 288       /* Do we have a chance to reduce size to desired one? */
 289       if ((icinfo.dwFlags & (VIDCF_CRUNCH|VIDCF_QUALITY)) == 0)
 290         return AVIERR_NOCOMPRESSOR;
 291
 292       assert(This->sInfo.dwRate != 0);
 293
 294       This->dwBytesPerFrame = MulDiv(pco->dwBytesPerSecond,
 295                                      This->sInfo.dwScale, This->sInfo.dwRate);
 296     } else {
 297       pco->dwBytesPerSecond = 0;
 298       This->dwBytesPerFrame = 0;
 299     }
 300
 301     if (icinfo.dwFlags & VIDCF_COMPRESSFRAMES) {
 302       memset(&icFrames, 0, sizeof(icFrames));
 303       icFrames.lpbiOutput  = This->lpbiOutput;
 304       icFrames.lpbiInput   = This->lpbiInput;
 305       icFrames.lFrameCount = This->sInfo.dwLength;
 306       icFrames.lQuality    = This->sInfo.dwQuality;
 307       icFrames.lDataRate   = pco->dwBytesPerSecond;
 308       icFrames.lKeyRate    = This->lKeyFrameEvery;
 309       icFrames.dwRate      = This->sInfo.dwRate;
 310       icFrames.dwScale     = This->sInfo.dwScale;
 311       ICSendMessage(This->hic, ICM_COMPRESS_FRAMES_INFO,
 312                     (LPARAM)&icFrames, (LPARAM)sizeof(icFrames));
 313     }
 314   } else
 315     This->sInfo.fccHandler = comptypeDIB;
 316
 317   return AVIERR_OK;
 318 }
 319
 320 static HRESULT WINAPI ICMStream_fnInfo(IAVIStream *iface,LPAVISTREAMINFOW psi,
 321                                         LONG size)
 322 {
 323   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 324
 325   TRACE("(%p,%p,%d)\n", iface, psi, size);
 326
 327   if (psi == NULL)
 328     return AVIERR_BADPARAM;
 329   if (size < 0)
 330     return AVIERR_BADSIZE;
 331
 332   memcpy(psi, &This->sInfo, min((DWORD)size, sizeof(This->sInfo)));
 333
 334   if ((DWORD)size < sizeof(This->sInfo))
 335     return AVIERR_BUFFERTOOSMALL;
 336   return AVIERR_OK;
 337 }
 338
 339 static LONG WINAPI ICMStream_fnFindSample(IAVIStream *iface, LONG pos,
 340                                            LONG flags)
 341 {
 342   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 343
 344   TRACE("(%p,%d,0x%08X)\n",iface,pos,flags);
 345
 346   if (flags & FIND_FROM_START) {
 347     pos = This->sInfo.dwStart;
 348     flags &= ~(FIND_FROM_START|FIND_PREV);
 349     flags |= FIND_NEXT;
 350   }
 351
 352   if (flags & FIND_RET)
 353     WARN(": FIND_RET flags will be ignored!\n");
 354
 355   if (flags & FIND_KEY) {
 356     if (This->hic == NULL)
 357       return pos; /* we decompress so every frame is a keyframe */
 358
 359     if (flags & FIND_PREV) {
 360       /* need to read old or new frames? */
 361       if (This->lLastKey <= pos || pos < This->lCurrent)
 362         IAVIStream_Read(iface, pos, 1, NULL, 0, NULL, NULL);
 363
 364       return This->lLastKey;
 365     }
 366   } else if (flags & FIND_ANY) {
 367     return pos; /* We really don't know, reread is to expensive, so guess. */
 368   } else if (flags & FIND_FORMAT) {
 369     if (flags & FIND_PREV)
 370       return 0;
 371   }
 372
 373   return -1;
 374 }
 375
 376 static HRESULT WINAPI ICMStream_fnReadFormat(IAVIStream *iface, LONG pos,
 377                                               LPVOID format, LONG *formatsize)
 378 {
 379   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 380
 381   LPBITMAPINFOHEADER lpbi;
 382   HRESULT            hr;
 383
 384   TRACE("(%p,%d,%p,%p)\n", iface, pos, format, formatsize);
 385
 386   if (formatsize == NULL)
 387     return AVIERR_BADPARAM;
 388
 389   if (This->pg == NULL) {
 390     hr = AVIFILE_OpenGetFrame(This);
 391
 392     if (FAILED(hr))
 393       return hr;
 394   }
 395
 396   lpbi = AVIStreamGetFrame(This->pg, pos);
 397   if (lpbi == NULL)
 398     return AVIERR_MEMORY;
 399
 400   if (This->hic == NULL) {
 401     LONG size = lpbi->biSize + lpbi->biClrUsed * sizeof(RGBQUAD);
 402
 403     if (size > 0) {
 404       if (This->sInfo.dwSuggestedBufferSize < lpbi->biSizeImage)
 405         This->sInfo.dwSuggestedBufferSize = lpbi->biSizeImage;
 406
 407       This->cbOutput = size;
 408       if (format != NULL) {
 409         if (This->lpbiOutput != NULL)
 410           memcpy(format, This->lpbiOutput, min(*formatsize, This->cbOutput));
 411         else
 412           memcpy(format, lpbi, min(*formatsize, size));
 413       }
 414     }
 415   } else if (format != NULL)
 416     memcpy(format, This->lpbiOutput, min(*formatsize, This->cbOutput));
 417
 418   if (*formatsize < This->cbOutput)
 419     hr = AVIERR_BUFFERTOOSMALL;
 420   else
 421     hr = AVIERR_OK;
 422
 423   *formatsize = This->cbOutput;
 424   return hr;
 425 }
 426
 427 static HRESULT WINAPI ICMStream_fnSetFormat(IAVIStream *iface, LONG pos,
 428                                              LPVOID format, LONG formatsize)
 429 {
 430   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 431
 432   TRACE("(%p,%d,%p,%d)\n", iface, pos, format, formatsize);
 433
 434   /* check parameters */
 435   if (format == NULL || formatsize <= 0)
 436     return AVIERR_BADPARAM;
 437
 438   /* We can only accept RGB data for writing */
 439   if (((LPBITMAPINFOHEADER)format)->biCompression != BI_RGB) {
 440     WARN(": need RGB data as input\n");
 441     return AVIERR_UNSUPPORTED;
 442   }
 443
 444   /* Input format already known?
 445    * Changing of palette is supported, but be quiet if it's the same */
 446   if (This->lpbiInput != NULL) {
 447     if (This->cbInput != formatsize)
 448       return AVIERR_UNSUPPORTED;
 449
 450     if (memcmp(format, This->lpbiInput, formatsize) == 0)
 451       return AVIERR_OK;
 452   }
 453
 454   /* Does the nested stream support writing? */
 455   if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
 456     return AVIERR_READONLY;
 457
 458   /* check if frame is already written */
 459   if (This->sInfo.dwLength + This->sInfo.dwStart > pos)
 460     return AVIERR_UNSUPPORTED;
 461
 462   /* check if we should compress */
 463   if (This->sInfo.fccHandler == 0 ||
 464       This->sInfo.fccHandler == mmioFOURCC('N','O','N','E'))
 465     This->sInfo.fccHandler = comptypeDIB;
 466
 467   /* only pass through? */
 468   if (This->sInfo.fccHandler == comptypeDIB)
 469     return IAVIStream_SetFormat(This->pStream, pos, format, formatsize);
 470
 471   /* initial format setting? */
 472   if (This->lpbiInput == NULL) {
 473     ULONG size;
 474
 475     assert(This->hic != NULL);
 476
 477     /* get memory for input format */
 478     This->lpbiInput = HeapAlloc(GetProcessHeap(), 0, formatsize);
 479     if (This->lpbiInput == NULL)
 480       return AVIERR_MEMORY;
 481     This->cbInput = formatsize;
 482     memcpy(This->lpbiInput, format, formatsize);
 483
 484     /* get output format */
 485     size = ICCompressGetFormatSize(This->hic, This->lpbiInput);
 486     if (size < sizeof(BITMAPINFOHEADER))
 487       return AVIERR_COMPRESSOR;
 488     This->lpbiOutput = HeapAlloc(GetProcessHeap(), 0, size);
 489     if (This->lpbiOutput == NULL)
 490       return AVIERR_MEMORY;
 491     This->cbOutput = size;
 492     if (ICCompressGetFormat(This->hic,This->lpbiInput,This->lpbiOutput) < S_OK)
 493       return AVIERR_COMPRESSOR;
 494
 495     /* update AVISTREAMINFO structure */
 496     This->sInfo.rcFrame.right  =
 497       This->sInfo.rcFrame.left + This->lpbiOutput->biWidth;
 498     This->sInfo.rcFrame.bottom =
 499       This->sInfo.rcFrame.top  + This->lpbiOutput->biHeight;
 500
 501     /* prepare codec for compression */
 502     if (ICCompressBegin(This->hic, This->lpbiInput, This->lpbiOutput) != S_OK)
 503       return AVIERR_COMPRESSOR;
 504
 505     /* allocate memory for compressed frame */
 506     size = ICCompressGetSize(This->hic, This->lpbiInput, This->lpbiOutput);
 507     This->lpbiCur = HeapAlloc(GetProcessHeap(), 0, This->cbOutput + size);
 508     if (This->lpbiCur == NULL)
 509       return AVIERR_MEMORY;
 510     memcpy(This->lpbiCur, This->lpbiOutput, This->cbOutput);
 511     This->lpCur = DIBPTR(This->lpbiCur);
 512
 513     /* allocate memory for last frame if needed */
 514     if (This->lKeyFrameEvery != 1 &&
 515         (This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
 516       size = ICDecompressGetFormatSize(This->hic, This->lpbiOutput);
 517       This->lpbiPrev = HeapAlloc(GetProcessHeap(), 0, size);
 518       if (This->lpbiPrev == NULL)
 519         return AVIERR_MEMORY;
 520       if (ICDecompressGetFormat(This->hic, This->lpbiOutput, This->lpbiPrev) < S_OK)
 521         return AVIERR_COMPRESSOR;
 522
 523       if (This->lpbiPrev->biSizeImage == 0) {
 524         This->lpbiPrev->biSizeImage =
 525           DIBWIDTHBYTES(*This->lpbiPrev) * This->lpbiPrev->biHeight;
 526       }
 527
 528       /* get memory for format and picture */
 529       size += This->lpbiPrev->biSizeImage;
 530       This->lpbiPrev = HeapReAlloc(GetProcessHeap(), 0, This->lpbiPrev, size);
 531       if (This->lpbiPrev == NULL)
 532         return AVIERR_MEMORY;
 533       This->lpPrev = DIBPTR(This->lpbiPrev);
 534
 535       /* prepare codec also for decompression */
 536       if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
 537         return AVIERR_COMPRESSOR;
 538     }
 539   } else {
 540     /* format change -- check that's only the palette */
 541     LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)format;
 542
 543     if (lpbi->biSize != This->lpbiInput->biSize ||
 544         lpbi->biWidth != This->lpbiInput->biWidth ||
 545         lpbi->biHeight != This->lpbiInput->biHeight ||
 546         lpbi->biBitCount != This->lpbiInput->biBitCount ||
 547         lpbi->biPlanes != This->lpbiInput->biPlanes ||
 548         lpbi->biCompression != This->lpbiInput->biCompression ||
 549         lpbi->biClrUsed != This->lpbiInput->biClrUsed)
 550       return AVIERR_UNSUPPORTED;
 551
 552     /* get new output format */
 553     if (ICCompressGetFormat(This->hic, lpbi, This->lpbiOutput) < S_OK)
 554       return AVIERR_BADFORMAT;
 555
 556     /* restart compression */
 557     ICCompressEnd(This->hic);
 558     if (ICCompressBegin(This->hic, lpbi, This->lpbiOutput) != S_OK)
 559       return AVIERR_COMPRESSOR;
 560
 561     /* check if we need to restart decompression also */
 562     if (This->lKeyFrameEvery != 1 &&
 563         (This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
 564       ICDecompressEnd(This->hic);
 565       if (ICDecompressGetFormat(This->hic,This->lpbiOutput,This->lpbiPrev) < S_OK)
 566         return AVIERR_COMPRESSOR;
 567       if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
 568         return AVIERR_COMPRESSOR;
 569     }
 570   }
 571
 572   /* tell nested stream the new format */
 573   return IAVIStream_SetFormat(This->pStream, pos,
 574                               This->lpbiOutput, This->cbOutput);
 575 }
 576
 577 static HRESULT WINAPI ICMStream_fnRead(IAVIStream *iface, LONG start,
 578                                         LONG samples, LPVOID buffer,
 579                                         LONG buffersize, LPLONG bytesread,
 580                                         LPLONG samplesread)
 581 {
 582   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 583
 584   LPBITMAPINFOHEADER lpbi;
 585
 586   TRACE("(%p,%d,%d,%p,%d,%p,%p)\n", iface, start, samples, buffer,
 587         buffersize, bytesread, samplesread);
 588
 589   /* clear return parameters if given */
 590   if (bytesread != NULL)
 591     *bytesread = 0;
 592   if (samplesread != NULL)
 593     *samplesread = 0;
 594
 595   if (samples == 0)
 596     return AVIERR_OK;
 597
 598   /* check parameters */
 599   if (samples != 1 && (bytesread == NULL && samplesread == NULL))
 600     return AVIERR_BADPARAM;
 601   if (samples == -1) /* read as much as we could */
 602     samples = 1;
 603
 604   if (This->pg == NULL) {
 605     HRESULT hr = AVIFILE_OpenGetFrame(This);
 606
 607     if (FAILED(hr))
 608       return hr;
 609   }
 610
 611   /* compress or decompress? */
 612   if (This->hic == NULL) {
 613     /* decompress */
 614     lpbi = AVIStreamGetFrame(This->pg, start);
 615     if (lpbi == NULL)
 616       return AVIERR_MEMORY;
 617
 618     if (buffer != NULL && buffersize > 0) {
 619       /* check buffersize */
 620       if (buffersize < lpbi->biSizeImage)
 621         return AVIERR_BUFFERTOOSMALL;
 622
 623       memcpy(buffer, DIBPTR(lpbi), lpbi->biSizeImage);
 624     }
 625
 626     /* fill out return parameters if given */
 627     if (bytesread != NULL)
 628       *bytesread = lpbi->biSizeImage;
 629   } else {
 630     /* compress */
 631     if (This->lCurrent > start)
 632       AVIFILE_Reset(This);
 633
 634     while (start > This->lCurrent) {
 635       HRESULT hr;
 636
 637       lpbi = AVIStreamGetFrame(This->pg, ++This->lCurrent);
 638       if (lpbi == NULL) {
 639         AVIFILE_Reset(This);
 640         return AVIERR_MEMORY;
 641       }
 642
 643       hr = AVIFILE_EncodeFrame(This, lpbi, DIBPTR(lpbi));
 644       if (FAILED(hr)) {
 645         AVIFILE_Reset(This);
 646         return hr;
 647       }
 648     }
 649
 650     if (buffer != NULL && buffersize > 0) {
 651       /* check buffersize */
 652       if (This->lpbiCur->biSizeImage > buffersize)
 653         return AVIERR_BUFFERTOOSMALL;
 654
 655       memcpy(buffer, This->lpCur, This->lpbiCur->biSizeImage);
 656     }
 657
 658     /* fill out return parameters if given */
 659     if (bytesread != NULL)
 660       *bytesread = This->lpbiCur->biSizeImage;
 661   }
 662
 663   /* fill out return parameters if given */
 664   if (samplesread != NULL)
 665     *samplesread = 1;
 666
 667   return AVIERR_OK;
 668 }
 669
 670 static HRESULT WINAPI ICMStream_fnWrite(IAVIStream *iface, LONG start,
 671                                          LONG samples, LPVOID buffer,
 672                                          LONG buffersize, DWORD flags,
 673                                          LPLONG sampwritten,
 674                                          LPLONG byteswritten)
 675 {
 676   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 677
 678   HRESULT hr;
 679
 680   TRACE("(%p,%d,%d,%p,%d,0x%08X,%p,%p)\n", iface, start, samples,
 681         buffer, buffersize, flags, sampwritten, byteswritten);
 682
 683   /* clear return parameters if given */
 684   if (sampwritten != NULL)
 685     *sampwritten = 0;
 686   if (byteswritten != NULL)
 687     *byteswritten = 0;
 688
 689   /* check parameters */
 690   if (buffer == NULL && (buffersize > 0 || samples > 0))
 691     return AVIERR_BADPARAM;
 692
 693   if (This->sInfo.fccHandler == comptypeDIB) {
 694     /* only pass through */
 695     flags |= AVIIF_KEYFRAME;
 696
 697     return IAVIStream_Write(This->pStream, start, samples, buffer, buffersize,
 698                             flags, sampwritten, byteswritten);
 699   } else {
 700     /* compress data before writing to pStream */
 701     if (samples != 1 && (sampwritten == NULL && byteswritten == NULL))
 702       return AVIERR_UNSUPPORTED;
 703
 704     This->lCurrent = start;
 705     hr = AVIFILE_EncodeFrame(This, This->lpbiInput, buffer);
 706     if (FAILED(hr))
 707       return hr;
 708
 709     if (This->lLastKey == start)
 710       flags |= AVIIF_KEYFRAME;
 711
 712     return IAVIStream_Write(This->pStream, start, samples, This->lpCur,
 713                             This->lpbiCur->biSizeImage, flags, byteswritten,
 714                             sampwritten);
 715   }
 716 }
 717
 718 static HRESULT WINAPI ICMStream_fnDelete(IAVIStream *iface, LONG start,
 719                                           LONG samples)
 720 {
 721   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 722
 723   TRACE("(%p,%d,%d)\n", iface, start, samples);
 724
 725   return IAVIStream_Delete(This->pStream, start, samples);
 726 }
 727
 728 static HRESULT WINAPI ICMStream_fnReadData(IAVIStream *iface, DWORD fcc,
 729                                             LPVOID lp, LPLONG lpread)
 730 {
 731   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 732
 733   TRACE("(%p,0x%08X,%p,%p)\n", iface, fcc, lp, lpread);
 734
 735   assert(This->pStream != NULL);
 736
 737   return IAVIStream_ReadData(This->pStream, fcc, lp, lpread);
 738 }
 739
 740 static HRESULT WINAPI ICMStream_fnWriteData(IAVIStream *iface, DWORD fcc,
 741                                              LPVOID lp, LONG size)
 742 {
 743   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 744
 745   TRACE("(%p,0x%08x,%p,%d)\n", iface, fcc, lp, size);
 746
 747   assert(This->pStream != NULL);
 748
 749   return IAVIStream_WriteData(This->pStream, fcc, lp, size);
 750 }
 751
 752 static HRESULT WINAPI ICMStream_fnSetInfo(IAVIStream *iface,
 753                                            LPAVISTREAMINFOW info, LONG infolen)
 754 {
 755   FIXME("(%p,%p,%d): stub\n", iface, info, infolen);
 756
 757   return E_FAIL;
 758 }
 759
 760 /***********************************************************************/
 761
 762 static HRESULT AVIFILE_EncodeFrame(IAVIStreamImpl *This,
 763                                    LPBITMAPINFOHEADER lpbi, LPVOID lpBits)
 764 {
 765   DWORD dwMinQual, dwMaxQual, dwCurQual;
 766   DWORD dwRequest;
 767   DWORD icmFlags = 0;
 768   DWORD idxFlags = 0;
 769   BOOL  bDecreasedQual = FALSE;
 770   BOOL  doSizeCheck;
 771   BOOL  noPrev;
 772
 773   /* make lKeyFrameEvery and at start a keyframe */
 774   if ((This->lKeyFrameEvery != 0 &&
 775        (This->lCurrent - This->lLastKey) >= This->lKeyFrameEvery) ||
 776       This->lCurrent == This->sInfo.dwStart) {
 777     idxFlags = AVIIF_KEYFRAME;
 778     icmFlags = ICCOMPRESS_KEYFRAME;
 779   }
 780
 781   if (This->lKeyFrameEvery != 0) {
 782     if (This->lCurrent == This->sInfo.dwStart) {
 783       if (idxFlags & AVIIF_KEYFRAME) {
 784         /* for keyframes allow to consume all unused bytes */
 785         dwRequest = This->dwBytesPerFrame + This->dwUnusedBytes;
 786         This->dwUnusedBytes = 0;
 787       } else {
 788         /* for non-keyframes only allow something of the unused bytes to be consumed */
 789         DWORD tmp1 = 0;
 790         DWORD tmp2;
 791
 792         if (This->dwBytesPerFrame >= This->dwUnusedBytes)
 793           tmp1 = This->dwBytesPerFrame / This->lKeyFrameEvery;
 794         tmp2 = (This->dwUnusedBytes + tmp1) / This->lKeyFrameEvery;
 795
 796         dwRequest = This->dwBytesPerFrame - tmp1 + tmp2;
 797         This->dwUnusedBytes -= tmp2;
 798       }
 799     } else
 800       dwRequest = MAX_FRAMESIZE;
 801   } else {
 802     /* only one keyframe at start desired */
 803     if (This->lCurrent == This->sInfo.dwStart) {
 804       dwRequest = This->dwBytesPerFrame + This->dwUnusedBytes;
 805       This->dwUnusedBytes = 0;
 806     } else
 807       dwRequest = MAX_FRAMESIZE;
 808   }
 809
 810   /* must we check for framesize to gain requested
 811    * datarate or could we trust codec? */
 812   doSizeCheck = (dwRequest != 0 && ((This->dwICMFlags & (VIDCF_CRUNCH|VIDCF_QUALITY)) == 0));
 813
 814   dwMaxQual = dwCurQual = This->sInfo.dwQuality;
 815   dwMinQual = ICQUALITY_LOW;
 816
 817   noPrev = TRUE;
 818   if ((icmFlags & ICCOMPRESS_KEYFRAME) == 0 &&
 819       (This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0)
 820     noPrev = FALSE;
 821
 822   do {
 823     DWORD   idxCkid = 0;
 824     DWORD   res;
 825
 826     res = ICCompress(This->hic,icmFlags,This->lpbiCur,This->lpCur,lpbi,lpBits,
 827                      &idxCkid, &idxFlags, This->lCurrent, dwRequest, dwCurQual,
 828                      noPrev ? NULL:This->lpbiPrev, noPrev ? NULL:This->lpPrev);
 829     if (res == ICERR_NEWPALETTE) {
 830       FIXME(": codec has changed palette -- unhandled!\n");
 831     } else if (res != ICERR_OK)
 832       return AVIERR_COMPRESSOR;
 833
 834     /* need to check for framesize */
 835     if (! doSizeCheck)
 836       break;
 837
 838     if (dwRequest >= This->lpbiCur->biSizeImage) {
 839       /* frame is smaller -- try to maximize quality */
 840       if (dwMaxQual - dwCurQual > 10) {
 841         DWORD tmp = dwRequest / 8;
 842
 843         if (tmp < MAX_FRAMESIZE_DIFF)
 844           tmp = MAX_FRAMESIZE_DIFF;
 845
 846         if (tmp < dwRequest - This->lpbiCur->biSizeImage && bDecreasedQual) {
 847           tmp = dwCurQual;
 848           dwCurQual = (dwMinQual + dwMaxQual) / 2;
 849           dwMinQual = tmp;
 850           continue;
 851         }
 852       } else
 853         break;
 854     } else if (dwMaxQual - dwMinQual <= 1) {
 855       break;
 856     } else {
 857       dwMaxQual = dwCurQual;
 858
 859       if (bDecreasedQual || dwCurQual == This->dwLastQuality)
 860         dwCurQual = (dwMinQual + dwMaxQual) / 2;
 861       else
 862         FIXME(": no new quality computed min=%u cur=%u max=%u last=%u\n",
 863               dwMinQual, dwCurQual, dwMaxQual, This->dwLastQuality);
 864
 865       bDecreasedQual = TRUE;
 866     }
 867   } while (TRUE);
 868
 869   /* remember some values */
 870   This->dwLastQuality = dwCurQual;
 871   This->dwUnusedBytes = dwRequest - This->lpbiCur->biSizeImage;
 872   if (icmFlags & ICCOMPRESS_KEYFRAME)
 873     This->lLastKey = This->lCurrent;
 874
 875   /* Does we manage previous frame? */
 876   if (This->lpPrev != NULL && This->lKeyFrameEvery != 1)
 877     ICDecompress(This->hic, 0, This->lpbiCur, This->lpCur,
 878                  This->lpbiPrev, This->lpPrev);
 879
 880   return AVIERR_OK;
 881 }
 882
 883 static HRESULT AVIFILE_OpenGetFrame(IAVIStreamImpl *This)
 884 {
 885   LPBITMAPINFOHEADER lpbi;
 886   DWORD              size;
 887
 888   /* pre-conditions */
 889   assert(This != NULL);
 890   assert(This->pStream != NULL);
 891   assert(This->pg == NULL);
 892
 893   This->pg = AVIStreamGetFrameOpen(This->pStream, NULL);
 894   if (This->pg == NULL)
 895     return AVIERR_ERROR;
 896
 897   /* When we only decompress this is enough */
 898   if (This->sInfo.fccHandler == comptypeDIB)
 899     return AVIERR_OK;
 900
 901   assert(This->hic != NULL);
 902   assert(This->lpbiOutput == NULL);
 903
 904   /* get input format */
 905   lpbi = AVIStreamGetFrame(This->pg, This->sInfo.dwStart);
 906   if (lpbi == NULL)
 907     return AVIERR_MEMORY;
 908
 909   /* get memory for output format */
 910   size = ICCompressGetFormatSize(This->hic, lpbi);
 911   if ((LONG)size < (LONG)sizeof(BITMAPINFOHEADER))
 912     return AVIERR_COMPRESSOR;
 913   This->lpbiOutput = HeapAlloc(GetProcessHeap(), 0, size);
 914   if (This->lpbiOutput == NULL)
 915     return AVIERR_MEMORY;
 916   This->cbOutput = size;
 917
 918   if (ICCompressGetFormat(This->hic, lpbi, This->lpbiOutput) < S_OK)
 919     return AVIERR_BADFORMAT;
 920
 921   /* update AVISTREAMINFO structure */
 922   This->sInfo.rcFrame.right  =
 923     This->sInfo.rcFrame.left + This->lpbiOutput->biWidth;
 924   This->sInfo.rcFrame.bottom =
 925     This->sInfo.rcFrame.top  + This->lpbiOutput->biHeight;
 926   This->sInfo.dwSuggestedBufferSize =
 927     ICCompressGetSize(This->hic, lpbi, This->lpbiOutput);
 928
 929   /* prepare codec for compression */
 930   if (ICCompressBegin(This->hic, lpbi, This->lpbiOutput) != S_OK)
 931     return AVIERR_COMPRESSOR;
 932
 933   /* allocate memory for current frame */
 934   size += This->sInfo.dwSuggestedBufferSize;
 935   This->lpbiCur = HeapAlloc(GetProcessHeap(), 0, size);
 936   if (This->lpbiCur == NULL)
 937     return AVIERR_MEMORY;
 938   memcpy(This->lpbiCur, This->lpbiOutput, This->cbOutput);
 939   This->lpCur = DIBPTR(This->lpbiCur);
 940
 941   /* allocate memory for last frame if needed */
 942   if (This->lKeyFrameEvery != 1 &&
 943       (This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
 944     size = ICDecompressGetFormatSize(This->hic, This->lpbiOutput);
 945     This->lpbiPrev = HeapAlloc(GetProcessHeap(), 0, size);
 946     if (This->lpbiPrev == NULL)
 947       return AVIERR_MEMORY;
 948     if (ICDecompressGetFormat(This->hic, This->lpbiOutput, This->lpbiPrev) < S_OK)
 949       return AVIERR_COMPRESSOR;
 950
 951     if (This->lpbiPrev->biSizeImage == 0) {
 952       This->lpbiPrev->biSizeImage =
 953         DIBWIDTHBYTES(*This->lpbiPrev) * This->lpbiPrev->biHeight;
 954     }
 955
 956     /* get memory for format and picture */
 957     size += This->lpbiPrev->biSizeImage;
 958     This->lpbiPrev = HeapReAlloc(GetProcessHeap(), 0, This->lpbiPrev, size );
 959     if (This->lpbiPrev == NULL)
 960       return AVIERR_MEMORY;
 961     This->lpPrev = DIBPTR(This->lpbiPrev);
 962
 963     /* prepare codec also for decompression */
 964     if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
 965       return AVIERR_COMPRESSOR;
 966   }
 967
 968   return AVIERR_OK;
 969 }