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