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

   1 /*
   2  * Copyright 1999 Marcus Meissner
   3  * Copyright 2002-2003 Michael Günnewig
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 /* TODO:
  21  *  - IAVIStreaming interface is missing for the IAVIStreamImpl
  22  *  - IAVIStream_fnFindSample: FIND_INDEX isn't supported.
  23  *  - IAVIStream_fnReadFormat: formatchanges aren't read in.
  24  *  - IAVIStream_fnDelete: a stub.
  25  *  - IAVIStream_fnSetInfo: a stub.
  26  *  - make thread safe
  27  *
  28  * KNOWN Bugs:
  29  *  - native version can hangup when reading a file generated with this DLL.
  30  *    When index is missing it works, but index seems to be okay.
  31  */
  32
  33 #include <assert.h>
  34 #include <stdarg.h>
  35
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "wingdi.h"
  39 #include "winuser.h"
  40 #include "winnls.h"
  41 #include "winerror.h"
  42 #include "mmsystem.h"
  43 #include "vfw.h"
  44
  45 #include "avifile_private.h"
  46 #include "extrachunk.h"
  47
  48 #include "wine/unicode.h"
  49 #include "wine/debug.h"
  50
  51 WINE_DEFAULT_DEBUG_CHANNEL(avifile);
  52
  53 #ifndef IDX_PER_BLOCK
  54 #define IDX_PER_BLOCK 2730
  55 #endif
  56
  57 /***********************************************************************/
  58
  59 static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile* iface,REFIID refiid,LPVOID *obj);
  60 static ULONG   WINAPI IAVIFile_fnAddRef(IAVIFile* iface);
  61 static ULONG   WINAPI IAVIFile_fnRelease(IAVIFile* iface);
  62 static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile*iface,AVIFILEINFOW*afi,LONG size);
  63 static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam);
  64 static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi);
  65 static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG size);
  66 static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG *size);
  67 static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile*iface);
  68 static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG lParam);
  69
  70 static const struct IAVIFileVtbl iavift = {
  71   IAVIFile_fnQueryInterface,
  72   IAVIFile_fnAddRef,
  73   IAVIFile_fnRelease,
  74   IAVIFile_fnInfo,
  75   IAVIFile_fnGetStream,
  76   IAVIFile_fnCreateStream,
  77   IAVIFile_fnWriteData,
  78   IAVIFile_fnReadData,
  79   IAVIFile_fnEndRecord,
  80   IAVIFile_fnDeleteStream
  81 };
  82
  83 static HRESULT WINAPI IPersistFile_fnQueryInterface(IPersistFile*iface,REFIID refiid,LPVOID*obj);
  84 static ULONG   WINAPI IPersistFile_fnAddRef(IPersistFile*iface);
  85 static ULONG   WINAPI IPersistFile_fnRelease(IPersistFile*iface);
  86 static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile*iface,CLSID*pClassID);
  87 static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile*iface);
  88 static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile*iface,LPCOLESTR pszFileName,DWORD dwMode);
  89 static HRESULT WINAPI IPersistFile_fnSave(IPersistFile*iface,LPCOLESTR pszFileName,BOOL fRemember);
  90 static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile*iface,LPCOLESTR pszFileName);
  91 static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile*iface,LPOLESTR*ppszFileName);
  92
  93 static const struct IPersistFileVtbl ipersistft = {
  94   IPersistFile_fnQueryInterface,
  95   IPersistFile_fnAddRef,
  96   IPersistFile_fnRelease,
  97   IPersistFile_fnGetClassID,
  98   IPersistFile_fnIsDirty,
  99   IPersistFile_fnLoad,
 100   IPersistFile_fnSave,
 101   IPersistFile_fnSaveCompleted,
 102   IPersistFile_fnGetCurFile
 103 };
 104
 105 static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj);
 106 static ULONG   WINAPI IAVIStream_fnAddRef(IAVIStream*iface);
 107 static ULONG   WINAPI IAVIStream_fnRelease(IAVIStream* iface);
 108 static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2);
 109 static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size);
 110 static LONG    WINAPI IAVIStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags);
 111 static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize);
 112 static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize);
 113 static HRESULT WINAPI IAVIStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread);
 114 static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
 115 static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples);
 116 static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread);
 117 static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size);
 118 static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen);
 119
 120 static const struct IAVIStreamVtbl iavist = {
 121   IAVIStream_fnQueryInterface,
 122   IAVIStream_fnAddRef,
 123   IAVIStream_fnRelease,
 124   IAVIStream_fnCreate,
 125   IAVIStream_fnInfo,
 126   IAVIStream_fnFindSample,
 127   IAVIStream_fnReadFormat,
 128   IAVIStream_fnSetFormat,
 129   IAVIStream_fnRead,
 130   IAVIStream_fnWrite,
 131   IAVIStream_fnDelete,
 132   IAVIStream_fnReadData,
 133   IAVIStream_fnWriteData,
 134   IAVIStream_fnSetInfo
 135 };
 136
 137 typedef struct _IAVIFileImpl IAVIFileImpl;
 138
 139 typedef struct _IPersistFileImpl {
 140   /* IUnknown stuff */
 141   const IPersistFileVtbl *lpVtbl;
 142
 143   /* IPersistFile stuff */
 144   IAVIFileImpl     *paf;
 145 } IPersistFileImpl;
 146
 147 typedef struct _IAVIStreamImpl {
 148   /* IUnknown stuff */
 149   const IAVIStreamVtbl *lpVtbl;
 150   LONG              ref;
 151
 152   /* IAVIStream stuff */
 153   IAVIFileImpl     *paf;
 154   DWORD             nStream;       /* the n-th stream in file */
 155   AVISTREAMINFOW    sInfo;
 156
 157   LPVOID            lpFormat;
 158   DWORD             cbFormat;
 159
 160   LPVOID            lpHandlerData;
 161   DWORD             cbHandlerData;
 162
 163   EXTRACHUNKS       extra;
 164
 165   LPDWORD           lpBuffer;
 166   DWORD             cbBuffer;       /* size of lpBuffer */
 167   DWORD             dwCurrentFrame; /* frame/block currently in lpBuffer */
 168
 169   LONG              lLastFrame;    /* last correct index in idxFrames */
 170   AVIINDEXENTRY    *idxFrames;
 171   DWORD             nIdxFrames;     /* upper index limit of idxFrames */
 172   AVIINDEXENTRY    *idxFmtChanges;
 173   DWORD             nIdxFmtChanges; /* upper index limit of idxFmtChanges */
 174 } IAVIStreamImpl;
 175
 176 struct _IAVIFileImpl {
 177   /* IUnknown stuff */
 178   const IAVIFileVtbl     *lpVtbl;
 179   LONG              ref;
 180
 181   /* IAVIFile stuff... */
 182   IPersistFileImpl  iPersistFile;
 183
 184   AVIFILEINFOW      fInfo;
 185   IAVIStreamImpl   *ppStreams[MAX_AVISTREAMS];
 186
 187   EXTRACHUNKS       fileextra;
 188
 189   DWORD             dwMoviChunkPos;  /* some stuff for saving ... */
 190   DWORD             dwIdxChunkPos;
 191   DWORD             dwNextFramePos;
 192   DWORD             dwInitialFrames;
 193
 194   MMCKINFO          ckLastRecord;
 195   AVIINDEXENTRY    *idxRecords;      /* won't be updated while loading */
 196   DWORD             nIdxRecords;     /* current fill level */
 197   DWORD             cbIdxRecords;    /* size of idxRecords */
 198
 199   /* IPersistFile stuff ... */
 200   HMMIO             hmmio;
 201   LPWSTR            szFileName;
 202   UINT              uMode;
 203   BOOL              fDirty;
 204 };
 205
 206 /***********************************************************************/
 207
 208 static HRESULT AVIFILE_AddFrame(IAVIStreamImpl *This, DWORD ckid, DWORD size,
 209                                 DWORD offset, DWORD flags);
 210 static HRESULT AVIFILE_AddRecord(IAVIFileImpl *This);
 211 static DWORD   AVIFILE_ComputeMoviStart(IAVIFileImpl *This);
 212 static void    AVIFILE_ConstructAVIStream(IAVIFileImpl *paf, DWORD nr,
 213                                           const AVISTREAMINFOW *asi);
 214 static void    AVIFILE_DestructAVIStream(IAVIStreamImpl *This);
 215 static HRESULT AVIFILE_LoadFile(IAVIFileImpl *This);
 216 static HRESULT AVIFILE_LoadIndex(const IAVIFileImpl *This, DWORD size, DWORD offset);
 217 static HRESULT AVIFILE_ParseIndex(const IAVIFileImpl *This, AVIINDEXENTRY *lp,
 218                                   LONG count, DWORD pos, BOOL *bAbsolute);
 219 static HRESULT AVIFILE_ReadBlock(IAVIStreamImpl *This, DWORD start,
 220                                  LPVOID buffer, DWORD size);
 221 static void    AVIFILE_SamplesToBlock(const IAVIStreamImpl *This, LPLONG pos,
 222                                       LPLONG offset);
 223 static HRESULT AVIFILE_SaveFile(IAVIFileImpl *This);
 224 static HRESULT AVIFILE_SaveIndex(const IAVIFileImpl *This);
 225 static ULONG   AVIFILE_SearchStream(const IAVIFileImpl *This, DWORD fccType,
 226                                     LONG lSkip);
 227 static void    AVIFILE_UpdateInfo(IAVIFileImpl *This);
 228 static HRESULT AVIFILE_WriteBlock(IAVIStreamImpl *This, DWORD block,
 229                                   FOURCC ckid, DWORD flags, LPCVOID buffer,
 230                                   LONG size);
 231
 232 HRESULT AVIFILE_CreateAVIFile(REFIID riid, LPVOID *ppv)
 233 {
 234   IAVIFileImpl *pfile;
 235   HRESULT       hr;
 236
 237   assert(riid != NULL && ppv != NULL);
 238
 239   *ppv = NULL;
 240
 241   pfile = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAVIFileImpl));
 242   if (pfile == NULL)
 243     return AVIERR_MEMORY;
 244
 245   pfile->lpVtbl = &iavift;
 246   pfile->ref = 0;
 247   pfile->iPersistFile.lpVtbl = &ipersistft;
 248   pfile->iPersistFile.paf = pfile;
 249
 250   hr = IAVIFile_QueryInterface((IAVIFile*)pfile, riid, ppv);
 251   if (FAILED(hr))
 252     HeapFree(GetProcessHeap(), 0, pfile);
 253
 254   return hr;
 255 }
 256
 257 static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile *iface, REFIID refiid,
 258                                                 LPVOID *obj)
 259 {
 260   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 261
 262   TRACE("(%p,%s,%p)\n", This, debugstr_guid(refiid), obj);
 263
 264   if (IsEqualGUID(&IID_IUnknown, refiid) ||
 265       IsEqualGUID(&IID_IAVIFile, refiid)) {
 266     *obj = iface;
 267     IAVIFile_AddRef(iface);
 268
 269     return S_OK;
 270   } else if (IsEqualGUID(&IID_IPersistFile, refiid)) {
 271     *obj = &This->iPersistFile;
 272     IAVIFile_AddRef(iface);
 273
 274     return S_OK;
 275   }
 276
 277   return OLE_E_ENUM_NOMORE;
 278 }
 279
 280 static ULONG WINAPI IAVIFile_fnAddRef(IAVIFile *iface)
 281 {
 282   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 283   ULONG ref = InterlockedIncrement(&This->ref);
 284
 285   TRACE("(%p) -> %d\n", iface, ref);
 286
 287   return ref;
 288 }
 289
 290 static ULONG WINAPI IAVIFile_fnRelease(IAVIFile *iface)
 291 {
 292   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 293   UINT i;
 294   ULONG ref = InterlockedDecrement(&This->ref);
 295
 296   TRACE("(%p) -> %d\n", iface, ref);
 297
 298   if (!ref) {
 299     if (This->fDirty) {
 300       /* need to write headers to file */
 301       AVIFILE_SaveFile(This);
 302     }
 303
 304     for (i = 0; i < This->fInfo.dwStreams; i++) {
 305       if (This->ppStreams[i] != NULL) {
 306         if (This->ppStreams[i]->ref != 0) {
 307           ERR(": someone has still %u reference to stream %u (%p)!\n",
 308                This->ppStreams[i]->ref, i, This->ppStreams[i]);
 309         }
 310         AVIFILE_DestructAVIStream(This->ppStreams[i]);
 311         HeapFree(GetProcessHeap(), 0, This->ppStreams[i]);
 312         This->ppStreams[i] = NULL;
 313       }
 314     }
 315
 316     if (This->idxRecords != NULL) {
 317       HeapFree(GetProcessHeap(), 0, This->idxRecords);
 318       This->idxRecords  = NULL;
 319       This->nIdxRecords = 0;
 320     }
 321
 322     if (This->fileextra.lp != NULL) {
 323       HeapFree(GetProcessHeap(), 0, This->fileextra.lp);
 324       This->fileextra.lp = NULL;
 325       This->fileextra.cb = 0;
 326     }
 327
 328     HeapFree(GetProcessHeap(), 0, This->szFileName);
 329     This->szFileName = NULL;
 330
 331     if (This->hmmio != NULL) {
 332       mmioClose(This->hmmio, 0);
 333       This->hmmio = NULL;
 334     }
 335
 336     HeapFree(GetProcessHeap(), 0, This);
 337   }
 338   return ref;
 339 }
 340
 341 static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile *iface, LPAVIFILEINFOW afi,
 342                                       LONG size)
 343 {
 344   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 345
 346   TRACE("(%p,%p,%d)\n",iface,afi,size);
 347
 348   if (afi == NULL)
 349     return AVIERR_BADPARAM;
 350   if (size < 0)
 351     return AVIERR_BADSIZE;
 352
 353   AVIFILE_UpdateInfo(This);
 354
 355   memcpy(afi, &This->fInfo, min((DWORD)size, sizeof(This->fInfo)));
 356
 357   if ((DWORD)size < sizeof(This->fInfo))
 358     return AVIERR_BUFFERTOOSMALL;
 359   return AVIERR_OK;
 360 }
 361
 362 static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile *iface, PAVISTREAM *avis,
 363                                            DWORD fccType, LONG lParam)
 364 {
 365   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 366
 367   ULONG nStream;
 368
 369   TRACE("(%p,%p,0x%08X,%d)\n", iface, avis, fccType, lParam);
 370
 371   if (avis == NULL || lParam < 0)
 372     return AVIERR_BADPARAM;
 373
 374   nStream = AVIFILE_SearchStream(This, fccType, lParam);
 375
 376   /* Does the requested stream exist? */
 377   if (nStream < This->fInfo.dwStreams &&
 378       This->ppStreams[nStream] != NULL) {
 379     *avis = (PAVISTREAM)This->ppStreams[nStream];
 380     IAVIStream_AddRef(*avis);
 381
 382     return AVIERR_OK;
 383   }
 384
 385   /* Sorry, but the specified stream doesn't exist */
 386   return AVIERR_NODATA;
 387 }
 388
 389 static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile *iface,PAVISTREAM *avis,
 390                                               LPAVISTREAMINFOW asi)
 391 {
 392   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 393
 394   DWORD n;
 395
 396   TRACE("(%p,%p,%p)\n", iface, avis, asi);
 397
 398   /* check parameters */
 399   if (avis == NULL || asi == NULL)
 400     return AVIERR_BADPARAM;
 401
 402   *avis = NULL;
 403
 404   /* Does the user have write permission? */
 405   if ((This->uMode & MMIO_RWMODE) == 0)
 406     return AVIERR_READONLY;
 407
 408   /* Can we add another stream? */
 409   n = This->fInfo.dwStreams;
 410   if (n >= MAX_AVISTREAMS || This->dwMoviChunkPos != 0) {
 411     /* already reached max nr of streams
 412      * or have already written frames to disk */
 413     return AVIERR_UNSUPPORTED;
 414   }
 415
 416   /* check AVISTREAMINFO for some really needed things */
 417   if (asi->fccType == 0 || asi->dwScale == 0 || asi->dwRate == 0)
 418     return AVIERR_BADFORMAT;
 419
 420   /* now it seems to be save to add the stream */
 421   assert(This->ppStreams[n] == NULL);
 422   This->ppStreams[n] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 423                                                    sizeof(IAVIStreamImpl));
 424   if (This->ppStreams[n] == NULL)
 425     return AVIERR_MEMORY;
 426
 427   /* initialize the new allocated stream */
 428   AVIFILE_ConstructAVIStream(This, n, asi);
 429
 430   This->fInfo.dwStreams++;
 431   This->fDirty = TRUE;
 432
 433   /* update our AVIFILEINFO structure */
 434   AVIFILE_UpdateInfo(This);
 435
 436   /* return it */
 437   *avis = (PAVISTREAM)This->ppStreams[n];
 438   IAVIStream_AddRef(*avis);
 439
 440   return AVIERR_OK;
 441 }
 442
 443 static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile *iface, DWORD ckid,
 444                                            LPVOID lpData, LONG size)
 445 {
 446   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 447
 448   TRACE("(%p,0x%08X,%p,%d)\n", iface, ckid, lpData, size);
 449
 450   /* check parameters */
 451   if (lpData == NULL)
 452     return AVIERR_BADPARAM;
 453   if (size < 0)
 454     return AVIERR_BADSIZE;
 455
 456   /* Do we have write permission? */
 457   if ((This->uMode & MMIO_RWMODE) == 0)
 458     return AVIERR_READONLY;
 459
 460   This->fDirty = TRUE;
 461
 462   return WriteExtraChunk(&This->fileextra, ckid, lpData, size);
 463 }
 464
 465 static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile *iface, DWORD ckid,
 466                                           LPVOID lpData, LONG *size)
 467 {
 468   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 469
 470   TRACE("(%p,0x%08X,%p,%p)\n", iface, ckid, lpData, size);
 471
 472   return ReadExtraChunk(&This->fileextra, ckid, lpData, size);
 473 }
 474
 475 static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile *iface)
 476 {
 477   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 478
 479   TRACE("(%p)\n",iface);
 480
 481   if ((This->uMode & MMIO_RWMODE) == 0)
 482     return AVIERR_READONLY;
 483
 484   This->fDirty = TRUE;
 485
 486   /* no frames written to any stream? -- compute start of 'movi'-chunk */
 487   if (This->dwMoviChunkPos == 0)
 488     AVIFILE_ComputeMoviStart(This);
 489
 490   This->fInfo.dwFlags  |= AVIFILEINFO_ISINTERLEAVED;
 491
 492   /* already written frames to any stream, ... */
 493   if (This->ckLastRecord.dwFlags & MMIO_DIRTY) {
 494     /* close last record */
 495     if (mmioAscend(This->hmmio, &This->ckLastRecord, 0) != 0)
 496       return AVIERR_FILEWRITE;
 497
 498     AVIFILE_AddRecord(This);
 499
 500     if (This->fInfo.dwSuggestedBufferSize < This->ckLastRecord.cksize + 3 * sizeof(DWORD))
 501       This->fInfo.dwSuggestedBufferSize = This->ckLastRecord.cksize + 3 * sizeof(DWORD);
 502   }
 503
 504   /* write out a new record into file, but don't close it */
 505   This->ckLastRecord.cksize  = 0;
 506   This->ckLastRecord.fccType = listtypeAVIRECORD;
 507   if (mmioSeek(This->hmmio, This->dwNextFramePos, SEEK_SET) == -1)
 508     return AVIERR_FILEWRITE;
 509   if (mmioCreateChunk(This->hmmio, &This->ckLastRecord, MMIO_CREATELIST) != 0)
 510     return AVIERR_FILEWRITE;
 511   This->dwNextFramePos += 3 * sizeof(DWORD);
 512
 513   return AVIERR_OK;
 514 }
 515
 516 static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile *iface, DWORD fccType,
 517                                               LONG lParam)
 518 {
 519   IAVIFileImpl *This = (IAVIFileImpl *)iface;
 520
 521   ULONG nStream;
 522
 523   TRACE("(%p,0x%08X,%d)\n", iface, fccType, lParam);
 524
 525   /* check parameter */
 526   if (lParam < 0)
 527     return AVIERR_BADPARAM;
 528
 529   /* Have user write permissions? */
 530   if ((This->uMode & MMIO_RWMODE) == 0)
 531     return AVIERR_READONLY;
 532
 533   nStream = AVIFILE_SearchStream(This, fccType, lParam);
 534
 535   /* Does the requested stream exist? */
 536   if (nStream < This->fInfo.dwStreams &&
 537       This->ppStreams[nStream] != NULL) {
 538     /* ... so delete it now */
 539     HeapFree(GetProcessHeap(), 0, This->ppStreams[nStream]);
 540
 541     if (This->fInfo.dwStreams - nStream > 0)
 542       memcpy(This->ppStreams + nStream, This->ppStreams + nStream + 1,
 543              (This->fInfo.dwStreams - nStream) * sizeof(IAVIStreamImpl*));
 544
 545     This->ppStreams[This->fInfo.dwStreams] = NULL;
 546     This->fInfo.dwStreams--;
 547     This->fDirty = TRUE;
 548
 549     /* This->fInfo will be updated further when asked for */
 550     return AVIERR_OK;
 551   } else
 552     return AVIERR_NODATA;
 553 }
 554
 555 /***********************************************************************/
 556
 557 static HRESULT WINAPI IPersistFile_fnQueryInterface(IPersistFile *iface,
 558                                                     REFIID refiid, LPVOID *obj)
 559 {
 560   IPersistFileImpl *This = (IPersistFileImpl *)iface;
 561
 562   assert(This->paf != NULL);
 563
 564   return IAVIFile_QueryInterface((PAVIFILE)This->paf, refiid, obj);
 565 }
 566
 567 static ULONG   WINAPI IPersistFile_fnAddRef(IPersistFile *iface)
 568 {
 569   IPersistFileImpl *This = (IPersistFileImpl *)iface;
 570
 571   assert(This->paf != NULL);
 572
 573   return IAVIFile_AddRef((PAVIFILE)This->paf);
 574 }
 575
 576 static ULONG   WINAPI IPersistFile_fnRelease(IPersistFile *iface)
 577 {
 578   IPersistFileImpl *This = (IPersistFileImpl *)iface;
 579
 580   assert(This->paf != NULL);
 581
 582   return IAVIFile_Release((PAVIFILE)This->paf);
 583 }
 584
 585 static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile *iface,
 586                                                 LPCLSID pClassID)
 587 {
 588   TRACE("(%p,%p)\n", iface, pClassID);
 589
 590   if (pClassID == NULL)
 591     return AVIERR_BADPARAM;
 592
 593   *pClassID = CLSID_AVIFile;
 594
 595   return AVIERR_OK;
 596 }
 597
 598 static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile *iface)
 599 {
 600   IPersistFileImpl *This = (IPersistFileImpl *)iface;
 601
 602   TRACE("(%p)\n", iface);
 603
 604   assert(This->paf != NULL);
 605
 606   return (This->paf->fDirty ? S_OK : S_FALSE);
 607 }
 608
 609 static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile *iface,
 610                                           LPCOLESTR pszFileName, DWORD dwMode)
 611 {
 612   IPersistFileImpl *This = (IPersistFileImpl *)iface;
 613
 614   int len;
 615
 616   TRACE("(%p,%s,0x%08X)\n", iface, debugstr_w(pszFileName), dwMode);
 617
 618   /* check parameter */
 619   if (pszFileName == NULL)
 620     return AVIERR_BADPARAM;
 621
 622   assert(This->paf != NULL);
 623   if (This->paf->hmmio != NULL)
 624     return AVIERR_ERROR; /* No reuse of this object for another file! */
 625
 626   /* remember mode and name */
 627   This->paf->uMode = dwMode;
 628
 629   len = lstrlenW(pszFileName) + 1;
 630   This->paf->szFileName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 631   if (This->paf->szFileName == NULL)
 632     return AVIERR_MEMORY;
 633   lstrcpyW(This->paf->szFileName, pszFileName);
 634
 635   /* try to open the file */
 636   This->paf->hmmio = mmioOpenW(This->paf->szFileName, NULL,
 637                                MMIO_ALLOCBUF | dwMode);
 638   if (This->paf->hmmio == NULL) {
 639     /* mmioOpenW not in native DLLs of Win9x -- try mmioOpenA */
 640     LPSTR szFileName;
 641
 642     len = WideCharToMultiByte(CP_ACP, 0, This->paf->szFileName, -1,
 643                                NULL, 0, NULL, NULL);
 644     szFileName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(CHAR));
 645     if (szFileName == NULL)
 646       return AVIERR_MEMORY;
 647
 648     WideCharToMultiByte(CP_ACP, 0, This->paf->szFileName, -1, szFileName,
 649                         len, NULL, NULL);
 650
 651     This->paf->hmmio = mmioOpenA(szFileName, NULL, MMIO_ALLOCBUF | dwMode);
 652     HeapFree(GetProcessHeap(), 0, szFileName);
 653     if (This->paf->hmmio == NULL)
 654       return AVIERR_FILEOPEN;
 655   }
 656
 657   /* should we create a new file? */
 658   if (dwMode & OF_CREATE) {
 659     memset(& This->paf->fInfo, 0, sizeof(This->paf->fInfo));
 660     This->paf->fInfo.dwFlags = AVIFILEINFO_HASINDEX | AVIFILEINFO_TRUSTCKTYPE;
 661
 662     return AVIERR_OK;
 663   } else
 664     return AVIFILE_LoadFile(This->paf);
 665 }
 666
 667 static HRESULT WINAPI IPersistFile_fnSave(IPersistFile *iface,
 668                                           LPCOLESTR pszFileName,BOOL fRemember)
 669 {
 670   TRACE("(%p,%s,%d)\n", iface, debugstr_w(pszFileName), fRemember);
 671
 672   /* We write directly to disk, so nothing to do. */
 673
 674   return AVIERR_OK;
 675 }
 676
 677 static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile *iface,
 678                                                    LPCOLESTR pszFileName)
 679 {
 680   TRACE("(%p,%s)\n", iface, debugstr_w(pszFileName));
 681
 682   /* We write directly to disk, so nothing to do. */
 683
 684   return AVIERR_OK;
 685 }
 686
 687 static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile *iface,
 688                                                 LPOLESTR *ppszFileName)
 689 {
 690   IPersistFileImpl *This = (IPersistFileImpl *)iface;
 691
 692   TRACE("(%p,%p)\n", iface, ppszFileName);
 693
 694   if (ppszFileName == NULL)
 695     return AVIERR_BADPARAM;
 696
 697   *ppszFileName = NULL;
 698
 699   assert(This->paf != NULL);
 700
 701   if (This->paf->szFileName != NULL) {
 702     int len = lstrlenW(This->paf->szFileName) + 1;
 703
 704     *ppszFileName = CoTaskMemAlloc(len * sizeof(WCHAR));
 705     if (*ppszFileName == NULL)
 706       return AVIERR_MEMORY;
 707
 708     strcpyW(*ppszFileName, This->paf->szFileName);
 709   }
 710
 711   return AVIERR_OK;
 712 }
 713
 714 /***********************************************************************/
 715
 716 static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream *iface,
 717                                                   REFIID refiid, LPVOID *obj)
 718 {
 719   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 720
 721   TRACE("(%p,%s,%p)\n", iface, debugstr_guid(refiid), obj);
 722
 723   if (IsEqualGUID(&IID_IUnknown, refiid) ||
 724       IsEqualGUID(&IID_IAVIStream, refiid)) {
 725     *obj = This;
 726     IAVIStream_AddRef(iface);
 727
 728     return S_OK;
 729   }
 730   /* FIXME: IAVIStreaming interface */
 731
 732   return OLE_E_ENUM_NOMORE;
 733 }
 734
 735 static ULONG WINAPI IAVIStream_fnAddRef(IAVIStream *iface)
 736 {
 737   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 738   ULONG ref = InterlockedIncrement(&This->ref);
 739
 740   TRACE("(%p) -> %d\n", iface, ref);
 741
 742   /* also add ref to parent, so that it doesn't kill us */
 743   if (This->paf != NULL)
 744     IAVIFile_AddRef((PAVIFILE)This->paf);
 745
 746   return ref;
 747 }
 748
 749 static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface)
 750 {
 751   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 752   ULONG ref = InterlockedDecrement(&This->ref);
 753
 754   TRACE("(%p) -> %d\n", iface, ref);
 755
 756   if (This->paf != NULL)
 757     IAVIFile_Release((PAVIFILE)This->paf);
 758
 759   return ref;
 760 }
 761
 762 static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream *iface, LPARAM lParam1,
 763                                           LPARAM lParam2)
 764 {
 765   TRACE("(%p,0x%08lX,0x%08lX)\n", iface, lParam1, lParam2);
 766
 767   /* This IAVIStream interface needs an AVIFile */
 768   return AVIERR_UNSUPPORTED;
 769 }
 770
 771 static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream *iface,LPAVISTREAMINFOW psi,
 772                                         LONG size)
 773 {
 774   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 775
 776   TRACE("(%p,%p,%d)\n", iface, psi, size);
 777
 778   if (psi == NULL)
 779     return AVIERR_BADPARAM;
 780   if (size < 0)
 781     return AVIERR_BADSIZE;
 782
 783   memcpy(psi, &This->sInfo, min((DWORD)size, sizeof(This->sInfo)));
 784
 785   if ((DWORD)size < sizeof(This->sInfo))
 786     return AVIERR_BUFFERTOOSMALL;
 787   return AVIERR_OK;
 788 }
 789
 790 static LONG WINAPI IAVIStream_fnFindSample(IAVIStream *iface, LONG pos,
 791                                            LONG flags)
 792 {
 793   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 794
 795   LONG offset = 0;
 796
 797   TRACE("(%p,%d,0x%08X)\n",iface,pos,flags);
 798
 799   if (flags & FIND_FROM_START) {
 800     pos = This->sInfo.dwStart;
 801     flags &= ~(FIND_FROM_START|FIND_PREV);
 802     flags |= FIND_NEXT;
 803   }
 804
 805   if (This->sInfo.dwSampleSize != 0) {
 806     /* convert samples into block number with offset */
 807     AVIFILE_SamplesToBlock(This, &pos, &offset);
 808   }
 809
 810   if (flags & FIND_TYPE) {
 811     if (flags & FIND_KEY) {
 812       while (0 <= pos && pos <= This->lLastFrame) {
 813         if (This->idxFrames[pos].dwFlags & AVIIF_KEYFRAME)
 814           goto RETURN_FOUND;
 815
 816         if (flags & FIND_NEXT)
 817           pos++;
 818         else
 819           pos--;
 820       };
 821     } else if (flags & FIND_ANY) {
 822       while (0 <= pos && pos <= This->lLastFrame) {
 823         if (This->idxFrames[pos].dwChunkLength > 0)
 824           goto RETURN_FOUND;
 825
 826         if (flags & FIND_NEXT)
 827           pos++;
 828         else
 829           pos--;
 830
 831       };
 832     } else if ((flags & FIND_FORMAT) && This->idxFmtChanges != NULL &&
 833                This->sInfo.fccType == streamtypeVIDEO) {
 834       if (flags & FIND_NEXT) {
 835         ULONG n;
 836
 837         for (n = 0; n < This->sInfo.dwFormatChangeCount; n++)
 838           if (This->idxFmtChanges[n].ckid >= pos) {
 839             pos = This->idxFmtChanges[n].ckid;
 840             goto RETURN_FOUND;
 841           }
 842       } else {
 843         LONG n;
 844
 845         for (n = (LONG)This->sInfo.dwFormatChangeCount; n >= 0; n--) {
 846           if (This->idxFmtChanges[n].ckid <= pos) {
 847             pos = This->idxFmtChanges[n].ckid;
 848             goto RETURN_FOUND;
 849           }
 850         }
 851
 852         if (pos > (LONG)This->sInfo.dwStart)
 853           return 0; /* format changes always for first frame */
 854       }
 855     }
 856
 857     return -1;
 858   }
 859
 860  RETURN_FOUND:
 861   if (pos < (LONG)This->sInfo.dwStart)
 862     return -1;
 863
 864   switch (flags & FIND_RET) {
 865   case FIND_LENGTH:
 866     /* physical size */
 867     pos = This->idxFrames[pos].dwChunkLength;
 868     break;
 869   case FIND_OFFSET:
 870     /* physical position */
 871     pos = This->idxFrames[pos].dwChunkOffset + 2 * sizeof(DWORD)
 872       + offset * This->sInfo.dwSampleSize;
 873     break;
 874   case FIND_SIZE:
 875     /* logical size */
 876     if (This->sInfo.dwSampleSize)
 877       pos = This->sInfo.dwSampleSize;
 878     else
 879       pos = 1;
 880     break;
 881   case FIND_INDEX:
 882     FIXME(": FIND_INDEX flag is not supported!\n");
 883     /* This is an index in the index-table on disc. */
 884     break;
 885   }; /* else logical position */
 886
 887   return pos;
 888 }
 889
 890 static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream *iface, LONG pos,
 891                                               LPVOID format, LONG *formatsize)
 892 {
 893   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 894
 895   TRACE("(%p,%d,%p,%p)\n", iface, pos, format, formatsize);
 896
 897   if (formatsize == NULL)
 898     return AVIERR_BADPARAM;
 899
 900   /* only interested in needed buffersize? */
 901   if (format == NULL || *formatsize <= 0) {
 902     *formatsize = This->cbFormat;
 903
 904     return AVIERR_OK;
 905   }
 906
 907   /* copy initial format (only as much as will fit) */
 908   memcpy(format, This->lpFormat, min(*(DWORD*)formatsize, This->cbFormat));
 909   if (*(DWORD*)formatsize < This->cbFormat) {
 910     *formatsize = This->cbFormat;
 911     return AVIERR_BUFFERTOOSMALL;
 912   }
 913
 914   /* Could format change? When yes will it change? */
 915   if ((This->sInfo.dwFlags & AVISTREAMINFO_FORMATCHANGES) &&
 916       pos > This->sInfo.dwStart) {
 917     LONG lLastFmt;
 918
 919     lLastFmt = IAVIStream_fnFindSample(iface, pos, FIND_FORMAT|FIND_PREV);
 920     if (lLastFmt > 0) {
 921       FIXME(": need to read formatchange for %d -- unimplemented!\n",lLastFmt);
 922     }
 923   }
 924
 925   *formatsize = This->cbFormat;
 926   return AVIERR_OK;
 927 }
 928
 929 static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream *iface, LONG pos,
 930                                              LPVOID format, LONG formatsize)
 931 {
 932   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 933
 934   LPBITMAPINFOHEADER lpbiNew = format;
 935
 936   TRACE("(%p,%d,%p,%d)\n", iface, pos, format, formatsize);
 937
 938   /* check parameters */
 939   if (format == NULL || formatsize <= 0)
 940     return AVIERR_BADPARAM;
 941
 942   /* Do we have write permission? */
 943   if ((This->paf->uMode & MMIO_RWMODE) == 0)
 944     return AVIERR_READONLY;
 945
 946   /* can only set format before frame is written! */
 947   if (This->lLastFrame > pos)
 948     return AVIERR_UNSUPPORTED;
 949
 950   /* initial format or a formatchange? */
 951   if (This->lpFormat == NULL) {
 952     /* initial format */
 953     if (This->paf->dwMoviChunkPos != 0)
 954       return AVIERR_ERROR; /* user has used API in wrong sequence! */
 955
 956     This->lpFormat = HeapAlloc(GetProcessHeap(), 0, formatsize);
 957     if (This->lpFormat == NULL)
 958       return AVIERR_MEMORY;
 959     This->cbFormat = formatsize;
 960
 961     memcpy(This->lpFormat, format, formatsize);
 962
 963     /* update some infos about stream */
 964     if (This->sInfo.fccType == streamtypeVIDEO) {
 965       LONG lDim;
 966
 967       lDim = This->sInfo.rcFrame.right - This->sInfo.rcFrame.left;
 968       if (lDim < lpbiNew->biWidth)
 969         This->sInfo.rcFrame.right = This->sInfo.rcFrame.left + lpbiNew->biWidth;
 970       lDim = This->sInfo.rcFrame.bottom - This->sInfo.rcFrame.top;
 971       if (lDim < lpbiNew->biHeight)
 972         This->sInfo.rcFrame.bottom = This->sInfo.rcFrame.top + lpbiNew->biHeight;
 973     } else if (This->sInfo.fccType == streamtypeAUDIO)
 974       This->sInfo.dwSampleSize = ((LPWAVEFORMATEX)This->lpFormat)->nBlockAlign;
 975
 976     return AVIERR_OK;
 977   } else {
 978     MMCKINFO           ck;
 979     LPBITMAPINFOHEADER lpbiOld = This->lpFormat;
 980     RGBQUAD           *rgbNew  = (RGBQUAD*)((LPBYTE)lpbiNew + lpbiNew->biSize);
 981     AVIPALCHANGE      *lppc = NULL;
 982     UINT               n;
 983
 984     /* perhaps format change, check it ... */
 985     if (This->cbFormat != formatsize)
 986       return AVIERR_UNSUPPORTED;
 987
 988     /* no format change, only the initial one */
 989     if (memcmp(This->lpFormat, format, formatsize) == 0)
 990       return AVIERR_OK;
 991
 992     /* check that's only the palette, which changes */
 993     if (lpbiOld->biSize        != lpbiNew->biSize ||
 994         lpbiOld->biWidth       != lpbiNew->biWidth ||
 995         lpbiOld->biHeight      != lpbiNew->biHeight ||
 996         lpbiOld->biPlanes      != lpbiNew->biPlanes ||
 997         lpbiOld->biBitCount    != lpbiNew->biBitCount ||
 998         lpbiOld->biCompression != lpbiNew->biCompression ||
 999         lpbiOld->biClrUsed     != lpbiNew->biClrUsed)
1000       return AVIERR_UNSUPPORTED;
1001
1002     This->sInfo.dwFlags |= AVISTREAMINFO_FORMATCHANGES;
1003
1004     /* simply say all colors have changed */
1005     ck.ckid   = MAKEAVICKID(cktypePALchange, This->nStream);
1006     ck.cksize = 2 * sizeof(WORD) + lpbiOld->biClrUsed * sizeof(PALETTEENTRY);
1007     lppc = HeapAlloc(GetProcessHeap(), 0, ck.cksize);
1008     if (lppc == NULL)
1009       return AVIERR_MEMORY;
1010
1011     lppc->bFirstEntry = 0;
1012     lppc->bNumEntries = (lpbiOld->biClrUsed < 256 ? lpbiOld->biClrUsed : 0);
1013     lppc->wFlags      = 0;
1014     for (n = 0; n < lpbiOld->biClrUsed; n++) {
1015       lppc->peNew[n].peRed   = rgbNew[n].rgbRed;
1016       lppc->peNew[n].peGreen = rgbNew[n].rgbGreen;
1017       lppc->peNew[n].peBlue  = rgbNew[n].rgbBlue;
1018       lppc->peNew[n].peFlags = 0;
1019     }
1020
1021     if (mmioSeek(This->paf->hmmio, This->paf->dwNextFramePos, SEEK_SET) == -1 ||
1022         mmioCreateChunk(This->paf->hmmio, &ck, 0) != S_OK ||
1023         mmioWrite(This->paf->hmmio, (HPSTR)lppc, ck.cksize) != ck.cksize ||
1024         mmioAscend(This->paf->hmmio, &ck, 0) != S_OK)
1025     {
1026       HeapFree(GetProcessHeap(), 0, lppc);
1027       return AVIERR_FILEWRITE;
1028     }
1029
1030     This->paf->dwNextFramePos += ck.cksize + 2 * sizeof(DWORD);
1031
1032     HeapFree(GetProcessHeap(), 0, lppc);
1033
1034     return AVIFILE_AddFrame(This, cktypePALchange, n, ck.dwDataOffset, 0);
1035   }
1036 }
1037
1038 static HRESULT WINAPI IAVIStream_fnRead(IAVIStream *iface, LONG start,
1039                                         LONG samples, LPVOID buffer,
1040                                         LONG buffersize, LPLONG bytesread,
1041                                         LPLONG samplesread)
1042 {
1043   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
1044
1045   DWORD    size;
1046   HRESULT  hr;
1047
1048   TRACE("(%p,%d,%d,%p,%d,%p,%p)\n", iface, start, samples, buffer,
1049         buffersize, bytesread, samplesread);
1050
1051   /* clear return parameters if given */
1052   if (bytesread != NULL)
1053     *bytesread = 0;
1054   if (samplesread != NULL)
1055     *samplesread = 0;
1056
1057   /* check parameters */
1058   if ((LONG)This->sInfo.dwStart > start)
1059     return AVIERR_NODATA; /* couldn't read before start of stream */
1060   if (This->sInfo.dwStart + This->sInfo.dwLength < (DWORD)start)
1061     return AVIERR_NODATA; /* start is past end of stream */
1062
1063   /* should we read as much as possible? */
1064   if (samples == -1) {
1065     /* User should know how much we have read */
1066     if (bytesread == NULL && samplesread == NULL)
1067       return AVIERR_BADPARAM;
1068
1069     if (This->sInfo.dwSampleSize != 0)
1070       samples = buffersize / This->sInfo.dwSampleSize;
1071     else
1072       samples = 1;
1073   }
1074
1075   /* limit to end of stream */
1076   if ((LONG)This->sInfo.dwLength < samples)
1077     samples = This->sInfo.dwLength;
1078   if ((start - This->sInfo.dwStart) > (This->sInfo.dwLength - samples))
1079     samples = This->sInfo.dwLength - (start - This->sInfo.dwStart);
1080
1081   /* nothing to read? Then leave ... */
1082   if (samples == 0)
1083     return AVIERR_OK;
1084
1085   if (This->sInfo.dwSampleSize != 0) {
1086     /* fixed samplesize -- we can read over frame/block boundaries */
1087     LONG block = start;
1088     LONG offset = 0;
1089
1090     /* convert start sample to block,offset pair */
1091     AVIFILE_SamplesToBlock(This, &block, &offset);
1092
1093     /* convert samples to bytes */
1094     samples *= This->sInfo.dwSampleSize;
1095
1096     while (samples > 0 && buffersize > 0) {
1097       if (block != This->dwCurrentFrame) {
1098         hr = AVIFILE_ReadBlock(This, block, NULL, 0);
1099         if (FAILED(hr))
1100           return hr;
1101       }
1102
1103       size = min((DWORD)samples, (DWORD)buffersize);
1104       size = min(size, This->cbBuffer - offset);
1105       memcpy(buffer, ((BYTE*)&This->lpBuffer[2]) + offset, size);
1106
1107       block++;
1108       offset = 0;
1109       buffer = ((LPBYTE)buffer)+size;
1110       samples    -= size;
1111       buffersize -= size;
1112
1113       /* fill out return parameters if given */
1114       if (bytesread != NULL)
1115         *bytesread   += size;
1116       if (samplesread != NULL)
1117         *samplesread += size / This->sInfo.dwSampleSize;
1118     }
1119
1120     if (samples == 0)
1121       return AVIERR_OK;
1122     else
1123       return AVIERR_BUFFERTOOSMALL;
1124   } else {
1125     /* variable samplesize -- we can only read one full frame/block */
1126     if (samples > 1)
1127       samples = 1;
1128
1129     assert(start <= This->lLastFrame);
1130     size = This->idxFrames[start].dwChunkLength;
1131     if (buffer != NULL && buffersize >= size) {
1132       hr = AVIFILE_ReadBlock(This, start, buffer, size);
1133       if (FAILED(hr))
1134         return hr;
1135     } else if (buffer != NULL)
1136       return AVIERR_BUFFERTOOSMALL;
1137
1138     /* fill out return parameters if given */
1139     if (bytesread != NULL)
1140       *bytesread = size;
1141     if (samplesread != NULL)
1142       *samplesread = samples;
1143
1144     return AVIERR_OK;
1145   }
1146 }
1147
1148 static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream *iface, LONG start,
1149                                          LONG samples, LPVOID buffer,
1150                                          LONG buffersize, DWORD flags,
1151                                          LPLONG sampwritten,
1152                                          LPLONG byteswritten)
1153 {
1154   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
1155
1156   FOURCC  ckid;
1157   HRESULT hr;
1158
1159   TRACE("(%p,%d,%d,%p,%d,0x%08X,%p,%p)\n", iface, start, samples,
1160         buffer, buffersize, flags, sampwritten, byteswritten);
1161
1162   /* clear return parameters if given */
1163   if (sampwritten != NULL)
1164     *sampwritten = 0;
1165   if (byteswritten != NULL)
1166     *byteswritten = 0;
1167
1168   /* check parameters */
1169   if (buffer == NULL && (buffersize > 0 || samples > 0))
1170     return AVIERR_BADPARAM;
1171
1172   /* Have we write permission? */
1173   if ((This->paf->uMode & MMIO_RWMODE) == 0)
1174     return AVIERR_READONLY;
1175
1176   switch (This->sInfo.fccType) {
1177   case streamtypeAUDIO:
1178     ckid = MAKEAVICKID(cktypeWAVEbytes, This->nStream);
1179     break;
1180   default:
1181     if ((flags & AVIIF_KEYFRAME) && buffersize != 0)
1182       ckid = MAKEAVICKID(cktypeDIBbits, This->nStream);
1183     else
1184       ckid = MAKEAVICKID(cktypeDIBcompressed, This->nStream);
1185     break;
1186   };
1187
1188   /* append to end of stream? */
1189   if (start == -1) {
1190     if (This->lLastFrame == -1)
1191       start = This->sInfo.dwStart;
1192     else
1193       start = This->sInfo.dwLength;
1194   } else if (This->lLastFrame == -1)
1195     This->sInfo.dwStart = start;
1196
1197   if (This->sInfo.dwSampleSize != 0) {
1198     /* fixed sample size -- audio like */
1199     if (samples * This->sInfo.dwSampleSize != buffersize)
1200       return AVIERR_BADPARAM;
1201
1202     /* Couldn't skip audio-like data -- User must supply appropriate silence */
1203     if (This->sInfo.dwLength != start)
1204       return AVIERR_UNSUPPORTED;
1205
1206     /* Convert position to frame/block */
1207     start = This->lLastFrame + 1;
1208
1209     if ((This->paf->fInfo.dwFlags & AVIFILEINFO_ISINTERLEAVED) == 0) {
1210       FIXME(": not interleaved, could collect audio data!\n");
1211     }
1212   } else {
1213     /* variable sample size -- video like */
1214     if (samples > 1)
1215       return AVIERR_UNSUPPORTED;
1216
1217     /* must we fill up with empty frames? */
1218     if (This->lLastFrame != -1) {
1219       FOURCC ckid2 = MAKEAVICKID(cktypeDIBcompressed, This->nStream);
1220
1221       while (start > This->lLastFrame + 1) {
1222         hr = AVIFILE_WriteBlock(This, This->lLastFrame + 1, ckid2, 0, NULL, 0);
1223         if (FAILED(hr))
1224           return hr;
1225       }
1226     }
1227   }
1228
1229   /* write the block now */
1230   hr = AVIFILE_WriteBlock(This, start, ckid, flags, buffer, buffersize);
1231   if (SUCCEEDED(hr)) {
1232     /* fill out return parameters if given */
1233     if (sampwritten != NULL)
1234       *sampwritten = samples;
1235     if (byteswritten != NULL)
1236       *byteswritten = buffersize;
1237   }
1238
1239   return hr;
1240 }
1241
1242 static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream *iface, LONG start,
1243                                           LONG samples)
1244 {
1245   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
1246
1247   FIXME("(%p,%d,%d): stub\n", iface, start, samples);
1248
1249   /* check parameters */
1250   if (start < 0 || samples < 0)
1251     return AVIERR_BADPARAM;
1252
1253   /* Delete before start of stream? */
1254   if (start + samples < This->sInfo.dwStart)
1255     return AVIERR_OK;
1256
1257   /* Delete after end of stream? */
1258   if (start > This->sInfo.dwLength)
1259     return AVIERR_OK;
1260
1261   /* For the rest we need write permissions */
1262   if ((This->paf->uMode & MMIO_RWMODE) == 0)
1263     return AVIERR_READONLY;
1264
1265   /* 1. overwrite the data with JUNK
1266    *
1267    * if ISINTERLEAVED {
1268    *   2. concat all neighboured JUNK-blocks in this record to one
1269    *   3. if this record only contains JUNK and is at end set dwNextFramePos
1270    *      to start of this record, repeat this.
1271    * } else {
1272    *   2. concat all neighboured JUNK-blocks.
1273    *   3. if the JUNK block is at the end, then set dwNextFramePos to
1274    *      start of this block.
1275    * }
1276    */
1277
1278   return AVIERR_UNSUPPORTED;
1279 }
1280
1281 static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream *iface, DWORD fcc,
1282                                             LPVOID lp, LPLONG lpread)
1283 {
1284   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
1285
1286   TRACE("(%p,0x%08X,%p,%p)\n", iface, fcc, lp, lpread);
1287
1288   if (fcc == ckidSTREAMHANDLERDATA) {
1289     if (This->lpHandlerData != NULL && This->cbHandlerData > 0) {
1290       if (lp == NULL || *lpread <= 0) {
1291         *lpread = This->cbHandlerData;
1292         return AVIERR_OK;
1293       }
1294
1295       memcpy(lp, This->lpHandlerData, min(This->cbHandlerData, *lpread));
1296       if (*lpread < This->cbHandlerData)
1297         return AVIERR_BUFFERTOOSMALL;
1298       return AVIERR_OK;
1299     } else
1300       return AVIERR_NODATA;
1301   } else
1302     return ReadExtraChunk(&This->extra, fcc, lp, lpread);
1303 }
1304
1305 static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream *iface, DWORD fcc,
1306                                              LPVOID lp, LONG size)
1307 {
1308   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
1309
1310   TRACE("(%p,0x%08x,%p,%d)\n", iface, fcc, lp, size);
1311
1312   /* check parameters */
1313   if (lp == NULL)
1314     return AVIERR_BADPARAM;
1315   if (size <= 0)
1316     return AVIERR_BADSIZE;
1317
1318   /* need write permission */
1319   if ((This->paf->uMode & MMIO_RWMODE) == 0)
1320     return AVIERR_READONLY;
1321
1322   /* already written something to this file? */
1323   if (This->paf->dwMoviChunkPos != 0) {
1324     /* the data will be inserted before the 'movi' chunk, so check for
1325      * enough space */
1326     DWORD dwPos = AVIFILE_ComputeMoviStart(This->paf);
1327
1328     /* ckid,size => 2 * sizeof(DWORD) */
1329     dwPos += 2 * sizeof(DWORD) + size;
1330     if (size >= This->paf->dwMoviChunkPos - 2 * sizeof(DWORD))
1331       return AVIERR_UNSUPPORTED; /* not enough space left */
1332   }
1333
1334   This->paf->fDirty = TRUE;
1335
1336   if (fcc == ckidSTREAMHANDLERDATA) {
1337     if (This->lpHandlerData != NULL) {
1338       FIXME(": handler data already set -- overwirte?\n");
1339       return AVIERR_UNSUPPORTED;
1340     }
1341
1342     This->lpHandlerData = HeapAlloc(GetProcessHeap(), 0, size);
1343     if (This->lpHandlerData == NULL)
1344       return AVIERR_MEMORY;
1345     This->cbHandlerData = size;
1346     memcpy(This->lpHandlerData, lp, size);
1347
1348     return AVIERR_OK;
1349   } else
1350     return WriteExtraChunk(&This->extra, fcc, lp, size);
1351 }
1352
1353 static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream *iface,
1354                                            LPAVISTREAMINFOW info, LONG infolen)
1355 {
1356   FIXME("(%p,%p,%d): stub\n", iface, info, infolen);
1357
1358   return E_FAIL;
1359 }
1360
1361 /***********************************************************************/
1362
1363 static HRESULT AVIFILE_AddFrame(IAVIStreamImpl *This, DWORD ckid, DWORD size, DWORD offset, DWORD flags)
1364 {
1365   UINT n;
1366
1367   /* pre-conditions */
1368   assert(This != NULL);
1369
1370   switch (TWOCCFromFOURCC(ckid)) {
1371   case cktypeDIBbits:
1372     if (This->paf->fInfo.dwFlags & AVIFILEINFO_TRUSTCKTYPE)
1373       flags |= AVIIF_KEYFRAME;
1374     break;
1375   case cktypeDIBcompressed:
1376     if (This->paf->fInfo.dwFlags & AVIFILEINFO_TRUSTCKTYPE)
1377       flags &= ~AVIIF_KEYFRAME;
1378     break;
1379   case cktypePALchange:
1380     if (This->sInfo.fccType != streamtypeVIDEO) {
1381       ERR(": found palette change in non-video stream!\n");
1382       return AVIERR_BADFORMAT;
1383     }
1384
1385     if (This->idxFmtChanges == NULL || This->nIdxFmtChanges <= This->sInfo.dwFormatChangeCount) {
1386       DWORD new_count = This->nIdxFmtChanges + 16;
1387       void *new_buffer;
1388
1389       if (This->idxFmtChanges == NULL) {
1390         This->idxFmtChanges =
1391           HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * sizeof(AVIINDEXENTRY));
1392         if (!This->idxFmtChanges) return AVIERR_MEMORY;
1393       } else {
1394         new_buffer = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->idxFmtChanges,
1395                 new_count * sizeof(AVIINDEXENTRY));
1396         if (!new_buffer) return AVIERR_MEMORY;
1397         This->idxFmtChanges = new_buffer;
1398       }
1399       This->nIdxFmtChanges = new_count;
1400     }
1401
1402     This->sInfo.dwFlags |= AVISTREAMINFO_FORMATCHANGES;
1403     n = ++This->sInfo.dwFormatChangeCount;
1404     This->idxFmtChanges[n].ckid          = This->lLastFrame;
1405     This->idxFmtChanges[n].dwFlags       = 0;
1406     This->idxFmtChanges[n].dwChunkOffset = offset;
1407     This->idxFmtChanges[n].dwChunkLength = size;
1408
1409     return AVIERR_OK;
1410   case cktypeWAVEbytes:
1411     if (This->paf->fInfo.dwFlags & AVIFILEINFO_TRUSTCKTYPE)
1412       flags |= AVIIF_KEYFRAME;
1413     break;
1414   default:
1415     WARN(": unknown TWOCC 0x%04X found\n", TWOCCFromFOURCC(ckid));
1416     break;
1417   };
1418
1419   /* first frame is always a keyframe */
1420   if (This->lLastFrame == -1)
1421     flags |= AVIIF_KEYFRAME;
1422
1423   if (This->sInfo.dwSuggestedBufferSize < size)
1424     This->sInfo.dwSuggestedBufferSize = size;
1425
1426   /* get memory for index */
1427   if (This->idxFrames == NULL || This->lLastFrame + 1 >= This->nIdxFrames) {
1428     This->nIdxFrames += 512;
1429     if (This->idxFrames == NULL)
1430       This->idxFrames = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->nIdxFrames * sizeof(AVIINDEXENTRY));
1431       else
1432         This->idxFrames = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->idxFrames,
1433                            This->nIdxFrames * sizeof(AVIINDEXENTRY));
1434     if (This->idxFrames == NULL)
1435       return AVIERR_MEMORY;
1436   }
1437
1438   This->lLastFrame++;
1439   This->idxFrames[This->lLastFrame].ckid          = ckid;
1440   This->idxFrames[This->lLastFrame].dwFlags       = flags;
1441   This->idxFrames[This->lLastFrame].dwChunkOffset = offset;
1442   This->idxFrames[This->lLastFrame].dwChunkLength = size;
1443
1444   /* update AVISTREAMINFO structure if necessary */
1445   if (This->sInfo.dwLength <= This->lLastFrame)
1446     This->sInfo.dwLength = This->lLastFrame + 1;
1447
1448   return AVIERR_OK;
1449 }
1450
1451 static HRESULT AVIFILE_AddRecord(IAVIFileImpl *This)
1452 {
1453   /* pre-conditions */
1454   assert(This != NULL && This->ppStreams[0] != NULL);
1455
1456   if (This->idxRecords == NULL || This->cbIdxRecords == 0) {
1457     This->cbIdxRecords += 1024 * sizeof(AVIINDEXENTRY);
1458     This->idxRecords = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->cbIdxRecords);
1459     if (This->idxRecords == NULL)
1460       return AVIERR_MEMORY;
1461   }
1462
1463   assert(This->nIdxRecords < This->cbIdxRecords/sizeof(AVIINDEXENTRY));
1464
1465   This->idxRecords[This->nIdxRecords].ckid          = listtypeAVIRECORD;
1466   This->idxRecords[This->nIdxRecords].dwFlags       = AVIIF_LIST;
1467   This->idxRecords[This->nIdxRecords].dwChunkOffset =
1468     This->ckLastRecord.dwDataOffset - 2 * sizeof(DWORD);
1469   This->idxRecords[This->nIdxRecords].dwChunkLength =
1470     This->ckLastRecord.cksize;
1471   This->nIdxRecords++;
1472
1473   return AVIERR_OK;
1474 }
1475
1476 static DWORD   AVIFILE_ComputeMoviStart(IAVIFileImpl *This)
1477 {
1478   DWORD dwPos;
1479   DWORD nStream;
1480
1481   /* RIFF,hdrl,movi,avih => (3 * 3 + 2) * sizeof(DWORD) = 11 * sizeof(DWORD) */
1482   dwPos = 11 * sizeof(DWORD) + sizeof(MainAVIHeader);
1483
1484   for (nStream = 0; nStream < This->fInfo.dwStreams; nStream++) {
1485     IAVIStreamImpl *pStream = This->ppStreams[nStream];
1486
1487     /* strl,strh,strf => (3 + 2 * 2) * sizeof(DWORD) = 7 * sizeof(DWORD) */
1488     dwPos += 7 * sizeof(DWORD) + sizeof(AVIStreamHeader);
1489     dwPos += ((pStream->cbFormat + 1) & ~1U);
1490     if (pStream->lpHandlerData != NULL && pStream->cbHandlerData > 0)
1491       dwPos += 2 * sizeof(DWORD) + ((pStream->cbHandlerData + 1) & ~1U);
1492     if (lstrlenW(pStream->sInfo.szName) > 0)
1493       dwPos += 2 * sizeof(DWORD) + ((lstrlenW(pStream->sInfo.szName) + 1) & ~1U);
1494   }
1495
1496   if (This->dwMoviChunkPos == 0) {
1497     This->dwNextFramePos = dwPos;
1498
1499     /* pad to multiple of AVI_HEADERSIZE only if we are more than 8 bytes away from it */
1500     if (((dwPos + AVI_HEADERSIZE) & ~(AVI_HEADERSIZE - 1)) - dwPos > 2 * sizeof(DWORD))
1501       This->dwNextFramePos = (dwPos + AVI_HEADERSIZE) & ~(AVI_HEADERSIZE - 1);
1502
1503     This->dwMoviChunkPos = This->dwNextFramePos - sizeof(DWORD);
1504   }
1505
1506   return dwPos;
1507 }
1508
1509 static void AVIFILE_ConstructAVIStream(IAVIFileImpl *paf, DWORD nr, const AVISTREAMINFOW *asi)
1510 {
1511   IAVIStreamImpl *pstream;
1512
1513   /* pre-conditions */
1514   assert(paf != NULL);
1515   assert(nr < MAX_AVISTREAMS);
1516   assert(paf->ppStreams[nr] != NULL);
1517
1518   pstream = paf->ppStreams[nr];
1519
1520   pstream->lpVtbl         = &iavist;
1521   pstream->ref            = 0;
1522   pstream->paf            = paf;
1523   pstream->nStream        = nr;
1524   pstream->dwCurrentFrame = (DWORD)-1;
1525   pstream->lLastFrame    = -1;
1526
1527   if (asi != NULL) {
1528     memcpy(&pstream->sInfo, asi, sizeof(pstream->sInfo));
1529
1530     if (asi->dwLength > 0) {
1531       /* pre-allocate mem for frame-index structure */
1532       pstream->idxFrames =
1533         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, asi->dwLength * sizeof(AVIINDEXENTRY));
1534       if (pstream->idxFrames != NULL)
1535         pstream->nIdxFrames = asi->dwLength;
1536     }
1537     if (asi->dwFormatChangeCount > 0) {
1538       /* pre-allocate mem for formatchange-index structure */
1539       pstream->idxFmtChanges =
1540         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, asi->dwFormatChangeCount * sizeof(AVIINDEXENTRY));
1541       if (pstream->idxFmtChanges != NULL)
1542         pstream->nIdxFmtChanges = asi->dwFormatChangeCount;
1543     }
1544
1545     /* These values will be computed */
1546     pstream->sInfo.dwLength              = 0;
1547     pstream->sInfo.dwSuggestedBufferSize = 0;
1548     pstream->sInfo.dwFormatChangeCount   = 0;
1549     pstream->sInfo.dwEditCount           = 1;
1550     if (pstream->sInfo.dwSampleSize > 0)
1551       SetRectEmpty(&pstream->sInfo.rcFrame);
1552   }
1553
1554   pstream->sInfo.dwCaps = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE;
1555 }
1556
1557 static void    AVIFILE_DestructAVIStream(IAVIStreamImpl *This)
1558 {
1559   /* pre-conditions */
1560   assert(This != NULL);
1561
1562   This->dwCurrentFrame = (DWORD)-1;
1563   This->lLastFrame    = -1;
1564   This->paf = NULL;
1565   if (This->idxFrames != NULL) {
1566     HeapFree(GetProcessHeap(), 0, This->idxFrames);
1567     This->idxFrames  = NULL;
1568     This->nIdxFrames = 0;
1569   }
1570   HeapFree(GetProcessHeap(), 0, This->idxFmtChanges);
1571   This->idxFmtChanges = NULL;
1572   if (This->lpBuffer != NULL) {
1573     HeapFree(GetProcessHeap(), 0, This->lpBuffer);
1574     This->lpBuffer = NULL;
1575     This->cbBuffer = 0;
1576   }
1577   if (This->lpHandlerData != NULL) {
1578     HeapFree(GetProcessHeap(), 0, This->lpHandlerData);
1579     This->lpHandlerData = NULL;
1580     This->cbHandlerData = 0;
1581   }
1582   if (This->extra.lp != NULL) {
1583     HeapFree(GetProcessHeap(), 0, This->extra.lp);
1584     This->extra.lp = NULL;
1585     This->extra.cb = 0;
1586   }
1587   if (This->lpFormat != NULL) {
1588     HeapFree(GetProcessHeap(), 0, This->lpFormat);
1589     This->lpFormat = NULL;
1590     This->cbFormat = 0;
1591   }
1592 }
1593
1594 static HRESULT AVIFILE_LoadFile(IAVIFileImpl *This)
1595 {
1596   MainAVIHeader   MainAVIHdr;
1597   MMCKINFO        ckRIFF;
1598   MMCKINFO        ckLIST1;
1599   MMCKINFO        ckLIST2;
1600   MMCKINFO        ck;
1601   IAVIStreamImpl *pStream;
1602   DWORD           nStream;
1603   HRESULT         hr;
1604
1605   if (This->hmmio == NULL)
1606     return AVIERR_FILEOPEN;
1607
1608   /* initialize stream ptr's */
1609   memset(This->ppStreams, 0, sizeof(This->ppStreams));
1610
1611   /* try to get "RIFF" chunk -- must not be at beginning of file! */
1612   ckRIFF.fccType = formtypeAVI;
1613   if (mmioDescend(This->hmmio, &ckRIFF, NULL, MMIO_FINDRIFF) != S_OK) {
1614     ERR(": not an AVI!\n");
1615     return AVIERR_FILEREAD;
1616   }
1617
1618   /* get "LIST" "hdrl" */
1619   ckLIST1.fccType = listtypeAVIHEADER;
1620   hr = FindChunkAndKeepExtras(&This->fileextra, This->hmmio, &ckLIST1, &ckRIFF, MMIO_FINDLIST);
1621   if (FAILED(hr))
1622     return hr;
1623
1624   /* get "avih" chunk */
1625   ck.ckid = ckidAVIMAINHDR;
1626   hr = FindChunkAndKeepExtras(&This->fileextra, This->hmmio, &ck, &ckLIST1, MMIO_FINDCHUNK);
1627   if (FAILED(hr))
1628     return hr;
1629
1630   if (ck.cksize != sizeof(MainAVIHdr)) {
1631     ERR(": invalid size of %d for MainAVIHeader!\n", ck.cksize);
1632     return AVIERR_BADFORMAT;
1633   }
1634   if (mmioRead(This->hmmio, (HPSTR)&MainAVIHdr, ck.cksize) != ck.cksize)
1635     return AVIERR_FILEREAD;
1636
1637   /* check for MAX_AVISTREAMS limit */
1638   if (MainAVIHdr.dwStreams > MAX_AVISTREAMS) {
1639     WARN("file contains %u streams, but only supports %d -- change MAX_AVISTREAMS!\n", MainAVIHdr.dwStreams, MAX_AVISTREAMS);
1640     return AVIERR_UNSUPPORTED;
1641   }
1642
1643   /* adjust permissions if copyrighted material in file */
1644   if (MainAVIHdr.dwFlags & AVIFILEINFO_COPYRIGHTED) {
1645     This->uMode &= ~MMIO_RWMODE;
1646     This->uMode |= MMIO_READ;
1647   }
1648
1649   /* convert MainAVIHeader into AVIFILINFOW */
1650   memset(&This->fInfo, 0, sizeof(This->fInfo));
1651   This->fInfo.dwRate                = MainAVIHdr.dwMicroSecPerFrame;
1652   This->fInfo.dwScale               = 1000000;
1653   This->fInfo.dwMaxBytesPerSec      = MainAVIHdr.dwMaxBytesPerSec;
1654   This->fInfo.dwFlags               = MainAVIHdr.dwFlags;
1655   This->fInfo.dwCaps                = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE;
1656   This->fInfo.dwLength              = MainAVIHdr.dwTotalFrames;
1657   This->fInfo.dwStreams             = MainAVIHdr.dwStreams;
1658   This->fInfo.dwSuggestedBufferSize = 0;
1659   This->fInfo.dwWidth               = MainAVIHdr.dwWidth;
1660   This->fInfo.dwHeight              = MainAVIHdr.dwHeight;
1661   LoadStringW(AVIFILE_hModule, IDS_AVIFILETYPE, This->fInfo.szFileType,
1662               sizeof(This->fInfo.szFileType)/sizeof(This->fInfo.szFileType[0]));
1663
1664   /* go back to into header list */
1665   if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
1666     return AVIERR_FILEREAD;
1667
1668   /* foreach stream exists a "LIST","strl" chunk */
1669   for (nStream = 0; nStream < This->fInfo.dwStreams; nStream++) {
1670     /* get next nested chunk in this "LIST","strl" */
1671     if (mmioDescend(This->hmmio, &ckLIST2, &ckLIST1, 0) != S_OK)
1672       return AVIERR_FILEREAD;
1673
1674     /* nested chunk must be of type "LIST","strl" -- when not normally JUNK */
1675     if (ckLIST2.ckid == FOURCC_LIST &&
1676         ckLIST2.fccType == listtypeSTREAMHEADER) {
1677       pStream = This->ppStreams[nStream] =
1678         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAVIStreamImpl));
1679       if (pStream == NULL)
1680         return AVIERR_MEMORY;
1681       AVIFILE_ConstructAVIStream(This, nStream, NULL);
1682
1683       ck.ckid = 0;
1684       while (mmioDescend(This->hmmio, &ck, &ckLIST2, 0) == S_OK) {
1685         switch (ck.ckid) {
1686         case ckidSTREAMHANDLERDATA:
1687           if (pStream->lpHandlerData != NULL)
1688             return AVIERR_BADFORMAT;
1689           pStream->lpHandlerData = HeapAlloc(GetProcessHeap(), 0, ck.cksize);
1690           if (pStream->lpHandlerData == NULL)
1691             return AVIERR_MEMORY;
1692           pStream->cbHandlerData = ck.cksize;
1693
1694           if (mmioRead(This->hmmio, pStream->lpHandlerData, ck.cksize) != ck.cksize)
1695             return AVIERR_FILEREAD;
1696           break;
1697         case ckidSTREAMFORMAT:
1698           if (pStream->lpFormat != NULL)
1699             return AVIERR_BADFORMAT;
1700           if (ck.cksize == 0)
1701             break;
1702
1703           pStream->lpFormat = HeapAlloc(GetProcessHeap(), 0, ck.cksize);
1704           if (pStream->lpFormat == NULL)
1705             return AVIERR_MEMORY;
1706           pStream->cbFormat = ck.cksize;
1707
1708           if (mmioRead(This->hmmio, pStream->lpFormat, ck.cksize) != ck.cksize)
1709             return AVIERR_FILEREAD;
1710
1711           if (pStream->sInfo.fccType == streamtypeVIDEO) {
1712             LPBITMAPINFOHEADER lpbi = pStream->lpFormat;
1713
1714             /* some corrections to the video format */
1715             if (lpbi->biClrUsed == 0 && lpbi->biBitCount <= 8)
1716               lpbi->biClrUsed = 1u << lpbi->biBitCount;
1717             if (lpbi->biCompression == BI_RGB && lpbi->biSizeImage == 0)
1718               lpbi->biSizeImage = DIBWIDTHBYTES(*lpbi) * lpbi->biHeight;
1719             if (lpbi->biCompression != BI_RGB && lpbi->biBitCount == 8) {
1720               if (pStream->sInfo.fccHandler == mmioFOURCC('R','L','E','0') ||
1721                   pStream->sInfo.fccHandler == mmioFOURCC('R','L','E',' '))
1722                 lpbi->biCompression = BI_RLE8;
1723             }
1724             if (lpbi->biCompression == BI_RGB &&
1725                 (pStream->sInfo.fccHandler == 0 ||
1726                  pStream->sInfo.fccHandler == mmioFOURCC('N','O','N','E')))
1727               pStream->sInfo.fccHandler = comptypeDIB;
1728
1729             /* init rcFrame if it's empty */
1730             if (IsRectEmpty(&pStream->sInfo.rcFrame))
1731               SetRect(&pStream->sInfo.rcFrame, 0, 0, lpbi->biWidth, lpbi->biHeight);
1732           }
1733           break;
1734         case ckidSTREAMHEADER:
1735           {
1736             static const WCHAR streamTypeFmt[] = {'%','4','.','4','h','s',0};
1737
1738             AVIStreamHeader streamHdr;
1739             WCHAR           szType[25];
1740             WCHAR           streamNameFmt[25];
1741             UINT            count;
1742             LONG            n = ck.cksize;
1743
1744             if (ck.cksize > sizeof(streamHdr))
1745               n = sizeof(streamHdr);
1746
1747             if (mmioRead(This->hmmio, (HPSTR)&streamHdr, n) != n)
1748               return AVIERR_FILEREAD;
1749
1750             pStream->sInfo.fccType               = streamHdr.fccType;
1751             pStream->sInfo.fccHandler            = streamHdr.fccHandler;
1752             pStream->sInfo.dwFlags               = streamHdr.dwFlags;
1753             pStream->sInfo.wPriority             = streamHdr.wPriority;
1754             pStream->sInfo.wLanguage             = streamHdr.wLanguage;
1755             pStream->sInfo.dwInitialFrames       = streamHdr.dwInitialFrames;
1756             pStream->sInfo.dwScale               = streamHdr.dwScale;
1757             pStream->sInfo.dwRate                = streamHdr.dwRate;
1758             pStream->sInfo.dwStart               = streamHdr.dwStart;
1759             pStream->sInfo.dwLength              = streamHdr.dwLength;
1760             pStream->sInfo.dwSuggestedBufferSize = 0;
1761             pStream->sInfo.dwQuality             = streamHdr.dwQuality;
1762             pStream->sInfo.dwSampleSize          = streamHdr.dwSampleSize;
1763             pStream->sInfo.rcFrame.left          = streamHdr.rcFrame.left;
1764             pStream->sInfo.rcFrame.top           = streamHdr.rcFrame.top;
1765             pStream->sInfo.rcFrame.right         = streamHdr.rcFrame.right;
1766             pStream->sInfo.rcFrame.bottom        = streamHdr.rcFrame.bottom;
1767             pStream->sInfo.dwEditCount           = 0;
1768             pStream->sInfo.dwFormatChangeCount   = 0;
1769
1770             /* generate description for stream like "filename.avi Type #n" */
1771             if (streamHdr.fccType == streamtypeVIDEO)
1772               LoadStringW(AVIFILE_hModule, IDS_VIDEO, szType, sizeof(szType)/sizeof(szType[0]));
1773             else if (streamHdr.fccType == streamtypeAUDIO)
1774               LoadStringW(AVIFILE_hModule, IDS_AUDIO, szType, sizeof(szType)/sizeof(szType[0]));
1775             else
1776               wsprintfW(szType, streamTypeFmt, (char*)&streamHdr.fccType);
1777
1778             /* get count of this streamtype up to this stream */
1779             count = 0;
1780             for (n = nStream; 0 <= n; n--) {
1781               if (This->ppStreams[n]->sInfo.fccHandler == streamHdr.fccType)
1782                 count++;
1783             }
1784
1785             memset(pStream->sInfo.szName, 0, sizeof(pStream->sInfo.szName));
1786
1787             LoadStringW(AVIFILE_hModule, IDS_AVISTREAMFORMAT, streamNameFmt, sizeof(streamNameFmt)/sizeof(streamNameFmt[0]));
1788
1789             /* FIXME: avoid overflow -- better use wsnprintfW, which doesn't exists ! */
1790             wsprintfW(pStream->sInfo.szName, streamNameFmt,
1791                       AVIFILE_BasenameW(This->szFileName), szType, count);
1792           }
1793           break;
1794         case ckidSTREAMNAME:
1795           { /* streamname will be saved as ASCII string */
1796             LPSTR str = HeapAlloc(GetProcessHeap(), 0, ck.cksize);
1797             if (str == NULL)
1798               return AVIERR_MEMORY;
1799
1800             if (mmioRead(This->hmmio, str, ck.cksize) != ck.cksize)
1801             {
1802               HeapFree(GetProcessHeap(), 0, str);
1803               return AVIERR_FILEREAD;
1804             }
1805
1806             MultiByteToWideChar(CP_ACP, 0, str, -1, pStream->sInfo.szName,
1807                                 sizeof(pStream->sInfo.szName)/sizeof(pStream->sInfo.szName[0]));
1808
1809             HeapFree(GetProcessHeap(), 0, str);
1810           }
1811           break;
1812         case ckidAVIPADDING:
1813         case mmioFOURCC('p','a','d','d'):
1814           break;
1815         default:
1816           WARN(": found extra chunk 0x%08X\n", ck.ckid);
1817           hr = ReadChunkIntoExtra(&pStream->extra, This->hmmio, &ck);
1818           if (FAILED(hr))
1819             return hr;
1820         };
1821         if (pStream->lpFormat != NULL && pStream->sInfo.fccType == streamtypeAUDIO)
1822         {
1823           WAVEFORMATEX *wfx = pStream->lpFormat;          /* wfx->nBlockAlign = wfx->nChannels * wfx->wBitsPerSample / 8; could be added */
1824           pStream->sInfo.dwSampleSize = wfx->nBlockAlign; /* to deal with corrupt wfx->nBlockAlign but Windows doesn't do this */
1825           TRACE("Block size reset to %u, chan=%u bpp=%u\n", wfx->nBlockAlign, wfx->nChannels, wfx->wBitsPerSample);
1826           pStream->sInfo.dwScale = 1;
1827           pStream->sInfo.dwRate = wfx->nSamplesPerSec;
1828         }
1829         if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
1830           return AVIERR_FILEREAD;
1831       }
1832     } else {
1833       /* nested chunks in "LIST","hdrl" which are not of type "LIST","strl" */
1834       hr = ReadChunkIntoExtra(&This->fileextra, This->hmmio, &ckLIST2);
1835       if (FAILED(hr))
1836         return hr;
1837     }
1838     if (mmioAscend(This->hmmio, &ckLIST2, 0) != S_OK)
1839       return AVIERR_FILEREAD;
1840   }
1841
1842   /* read any extra headers in "LIST","hdrl" */
1843   FindChunkAndKeepExtras(&This->fileextra, This->hmmio, &ck, &ckLIST1, 0);
1844   if (mmioAscend(This->hmmio, &ckLIST1, 0) != S_OK)
1845     return AVIERR_FILEREAD;
1846
1847   /* search "LIST","movi" chunk in "RIFF","AVI " */
1848   ckLIST1.fccType = listtypeAVIMOVIE;
1849   hr = FindChunkAndKeepExtras(&This->fileextra, This->hmmio, &ckLIST1, &ckRIFF,
1850                               MMIO_FINDLIST);
1851   if (FAILED(hr))
1852     return hr;
1853
1854   This->dwMoviChunkPos = ckLIST1.dwDataOffset;
1855   This->dwIdxChunkPos  = ckLIST1.cksize + ckLIST1.dwDataOffset;
1856   if (mmioAscend(This->hmmio, &ckLIST1, 0) != S_OK)
1857     return AVIERR_FILEREAD;
1858
1859   /* try to find an index */
1860   ck.ckid = ckidAVINEWINDEX;
1861   hr = FindChunkAndKeepExtras(&This->fileextra, This->hmmio,
1862                               &ck, &ckRIFF, MMIO_FINDCHUNK);
1863   if (SUCCEEDED(hr) && ck.cksize > 0) {
1864     if (FAILED(AVIFILE_LoadIndex(This, ck.cksize, ckLIST1.dwDataOffset)))
1865       This->fInfo.dwFlags &= ~AVIFILEINFO_HASINDEX;
1866   }
1867
1868   /* when we haven't found an index or it's bad, then build one
1869    * by parsing 'movi' chunk */
1870   if ((This->fInfo.dwFlags & AVIFILEINFO_HASINDEX) == 0) {
1871     for (nStream = 0; nStream < This->fInfo.dwStreams; nStream++)
1872       This->ppStreams[nStream]->lLastFrame = -1;
1873
1874     if (mmioSeek(This->hmmio, ckLIST1.dwDataOffset + sizeof(DWORD), SEEK_SET) == -1) {
1875       ERR(": Oops, can't seek back to 'movi' chunk!\n");
1876       return AVIERR_FILEREAD;
1877     }
1878
1879     /* seek through the 'movi' list until end */
1880     while (mmioDescend(This->hmmio, &ck, &ckLIST1, 0) == S_OK) {
1881       if (ck.ckid != FOURCC_LIST) {
1882         if (mmioAscend(This->hmmio, &ck, 0) == S_OK) {
1883           nStream = StreamFromFOURCC(ck.ckid);
1884
1885           if (nStream > This->fInfo.dwStreams)
1886             return AVIERR_BADFORMAT;
1887
1888           AVIFILE_AddFrame(This->ppStreams[nStream], ck.ckid, ck.cksize,
1889                            ck.dwDataOffset - 2 * sizeof(DWORD), 0);
1890         } else {
1891           nStream = StreamFromFOURCC(ck.ckid);
1892           WARN(": file seems to be truncated!\n");
1893           if (nStream <= This->fInfo.dwStreams &&
1894               This->ppStreams[nStream]->sInfo.dwSampleSize > 0) {
1895             ck.cksize = mmioSeek(This->hmmio, 0, SEEK_END);
1896             if (ck.cksize != -1) {
1897               ck.cksize -= ck.dwDataOffset;
1898               ck.cksize &= ~(This->ppStreams[nStream]->sInfo.dwSampleSize - 1);
1899
1900               AVIFILE_AddFrame(This->ppStreams[nStream], ck.ckid, ck.cksize,
1901                                ck.dwDataOffset - 2 * sizeof(DWORD), 0);
1902             }
1903           }
1904         }
1905       }
1906     }
1907   }
1908
1909   for (nStream = 0; nStream < This->fInfo.dwStreams; nStream++)
1910   {
1911     DWORD sugbuf =  This->ppStreams[nStream]->sInfo.dwSuggestedBufferSize;
1912     if (This->fInfo.dwSuggestedBufferSize < sugbuf)
1913       This->fInfo.dwSuggestedBufferSize = sugbuf;
1914   }
1915
1916   /* find other chunks */
1917   FindChunkAndKeepExtras(&This->fileextra, This->hmmio, &ck, &ckRIFF, 0);
1918
1919   return AVIERR_OK;
1920 }
1921
1922 static HRESULT AVIFILE_LoadIndex(const IAVIFileImpl *This, DWORD size, DWORD offset)
1923 {
1924   AVIINDEXENTRY *lp;
1925   DWORD          pos, n;
1926   HRESULT        hr = AVIERR_OK;
1927   BOOL           bAbsolute = TRUE;
1928
1929   lp = HeapAlloc(GetProcessHeap(), 0, IDX_PER_BLOCK * sizeof(AVIINDEXENTRY));
1930   if (lp == NULL)
1931     return AVIERR_MEMORY;
1932
1933   /* adjust limits for index tables, so that inserting will be faster */
1934   for (n = 0; n < This->fInfo.dwStreams; n++) {
1935     IAVIStreamImpl *pStream = This->ppStreams[n];
1936
1937     pStream->lLastFrame = -1;
1938
1939     if (pStream->idxFrames != NULL) {
1940       HeapFree(GetProcessHeap(), 0, pStream->idxFrames);
1941       pStream->idxFrames  = NULL;
1942       pStream->nIdxFrames = 0;
1943     }
1944
1945     if (pStream->sInfo.dwSampleSize != 0) {
1946       if (n > 0 && This->fInfo.dwFlags & AVIFILEINFO_ISINTERLEAVED) {
1947         pStream->nIdxFrames = This->ppStreams[0]->nIdxFrames;
1948       } else if (pStream->sInfo.dwSuggestedBufferSize) {
1949         pStream->nIdxFrames =
1950           pStream->sInfo.dwLength / pStream->sInfo.dwSuggestedBufferSize;
1951       }
1952     } else
1953       pStream->nIdxFrames = pStream->sInfo.dwLength;
1954
1955     pStream->idxFrames =
1956       HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pStream->nIdxFrames * sizeof(AVIINDEXENTRY));
1957     if (pStream->idxFrames == NULL && pStream->nIdxFrames > 0) {
1958       pStream->nIdxFrames = 0;
1959       HeapFree(GetProcessHeap(), 0, lp);
1960       return AVIERR_MEMORY;
1961     }
1962   }
1963
1964   pos = (DWORD)-1;
1965   while (size != 0) {
1966     LONG read = min(IDX_PER_BLOCK * sizeof(AVIINDEXENTRY), size);
1967
1968     if (mmioRead(This->hmmio, (HPSTR)lp, read) != read) {
1969       hr = AVIERR_FILEREAD;
1970       break;
1971     }
1972     size -= read;
1973
1974     if (pos == (DWORD)-1)
1975       pos = offset - lp->dwChunkOffset + sizeof(DWORD);
1976
1977     AVIFILE_ParseIndex(This, lp, read / sizeof(AVIINDEXENTRY),
1978                        pos, &bAbsolute);
1979   }
1980
1981   HeapFree(GetProcessHeap(), 0, lp);
1982
1983   /* checking ... */
1984   for (n = 0; n < This->fInfo.dwStreams; n++) {
1985     IAVIStreamImpl *pStream = This->ppStreams[n];
1986
1987     if (pStream->sInfo.dwSampleSize == 0 &&
1988         pStream->sInfo.dwLength != pStream->lLastFrame+1)
1989       ERR("stream %u length mismatch: dwLength=%u found=%d\n",
1990            n, pStream->sInfo.dwLength, pStream->lLastFrame);
1991   }
1992
1993   return hr;
1994 }
1995
1996 static HRESULT AVIFILE_ParseIndex(const IAVIFileImpl *This, AVIINDEXENTRY *lp,
1997                                   LONG count, DWORD pos, BOOL *bAbsolute)
1998 {
1999   if (lp == NULL)
2000     return AVIERR_BADPARAM;
2001
2002   for (; count > 0; count--, lp++) {
2003     WORD nStream = StreamFromFOURCC(lp->ckid);
2004
2005     if (lp->ckid == listtypeAVIRECORD || nStream == 0x7F)
2006       continue; /* skip these */
2007
2008     if (nStream > This->fInfo.dwStreams)
2009       return AVIERR_BADFORMAT;
2010
2011     if (*bAbsolute && lp->dwChunkOffset < This->dwMoviChunkPos)
2012       *bAbsolute = FALSE;
2013
2014     if (*bAbsolute)
2015       lp->dwChunkOffset += sizeof(DWORD);
2016     else
2017       lp->dwChunkOffset += pos;
2018
2019     if (FAILED(AVIFILE_AddFrame(This->ppStreams[nStream], lp->ckid, lp->dwChunkLength, lp->dwChunkOffset, lp->dwFlags)))
2020       return AVIERR_MEMORY;
2021   }
2022
2023   return AVIERR_OK;
2024 }
2025
2026 static HRESULT AVIFILE_ReadBlock(IAVIStreamImpl *This, DWORD pos,
2027                                  LPVOID buffer, DWORD size)
2028 {
2029   /* pre-conditions */
2030   assert(This != NULL);
2031   assert(This->paf != NULL);
2032   assert(This->paf->hmmio != NULL);
2033   assert(This->sInfo.dwStart <= pos && pos < This->sInfo.dwLength);
2034   assert(pos <= This->lLastFrame);
2035
2036   /* should we read as much as block gives us? */
2037   if (size == 0 || size > This->idxFrames[pos].dwChunkLength)
2038     size = This->idxFrames[pos].dwChunkLength;
2039
2040   /* read into out own buffer or given one? */
2041   if (buffer == NULL) {
2042     /* we also read the chunk */
2043     size += 2 * sizeof(DWORD);
2044
2045     /* check that buffer is big enough -- don't trust dwSuggestedBufferSize */
2046     if (This->lpBuffer == NULL || This->cbBuffer < size) {
2047       DWORD maxSize = max(size, This->sInfo.dwSuggestedBufferSize);
2048
2049       if (This->lpBuffer == NULL) {
2050         This->lpBuffer = HeapAlloc(GetProcessHeap(), 0, maxSize);
2051         if (!This->lpBuffer) return AVIERR_MEMORY;
2052       } else {
2053         void *new_buffer = HeapReAlloc(GetProcessHeap(), 0, This->lpBuffer, maxSize);
2054         if (!new_buffer) return AVIERR_MEMORY;
2055         This->lpBuffer = new_buffer;
2056       }
2057       This->cbBuffer = maxSize;
2058     }
2059
2060     /* now read the complete chunk into our buffer */
2061     if (mmioSeek(This->paf->hmmio, This->idxFrames[pos].dwChunkOffset, SEEK_SET) == -1)
2062       return AVIERR_FILEREAD;
2063     if (mmioRead(This->paf->hmmio, (HPSTR)This->lpBuffer, size) != size)
2064       return AVIERR_FILEREAD;
2065
2066     /* check if it was the correct block which we have read */
2067     if (This->lpBuffer[0] != This->idxFrames[pos].ckid ||
2068         This->lpBuffer[1] != This->idxFrames[pos].dwChunkLength) {
2069       ERR(": block %d not found at 0x%08X\n", pos, This->idxFrames[pos].dwChunkOffset);
2070       ERR(": Index says: '%4.4s'(0x%08X) size 0x%08X\n",
2071           (char*)&This->idxFrames[pos].ckid, This->idxFrames[pos].ckid,
2072           This->idxFrames[pos].dwChunkLength);
2073       ERR(": Data  says: '%4.4s'(0x%08X) size 0x%08X\n",
2074           (char*)&This->lpBuffer[0], This->lpBuffer[0], This->lpBuffer[1]);
2075       return AVIERR_FILEREAD;
2076     }
2077   } else {
2078     if (mmioSeek(This->paf->hmmio, This->idxFrames[pos].dwChunkOffset + 2 * sizeof(DWORD), SEEK_SET) == -1)
2079       return AVIERR_FILEREAD;
2080     if (mmioRead(This->paf->hmmio, buffer, size) != size)
2081       return AVIERR_FILEREAD;
2082   }
2083
2084   return AVIERR_OK;
2085 }
2086
2087 static void AVIFILE_SamplesToBlock(const IAVIStreamImpl *This, LPLONG pos, LPLONG offset)
2088 {
2089   LONG block;
2090
2091   /* pre-conditions */
2092   assert(This != NULL);
2093   assert(pos != NULL);
2094   assert(offset != NULL);
2095   assert(This->sInfo.dwSampleSize != 0);
2096   assert(*pos >= This->sInfo.dwStart);
2097
2098   /* convert start sample to start bytes */
2099   (*offset)  = (*pos) - This->sInfo.dwStart;
2100   (*offset) *= This->sInfo.dwSampleSize;
2101
2102   /* convert bytes to block number */
2103   for (block = 0; block <= This->lLastFrame; block++) {
2104     if (This->idxFrames[block].dwChunkLength <= *offset)
2105       (*offset) -= This->idxFrames[block].dwChunkLength;
2106     else
2107       break;
2108   }
2109
2110   *pos = block;
2111 }
2112
2113 static HRESULT AVIFILE_SaveFile(IAVIFileImpl *This)
2114 {
2115   MainAVIHeader   MainAVIHdr;
2116   IAVIStreamImpl* pStream;
2117   MMCKINFO        ckRIFF;
2118   MMCKINFO        ckLIST1;
2119   MMCKINFO        ckLIST2;
2120   MMCKINFO        ck;
2121   DWORD           nStream;
2122   DWORD           dwPos;
2123   HRESULT         hr;
2124
2125   /* initialize some things */
2126   if (This->dwMoviChunkPos == 0)
2127     AVIFILE_ComputeMoviStart(This);
2128
2129   /* written one record to much? */
2130   if (This->ckLastRecord.dwFlags & MMIO_DIRTY) {
2131     This->dwNextFramePos -= 3 * sizeof(DWORD);
2132     if (This->nIdxRecords > 0)
2133       This->nIdxRecords--;
2134   }
2135
2136   AVIFILE_UpdateInfo(This);
2137
2138   assert(This->fInfo.dwScale != 0);
2139
2140   memset(&MainAVIHdr, 0, sizeof(MainAVIHdr));
2141   MainAVIHdr.dwMicroSecPerFrame    = MulDiv(This->fInfo.dwRate, 1000000,
2142                                             This->fInfo.dwScale);
2143   MainAVIHdr.dwMaxBytesPerSec      = This->fInfo.dwMaxBytesPerSec;
2144   MainAVIHdr.dwPaddingGranularity  = AVI_HEADERSIZE;
2145   MainAVIHdr.dwFlags               = This->fInfo.dwFlags;
2146   MainAVIHdr.dwTotalFrames         = This->fInfo.dwLength;
2147   MainAVIHdr.dwInitialFrames       = 0;
2148   MainAVIHdr.dwStreams             = This->fInfo.dwStreams;
2149   MainAVIHdr.dwSuggestedBufferSize = This->fInfo.dwSuggestedBufferSize;
2150   MainAVIHdr.dwWidth               = This->fInfo.dwWidth;
2151   MainAVIHdr.dwHeight              = This->fInfo.dwHeight;
2152   MainAVIHdr.dwInitialFrames       = This->dwInitialFrames;
2153
2154   /* now begin writing ... */
2155   mmioSeek(This->hmmio, 0, SEEK_SET);
2156
2157   /* RIFF chunk */
2158   ckRIFF.cksize  = 0;
2159   ckRIFF.fccType = formtypeAVI;
2160   if (mmioCreateChunk(This->hmmio, &ckRIFF, MMIO_CREATERIFF) != S_OK)
2161     return AVIERR_FILEWRITE;
2162
2163   /* AVI headerlist */
2164   ckLIST1.cksize  = 0;
2165   ckLIST1.fccType = listtypeAVIHEADER;
2166   if (mmioCreateChunk(This->hmmio, &ckLIST1, MMIO_CREATELIST) != S_OK)
2167     return AVIERR_FILEWRITE;
2168
2169   /* MainAVIHeader */
2170   ck.ckid    = ckidAVIMAINHDR;
2171   ck.cksize  = sizeof(MainAVIHdr);
2172   ck.fccType = 0;
2173   if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK)
2174     return AVIERR_FILEWRITE;
2175   if (mmioWrite(This->hmmio, (HPSTR)&MainAVIHdr, ck.cksize) != ck.cksize)
2176     return AVIERR_FILEWRITE;
2177   if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
2178     return AVIERR_FILEWRITE;
2179
2180   /* write the headers of each stream into a separate streamheader list */
2181   for (nStream = 0; nStream < This->fInfo.dwStreams; nStream++) {
2182     AVIStreamHeader strHdr;
2183
2184     pStream = This->ppStreams[nStream];
2185
2186     /* begin the new streamheader list */
2187     ckLIST2.cksize  = 0;
2188     ckLIST2.fccType = listtypeSTREAMHEADER;
2189     if (mmioCreateChunk(This->hmmio, &ckLIST2, MMIO_CREATELIST) != S_OK)
2190       return AVIERR_FILEWRITE;
2191
2192     /* create an AVIStreamHeader from the AVSTREAMINFO */
2193     strHdr.fccType               = pStream->sInfo.fccType;
2194     strHdr.fccHandler            = pStream->sInfo.fccHandler;
2195     strHdr.dwFlags               = pStream->sInfo.dwFlags;
2196     strHdr.wPriority             = pStream->sInfo.wPriority;
2197     strHdr.wLanguage             = pStream->sInfo.wLanguage;
2198     strHdr.dwInitialFrames       = pStream->sInfo.dwInitialFrames;
2199     strHdr.dwScale               = pStream->sInfo.dwScale;
2200     strHdr.dwRate                = pStream->sInfo.dwRate;
2201     strHdr.dwStart               = pStream->sInfo.dwStart;
2202     strHdr.dwLength              = pStream->sInfo.dwLength;
2203     strHdr.dwSuggestedBufferSize = pStream->sInfo.dwSuggestedBufferSize;
2204     strHdr.dwQuality             = pStream->sInfo.dwQuality;
2205     strHdr.dwSampleSize          = pStream->sInfo.dwSampleSize;
2206     strHdr.rcFrame.left          = pStream->sInfo.rcFrame.left;
2207     strHdr.rcFrame.top           = pStream->sInfo.rcFrame.top;
2208     strHdr.rcFrame.right         = pStream->sInfo.rcFrame.right;
2209     strHdr.rcFrame.bottom        = pStream->sInfo.rcFrame.bottom;
2210
2211     /* now write the AVIStreamHeader */
2212     ck.ckid   = ckidSTREAMHEADER;
2213     ck.cksize = sizeof(strHdr);
2214     if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK)
2215       return AVIERR_FILEWRITE;
2216     if (mmioWrite(This->hmmio, (HPSTR)&strHdr, ck.cksize) != ck.cksize)
2217       return AVIERR_FILEWRITE;
2218     if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
2219       return AVIERR_FILEWRITE;
2220
2221     /* ... the hopefully ever present streamformat ... */
2222     ck.ckid   = ckidSTREAMFORMAT;
2223     ck.cksize = pStream->cbFormat;
2224     if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK)
2225       return AVIERR_FILEWRITE;
2226     if (pStream->lpFormat != NULL && ck.cksize > 0) {
2227       if (mmioWrite(This->hmmio, pStream->lpFormat, ck.cksize) != ck.cksize)
2228         return AVIERR_FILEWRITE;
2229     }
2230     if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
2231       return AVIERR_FILEWRITE;
2232
2233     /* ... some optional existing handler data ... */
2234     if (pStream->lpHandlerData != NULL && pStream->cbHandlerData > 0) {
2235       ck.ckid   = ckidSTREAMHANDLERDATA;
2236       ck.cksize = pStream->cbHandlerData;
2237       if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK)
2238         return AVIERR_FILEWRITE;
2239       if (mmioWrite(This->hmmio, pStream->lpHandlerData, ck.cksize) != ck.cksize)
2240         return AVIERR_FILEWRITE;
2241       if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
2242         return AVIERR_FILEWRITE;
2243     }
2244
2245     /* ... some optional additional extra chunk for this stream ... */
2246     if (pStream->extra.lp != NULL && pStream->extra.cb > 0) {
2247       /* the chunk header(s) are already in the structure */
2248       if (mmioWrite(This->hmmio, pStream->extra.lp, pStream->extra.cb) != pStream->extra.cb)
2249         return AVIERR_FILEWRITE;
2250     }
2251
2252     /* ... an optional name for this stream ... */
2253     if (lstrlenW(pStream->sInfo.szName) > 0) {
2254       LPSTR str;
2255
2256       ck.ckid   = ckidSTREAMNAME;
2257       ck.cksize = lstrlenW(pStream->sInfo.szName) + 1;
2258       if (ck.cksize & 1) /* align */
2259         ck.cksize++;
2260       if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK)
2261         return AVIERR_FILEWRITE;
2262
2263       /* the streamname must be saved in ASCII not Unicode */
2264       str = HeapAlloc(GetProcessHeap(), 0, ck.cksize);
2265       if (str == NULL)
2266         return AVIERR_MEMORY;
2267       WideCharToMultiByte(CP_ACP, 0, pStream->sInfo.szName, -1, str,
2268                           ck.cksize, NULL, NULL);
2269
2270       if (mmioWrite(This->hmmio, str, ck.cksize) != ck.cksize) {
2271         HeapFree(GetProcessHeap(), 0, str);
2272         return AVIERR_FILEWRITE;
2273       }
2274
2275       HeapFree(GetProcessHeap(), 0, str);
2276       if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
2277         return AVIERR_FILEWRITE;
2278     }
2279
2280     /* close streamheader list for this stream */
2281     if (mmioAscend(This->hmmio, &ckLIST2, 0) != S_OK)
2282       return AVIERR_FILEWRITE;
2283   } /* for (0 <= nStream < MainAVIHdr.dwStreams) */
2284
2285   /* close the aviheader list */
2286   if (mmioAscend(This->hmmio, &ckLIST1, 0) != S_OK)
2287     return AVIERR_FILEWRITE;
2288
2289   /* check for padding to pre-guessed 'movi'-chunk position */
2290   dwPos = ckLIST1.dwDataOffset + ckLIST1.cksize;
2291   if (This->dwMoviChunkPos - 2 * sizeof(DWORD) > dwPos) {
2292     ck.ckid   = ckidAVIPADDING;
2293     ck.cksize = This->dwMoviChunkPos - dwPos - 4 * sizeof(DWORD);
2294     assert((LONG)ck.cksize >= 0);
2295
2296     if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK)
2297       return AVIERR_FILEWRITE;
2298     if (mmioSeek(This->hmmio, ck.cksize, SEEK_CUR) == -1)
2299       return AVIERR_FILEWRITE;
2300     if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
2301       return AVIERR_FILEWRITE;
2302   }
2303
2304   /* now write the 'movi' chunk */
2305   mmioSeek(This->hmmio, This->dwMoviChunkPos - 2 * sizeof(DWORD), SEEK_SET);
2306   ckLIST1.cksize  = 0;
2307   ckLIST1.fccType = listtypeAVIMOVIE;
2308   if (mmioCreateChunk(This->hmmio, &ckLIST1, MMIO_CREATELIST) != S_OK)
2309     return AVIERR_FILEWRITE;
2310   if (mmioSeek(This->hmmio, This->dwNextFramePos, SEEK_SET) == -1)
2311     return AVIERR_FILEWRITE;
2312   if (mmioAscend(This->hmmio, &ckLIST1, 0) != S_OK)
2313     return AVIERR_FILEWRITE;
2314
2315   /* write 'idx1' chunk */
2316   hr = AVIFILE_SaveIndex(This);
2317   if (FAILED(hr))
2318     return hr;
2319
2320   /* write optional extra file chunks */
2321   if (This->fileextra.lp != NULL && This->fileextra.cb > 0) {
2322     /* as for the streams, are the chunk header(s) in the structure */
2323     if (mmioWrite(This->hmmio, This->fileextra.lp, This->fileextra.cb) != This->fileextra.cb)
2324       return AVIERR_FILEWRITE;
2325   }
2326
2327   /* close RIFF chunk */
2328   if (mmioAscend(This->hmmio, &ckRIFF, 0) != S_OK)
2329     return AVIERR_FILEWRITE;
2330
2331   /* add some JUNK at end for bad parsers */
2332   memset(&ckRIFF, 0, sizeof(ckRIFF));
2333   mmioWrite(This->hmmio, (HPSTR)&ckRIFF, sizeof(ckRIFF));
2334   mmioFlush(This->hmmio, 0);
2335
2336   return AVIERR_OK;
2337 }
2338
2339 static HRESULT AVIFILE_SaveIndex(const IAVIFileImpl *This)
2340 {
2341   IAVIStreamImpl *pStream;
2342   AVIINDEXENTRY   idx;
2343   MMCKINFO        ck;
2344   DWORD           nStream;
2345   LONG            n;
2346
2347   ck.ckid   = ckidAVINEWINDEX;
2348   ck.cksize = 0;
2349   if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK)
2350     return AVIERR_FILEWRITE;
2351
2352   if (This->fInfo.dwFlags & AVIFILEINFO_ISINTERLEAVED) {
2353     /* is interleaved -- write block of corresponding frames */
2354     LONG lInitialFrames = 0;
2355     LONG stepsize;
2356     LONG i;
2357
2358     if (This->ppStreams[0]->sInfo.dwSampleSize == 0)
2359       stepsize = 1;
2360     else
2361       stepsize = AVIStreamTimeToSample((PAVISTREAM)This->ppStreams[0], 1000000);
2362
2363     assert(stepsize > 0);
2364
2365     for (nStream = 0; nStream < This->fInfo.dwStreams; nStream++) {
2366       if (lInitialFrames < This->ppStreams[nStream]->sInfo.dwInitialFrames)
2367         lInitialFrames = This->ppStreams[nStream]->sInfo.dwInitialFrames;
2368     }
2369
2370     for (i = -lInitialFrames; i < (LONG)This->fInfo.dwLength - lInitialFrames;
2371          i += stepsize) {
2372       DWORD nFrame = lInitialFrames + i;
2373
2374       assert(nFrame < This->nIdxRecords);
2375
2376       idx.ckid          = listtypeAVIRECORD;
2377       idx.dwFlags       = AVIIF_LIST;
2378       idx.dwChunkLength = This->idxRecords[nFrame].dwChunkLength;
2379       idx.dwChunkOffset = This->idxRecords[nFrame].dwChunkOffset
2380         - This->dwMoviChunkPos;
2381       if (mmioWrite(This->hmmio, (HPSTR)&idx, sizeof(idx)) != sizeof(idx))
2382         return AVIERR_FILEWRITE;
2383
2384       for (nStream = 0; nStream < This->fInfo.dwStreams; nStream++) {
2385         pStream = This->ppStreams[nStream];
2386
2387         /* heave we reached start of this stream? */
2388         if (-(LONG)pStream->sInfo.dwInitialFrames > i)
2389           continue;
2390
2391         if (pStream->sInfo.dwInitialFrames < lInitialFrames)
2392           nFrame -= (lInitialFrames - pStream->sInfo.dwInitialFrames);
2393
2394         /* reached end of this stream? */
2395         if (pStream->lLastFrame <= nFrame)
2396           continue;
2397
2398         if ((pStream->sInfo.dwFlags & AVISTREAMINFO_FORMATCHANGES) &&
2399             pStream->sInfo.dwFormatChangeCount != 0 &&
2400             pStream->idxFmtChanges != NULL) {
2401           DWORD pos;
2402
2403           for (pos = 0; pos < pStream->sInfo.dwFormatChangeCount; pos++) {
2404             if (pStream->idxFmtChanges[pos].ckid == nFrame) {
2405               idx.dwFlags = AVIIF_NOTIME;
2406               idx.ckid    = MAKEAVICKID(cktypePALchange, pStream->nStream);
2407               idx.dwChunkLength = pStream->idxFmtChanges[pos].dwChunkLength;
2408               idx.dwChunkOffset = pStream->idxFmtChanges[pos].dwChunkOffset
2409                 - This->dwMoviChunkPos;
2410
2411               if (mmioWrite(This->hmmio, (HPSTR)&idx, sizeof(idx)) != sizeof(idx))
2412                 return AVIERR_FILEWRITE;
2413               break;
2414             }
2415           }
2416         } /* if have formatchanges */
2417
2418         idx.ckid          = pStream->idxFrames[nFrame].ckid;
2419         idx.dwFlags       = pStream->idxFrames[nFrame].dwFlags;
2420         idx.dwChunkLength = pStream->idxFrames[nFrame].dwChunkLength;
2421         idx.dwChunkOffset = pStream->idxFrames[nFrame].dwChunkOffset
2422           - This->dwMoviChunkPos;
2423         if (mmioWrite(This->hmmio, (HPSTR)&idx, sizeof(idx)) != sizeof(idx))
2424           return AVIERR_FILEWRITE;
2425       }
2426     }
2427   } else {
2428     /* not interleaved -- write index for each stream at once */
2429     for (nStream = 0; nStream < This->fInfo.dwStreams; nStream++) {
2430       pStream = This->ppStreams[nStream];
2431
2432       for (n = 0; n <= pStream->lLastFrame; n++) {
2433         if ((pStream->sInfo.dwFlags & AVISTREAMINFO_FORMATCHANGES) &&
2434             (pStream->sInfo.dwFormatChangeCount != 0)) {
2435           DWORD pos;
2436
2437           for (pos = 0; pos < pStream->sInfo.dwFormatChangeCount; pos++) {
2438             if (pStream->idxFmtChanges[pos].ckid == n) {
2439               idx.dwFlags = AVIIF_NOTIME;
2440               idx.ckid    = MAKEAVICKID(cktypePALchange, pStream->nStream);
2441               idx.dwChunkLength = pStream->idxFmtChanges[pos].dwChunkLength;
2442               idx.dwChunkOffset =
2443                 pStream->idxFmtChanges[pos].dwChunkOffset - This->dwMoviChunkPos;
2444               if (mmioWrite(This->hmmio, (HPSTR)&idx, sizeof(idx)) != sizeof(idx))
2445                 return AVIERR_FILEWRITE;
2446               break;
2447             }
2448           }
2449         } /* if have formatchanges */
2450
2451         idx.ckid          = pStream->idxFrames[n].ckid;
2452         idx.dwFlags       = pStream->idxFrames[n].dwFlags;
2453         idx.dwChunkLength = pStream->idxFrames[n].dwChunkLength;
2454         idx.dwChunkOffset = pStream->idxFrames[n].dwChunkOffset
2455           - This->dwMoviChunkPos;
2456
2457         if (mmioWrite(This->hmmio, (HPSTR)&idx, sizeof(idx)) != sizeof(idx))
2458           return AVIERR_FILEWRITE;
2459       }
2460     }
2461   } /* if not interleaved */
2462
2463   if (mmioAscend(This->hmmio, &ck, 0) != S_OK)
2464     return AVIERR_FILEWRITE;
2465
2466   return AVIERR_OK;
2467 }
2468
2469 static ULONG  AVIFILE_SearchStream(const IAVIFileImpl *This, DWORD fcc, LONG lSkip)
2470 {
2471   UINT i;
2472   UINT nStream;
2473
2474   /* pre-condition */
2475   assert(lSkip >= 0);
2476
2477   if (fcc != 0) {
2478     /* search the number of the specified stream */
2479     nStream = (ULONG)-1;
2480     for (i = 0; i < This->fInfo.dwStreams; i++) {
2481       assert(This->ppStreams[i] != NULL);
2482
2483       if (This->ppStreams[i]->sInfo.fccType == fcc) {
2484         if (lSkip == 0) {
2485           nStream = i;
2486           break;
2487         } else
2488           lSkip--;
2489       }
2490     }
2491   } else
2492     nStream = lSkip;
2493
2494   return nStream;
2495 }
2496
2497 static void    AVIFILE_UpdateInfo(IAVIFileImpl *This)
2498 {
2499   UINT i;
2500
2501   /* pre-conditions */
2502   assert(This != NULL);
2503
2504   This->fInfo.dwMaxBytesPerSec      = 0;
2505   This->fInfo.dwCaps                = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE;
2506   This->fInfo.dwSuggestedBufferSize = 0;
2507   This->fInfo.dwWidth               = 0;
2508   This->fInfo.dwHeight              = 0;
2509   This->fInfo.dwScale               = 0;
2510   This->fInfo.dwRate                = 0;
2511   This->fInfo.dwLength              = 0;
2512   This->dwInitialFrames             = 0;
2513
2514   for (i = 0; i < This->fInfo.dwStreams; i++) {
2515     AVISTREAMINFOW *psi;
2516     DWORD           n;
2517
2518     /* pre-conditions */
2519     assert(This->ppStreams[i] != NULL);
2520
2521     psi = &This->ppStreams[i]->sInfo;
2522     assert(psi->dwScale != 0);
2523     assert(psi->dwRate != 0);
2524
2525     if (i == 0) {
2526       /* use first stream timings as base */
2527       This->fInfo.dwScale  = psi->dwScale;
2528       This->fInfo.dwRate   = psi->dwRate;
2529       This->fInfo.dwLength = psi->dwLength;
2530     } else {
2531       n = AVIStreamSampleToSample((PAVISTREAM)This->ppStreams[0],
2532                                   (PAVISTREAM)This->ppStreams[i],psi->dwLength);
2533       if (This->fInfo.dwLength < n)
2534         This->fInfo.dwLength = n;
2535     }
2536
2537     if (This->dwInitialFrames < psi->dwInitialFrames)
2538       This->dwInitialFrames = psi->dwInitialFrames;
2539
2540     if (This->fInfo.dwSuggestedBufferSize < psi->dwSuggestedBufferSize)
2541       This->fInfo.dwSuggestedBufferSize = psi->dwSuggestedBufferSize;
2542
2543     if (psi->dwSampleSize != 0) {
2544       /* fixed sample size -- exact computation */
2545       This->fInfo.dwMaxBytesPerSec += MulDiv(psi->dwSampleSize, psi->dwRate,
2546                                              psi->dwScale);
2547     } else {
2548       /* variable sample size -- only upper limit */
2549       This->fInfo.dwMaxBytesPerSec += MulDiv(psi->dwSuggestedBufferSize,
2550                                              psi->dwRate, psi->dwScale);
2551
2552       /* update dimensions */
2553       n = psi->rcFrame.right - psi->rcFrame.left;
2554       if (This->fInfo.dwWidth < n)
2555         This->fInfo.dwWidth = n;
2556       n = psi->rcFrame.bottom - psi->rcFrame.top;
2557       if (This->fInfo.dwHeight < n)
2558         This->fInfo.dwHeight = n;
2559     }
2560   }
2561 }
2562
2563 static HRESULT AVIFILE_WriteBlock(IAVIStreamImpl *This, DWORD block,
2564                                   FOURCC ckid, DWORD flags, LPCVOID buffer,
2565                                   LONG size)
2566 {
2567   MMCKINFO ck;
2568
2569   ck.ckid    = ckid;
2570   ck.cksize  = size;
2571   ck.fccType = 0;
2572
2573   /* if no frame/block is already written, we must compute start of movi chunk */
2574   if (This->paf->dwMoviChunkPos == 0)
2575     AVIFILE_ComputeMoviStart(This->paf);
2576
2577   if (mmioSeek(This->paf->hmmio, This->paf->dwNextFramePos, SEEK_SET) == -1)
2578     return AVIERR_FILEWRITE;
2579
2580   if (mmioCreateChunk(This->paf->hmmio, &ck, 0) != S_OK)
2581     return AVIERR_FILEWRITE;
2582   if (buffer != NULL && size > 0) {
2583     if (mmioWrite(This->paf->hmmio, buffer, size) != size)
2584       return AVIERR_FILEWRITE;
2585   }
2586   if (mmioAscend(This->paf->hmmio, &ck, 0) != S_OK)
2587     return AVIERR_FILEWRITE;
2588
2589   This->paf->fDirty         = TRUE;
2590   This->paf->dwNextFramePos = mmioSeek(This->paf->hmmio, 0, SEEK_CUR);
2591
2592   return AVIFILE_AddFrame(This, ckid, size,
2593                           ck.dwDataOffset - 2 * sizeof(DWORD), flags);
2594 }