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