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