?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winefile: Use SendMessageW instead of SNDMSG.
[wine.git] / dlls / avifil32 / api.c
blob592bac34b7b6b3d2dbc8b6e05619970d4ad99631
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 #include <stdarg.h>
21
22 #define COBJMACROS
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winnls.h"
27 #include "wingdi.h"
28 #include "winuser.h"
29 #include "winreg.h"
30 #include "winerror.h"
31
32 #include "ole2.h"
33 #include "shellapi.h"
34 #include "shlobj.h"
35 #include "vfw.h"
36 #include "msacm.h"
37
38 #include "avifile_private.h"
39
40 #include "wine/debug.h"
41 #include "wine/unicode.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(avifile);
44
45
46 /***********************************************************************
47 * for AVIBuildFilterW -- uses fixed size table
48 */
49 #define MAX_FILTERS 30 /* 30 => 7kB */
50
51 typedef struct _AVIFilter {
52 WCHAR szClsid[40];
53 WCHAR szExtensions[MAX_FILTERS * 7];
54 } AVIFilter;
55
56 /***********************************************************************
57 * for AVISaveOptions
58 */
59 static struct {
60 UINT uFlags;
61 INT nStreams;
62 PAVISTREAM *ppavis;
63 LPAVICOMPRESSOPTIONS *ppOptions;
64 INT nCurrent;
65 } SaveOpts;
66
67 /***********************************************************************
68 * copied from dlls/ole32/compobj.c
69 */
70 static HRESULT AVIFILE_CLSIDFromString(LPCSTR idstr, LPCLSID id)
71 {
72 BYTE const *s;
73 BYTE *p;
74 INT i;
75 BYTE table[256];
76
77 if (!idstr) {
78 memset(id, 0, sizeof(CLSID));
79 return S_OK;
80 }
81
82 /* validate the CLSID string */
83 if (lstrlenA(idstr) != 38)
84 return CO_E_CLASSSTRING;
85
86 s = (BYTE const*)idstr;
87 if ((s[0]!='{') || (s[9]!='-') || (s[14]!='-') || (s[19]!='-') ||
88 (s[24]!='-') || (s[37]!='}'))
89 return CO_E_CLASSSTRING;
90
91 for (i = 1; i < 37; i++) {
92 if ((i == 9) || (i == 14) || (i == 19) || (i == 24))
93 continue;
94 if (!(((s[i] >= '0') && (s[i] <= '9')) ||
95 ((s[i] >= 'a') && (s[i] <= 'f')) ||
96 ((s[i] >= 'A') && (s[i] <= 'F')))
97 )
98 return CO_E_CLASSSTRING;
99 }
100
101 TRACE("%s -> %p\n", s, id);
102
103 /* quick lookup table */
104 memset(table, 0, 256);
105
106 for (i = 0; i < 10; i++)
107 table['0' + i] = i;
108
109 for (i = 0; i < 6; i++) {
110 table['A' + i] = i+10;
111 table['a' + i] = i+10;
112 }
113
114 /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
115 p = (BYTE *) id;
116
117 s++; /* skip leading brace */
118 for (i = 0; i < 4; i++) {
119 p[3 - i] = table[*s]<<4 | table[*(s+1)];
120 s += 2;
121 }
122 p += 4;
123 s++; /* skip - */
124
125 for (i = 0; i < 2; i++) {
126 p[1-i] = table[*s]<<4 | table[*(s+1)];
127 s += 2;
128 }
129 p += 2;
130 s++; /* skip - */
131
132 for (i = 0; i < 2; i++) {
133 p[1-i] = table[*s]<<4 | table[*(s+1)];
134 s += 2;
135 }
136 p += 2;
137 s++; /* skip - */
138
139 /* these are just sequential bytes */
140 for (i = 0; i < 2; i++) {
141 *p++ = table[*s]<<4 | table[*(s+1)];
142 s += 2;
143 }
144 s++; /* skip - */
145
146 for (i = 0; i < 6; i++) {
147 *p++ = table[*s]<<4 | table[*(s+1)];
148 s += 2;
149 }
150
151 return S_OK;
152 }
153
154 static BOOL AVIFILE_GetFileHandlerByExtension(LPCWSTR szFile, LPCLSID lpclsid)
155 {
156 CHAR szRegKey[25];
157 CHAR szValue[100];
158 LPWSTR szExt = strrchrW(szFile, '.');
159 LONG len = sizeof(szValue) / sizeof(szValue[0]);
160
161 if (szExt == NULL)
162 return FALSE;
163
164 szExt++;
165
166 wsprintfA(szRegKey, "AVIFile\\Extensions\\%.3ls", szExt);
167 if (RegQueryValueA(HKEY_CLASSES_ROOT, szRegKey, szValue, &len) != ERROR_SUCCESS)
168 return FALSE;
169
170 return (AVIFILE_CLSIDFromString(szValue, lpclsid) == S_OK);
171 }
172
173 /***********************************************************************
174 * AVIFileInit (AVIFIL32.@)
175 * AVIFileInit (AVIFILE.100)
176 */
177 void WINAPI AVIFileInit(void) {
178 OleInitialize(NULL);
179 }
180
181 /***********************************************************************
182 * AVIFileExit (AVIFIL32.@)
183 * AVIFileExit (AVIFILE.101)
184 */
185 void WINAPI AVIFileExit(void) {
186 /* need to free ole32.dll if we are the last exit call */
187 /* OleUninitialize() */
188 FIXME("(): stub!\n");
189 }
190
191 /***********************************************************************
192 * AVIFileOpen (AVIFIL32.@)
193 * AVIFileOpenA (AVIFIL32.@)
194 * AVIFileOpen (AVIFILE.102)
195 */
196 HRESULT WINAPI AVIFileOpenA(PAVIFILE *ppfile, LPCSTR szFile, UINT uMode,
197 LPCLSID lpHandler)
198 {
199 LPWSTR wszFile = NULL;
200 HRESULT hr;
201 int len;
202
203 TRACE("(%p,%s,0x%08X,%s)\n", ppfile, debugstr_a(szFile), uMode,
204 debugstr_guid(lpHandler));
205
206 /* check parameters */
207 if (ppfile == NULL || szFile == NULL)
208 return AVIERR_BADPARAM;
209
210 /* convert ASCII string to Unicode and call unicode function */
211 len = MultiByteToWideChar(CP_ACP, 0, szFile, -1, NULL, 0);
212 if (len <= 0)
213 return AVIERR_BADPARAM;
214
215 wszFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
216 if (wszFile == NULL)
217 return AVIERR_MEMORY;
218
219 MultiByteToWideChar(CP_ACP, 0, szFile, -1, wszFile, len);
220
221 hr = AVIFileOpenW(ppfile, wszFile, uMode, lpHandler);
222
223 HeapFree(GetProcessHeap(), 0, wszFile);
224
225 return hr;
226 }
227
228 /***********************************************************************
229 * AVIFileOpenW (AVIFIL32.@)
230 */
231 HRESULT WINAPI AVIFileOpenW(PAVIFILE *ppfile, LPCWSTR szFile, UINT uMode,
232 LPCLSID lpHandler)
233 {
234 IPersistFile *ppersist = NULL;
235 CLSID clsidHandler;
236 HRESULT hr;
237
238 TRACE("(%p,%s,0x%X,%s)\n", ppfile, debugstr_w(szFile), uMode,
239 debugstr_guid(lpHandler));
240
241 /* check parameters */
242 if (ppfile == NULL || szFile == NULL)
243 return AVIERR_BADPARAM;
244
245 *ppfile = NULL;
246
247 /* if no handler then try guessing it by extension */
248 if (lpHandler == NULL) {
249 if (! AVIFILE_GetFileHandlerByExtension(szFile, &clsidHandler))
250 return AVIERR_UNSUPPORTED;
251 } else
252 memcpy(&clsidHandler, lpHandler, sizeof(clsidHandler));
253
254 /* create instance of handler */
255 hr = CoCreateInstance(&clsidHandler, NULL, CLSCTX_INPROC, &IID_IAVIFile, (LPVOID*)ppfile);
256 if (FAILED(hr) || *ppfile == NULL)
257 return hr;
258
259 /* ask for IPersistFile interface for loading/creating the file */
260 hr = IAVIFile_QueryInterface(*ppfile, &IID_IPersistFile, (LPVOID*)&ppersist);
261 if (FAILED(hr) || ppersist == NULL) {
262 IAVIFile_Release(*ppfile);
263 *ppfile = NULL;
264 return hr;
265 }
266
267 hr = IPersistFile_Load(ppersist, szFile, uMode);
268 IPersistFile_Release(ppersist);
269 if (FAILED(hr)) {
270 IAVIFile_Release(*ppfile);
271 *ppfile = NULL;
272 }
273
274 return hr;
275 }
276
277 /***********************************************************************
278 * AVIFileAddRef (AVIFIL32.@)
279 * AVIFileAddRef (AVIFILE.140)
280 */
281 ULONG WINAPI AVIFileAddRef(PAVIFILE pfile)
282 {
283 TRACE("(%p)\n", pfile);
284
285 if (pfile == NULL) {
286 ERR(": bad handle passed!\n");
287 return 0;
288 }
289
290 return IAVIFile_AddRef(pfile);
291 }
292
293 /***********************************************************************
294 * AVIFileRelease (AVIFIL32.@)
295 * AVIFileRelease (AVIFILE.141)
296 */
297 ULONG WINAPI AVIFileRelease(PAVIFILE pfile)
298 {
299 TRACE("(%p)\n", pfile);
300
301 if (pfile == NULL) {
302 ERR(": bad handle passed!\n");
303 return 0;
304 }
305
306 return IAVIFile_Release(pfile);
307 }
308
309 /***********************************************************************
310 * AVIFileInfo (AVIFIL32.@)
311 * AVIFileInfoA (AVIFIL32.@)
312 * AVIFileInfo (AVIFILE.142)
313 */
314 HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile, LPAVIFILEINFOA afi, LONG size)
315 {
316 AVIFILEINFOW afiw;
317 HRESULT hres;
318
319 TRACE("(%p,%p,%d)\n", pfile, afi, size);
320
321 if (pfile == NULL)
322 return AVIERR_BADHANDLE;
323 if ((DWORD)size < sizeof(AVIFILEINFOA))
324 return AVIERR_BADSIZE;
325
326 hres = IAVIFile_Info(pfile, &afiw, sizeof(afiw));
327
328 memcpy(afi, &afiw, sizeof(*afi) - sizeof(afi->szFileType));
329 WideCharToMultiByte(CP_ACP, 0, afiw.szFileType, -1, afi->szFileType,
330 sizeof(afi->szFileType), NULL, NULL);
331 afi->szFileType[sizeof(afi->szFileType) - 1] = 0;
332
333 return hres;
334 }
335
336 /***********************************************************************
337 * AVIFileInfoW (AVIFIL32.@)
338 */
339 HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile, LPAVIFILEINFOW afiw, LONG size)
340 {
341 TRACE("(%p,%p,%d)\n", pfile, afiw, size);
342
343 if (pfile == NULL)
344 return AVIERR_BADHANDLE;
345
346 return IAVIFile_Info(pfile, afiw, size);
347 }
348
349 /***********************************************************************
350 * AVIFileGetStream (AVIFIL32.@)
351 * AVIFileGetStream (AVIFILE.143)
352 */
353 HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile, PAVISTREAM *avis,
354 DWORD fccType, LONG lParam)
355 {
356 TRACE("(%p,%p,'%4.4s',%d)\n", pfile, avis, (char*)&fccType, lParam);
357
358 if (pfile == NULL)
359 return AVIERR_BADHANDLE;
360
361 return IAVIFile_GetStream(pfile, avis, fccType, lParam);
362 }
363
364 /***********************************************************************
365 * AVIFileCreateStream (AVIFIL32.@)
366 * AVIFileCreateStreamA (AVIFIL32.@)
367 * AVIFileCreateStream (AVIFILE.144)
368 */
369 HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile, PAVISTREAM *ppavi,
370 LPAVISTREAMINFOA psi)
371 {
372 AVISTREAMINFOW psiw;
373
374 TRACE("(%p,%p,%p)\n", pfile, ppavi, psi);
375
376 if (pfile == NULL)
377 return AVIERR_BADHANDLE;
378
379 /* Only the szName at the end is different */
380 memcpy(&psiw, psi, sizeof(*psi) - sizeof(psi->szName));
381 MultiByteToWideChar(CP_ACP, 0, psi->szName, -1, psiw.szName,
382 sizeof(psiw.szName) / sizeof(psiw.szName[0]));
383
384 return IAVIFile_CreateStream(pfile, ppavi, &psiw);
385 }
386
387 /***********************************************************************
388 * AVIFileCreateStreamW (AVIFIL32.@)
389 */
390 HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile, PAVISTREAM *avis,
391 LPAVISTREAMINFOW asi)
392 {
393 TRACE("(%p,%p,%p)\n", pfile, avis, asi);
394
395 if (pfile == NULL)
396 return AVIERR_BADHANDLE;
397
398 return IAVIFile_CreateStream(pfile, avis, asi);
399 }
400
401 /***********************************************************************
402 * AVIFileWriteData (AVIFIL32.@)
403 * AVIFileWriteData (AVIFILE.146)
404 */
405 HRESULT WINAPI AVIFileWriteData(PAVIFILE pfile,DWORD fcc,LPVOID lp,LONG size)
406 {
407 TRACE("(%p,'%4.4s',%p,%d)\n", pfile, (char*)&fcc, lp, size);
408
409 if (pfile == NULL)
410 return AVIERR_BADHANDLE;
411
412 return IAVIFile_WriteData(pfile, fcc, lp, size);
413 }
414
415 /***********************************************************************
416 * AVIFileReadData (AVIFIL32.@)
417 * AVIFileReadData (AVIFILE.147)
418 */
419 HRESULT WINAPI AVIFileReadData(PAVIFILE pfile,DWORD fcc,LPVOID lp,LPLONG size)
420 {
421 TRACE("(%p,'%4.4s',%p,%p)\n", pfile, (char*)&fcc, lp, size);
422
423 if (pfile == NULL)
424 return AVIERR_BADHANDLE;
425
426 return IAVIFile_ReadData(pfile, fcc, lp, size);
427 }
428
429 /***********************************************************************
430 * AVIFileEndRecord (AVIFIL32.@)
431 * AVIFileEndRecord (AVIFILE.148)
432 */
433 HRESULT WINAPI AVIFileEndRecord(PAVIFILE pfile)
434 {
435 TRACE("(%p)\n", pfile);
436
437 if (pfile == NULL)
438 return AVIERR_BADHANDLE;
439
440 return IAVIFile_EndRecord(pfile);
441 }
442
443 /***********************************************************************
444 * AVIStreamAddRef (AVIFIL32.@)
445 * AVIStreamAddRef (AVIFILE.160)
446 */
447 ULONG WINAPI AVIStreamAddRef(PAVISTREAM pstream)
448 {
449 TRACE("(%p)\n", pstream);
450
451 if (pstream == NULL) {
452 ERR(": bad handle passed!\n");
453 return 0;
454 }
455
456 return IAVIStream_AddRef(pstream);
457 }
458
459 /***********************************************************************
460 * AVIStreamRelease (AVIFIL32.@)
461 * AVIStreamRelease (AVIFILE.161)
462 */
463 ULONG WINAPI AVIStreamRelease(PAVISTREAM pstream)
464 {
465 TRACE("(%p)\n", pstream);
466
467 if (pstream == NULL) {
468 ERR(": bad handle passed!\n");
469 return 0;
470 }
471
472 return IAVIStream_Release(pstream);
473 }
474
475 /***********************************************************************
476 * AVIStreamCreate (AVIFIL32.@)
477 * AVIStreamCreate (AVIFILE.104)
478 */
479 HRESULT WINAPI AVIStreamCreate(PAVISTREAM *ppavi, LONG lParam1, LONG lParam2,
480 LPCLSID pclsidHandler)
481 {
482 HRESULT hr;
483
484 TRACE("(%p,0x%08X,0x%08X,%s)\n", ppavi, lParam1, lParam2,
485 debugstr_guid(pclsidHandler));
486
487 if (ppavi == NULL)
488 return AVIERR_BADPARAM;
489
490 *ppavi = NULL;
491 if (pclsidHandler == NULL)
492 return AVIERR_UNSUPPORTED;
493
494 hr = CoCreateInstance(pclsidHandler, NULL, CLSCTX_INPROC, &IID_IAVIStream, (LPVOID*)ppavi);
495 if (FAILED(hr) || *ppavi == NULL)
496 return hr;
497
498 hr = IAVIStream_Create(*ppavi, lParam1, lParam2);
499 if (FAILED(hr)) {
500 IAVIStream_Release(*ppavi);
501 *ppavi = NULL;
502 }
503
504 return hr;
505 }
506
507 /***********************************************************************
508 * AVIStreamInfo (AVIFIL32.@)
509 * AVIStreamInfoA (AVIFIL32.@)
510 * AVIStreamInfo (AVIFILE.162)
511 */
512 HRESULT WINAPI AVIStreamInfoA(PAVISTREAM pstream, LPAVISTREAMINFOA asi,
513 LONG size)
514 {
515 AVISTREAMINFOW asiw;
516 HRESULT hres;
517
518 TRACE("(%p,%p,%d)\n", pstream, asi, size);
519
520 if (pstream == NULL)
521 return AVIERR_BADHANDLE;
522 if ((DWORD)size < sizeof(AVISTREAMINFOA))
523 return AVIERR_BADSIZE;
524
525 hres = IAVIStream_Info(pstream, &asiw, sizeof(asiw));
526
527 memcpy(asi, &asiw, sizeof(asiw) - sizeof(asiw.szName));
528 WideCharToMultiByte(CP_ACP, 0, asiw.szName, -1, asi->szName,
529 sizeof(asi->szName), NULL, NULL);
530 asi->szName[sizeof(asi->szName) - 1] = 0;
531
532 return hres;
533 }
534
535 /***********************************************************************
536 * AVIStreamInfoW (AVIFIL32.@)
537 */
538 HRESULT WINAPI AVIStreamInfoW(PAVISTREAM pstream, LPAVISTREAMINFOW asi,
539 LONG size)
540 {
541 TRACE("(%p,%p,%d)\n", pstream, asi, size);
542
543 if (pstream == NULL)
544 return AVIERR_BADHANDLE;
545
546 return IAVIStream_Info(pstream, asi, size);
547 }
548
549 /***********************************************************************
550 * AVIStreamFindSample (AVIFIL32.@)
551 * AVIStreamFindSample (AVIFILE.163)
552 */
553 HRESULT WINAPI AVIStreamFindSample(PAVISTREAM pstream, LONG pos, DWORD flags)
554 {
555 TRACE("(%p,%d,0x%X)\n", pstream, pos, flags);
556
557 if (pstream == NULL)
558 return -1;
559
560 return IAVIStream_FindSample(pstream, pos, flags);
561 }
562
563 /***********************************************************************
564 * AVIStreamReadFormat (AVIFIL32.@)
565 * AVIStreamReadFormat (AVIFILE.164)
566 */
567 HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM pstream, LONG pos,
568 LPVOID format, LPLONG formatsize)
569 {
570 TRACE("(%p,%d,%p,%p)\n", pstream, pos, format, formatsize);
571
572 if (pstream == NULL)
573 return AVIERR_BADHANDLE;
574
575 return IAVIStream_ReadFormat(pstream, pos, format, formatsize);
576 }
577
578 /***********************************************************************
579 * AVIStreamSetFormat (AVIFIL32.@)
580 * AVIStreamSetFormat (AVIFILE.169)
581 */
582 HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM pstream, LONG pos,
583 LPVOID format, LONG formatsize)
584 {
585 TRACE("(%p,%d,%p,%d)\n", pstream, pos, format, formatsize);
586
587 if (pstream == NULL)
588 return AVIERR_BADHANDLE;
589
590 return IAVIStream_SetFormat(pstream, pos, format, formatsize);
591 }
592
593 /***********************************************************************
594 * AVIStreamRead (AVIFIL32.@)
595 * AVIStreamRead (AVIFILE.167)
596 */
597 HRESULT WINAPI AVIStreamRead(PAVISTREAM pstream, LONG start, LONG samples,
598 LPVOID buffer, LONG buffersize,
599 LPLONG bytesread, LPLONG samplesread)
600 {
601 TRACE("(%p,%d,%d,%p,%d,%p,%p)\n", pstream, start, samples, buffer,
602 buffersize, bytesread, samplesread);
603
604 if (pstream == NULL)
605 return AVIERR_BADHANDLE;
606
607 return IAVIStream_Read(pstream, start, samples, buffer, buffersize,
608 bytesread, samplesread);
609 }
610
611 /***********************************************************************
612 * AVIStreamWrite (AVIFIL32.@)
613 * AVIStreamWrite (AVIFILE.168)
614 */
615 HRESULT WINAPI AVIStreamWrite(PAVISTREAM pstream, LONG start, LONG samples,
616 LPVOID buffer, LONG buffersize, DWORD flags,
617 LPLONG sampwritten, LPLONG byteswritten)
618 {
619 TRACE("(%p,%d,%d,%p,%d,0x%X,%p,%p)\n", pstream, start, samples, buffer,
620 buffersize, flags, sampwritten, byteswritten);
621
622 if (pstream == NULL)
623 return AVIERR_BADHANDLE;
624
625 return IAVIStream_Write(pstream, start, samples, buffer, buffersize,
626 flags, sampwritten, byteswritten);
627 }
628
629 /***********************************************************************
630 * AVIStreamReadData (AVIFIL32.@)
631 * AVIStreamReadData (AVIFILE.165)
632 */
633 HRESULT WINAPI AVIStreamReadData(PAVISTREAM pstream, DWORD fcc, LPVOID lp,
634 LPLONG lpread)
635 {
636 TRACE("(%p,'%4.4s',%p,%p)\n", pstream, (char*)&fcc, lp, lpread);
637
638 if (pstream == NULL)
639 return AVIERR_BADHANDLE;
640
641 return IAVIStream_ReadData(pstream, fcc, lp, lpread);
642 }
643
644 /***********************************************************************
645 * AVIStreamWriteData (AVIFIL32.@)
646 * AVIStreamWriteData (AVIFILE.166)
647 */
648 HRESULT WINAPI AVIStreamWriteData(PAVISTREAM pstream, DWORD fcc, LPVOID lp,
649 LONG size)
650 {
651 TRACE("(%p,'%4.4s',%p,%d)\n", pstream, (char*)&fcc, lp, size);
652
653 if (pstream == NULL)
654 return AVIERR_BADHANDLE;
655
656 return IAVIStream_WriteData(pstream, fcc, lp, size);
657 }
658
659 /***********************************************************************
660 * AVIStreamGetFrameOpen (AVIFIL32.@)
661 * AVIStreamGetFrameOpen (AVIFILE.112)
662 */
663 PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pstream,
664 LPBITMAPINFOHEADER lpbiWanted)
665 {
666 PGETFRAME pg = NULL;
667
668 TRACE("(%p,%p)\n", pstream, lpbiWanted);
669
670 if (FAILED(IAVIStream_QueryInterface(pstream, &IID_IGetFrame, (LPVOID*)&pg)) ||
671 pg == NULL) {
672 pg = AVIFILE_CreateGetFrame(pstream);
673 if (pg == NULL)
674 return NULL;
675 }
676
677 if (FAILED(IGetFrame_SetFormat(pg, lpbiWanted, NULL, 0, 0, -1, -1))) {
678 IGetFrame_Release(pg);
679 return NULL;
680 }
681
682 return pg;
683 }
684
685 /***********************************************************************
686 * AVIStreamGetFrame (AVIFIL32.@)
687 * AVIStreamGetFrame (AVIFILE.110)
688 */
689 LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pg, LONG pos)
690 {
691 TRACE("(%p,%d)\n", pg, pos);
692
693 if (pg == NULL)
694 return NULL;
695
696 return IGetFrame_GetFrame(pg, pos);
697 }
698
699 /***********************************************************************
700 * AVIStreamGetFrameClose (AVIFIL32.@)
701 * AVIStreamGetFrameClose (AVIFILE.111)
702 */
703 HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pg)
704 {
705 TRACE("(%p)\n", pg);
706
707 if (pg != NULL)
708 return IGetFrame_Release(pg);
709 return 0;
710 }
711
712 /***********************************************************************
713 * AVIMakeCompressedStream (AVIFIL32.@)
714 */
715 HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,
716 PAVISTREAM psSource,
717 LPAVICOMPRESSOPTIONS aco,
718 LPCLSID pclsidHandler)
719 {
720 AVISTREAMINFOW asiw;
721 CHAR szRegKey[25];
722 CHAR szValue[100];
723 CLSID clsidHandler;
724 HRESULT hr;
725 LONG size = sizeof(szValue);
726
727 TRACE("(%p,%p,%p,%s)\n", ppsCompressed, psSource, aco,
728 debugstr_guid(pclsidHandler));
729
730 if (ppsCompressed == NULL)
731 return AVIERR_BADPARAM;
732 if (psSource == NULL)
733 return AVIERR_BADHANDLE;
734
735 *ppsCompressed = NULL;
736
737 /* if no handler given get default ones based on streamtype */
738 if (pclsidHandler == NULL) {
739 hr = IAVIStream_Info(psSource, &asiw, sizeof(asiw));
740 if (FAILED(hr))
741 return hr;
742
743 wsprintfA(szRegKey, "AVIFile\\Compressors\\%4.4s", (char*)&asiw.fccType);
744 if (RegQueryValueA(HKEY_CLASSES_ROOT, szRegKey, szValue, &size) != ERROR_SUCCESS)
745 return AVIERR_UNSUPPORTED;
746 if (AVIFILE_CLSIDFromString(szValue, &clsidHandler) != S_OK)
747 return AVIERR_UNSUPPORTED;
748 } else
749 memcpy(&clsidHandler, pclsidHandler, sizeof(clsidHandler));
750
751 hr = CoCreateInstance(&clsidHandler, NULL, CLSCTX_INPROC, &IID_IAVIStream, (LPVOID*)ppsCompressed);
752 if (FAILED(hr) || *ppsCompressed == NULL)
753 return hr;
754
755 hr = IAVIStream_Create(*ppsCompressed, (LPARAM)psSource, (LPARAM)aco);
756 if (FAILED(hr)) {
757 IAVIStream_Release(*ppsCompressed);
758 *ppsCompressed = NULL;
759 }
760
761 return hr;
762 }
763
764 /***********************************************************************
765 * AVIMakeFileFromStreams (AVIFIL32.@)
766 */
767 HRESULT WINAPI AVIMakeFileFromStreams(PAVIFILE *ppfile, int nStreams,
768 PAVISTREAM *ppStreams)
769 {
770 TRACE("(%p,%d,%p)\n", ppfile, nStreams, ppStreams);
771
772 if (nStreams < 0 || ppfile == NULL || ppStreams == NULL)
773 return AVIERR_BADPARAM;
774
775 *ppfile = AVIFILE_CreateAVITempFile(nStreams, ppStreams);
776 if (*ppfile == NULL)
777 return AVIERR_MEMORY;
778
779 return AVIERR_OK;
780 }
781
782 /***********************************************************************
783 * AVIStreamOpenFromFile (AVIFIL32.@)
784 * AVIStreamOpenFromFileA (AVIFIL32.@)
785 * AVIStreamOpenFromFile (AVIFILE.103)
786 */
787 HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM *ppavi, LPCSTR szFile,
788 DWORD fccType, LONG lParam,
789 UINT mode, LPCLSID pclsidHandler)
790 {
791 PAVIFILE pfile = NULL;
792 HRESULT hr;
793
794 TRACE("(%p,%s,'%4.4s',%d,0x%X,%s)\n", ppavi, debugstr_a(szFile),
795 (char*)&fccType, lParam, mode, debugstr_guid(pclsidHandler));
796
797 if (ppavi == NULL || szFile == NULL)
798 return AVIERR_BADPARAM;
799
800 *ppavi = NULL;
801
802 hr = AVIFileOpenA(&pfile, szFile, mode, pclsidHandler);
803 if (FAILED(hr) || pfile == NULL)
804 return hr;
805
806 hr = IAVIFile_GetStream(pfile, ppavi, fccType, lParam);
807 IAVIFile_Release(pfile);
808
809 return hr;
810 }
811
812 /***********************************************************************
813 * AVIStreamOpenFromFileW (AVIFIL32.@)
814 */
815 HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM *ppavi, LPCWSTR szFile,
816 DWORD fccType, LONG lParam,
817 UINT mode, LPCLSID pclsidHandler)
818 {
819 PAVIFILE pfile = NULL;
820 HRESULT hr;
821
822 TRACE("(%p,%s,'%4.4s',%d,0x%X,%s)\n", ppavi, debugstr_w(szFile),
823 (char*)&fccType, lParam, mode, debugstr_guid(pclsidHandler));
824
825 if (ppavi == NULL || szFile == NULL)
826 return AVIERR_BADPARAM;
827
828 *ppavi = NULL;
829
830 hr = AVIFileOpenW(&pfile, szFile, mode, pclsidHandler);
831 if (FAILED(hr) || pfile == NULL)
832 return hr;
833
834 hr = IAVIFile_GetStream(pfile, ppavi, fccType, lParam);
835 IAVIFile_Release(pfile);
836
837 return hr;
838 }
839
840 /***********************************************************************
841 * AVIStreamBeginStreaming (AVIFIL32.@)
842 */
843 LONG WINAPI AVIStreamBeginStreaming(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate)
844 {
845 IAVIStreaming* pstream = NULL;
846 HRESULT hr;
847
848 TRACE("(%p,%d,%d,%d)\n", pavi, lStart, lEnd, lRate);
849
850 if (pavi == NULL)
851 return AVIERR_BADHANDLE;
852
853 hr = IAVIStream_QueryInterface(pavi, &IID_IAVIStreaming, (LPVOID*)&pstream);
854 if (SUCCEEDED(hr) && pstream != NULL) {
855 hr = IAVIStreaming_Begin(pstream, lStart, lEnd, lRate);
856 IAVIStreaming_Release(pstream);
857 } else
858 hr = AVIERR_OK;
859
860 return hr;
861 }
862
863 /***********************************************************************
864 * AVIStreamEndStreaming (AVIFIL32.@)
865 */
866 LONG WINAPI AVIStreamEndStreaming(PAVISTREAM pavi)
867 {
868 IAVIStreaming* pstream = NULL;
869 HRESULT hr;
870
871 TRACE("(%p)\n", pavi);
872
873 hr = IAVIStream_QueryInterface(pavi, &IID_IAVIStreaming, (LPVOID*)&pstream);
874 if (SUCCEEDED(hr) && pstream != NULL) {
875 IAVIStreaming_End(pstream);
876 IAVIStreaming_Release(pstream);
877 }
878
879 return AVIERR_OK;
880 }
881
882 /***********************************************************************
883 * AVIStreamStart (AVIFILE.130)
884 * AVIStreamStart (AVIFIL32.@)
885 */
886 LONG WINAPI AVIStreamStart(PAVISTREAM pstream)
887 {
888 AVISTREAMINFOW asiw;
889
890 TRACE("(%p)\n", pstream);
891
892 if (pstream == NULL)
893 return 0;
894
895 if (FAILED(IAVIStream_Info(pstream, &asiw, sizeof(asiw))))
896 return 0;
897
898 return asiw.dwStart;
899 }
900
901 /***********************************************************************
902 * AVIStreamLength (AVIFILE.131)
903 * AVIStreamLength (AVIFIL32.@)
904 */
905 LONG WINAPI AVIStreamLength(PAVISTREAM pstream)
906 {
907 AVISTREAMINFOW asiw;
908
909 TRACE("(%p)\n", pstream);
910
911 if (pstream == NULL)
912 return 0;
913
914 if (FAILED(IAVIStream_Info(pstream, &asiw, sizeof(asiw))))
915 return 0;
916
917 return asiw.dwLength;
918 }
919
920 /***********************************************************************
921 * AVIStreamSampleToTime (AVIFILE.133)
922 * AVIStreamSampleToTime (AVIFIL32.@)
923 */
924 LONG WINAPI AVIStreamSampleToTime(PAVISTREAM pstream, LONG lSample)
925 {
926 AVISTREAMINFOW asiw;
927 LONG time;
928
929 TRACE("(%p,%d)\n", pstream, lSample);
930
931 if (pstream == NULL)
932 return -1;
933
934 if (FAILED(IAVIStream_Info(pstream, &asiw, sizeof(asiw))))
935 return -1;
936 if (asiw.dwRate == 0)
937 return -1;
938
939 /* limit to stream bounds */
940 if (lSample < asiw.dwStart)
941 lSample = asiw.dwStart;
942 if (lSample > asiw.dwStart + asiw.dwLength)
943 lSample = asiw.dwStart + asiw.dwLength;
944
945 if (asiw.dwRate / asiw.dwScale < 1000)
946 time = (LONG)(((float)lSample * asiw.dwScale * 1000) / asiw.dwRate);
947 else
948 time = (LONG)(((float)lSample * asiw.dwScale * 1000 + (asiw.dwRate - 1)) / asiw.dwRate);
949
950 TRACE(" -> %d\n",time);
951 return time;
952 }
953
954 /***********************************************************************
955 * AVIStreamTimeToSample (AVIFILE.132)
956 * AVIStreamTimeToSample (AVIFIL32.@)
957 */
958 LONG WINAPI AVIStreamTimeToSample(PAVISTREAM pstream, LONG lTime)
959 {
960 AVISTREAMINFOW asiw;
961 ULONG sample;
962
963 TRACE("(%p,%d)\n", pstream, lTime);
964
965 if (pstream == NULL || lTime < 0)
966 return -1;
967
968 if (FAILED(IAVIStream_Info(pstream, &asiw, sizeof(asiw))))
969 return -1;
970 if (asiw.dwScale == 0)
971 return -1;
972
973 if (asiw.dwRate / asiw.dwScale < 1000)
974 sample = (LONG)((((float)asiw.dwRate * lTime) / (asiw.dwScale * 1000)));
975 else
976 sample = (LONG)(((float)asiw.dwRate * lTime + (asiw.dwScale * 1000 - 1)) / (asiw.dwScale * 1000));
977
978 /* limit to stream bounds */
979 if (sample < asiw.dwStart)
980 sample = asiw.dwStart;
981 if (sample > asiw.dwStart + asiw.dwLength)
982 sample = asiw.dwStart + asiw.dwLength;
983
984 TRACE(" -> %d\n", sample);
985 return sample;
986 }
987
988 /***********************************************************************
989 * AVIBuildFilter (AVIFIL32.@)
990 * AVIBuildFilterA (AVIFIL32.@)
991 * AVIBuildFilter (AVIFILE.123)
992 */
993 HRESULT WINAPI AVIBuildFilterA(LPSTR szFilter, LONG cbFilter, BOOL fSaving)
994 {
995 LPWSTR wszFilter;
996 HRESULT hr;
997
998 TRACE("(%p,%d,%d)\n", szFilter, cbFilter, fSaving);
999
1000 /* check parameters */
1001 if (szFilter == NULL)
1002 return AVIERR_BADPARAM;
1003 if (cbFilter < 2)
1004 return AVIERR_BADSIZE;
1005
1006 szFilter[0] = 0;
1007 szFilter[1] = 0;
1008
1009 wszFilter = HeapAlloc(GetProcessHeap(), 0, cbFilter * sizeof(WCHAR));
1010 if (wszFilter == NULL)
1011 return AVIERR_MEMORY;
1012
1013 hr = AVIBuildFilterW(wszFilter, cbFilter, fSaving);
1014 if (SUCCEEDED(hr)) {
1015 WideCharToMultiByte(CP_ACP, 0, wszFilter, cbFilter,
1016 szFilter, cbFilter, NULL, NULL);
1017 }
1018
1019 HeapFree(GetProcessHeap(), 0, wszFilter);
1020
1021 return hr;
1022 }
1023
1024 /***********************************************************************
1025 * AVIBuildFilterW (AVIFIL32.@)
1026 */
1027 HRESULT WINAPI AVIBuildFilterW(LPWSTR szFilter, LONG cbFilter, BOOL fSaving)
1028 {
1029 static const WCHAR szClsid[] = {'C','L','S','I','D',0};
1030 static const WCHAR szExtensionFmt[] = {';','*','.','%','s',0};
1031 static const WCHAR szAVIFileExtensions[] =
1032 {'A','V','I','F','i','l','e','\\','E','x','t','e','n','s','i','o','n','s',0};
1033
1034 AVIFilter *lp;
1035 WCHAR szAllFiles[40];
1036 WCHAR szFileExt[10];
1037 WCHAR szValue[128];
1038 HKEY hKey;
1039 DWORD n, i;
1040 LONG size;
1041 DWORD count = 0;
1042
1043 TRACE("(%p,%d,%d)\n", szFilter, cbFilter, fSaving);
1044
1045 /* check parameters */
1046 if (szFilter == NULL)
1047 return AVIERR_BADPARAM;
1048 if (cbFilter < 2)
1049 return AVIERR_BADSIZE;
1050
1051 lp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_FILTERS * sizeof(AVIFilter));
1052 if (lp == NULL)
1053 return AVIERR_MEMORY;
1054
1055 /*
1056 * 1. iterate over HKEY_CLASSES_ROOT\\AVIFile\\Extensions and collect
1057 * extensions and CLSID's
1058 * 2. iterate over collected CLSID's and copy its description and its
1059 * extensions to szFilter if it fits
1060 *
1061 * First filter is named "All multimedia files" and its filter is a
1062 * collection of all possible extensions except "*.*".
1063 */
1064 if (RegOpenKeyW(HKEY_CLASSES_ROOT, szAVIFileExtensions, &hKey) != S_OK) {
1065 HeapFree(GetProcessHeap(), 0, lp);
1066 return AVIERR_ERROR;
1067 }
1068 for (n = 0;RegEnumKeyW(hKey, n, szFileExt, sizeof(szFileExt)) == S_OK;n++) {
1069 /* get CLSID to extension */
1070 size = sizeof(szValue)/sizeof(szValue[0]);
1071 if (RegQueryValueW(hKey, szFileExt, szValue, &size) != S_OK)
1072 break;
1073
1074 /* search if the CLSID is already known */
1075 for (i = 1; i <= count; i++) {
1076 if (lstrcmpW(lp[i].szClsid, szValue) == 0)
1077 break; /* a new one */
1078 }
1079
1080 if (count - i == -1U) {
1081 /* it's a new CLSID */
1082
1083 /* FIXME: How do we get info's about read/write capabilities? */
1084
1085 if (count >= MAX_FILTERS) {
1086 /* try to inform user of our full fixed size table */
1087 ERR(": More than %d filters found! Adjust MAX_FILTERS in dlls/avifil32/api.c\n", MAX_FILTERS);
1088 break;
1089 }
1090
1091 lstrcpyW(lp[i].szClsid, szValue);
1092
1093 count++;
1094 }
1095
1096 /* append extension to the filter */
1097 wsprintfW(szValue, szExtensionFmt, szFileExt);
1098 if (lp[i].szExtensions[0] == 0)
1099 lstrcatW(lp[i].szExtensions, szValue + 1);
1100 else
1101 lstrcatW(lp[i].szExtensions, szValue);
1102
1103 /* also append to the "all multimedia"-filter */
1104 if (lp[0].szExtensions[0] == 0)
1105 lstrcatW(lp[0].szExtensions, szValue + 1);
1106 else
1107 lstrcatW(lp[0].szExtensions, szValue);
1108 }
1109 RegCloseKey(hKey);
1110
1111 /* 2. get descriptions for the CLSIDs and fill out szFilter */
1112 if (RegOpenKeyW(HKEY_CLASSES_ROOT, szClsid, &hKey) != S_OK) {
1113 HeapFree(GetProcessHeap(), 0, lp);
1114 return AVIERR_ERROR;
1115 }
1116 for (n = 0; n <= count; n++) {
1117 /* first the description */
1118 if (n != 0) {
1119 size = sizeof(szValue)/sizeof(szValue[0]);
1120 if (RegQueryValueW(hKey, lp[n].szClsid, szValue, &size) == S_OK) {
1121 size = lstrlenW(szValue);
1122 lstrcpynW(szFilter, szValue, cbFilter);
1123 }
1124 } else
1125 size = LoadStringW(AVIFILE_hModule,IDS_ALLMULTIMEDIA,szFilter,cbFilter);
1126
1127 /* check for enough space */
1128 size++;
1129 if (cbFilter < size + lstrlenW(lp[n].szExtensions) + 2) {
1130 szFilter[0] = 0;
1131 szFilter[1] = 0;
1132 HeapFree(GetProcessHeap(), 0, lp);
1133 RegCloseKey(hKey);
1134 return AVIERR_BUFFERTOOSMALL;
1135 }
1136 cbFilter -= size;
1137 szFilter += size;
1138
1139 /* and then the filter */
1140 lstrcpynW(szFilter, lp[n].szExtensions, cbFilter);
1141 size = lstrlenW(lp[n].szExtensions) + 1;
1142 cbFilter -= size;
1143 szFilter += size;
1144 }
1145
1146 RegCloseKey(hKey);
1147 HeapFree(GetProcessHeap(), 0, lp);
1148
1149 /* add "All files" "*.*" filter if enough space left */
1150 size = LoadStringW(AVIFILE_hModule, IDS_ALLFILES,
1151 szAllFiles, sizeof(szAllFiles)) + 1;
1152 if (cbFilter > size) {
1153 int i;
1154
1155 /* replace '@' with \000 to separate description of filter */
1156 for (i = 0; i < size && szAllFiles[i] != 0; i++) {
1157 if (szAllFiles[i] == '@') {
1158 szAllFiles[i] = 0;
1159 break;
1160 }
1161 }
1162
1163 memcpy(szFilter, szAllFiles, size * sizeof(szAllFiles[0]));
1164 szFilter += size;
1165 szFilter[0] = 0;
1166
1167 return AVIERR_OK;
1168 } else {
1169 szFilter[0] = 0;
1170 return AVIERR_BUFFERTOOSMALL;
1171 }
1172 }
1173
1174 static BOOL AVISaveOptionsFmtChoose(HWND hWnd)
1175 {
1176 LPAVICOMPRESSOPTIONS pOptions = SaveOpts.ppOptions[SaveOpts.nCurrent];
1177 AVISTREAMINFOW sInfo;
1178
1179 TRACE("(%p)\n", hWnd);
1180
1181 if (pOptions == NULL || SaveOpts.ppavis[SaveOpts.nCurrent] == NULL) {
1182 ERR(": bad state!\n");
1183 return FALSE;
1184 }
1185
1186 if (FAILED(AVIStreamInfoW(SaveOpts.ppavis[SaveOpts.nCurrent],
1187 &sInfo, sizeof(sInfo)))) {
1188 ERR(": AVIStreamInfoW failed!\n");
1189 return FALSE;
1190 }
1191
1192 if (sInfo.fccType == streamtypeVIDEO) {
1193 COMPVARS cv;
1194 BOOL ret;
1195
1196 memset(&cv, 0, sizeof(cv));
1197
1198 if ((pOptions->dwFlags & AVICOMPRESSF_VALID) == 0) {
1199 memset(pOptions, 0, sizeof(AVICOMPRESSOPTIONS));
1200 pOptions->fccType = streamtypeVIDEO;
1201 pOptions->fccHandler = comptypeDIB;
1202 pOptions->dwQuality = (DWORD)ICQUALITY_DEFAULT;
1203 }
1204
1205 cv.cbSize = sizeof(cv);
1206 cv.dwFlags = ICMF_COMPVARS_VALID;
1207 /*cv.fccType = pOptions->fccType; */
1208 cv.fccHandler = pOptions->fccHandler;
1209 cv.lQ = pOptions->dwQuality;
1210 cv.lpState = pOptions->lpParms;
1211 cv.cbState = pOptions->cbParms;
1212 if (pOptions->dwFlags & AVICOMPRESSF_KEYFRAMES)
1213 cv.lKey = pOptions->dwKeyFrameEvery;
1214 else
1215 cv.lKey = 0;
1216 if (pOptions->dwFlags & AVICOMPRESSF_DATARATE)
1217 cv.lDataRate = pOptions->dwBytesPerSecond / 1024; /* need kBytes */
1218 else
1219 cv.lDataRate = 0;
1220
1221 ret = ICCompressorChoose(hWnd, SaveOpts.uFlags, NULL,
1222 SaveOpts.ppavis[SaveOpts.nCurrent], &cv, NULL);
1223
1224 if (ret) {
1225 pOptions->fccHandler = cv.fccHandler;
1226 pOptions->lpParms = cv.lpState;
1227 pOptions->cbParms = cv.cbState;
1228 pOptions->dwQuality = cv.lQ;
1229 if (cv.lKey != 0) {
1230 pOptions->dwKeyFrameEvery = cv.lKey;
1231 pOptions->dwFlags |= AVICOMPRESSF_KEYFRAMES;
1232 } else
1233 pOptions->dwFlags &= ~AVICOMPRESSF_KEYFRAMES;
1234 if (cv.lDataRate != 0) {
1235 pOptions->dwBytesPerSecond = cv.lDataRate * 1024; /* need bytes */
1236 pOptions->dwFlags |= AVICOMPRESSF_DATARATE;
1237 } else
1238 pOptions->dwFlags &= ~AVICOMPRESSF_DATARATE;
1239 pOptions->dwFlags |= AVICOMPRESSF_VALID;
1240 }
1241 ICCompressorFree(&cv);
1242
1243 return ret;
1244 } else if (sInfo.fccType == streamtypeAUDIO) {
1245 ACMFORMATCHOOSEW afmtc;
1246 MMRESULT ret;
1247 LONG size;
1248
1249 /* FIXME: check ACM version -- Which version is needed? */
1250
1251 memset(&afmtc, 0, sizeof(afmtc));
1252 afmtc.cbStruct = sizeof(afmtc);
1253 afmtc.fdwStyle = 0;
1254 afmtc.hwndOwner = hWnd;
1255
1256 acmMetrics(NULL, ACM_METRIC_MAX_SIZE_FORMAT, &size);
1257 if ((pOptions->cbFormat == 0 || pOptions->lpFormat == NULL) && size != 0) {
1258 pOptions->lpFormat = HeapAlloc(GetProcessHeap(), 0, size);
1259 pOptions->cbFormat = size;
1260 } else if (pOptions->cbFormat < (DWORD)size) {
1261 pOptions->lpFormat = HeapReAlloc(GetProcessHeap(), 0, pOptions->lpFormat, size);
1262 pOptions->cbFormat = size;
1263 }
1264 if (pOptions->lpFormat == NULL)
1265 return FALSE;
1266 afmtc.pwfx = pOptions->lpFormat;
1267 afmtc.cbwfx = pOptions->cbFormat;
1268
1269 size = 0;
1270 AVIStreamFormatSize(SaveOpts.ppavis[SaveOpts.nCurrent],
1271 sInfo.dwStart, &size);
1272 if (size < (LONG)sizeof(PCMWAVEFORMAT))
1273 size = sizeof(PCMWAVEFORMAT);
1274 afmtc.pwfxEnum = HeapAlloc(GetProcessHeap(), 0, size);
1275 if (afmtc.pwfxEnum != NULL) {
1276 AVIStreamReadFormat(SaveOpts.ppavis[SaveOpts.nCurrent],
1277 sInfo.dwStart, afmtc.pwfxEnum, &size);
1278 afmtc.fdwEnum = ACM_FORMATENUMF_CONVERT;
1279 }
1280
1281 ret = acmFormatChooseW(&afmtc);
1282 if (ret == S_OK)
1283 pOptions->dwFlags |= AVICOMPRESSF_VALID;
1284
1285 HeapFree(GetProcessHeap(), 0, afmtc.pwfxEnum);
1286 return (ret == S_OK ? TRUE : FALSE);
1287 } else {
1288 ERR(": unknown streamtype 0x%08X\n", sInfo.fccType);
1289 return FALSE;
1290 }
1291 }
1292
1293 static void AVISaveOptionsUpdate(HWND hWnd)
1294 {
1295 static const WCHAR szVideoFmt[]={'%','l','d','x','%','l','d','x','%','d',0};
1296 static const WCHAR szAudioFmt[]={'%','s',' ','%','s',0};
1297
1298 WCHAR szFormat[128];
1299 AVISTREAMINFOW sInfo;
1300 LPVOID lpFormat;
1301 LONG size;
1302
1303 TRACE("(%p)\n", hWnd);
1304
1305 SaveOpts.nCurrent = SendDlgItemMessageW(hWnd,IDC_STREAM,CB_GETCURSEL,0,0);
1306 if (SaveOpts.nCurrent < 0)
1307 return;
1308
1309 if (FAILED(AVIStreamInfoW(SaveOpts.ppavis[SaveOpts.nCurrent], &sInfo, sizeof(sInfo))))
1310 return;
1311
1312 AVIStreamFormatSize(SaveOpts.ppavis[SaveOpts.nCurrent],sInfo.dwStart,&size);
1313 if (size > 0) {
1314 szFormat[0] = 0;
1315
1316 /* read format to build format description string */
1317 lpFormat = HeapAlloc(GetProcessHeap(), 0, size);
1318 if (lpFormat != NULL) {
1319 if (SUCCEEDED(AVIStreamReadFormat(SaveOpts.ppavis[SaveOpts.nCurrent],sInfo.dwStart,lpFormat, &size))) {
1320 if (sInfo.fccType == streamtypeVIDEO) {
1321 LPBITMAPINFOHEADER lpbi = lpFormat;
1322 ICINFO icinfo;
1323
1324 wsprintfW(szFormat, szVideoFmt, lpbi->biWidth,
1325 lpbi->biHeight, lpbi->biBitCount);
1326
1327 if (lpbi->biCompression != BI_RGB) {
1328 HIC hic;
1329
1330 hic = ICLocate(ICTYPE_VIDEO, sInfo.fccHandler, lpFormat,
1331 NULL, ICMODE_DECOMPRESS);
1332 if (hic != NULL) {
1333 if (ICGetInfo(hic, &icinfo, sizeof(icinfo)) == S_OK)
1334 lstrcatW(szFormat, icinfo.szDescription);
1335 ICClose(hic);
1336 }
1337 } else {
1338 LoadStringW(AVIFILE_hModule, IDS_UNCOMPRESSED,
1339 icinfo.szDescription, sizeof(icinfo.szDescription));
1340 lstrcatW(szFormat, icinfo.szDescription);
1341 }
1342 } else if (sInfo.fccType == streamtypeAUDIO) {
1343 ACMFORMATTAGDETAILSW aftd;
1344 ACMFORMATDETAILSW afd;
1345
1346 memset(&aftd, 0, sizeof(aftd));
1347 memset(&afd, 0, sizeof(afd));
1348
1349 aftd.cbStruct = sizeof(aftd);
1350 aftd.dwFormatTag = afd.dwFormatTag =
1351 ((PWAVEFORMATEX)lpFormat)->wFormatTag;
1352 aftd.cbFormatSize = afd.cbwfx = size;
1353
1354 afd.cbStruct = sizeof(afd);
1355 afd.pwfx = lpFormat;
1356
1357 if (acmFormatTagDetailsW(NULL, &aftd,
1358 ACM_FORMATTAGDETAILSF_FORMATTAG) == S_OK) {
1359 if (acmFormatDetailsW(NULL,&afd,ACM_FORMATDETAILSF_FORMAT) == S_OK)
1360 wsprintfW(szFormat, szAudioFmt, afd.szFormat, aftd.szFormatTag);
1361 }
1362 }
1363 }
1364 HeapFree(GetProcessHeap(), 0, lpFormat);
1365 }
1366
1367 /* set text for format description */
1368 SetDlgItemTextW(hWnd, IDC_FORMATTEXT, szFormat);
1369
1370 /* Disable option button for unsupported streamtypes */
1371 if (sInfo.fccType == streamtypeVIDEO ||
1372 sInfo.fccType == streamtypeAUDIO)
1373 EnableWindow(GetDlgItem(hWnd, IDC_OPTIONS), TRUE);
1374 else
1375 EnableWindow(GetDlgItem(hWnd, IDC_OPTIONS), FALSE);
1376 }
1377
1378 }
1379
1380 static INT_PTR CALLBACK AVISaveOptionsDlgProc(HWND hWnd, UINT uMsg,
1381 WPARAM wParam, LPARAM lParam)
1382 {
1383 DWORD dwInterleave;
1384 BOOL bIsInterleaved;
1385 INT n;
1386
1387 /*TRACE("(%p,%u,0x%04X,0x%08lX)\n", hWnd, uMsg, wParam, lParam);*/
1388
1389 switch (uMsg) {
1390 case WM_INITDIALOG:
1391 SaveOpts.nCurrent = 0;
1392 if (SaveOpts.nStreams == 1) {
1393 EndDialog(hWnd, AVISaveOptionsFmtChoose(hWnd));
1394 return TRUE;
1395 }
1396
1397 /* add streams */
1398 for (n = 0; n < SaveOpts.nStreams; n++) {
1399 AVISTREAMINFOW sInfo;
1400
1401 AVIStreamInfoW(SaveOpts.ppavis[n], &sInfo, sizeof(sInfo));
1402 SendDlgItemMessageW(hWnd, IDC_STREAM, CB_ADDSTRING,
1403 0L, (LPARAM)sInfo.szName);
1404 }
1405
1406 /* select first stream */
1407 SendDlgItemMessageW(hWnd, IDC_STREAM, CB_SETCURSEL, 0, 0);
1408 SendMessageW(hWnd, WM_COMMAND, MAKELONG(IDC_STREAM, CBN_SELCHANGE), (LPARAM)hWnd);
1409
1410 /* initialize interleave */
1411 if (SaveOpts.ppOptions[0] != NULL &&
1412 (SaveOpts.ppOptions[0]->dwFlags & AVICOMPRESSF_VALID)) {
1413 bIsInterleaved = (SaveOpts.ppOptions[0]->dwFlags & AVICOMPRESSF_INTERLEAVE);
1414 dwInterleave = SaveOpts.ppOptions[0]->dwInterleaveEvery;
1415 } else {
1416 bIsInterleaved = TRUE;
1417 dwInterleave = 0;
1418 }
1419 CheckDlgButton(hWnd, IDC_INTERLEAVE, bIsInterleaved);
1420 SetDlgItemInt(hWnd, IDC_INTERLEAVEEVERY, dwInterleave, FALSE);
1421 EnableWindow(GetDlgItem(hWnd, IDC_INTERLEAVEEVERY), bIsInterleaved);
1422 break;
1423 case WM_COMMAND:
1424 switch (LOWORD(wParam)) {
1425 case IDOK:
1426 /* get data from controls and save them */
1427 dwInterleave = GetDlgItemInt(hWnd, IDC_INTERLEAVEEVERY, NULL, 0);
1428 bIsInterleaved = IsDlgButtonChecked(hWnd, IDC_INTERLEAVE);
1429 for (n = 0; n < SaveOpts.nStreams; n++) {
1430 if (SaveOpts.ppOptions[n] != NULL) {
1431 if (bIsInterleaved) {
1432 SaveOpts.ppOptions[n]->dwFlags |= AVICOMPRESSF_INTERLEAVE;
1433 SaveOpts.ppOptions[n]->dwInterleaveEvery = dwInterleave;
1434 } else
1435 SaveOpts.ppOptions[n]->dwFlags &= ~AVICOMPRESSF_INTERLEAVE;
1436 }
1437 }
1438 /* fall through */
1439 case IDCANCEL:
1440 EndDialog(hWnd, LOWORD(wParam) == IDOK);
1441 break;
1442 case IDC_INTERLEAVE:
1443 EnableWindow(GetDlgItem(hWnd, IDC_INTERLEAVEEVERY),
1444 IsDlgButtonChecked(hWnd, IDC_INTERLEAVE));
1445 break;
1446 case IDC_STREAM:
1447 if (HIWORD(wParam) == CBN_SELCHANGE) {
1448 /* update control elements */
1449 AVISaveOptionsUpdate(hWnd);
1450 }
1451 break;
1452 case IDC_OPTIONS:
1453 AVISaveOptionsFmtChoose(hWnd);
1454 break;
1455 };
1456 return TRUE;
1457 };
1458
1459 return FALSE;
1460 }
1461
1462 /***********************************************************************
1463 * AVISaveOptions (AVIFIL32.@)
1464 */
1465 BOOL WINAPI AVISaveOptions(HWND hWnd, UINT uFlags, INT nStreams,
1466 PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *ppOptions)
1467 {
1468 LPAVICOMPRESSOPTIONS pSavedOptions = NULL;
1469 INT ret, n;
1470
1471 TRACE("(%p,0x%X,%d,%p,%p)\n", hWnd, uFlags, nStreams,
1472 ppavi, ppOptions);
1473
1474 /* check parameters */
1475 if (nStreams <= 0 || ppavi == NULL || ppOptions == NULL)
1476 return AVIERR_BADPARAM;
1477
1478 /* save options in case the user presses cancel */
1479 if (ppOptions != NULL && nStreams > 1) {
1480 pSavedOptions = HeapAlloc(GetProcessHeap(), 0, nStreams * sizeof(AVICOMPRESSOPTIONS));
1481 if (pSavedOptions == NULL)
1482 return FALSE;
1483
1484 for (n = 0; n < nStreams; n++) {
1485 if (ppOptions[n] != NULL)
1486 memcpy(pSavedOptions + n, ppOptions[n], sizeof(AVICOMPRESSOPTIONS));
1487 }
1488 }
1489
1490 SaveOpts.uFlags = uFlags;
1491 SaveOpts.nStreams = nStreams;
1492 SaveOpts.ppavis = ppavi;
1493 SaveOpts.ppOptions = ppOptions;
1494
1495 ret = DialogBoxW(AVIFILE_hModule, MAKEINTRESOURCEW(IDD_SAVEOPTIONS),
1496 hWnd, AVISaveOptionsDlgProc);
1497
1498 if (ret == -1)
1499 ret = FALSE;
1500
1501 /* restore options when user pressed cancel */
1502 if (pSavedOptions != NULL) {
1503 if (ret == FALSE) {
1504 for (n = 0; n < nStreams; n++) {
1505 if (ppOptions[n] != NULL)
1506 memcpy(ppOptions[n], pSavedOptions + n, sizeof(AVICOMPRESSOPTIONS));
1507 }
1508 }
1509 HeapFree(GetProcessHeap(), 0, pSavedOptions);
1510 }
1511
1512 return (BOOL)ret;
1513 }
1514
1515 /***********************************************************************
1516 * AVISaveOptionsFree (AVIFIL32.@)
1517 * AVISaveOptionsFree (AVIFILE.124)
1518 */
1519 HRESULT WINAPI AVISaveOptionsFree(INT nStreams,LPAVICOMPRESSOPTIONS*ppOptions)
1520 {
1521 TRACE("(%d,%p)\n", nStreams, ppOptions);
1522
1523 if (nStreams < 0 || ppOptions == NULL)
1524 return AVIERR_BADPARAM;
1525
1526 for (; nStreams > 0; nStreams--) {
1527 if (ppOptions[nStreams] != NULL) {
1528 ppOptions[nStreams]->dwFlags &= ~AVICOMPRESSF_VALID;
1529
1530 if (ppOptions[nStreams]->lpParms != NULL) {
1531 HeapFree(GetProcessHeap(), 0, ppOptions[nStreams]->lpParms);
1532 ppOptions[nStreams]->lpParms = NULL;
1533 ppOptions[nStreams]->cbParms = 0;
1534 }
1535 if (ppOptions[nStreams]->lpFormat != NULL) {
1536 HeapFree(GetProcessHeap(), 0, ppOptions[nStreams]->lpFormat);
1537 ppOptions[nStreams]->lpFormat = NULL;
1538 ppOptions[nStreams]->cbFormat = 0;
1539 }
1540 }
1541 }
1542
1543 return AVIERR_OK;
1544 }
1545
1546 /***********************************************************************
1547 * AVISaveVA (AVIFIL32.@)
1548 */
1549 HRESULT WINAPI AVISaveVA(LPCSTR szFile, CLSID *pclsidHandler,
1550 AVISAVECALLBACK lpfnCallback, int nStream,
1551 PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *plpOptions)
1552 {
1553 LPWSTR wszFile = NULL;
1554 HRESULT hr;
1555 int len;
1556
1557 TRACE("%s,%p,%p,%d,%p,%p)\n", debugstr_a(szFile), pclsidHandler,
1558 lpfnCallback, nStream, ppavi, plpOptions);
1559
1560 if (szFile == NULL || ppavi == NULL || plpOptions == NULL)
1561 return AVIERR_BADPARAM;
1562
1563 /* convert ASCII string to Unicode and call Unicode function */
1564 len = MultiByteToWideChar(CP_ACP, 0, szFile, -1, NULL, 0);
1565 if (len <= 0)
1566 return AVIERR_BADPARAM;
1567
1568 wszFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1569 if (wszFile == NULL)
1570 return AVIERR_MEMORY;
1571
1572 MultiByteToWideChar(CP_ACP, 0, szFile, -1, wszFile, len);
1573
1574 hr = AVISaveVW(wszFile, pclsidHandler, lpfnCallback,
1575 nStream, ppavi, plpOptions);
1576
1577 HeapFree(GetProcessHeap(), 0, wszFile);
1578
1579 return hr;
1580 }
1581
1582 /***********************************************************************
1583 * AVIFILE_AVISaveDefaultCallback (internal)
1584 */
1585 static BOOL WINAPI AVIFILE_AVISaveDefaultCallback(INT progress)
1586 {
1587 TRACE("(%d)\n", progress);
1588
1589 return FALSE;
1590 }
1591
1592 /***********************************************************************
1593 * AVISaveVW (AVIFIL32.@)
1594 */
1595 HRESULT WINAPI AVISaveVW(LPCWSTR szFile, CLSID *pclsidHandler,
1596 AVISAVECALLBACK lpfnCallback, int nStreams,
1597 PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *plpOptions)
1598 {
1599 LONG lStart[MAX_AVISTREAMS];
1600 PAVISTREAM pOutStreams[MAX_AVISTREAMS];
1601 PAVISTREAM pInStreams[MAX_AVISTREAMS];
1602 AVIFILEINFOW fInfo;
1603 AVISTREAMINFOW sInfo;
1604
1605 PAVIFILE pfile = NULL; /* the output AVI file */
1606 LONG lFirstVideo = -1;
1607 int curStream;
1608
1609 /* for interleaving ... */
1610 DWORD dwInterleave = 0; /* interleave rate */
1611 DWORD dwFileInitialFrames;
1612 LONG lFileLength;
1613 LONG lSampleInc;
1614
1615 /* for reading/writing the data ... */
1616 LPVOID lpBuffer = NULL;
1617 LONG cbBuffer; /* real size of lpBuffer */
1618 LONG lBufferSize; /* needed bytes for format(s), etc. */
1619 LONG lReadBytes;
1620 LONG lReadSamples;
1621 HRESULT hres;
1622
1623 TRACE("(%s,%p,%p,%d,%p,%p)\n", debugstr_w(szFile), pclsidHandler,
1624 lpfnCallback, nStreams, ppavi, plpOptions);
1625
1626 if (szFile == NULL || ppavi == NULL || plpOptions == NULL)
1627 return AVIERR_BADPARAM;
1628 if (nStreams >= MAX_AVISTREAMS) {
1629 WARN("Can't write AVI with %d streams only supports %d -- change MAX_AVISTREAMS!\n", nStreams, MAX_AVISTREAMS);
1630 return AVIERR_INTERNAL;
1631 }
1632
1633 if (lpfnCallback == NULL)
1634 lpfnCallback = AVIFILE_AVISaveDefaultCallback;
1635
1636 /* clear local variable(s) */
1637 for (curStream = 0; curStream < nStreams; curStream++) {
1638 pInStreams[curStream] = NULL;
1639 pOutStreams[curStream] = NULL;
1640 }
1641
1642 /* open output AVI file (create it if it doesn't exist) */
1643 hres = AVIFileOpenW(&pfile, szFile, OF_CREATE|OF_SHARE_EXCLUSIVE|OF_WRITE,
1644 pclsidHandler);
1645 if (FAILED(hres))
1646 return hres;
1647 AVIFileInfoW(pfile, &fInfo, sizeof(fInfo)); /* for dwCaps */
1648
1649 /* initialize our data structures part 1 */
1650 for (curStream = 0; curStream < nStreams; curStream++) {
1651 PAVISTREAM pCurStream = ppavi[curStream];
1652
1653 hres = AVIStreamInfoW(pCurStream, &sInfo, sizeof(sInfo));
1654 if (FAILED(hres))
1655 goto error;
1656
1657 /* search first video stream and check for interleaving */
1658 if (sInfo.fccType == streamtypeVIDEO) {
1659 /* remember first video stream -- needed for interleaving */
1660 if (lFirstVideo < 0)
1661 lFirstVideo = curStream;
1662 } else if (!dwInterleave && plpOptions != NULL) {
1663 /* check if any non-video stream wants to be interleaved */
1664 WARN("options.flags=0x%X options.dwInterleave=%u\n",plpOptions[curStream]->dwFlags,plpOptions[curStream]->dwInterleaveEvery);
1665 if (plpOptions[curStream] != NULL &&
1666 plpOptions[curStream]->dwFlags & AVICOMPRESSF_INTERLEAVE)
1667 dwInterleave = plpOptions[curStream]->dwInterleaveEvery;
1668 }
1669
1670 /* create de-/compressed stream interface if needed */
1671 pInStreams[curStream] = NULL;
1672 if (plpOptions != NULL && plpOptions[curStream] != NULL) {
1673 if (plpOptions[curStream]->fccHandler ||
1674 plpOptions[curStream]->lpFormat != NULL) {
1675 DWORD dwKeySave = plpOptions[curStream]->dwKeyFrameEvery;
1676
1677 if (fInfo.dwCaps & AVIFILECAPS_ALLKEYFRAMES)
1678 plpOptions[curStream]->dwKeyFrameEvery = 1;
1679
1680 hres = AVIMakeCompressedStream(&pInStreams[curStream], pCurStream,
1681 plpOptions[curStream], NULL);
1682 plpOptions[curStream]->dwKeyFrameEvery = dwKeySave;
1683 if (FAILED(hres) || pInStreams[curStream] == NULL) {
1684 pInStreams[curStream] = NULL;
1685 goto error;
1686 }
1687
1688 /* test stream interface and update stream-info */
1689 hres = AVIStreamInfoW(pInStreams[curStream], &sInfo, sizeof(sInfo));
1690 if (FAILED(hres))
1691 goto error;
1692 }
1693 }
1694
1695 /* now handle streams which will only be copied */
1696 if (pInStreams[curStream] == NULL) {
1697 pCurStream = pInStreams[curStream] = ppavi[curStream];
1698 AVIStreamAddRef(pCurStream);
1699 } else
1700 pCurStream = pInStreams[curStream];
1701
1702 lStart[curStream] = sInfo.dwStart;
1703 } /* for all streams */
1704
1705 /* check that first video stream is the first stream */
1706 if (lFirstVideo > 0) {
1707 PAVISTREAM pTmp = pInStreams[lFirstVideo];
1708 LONG lTmp = lStart[lFirstVideo];
1709
1710 pInStreams[lFirstVideo] = pInStreams[0];
1711 pInStreams[0] = pTmp;
1712 lStart[lFirstVideo] = lStart[0];
1713 lStart[0] = lTmp;
1714 lFirstVideo = 0;
1715 }
1716
1717 /* allocate buffer for formats, data, etc. of an initial size of 64 kBytes*/
1718 cbBuffer = 0x00010000;
1719 lpBuffer = HeapAlloc(GetProcessHeap(), 0, cbBuffer);
1720 if (lpBuffer == NULL) {
1721 hres = AVIERR_MEMORY;
1722 goto error;
1723 }
1724
1725 AVIStreamInfoW(pInStreams[0], &sInfo, sizeof(sInfo));
1726 lFileLength = sInfo.dwLength;
1727 dwFileInitialFrames = 0;
1728 if (lFirstVideo >= 0) {
1729 /* check for correct version of the format
1730 * -- need at least BITMAPINFOHEADER or newer
1731 */
1732 lSampleInc = 1;
1733 lBufferSize = cbBuffer;
1734 hres = AVIStreamReadFormat(pInStreams[lFirstVideo], AVIStreamStart(pInStreams[lFirstVideo]), lpBuffer, &lBufferSize);
1735 if (lBufferSize < (LONG)sizeof(BITMAPINFOHEADER))
1736 hres = AVIERR_INTERNAL;
1737 if (FAILED(hres))
1738 goto error;
1739 } else /* use one second blocks for interleaving if no video present */
1740 lSampleInc = AVIStreamTimeToSample(pInStreams[0], 1000000);
1741
1742 /* create output streams */
1743 for (curStream = 0; curStream < nStreams; curStream++) {
1744 AVIStreamInfoW(pInStreams[curStream], &sInfo, sizeof(sInfo));
1745
1746 sInfo.dwInitialFrames = 0;
1747 if (dwInterleave != 0 && curStream > 0 && sInfo.fccType != streamtypeVIDEO) {
1748 /* 750 ms initial frames for non-video streams */
1749 sInfo.dwInitialFrames = AVIStreamTimeToSample(pInStreams[0], 750);
1750 }
1751
1752 hres = AVIFileCreateStreamW(pfile, &pOutStreams[curStream], &sInfo);
1753 if (pOutStreams[curStream] != NULL && SUCCEEDED(hres)) {
1754 /* copy initial format for this stream */
1755 lBufferSize = cbBuffer;
1756 hres = AVIStreamReadFormat(pInStreams[curStream], sInfo.dwStart,
1757 lpBuffer, &lBufferSize);
1758 if (FAILED(hres))
1759 goto error;
1760 hres = AVIStreamSetFormat(pOutStreams[curStream], 0, lpBuffer, lBufferSize);
1761 if (FAILED(hres))
1762 goto error;
1763
1764 /* try to copy stream handler data */
1765 lBufferSize = cbBuffer;
1766 hres = AVIStreamReadData(pInStreams[curStream], ckidSTREAMHANDLERDATA,
1767 lpBuffer, &lBufferSize);
1768 if (SUCCEEDED(hres) && lBufferSize > 0) {
1769 hres = AVIStreamWriteData(pOutStreams[curStream],ckidSTREAMHANDLERDATA,
1770 lpBuffer, lBufferSize);
1771 if (FAILED(hres))
1772 goto error;
1773 }
1774
1775 if (dwFileInitialFrames < sInfo.dwInitialFrames)
1776 dwFileInitialFrames = sInfo.dwInitialFrames;
1777 lReadBytes =
1778 AVIStreamSampleToSample(pOutStreams[0], pInStreams[curStream],
1779 sInfo.dwLength);
1780 if (lFileLength < lReadBytes)
1781 lFileLength = lReadBytes;
1782 } else {
1783 /* creation of de-/compression stream interface failed */
1784 WARN("creation of (de-)compression stream failed for stream %d\n",curStream);
1785 AVIStreamRelease(pInStreams[curStream]);
1786 if (curStream + 1 >= nStreams) {
1787 /* move the others one up */
1788 PAVISTREAM *ppas = &pInStreams[curStream];
1789 int n = nStreams - (curStream + 1);
1790
1791 do {
1792 *ppas = pInStreams[curStream + 1];
1793 } while (--n);
1794 }
1795 nStreams--;
1796 curStream--;
1797 }
1798 } /* create output streams for all input streams */
1799
1800 /* have we still something to write, or lost everything? */
1801 if (nStreams <= 0)
1802 goto error;
1803
1804 if (dwInterleave) {
1805 LONG lCurFrame = -dwFileInitialFrames;
1806
1807 /* interleaved file */
1808 if (dwInterleave == 1)
1809 AVIFileEndRecord(pfile);
1810
1811 for (; lCurFrame < lFileLength; lCurFrame += lSampleInc) {
1812 for (curStream = 0; curStream < nStreams; curStream++) {
1813 LONG lLastSample;
1814
1815 hres = AVIStreamInfoW(pOutStreams[curStream], &sInfo, sizeof(sInfo));
1816 if (FAILED(hres))
1817 goto error;
1818
1819 /* initial frames phase at the end for this stream? */
1820 if (-(LONG)sInfo.dwInitialFrames > lCurFrame)
1821 continue;
1822
1823 if ((lFileLength - lSampleInc) <= lCurFrame) {
1824 lLastSample = AVIStreamLength(pInStreams[curStream]);
1825 lFirstVideo = lLastSample + AVIStreamStart(pInStreams[curStream]);
1826 } else {
1827 if (curStream != 0) {
1828 lFirstVideo =
1829 AVIStreamSampleToSample(pInStreams[curStream], pInStreams[0],
1830 (sInfo.fccType == streamtypeVIDEO ?
1831 (LONG)dwInterleave : lSampleInc) +
1832 sInfo.dwInitialFrames + lCurFrame);
1833 } else
1834 lFirstVideo = lSampleInc + (sInfo.dwInitialFrames + lCurFrame);
1835
1836 lLastSample = AVIStreamEnd(pInStreams[curStream]);
1837 if (lLastSample <= lFirstVideo)
1838 lFirstVideo = lLastSample;
1839 }
1840
1841 /* copy needed samples now */
1842 WARN("copy from stream %d samples %d to %d...\n",curStream,
1843 lStart[curStream],lFirstVideo);
1844 while (lFirstVideo > lStart[curStream]) {
1845 DWORD flags = 0;
1846
1847 /* copy format in case it can change */
1848 lBufferSize = cbBuffer;
1849 hres = AVIStreamReadFormat(pInStreams[curStream], lStart[curStream],
1850 lpBuffer, &lBufferSize);
1851 if (FAILED(hres))
1852 goto error;
1853 AVIStreamSetFormat(pOutStreams[curStream], lStart[curStream],
1854 lpBuffer, lBufferSize);
1855
1856 /* try to read data until we got it, or error */
1857 do {
1858 hres = AVIStreamRead(pInStreams[curStream], lStart[curStream],
1859 lFirstVideo - lStart[curStream], lpBuffer,
1860 cbBuffer, &lReadBytes, &lReadSamples);
1861 } while ((hres == AVIERR_BUFFERTOOSMALL) &&
1862 (lpBuffer = HeapReAlloc(GetProcessHeap(), 0, lpBuffer, cbBuffer *= 2)) != NULL);
1863 if (lpBuffer == NULL)
1864 hres = AVIERR_MEMORY;
1865 if (FAILED(hres))
1866 goto error;
1867
1868 if (AVIStreamIsKeyFrame(pInStreams[curStream], (LONG)sInfo.dwStart))
1869 flags = AVIIF_KEYFRAME;
1870 hres = AVIStreamWrite(pOutStreams[curStream], -1, lReadSamples,
1871 lpBuffer, lReadBytes, flags, NULL, NULL);
1872 if (FAILED(hres))
1873 goto error;
1874
1875 lStart[curStream] += lReadSamples;
1876 }
1877 lStart[curStream] = lFirstVideo;
1878 } /* stream by stream */
1879
1880 /* need to close this block? */
1881 if (dwInterleave == 1) {
1882 hres = AVIFileEndRecord(pfile);
1883 if (FAILED(hres))
1884 break;
1885 }
1886
1887 /* show progress */
1888 if (lpfnCallback(MulDiv(dwFileInitialFrames + lCurFrame, 100,
1889 dwFileInitialFrames + lFileLength))) {
1890 hres = AVIERR_USERABORT;
1891 break;
1892 }
1893 } /* copy frame by frame */
1894 } else {
1895 /* non-interleaved file */
1896
1897 for (curStream = 0; curStream < nStreams; curStream++) {
1898 /* show progress */
1899 if (lpfnCallback(MulDiv(curStream, 100, nStreams))) {
1900 hres = AVIERR_USERABORT;
1901 goto error;
1902 }
1903
1904 AVIStreamInfoW(pInStreams[curStream], &sInfo, sizeof(sInfo));
1905
1906 if (sInfo.dwSampleSize != 0) {
1907 /* sample-based data like audio */
1908 while (sInfo.dwStart < sInfo.dwLength) {
1909 LONG lSamples = cbBuffer / sInfo.dwSampleSize;
1910
1911 /* copy format in case it can change */
1912 lBufferSize = cbBuffer;
1913 hres = AVIStreamReadFormat(pInStreams[curStream], sInfo.dwStart,
1914 lpBuffer, &lBufferSize);
1915 if (FAILED(hres))
1916 return hres;
1917 AVIStreamSetFormat(pOutStreams[curStream], sInfo.dwStart,
1918 lpBuffer, lBufferSize);
1919
1920 /* limit to stream boundaries */
1921 if (lSamples != (LONG)(sInfo.dwLength - sInfo.dwStart))
1922 lSamples = sInfo.dwLength - sInfo.dwStart;
1923
1924 /* now try to read until we get it, or an error occurs */
1925 do {
1926 lReadBytes = cbBuffer;
1927 lReadSamples = 0;
1928 hres = AVIStreamRead(pInStreams[curStream],sInfo.dwStart,lSamples,
1929 lpBuffer,cbBuffer,&lReadBytes,&lReadSamples);
1930 } while ((hres == AVIERR_BUFFERTOOSMALL) &&
1931 (lpBuffer = HeapReAlloc(GetProcessHeap(), 0, lpBuffer, cbBuffer *= 2)) != NULL);
1932 if (lpBuffer == NULL)
1933 hres = AVIERR_MEMORY;
1934 if (FAILED(hres))
1935 goto error;
1936 if (lReadSamples != 0) {
1937 sInfo.dwStart += lReadSamples;
1938 hres = AVIStreamWrite(pOutStreams[curStream], -1, lReadSamples,
1939 lpBuffer, lReadBytes, 0, NULL , NULL);
1940 if (FAILED(hres))
1941 goto error;
1942
1943 /* show progress */
1944 if (lpfnCallback(MulDiv(sInfo.dwStart,100,nStreams*sInfo.dwLength)+
1945 MulDiv(curStream, 100, nStreams))) {
1946 hres = AVIERR_USERABORT;
1947 goto error;
1948 }
1949 } else {
1950 if ((sInfo.dwLength - sInfo.dwStart) != 1) {
1951 hres = AVIERR_FILEREAD;
1952 goto error;
1953 }
1954 }
1955 }
1956 } else {
1957 /* block-based data like video */
1958 for (; sInfo.dwStart < sInfo.dwLength; sInfo.dwStart++) {
1959 DWORD flags = 0;
1960
1961 /* copy format in case it can change */
1962 lBufferSize = cbBuffer;
1963 hres = AVIStreamReadFormat(pInStreams[curStream], sInfo.dwStart,
1964 lpBuffer, &lBufferSize);
1965 if (FAILED(hres))
1966 goto error;
1967 AVIStreamSetFormat(pOutStreams[curStream], sInfo.dwStart,
1968 lpBuffer, lBufferSize);
1969
1970 /* try to read block and resize buffer if necessary */
1971 do {
1972 lReadSamples = 0;
1973 lReadBytes = cbBuffer;
1974 hres = AVIStreamRead(pInStreams[curStream], sInfo.dwStart, 1,
1975 lpBuffer, cbBuffer,&lReadBytes,&lReadSamples);
1976 } while ((hres == AVIERR_BUFFERTOOSMALL) &&
1977 (lpBuffer = HeapReAlloc(GetProcessHeap(), 0, lpBuffer, cbBuffer *= 2)) != NULL);
1978 if (lpBuffer == NULL)
1979 hres = AVIERR_MEMORY;
1980 if (FAILED(hres))
1981 goto error;
1982 if (lReadSamples != 1) {
1983 hres = AVIERR_FILEREAD;
1984 goto error;
1985 }
1986
1987 if (AVIStreamIsKeyFrame(pInStreams[curStream], (LONG)sInfo.dwStart))
1988 flags = AVIIF_KEYFRAME;
1989 hres = AVIStreamWrite(pOutStreams[curStream], -1, lReadSamples,
1990 lpBuffer, lReadBytes, flags, NULL, NULL);
1991 if (FAILED(hres))
1992 goto error;
1993
1994 /* show progress */
1995 if (lpfnCallback(MulDiv(sInfo.dwStart,100,nStreams*sInfo.dwLength)+
1996 MulDiv(curStream, 100, nStreams))) {
1997 hres = AVIERR_USERABORT;
1998 goto error;
1999 }
2000 } /* copy all blocks */
2001 }
2002 } /* copy data stream by stream */
2003 }
2004
2005 error:
2006 HeapFree(GetProcessHeap(), 0, lpBuffer);
2007 if (pfile != NULL) {
2008 for (curStream = 0; curStream < nStreams; curStream++) {
2009 if (pOutStreams[curStream] != NULL)
2010 AVIStreamRelease(pOutStreams[curStream]);
2011 if (pInStreams[curStream] != NULL)
2012 AVIStreamRelease(pInStreams[curStream]);
2013 }
2014
2015 AVIFileRelease(pfile);
2016 }
2017
2018 return hres;
2019 }
2020
2021 /***********************************************************************
2022 * CreateEditableStream (AVIFIL32.@)
2023 */
2024 HRESULT WINAPI CreateEditableStream(PAVISTREAM *ppEditable, PAVISTREAM pSource)
2025 {
2026 IAVIEditStream *pEdit = NULL;
2027 HRESULT hr;
2028
2029 TRACE("(%p,%p)\n", ppEditable, pSource);
2030
2031 if (ppEditable == NULL)
2032 return AVIERR_BADPARAM;
2033
2034 *ppEditable = NULL;
2035
2036 if (pSource != NULL) {
2037 hr = IAVIStream_QueryInterface(pSource, &IID_IAVIEditStream,
2038 (LPVOID*)&pEdit);
2039 if (SUCCEEDED(hr) && pEdit != NULL) {
2040 hr = IAVIEditStream_Clone(pEdit, ppEditable);
2041 IAVIEditStream_Release(pEdit);
2042
2043 return hr;
2044 }
2045 }
2046
2047 /* need own implementation of IAVIEditStream */
2048 pEdit = AVIFILE_CreateEditStream(pSource);
2049 if (pEdit == NULL)
2050 return AVIERR_MEMORY;
2051
2052 hr = IAVIEditStream_QueryInterface(pEdit, &IID_IAVIStream,
2053 (LPVOID*)ppEditable);
2054 IAVIEditStream_Release(pEdit);
2055
2056 return hr;
2057 }
2058
2059 /***********************************************************************
2060 * EditStreamClone (AVIFIL32.@)
2061 */
2062 HRESULT WINAPI EditStreamClone(PAVISTREAM pStream, PAVISTREAM *ppResult)
2063 {
2064 PAVIEDITSTREAM pEdit = NULL;
2065 HRESULT hr;
2066
2067 TRACE("(%p,%p)\n", pStream, ppResult);
2068
2069 if (pStream == NULL)
2070 return AVIERR_BADHANDLE;
2071 if (ppResult == NULL)
2072 return AVIERR_BADPARAM;
2073
2074 *ppResult = NULL;
2075
2076 hr = IAVIStream_QueryInterface(pStream, &IID_IAVIEditStream,(LPVOID*)&pEdit);
2077 if (SUCCEEDED(hr) && pEdit != NULL) {
2078 hr = IAVIEditStream_Clone(pEdit, ppResult);
2079
2080 IAVIEditStream_Release(pEdit);
2081 } else
2082 hr = AVIERR_UNSUPPORTED;
2083
2084 return hr;
2085 }
2086
2087 /***********************************************************************
2088 * EditStreamCopy (AVIFIL32.@)
2089 */
2090 HRESULT WINAPI EditStreamCopy(PAVISTREAM pStream, LONG *plStart,
2091 LONG *plLength, PAVISTREAM *ppResult)
2092 {
2093 PAVIEDITSTREAM pEdit = NULL;
2094 HRESULT hr;
2095
2096 TRACE("(%p,%p,%p,%p)\n", pStream, plStart, plLength, ppResult);
2097
2098 if (pStream == NULL)
2099 return AVIERR_BADHANDLE;
2100 if (plStart == NULL || plLength == NULL || ppResult == NULL)
2101 return AVIERR_BADPARAM;
2102
2103 *ppResult = NULL;
2104
2105 hr = IAVIStream_QueryInterface(pStream, &IID_IAVIEditStream,(LPVOID*)&pEdit);
2106 if (SUCCEEDED(hr) && pEdit != NULL) {
2107 hr = IAVIEditStream_Copy(pEdit, plStart, plLength, ppResult);
2108
2109 IAVIEditStream_Release(pEdit);
2110 } else
2111 hr = AVIERR_UNSUPPORTED;
2112
2113 return hr;
2114 }
2115
2116 /***********************************************************************
2117 * EditStreamCut (AVIFIL32.@)
2118 */
2119 HRESULT WINAPI EditStreamCut(PAVISTREAM pStream, LONG *plStart,
2120 LONG *plLength, PAVISTREAM *ppResult)
2121 {
2122 PAVIEDITSTREAM pEdit = NULL;
2123 HRESULT hr;
2124
2125 TRACE("(%p,%p,%p,%p)\n", pStream, plStart, plLength, ppResult);
2126
2127 if (ppResult != NULL)
2128 *ppResult = NULL;
2129 if (pStream == NULL)
2130 return AVIERR_BADHANDLE;
2131 if (plStart == NULL || plLength == NULL)
2132 return AVIERR_BADPARAM;
2133
2134 hr = IAVIStream_QueryInterface(pStream, &IID_IAVIEditStream,(LPVOID*)&pEdit);
2135 if (SUCCEEDED(hr) && pEdit != NULL) {
2136 hr = IAVIEditStream_Cut(pEdit, plStart, plLength, ppResult);
2137
2138 IAVIEditStream_Release(pEdit);
2139 } else
2140 hr = AVIERR_UNSUPPORTED;
2141
2142 return hr;
2143 }
2144
2145 /***********************************************************************
2146 * EditStreamPaste (AVIFIL32.@)
2147 */
2148 HRESULT WINAPI EditStreamPaste(PAVISTREAM pDest, LONG *plStart, LONG *plLength,
2149 PAVISTREAM pSource, LONG lStart, LONG lEnd)
2150 {
2151 PAVIEDITSTREAM pEdit = NULL;
2152 HRESULT hr;
2153
2154 TRACE("(%p,%p,%p,%p,%d,%d)\n", pDest, plStart, plLength,
2155 pSource, lStart, lEnd);
2156
2157 if (pDest == NULL || pSource == NULL)
2158 return AVIERR_BADHANDLE;
2159 if (plStart == NULL || plLength == NULL || lStart < 0)
2160 return AVIERR_BADPARAM;
2161
2162 hr = IAVIStream_QueryInterface(pDest, &IID_IAVIEditStream,(LPVOID*)&pEdit);
2163 if (SUCCEEDED(hr) && pEdit != NULL) {
2164 hr = IAVIEditStream_Paste(pEdit, plStart, plLength, pSource, lStart, lEnd);
2165
2166 IAVIEditStream_Release(pEdit);
2167 } else
2168 hr = AVIERR_UNSUPPORTED;
2169
2170 return hr;
2171 }
2172
2173 /***********************************************************************
2174 * EditStreamSetInfoA (AVIFIL32.@)
2175 */
2176 HRESULT WINAPI EditStreamSetInfoA(PAVISTREAM pstream, LPAVISTREAMINFOA asi,
2177 LONG size)
2178 {
2179 AVISTREAMINFOW asiw;
2180
2181 TRACE("(%p,%p,%d)\n", pstream, asi, size);
2182
2183 if (pstream == NULL)
2184 return AVIERR_BADHANDLE;
2185 if ((DWORD)size < sizeof(AVISTREAMINFOA))
2186 return AVIERR_BADSIZE;
2187
2188 memcpy(&asiw, asi, sizeof(asiw) - sizeof(asiw.szName));
2189 MultiByteToWideChar(CP_ACP, 0, asi->szName, -1,
2190 asiw.szName, sizeof(asiw.szName)/sizeof(WCHAR));
2191
2192 return EditStreamSetInfoW(pstream, &asiw, sizeof(asiw));
2193 }
2194
2195 /***********************************************************************
2196 * EditStreamSetInfoW (AVIFIL32.@)
2197 */
2198 HRESULT WINAPI EditStreamSetInfoW(PAVISTREAM pstream, LPAVISTREAMINFOW asi,
2199 LONG size)
2200 {
2201 PAVIEDITSTREAM pEdit = NULL;
2202 HRESULT hr;
2203
2204 TRACE("(%p,%p,%d)\n", pstream, asi, size);
2205
2206 hr = IAVIStream_QueryInterface(pstream, &IID_IAVIEditStream,(LPVOID*)&pEdit);
2207 if (SUCCEEDED(hr) && pEdit != NULL) {
2208 hr = IAVIEditStream_SetInfo(pEdit, asi, size);
2209
2210 IAVIEditStream_Release(pEdit);
2211 } else
2212 hr = AVIERR_UNSUPPORTED;
2213
2214 return hr;
2215 }
2216
2217 /***********************************************************************
2218 * EditStreamSetNameA (AVIFIL32.@)
2219 */
2220 HRESULT WINAPI EditStreamSetNameA(PAVISTREAM pstream, LPCSTR szName)
2221 {
2222 AVISTREAMINFOA asia;
2223 HRESULT hres;
2224
2225 TRACE("(%p,%s)\n", pstream, debugstr_a(szName));
2226
2227 if (pstream == NULL)
2228 return AVIERR_BADHANDLE;
2229 if (szName == NULL)
2230 return AVIERR_BADPARAM;
2231
2232 hres = AVIStreamInfoA(pstream, &asia, sizeof(asia));
2233 if (FAILED(hres))
2234 return hres;
2235
2236 memset(asia.szName, 0, sizeof(asia.szName));
2237 lstrcpynA(asia.szName, szName, sizeof(asia.szName)/sizeof(asia.szName[0]));
2238
2239 return EditStreamSetInfoA(pstream, &asia, sizeof(asia));
2240 }
2241
2242 /***********************************************************************
2243 * EditStreamSetNameW (AVIFIL32.@)
2244 */
2245 HRESULT WINAPI EditStreamSetNameW(PAVISTREAM pstream, LPCWSTR szName)
2246 {
2247 AVISTREAMINFOW asiw;
2248 HRESULT hres;
2249
2250 TRACE("(%p,%s)\n", pstream, debugstr_w(szName));
2251
2252 if (pstream == NULL)
2253 return AVIERR_BADHANDLE;
2254 if (szName == NULL)
2255 return AVIERR_BADPARAM;
2256
2257 hres = IAVIStream_Info(pstream, &asiw, sizeof(asiw));
2258 if (FAILED(hres))
2259 return hres;
2260
2261 memset(asiw.szName, 0, sizeof(asiw.szName));
2262 lstrcpynW(asiw.szName, szName, sizeof(asiw.szName)/sizeof(asiw.szName[0]));
2263
2264 return EditStreamSetInfoW(pstream, &asiw, sizeof(asiw));
2265 }
2266
2267 /***********************************************************************
2268 * AVIClearClipboard (AVIFIL32.@)
2269 */
2270 HRESULT WINAPI AVIClearClipboard(void)
2271 {
2272 TRACE("()\n");
2273
2274 return AVIERR_UNSUPPORTED; /* OleSetClipboard(NULL); */
2275 }
2276
2277 /***********************************************************************
2278 * AVIGetFromClipboard (AVIFIL32.@)
2279 */
2280 HRESULT WINAPI AVIGetFromClipboard(PAVIFILE *ppfile)
2281 {
2282 FIXME("(%p), stub!\n", ppfile);
2283
2284 *ppfile = NULL;
2285
2286 return AVIERR_UNSUPPORTED;
2287 }
2288
2289 /***********************************************************************
2290 * AVIMakeStreamFromClipboard (AVIFIL32.@)
2291 */
2292 HRESULT WINAPI AVIMakeStreamFromClipboard(UINT cfFormat, HANDLE hGlobal,
2293 PAVISTREAM * ppstream)
2294 {
2295 FIXME("(0x%08x,%p,%p), stub!\n", cfFormat, hGlobal, ppstream);
2296
2297 if (ppstream == NULL)
2298 return AVIERR_BADHANDLE;
2299
2300 return AVIERR_UNSUPPORTED;
2301 }
2302
2303 /***********************************************************************
2304 * AVIPutFileOnClipboard (AVIFIL32.@)
2305 */
2306 HRESULT WINAPI AVIPutFileOnClipboard(PAVIFILE pfile)
2307 {
2308 FIXME("(%p), stub!\n", pfile);
2309
2310 if (pfile == NULL)
2311 return AVIERR_BADHANDLE;
2312
2313 return AVIERR_UNSUPPORTED;
2314 }
2315
2316 HRESULT WINAPIV AVISaveA(LPCSTR szFile, CLSID * pclsidHandler, AVISAVECALLBACK lpfnCallback,
2317 int nStreams, PAVISTREAM pavi, LPAVICOMPRESSOPTIONS lpOptions, ...)
2318 {
2319 FIXME("(%s,%p,%p,0x%08x,%p,%p), stub!\n", debugstr_a(szFile), pclsidHandler, lpfnCallback,
2320 nStreams, pavi, lpOptions);
2321
2322 return AVIERR_UNSUPPORTED;
2323 }
2324
2325 HRESULT WINAPIV AVISaveW(LPCWSTR szFile, CLSID * pclsidHandler, AVISAVECALLBACK lpfnCallback,
2326 int nStreams, PAVISTREAM pavi, LPAVICOMPRESSOPTIONS lpOptions, ...)
2327 {
2328 FIXME("(%s,%p,%p,0x%08x,%p,%p), stub!\n", debugstr_w(szFile), pclsidHandler, lpfnCallback,
2329 nStreams, pavi, lpOptions);
2330
2331 return AVIERR_UNSUPPORTED;
2332 }
Windows API implementation