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