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