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