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

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