git.oblomov.eu Git - wine/blob - dlls/avifil32/api.c

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