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