include/vfw.h

   1 /*
   2  * Copyright (C) the Wine project
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef __WINE_VFW_H
  20 #define __WINE_VFW_H
  21
  22 #include "windef.h"
  23 #include "mmsystem.h"
  24 #include "wingdi.h"
  25
  26 #define VFWAPI  WINAPI
  27 #define VFWAPIV WINAPIV
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif  /* __cplusplus */
  32
  33 typedef HANDLE HDRAWDIB;
  34
  35 DWORD       VFWAPI  VideoForWindowsVersion(void);
  36 LONG        VFWAPI  InitVFW(void);
  37 LONG        VFWAPI  TermVFW(void);
  38
  39 /*****************************************************************************
  40  * Predeclare the interfaces
  41  */
  42 typedef struct IAVIStream IAVIStream,*PAVISTREAM;
  43 typedef struct IAVIFile IAVIFile,*PAVIFILE;
  44 typedef struct IGetFrame IGetFrame,*PGETFRAME;
  45 typedef struct IAVIEditStream IAVIEditStream, *PAVIEDITSTREAM;
  46
  47 /* Installable Compressor Manager */
  48
  49 DECLARE_HANDLE(HIC);
  50
  51 /* error return codes */
  52 #define ICERR_OK                0
  53 #define ICERR_DONTDRAW          1
  54 #define ICERR_NEWPALETTE        2
  55 #define ICERR_GOTOKEYFRAME      3
  56 #define ICERR_STOPDRAWING       4
  57
  58 #define ICERR_UNSUPPORTED       -1
  59 #define ICERR_BADFORMAT         -2
  60 #define ICERR_MEMORY            -3
  61 #define ICERR_INTERNAL          -4
  62 #define ICERR_BADFLAGS          -5
  63 #define ICERR_BADPARAM          -6
  64 #define ICERR_BADSIZE           -7
  65 #define ICERR_BADHANDLE         -8
  66 #define ICERR_CANTUPDATE        -9
  67 #define ICERR_ABORT             -10
  68 #define ICERR_ERROR             -100
  69 #define ICERR_BADBITDEPTH       -200
  70 #define ICERR_BADIMAGESIZE      -201
  71
  72 #define ICERR_CUSTOM            -400
  73
  74 /* ICM Messages */
  75 #define ICM_USER                (DRV_USER+0x0000)
  76
  77 /* ICM driver message range */
  78 #define ICM_RESERVED_LOW        (DRV_USER+0x1000)
  79 #define ICM_RESERVED_HIGH       (DRV_USER+0x2000)
  80 #define ICM_RESERVED            ICM_RESERVED_LOW
  81
  82 #define ICM_GETSTATE            (ICM_RESERVED+0)
  83 #define ICM_SETSTATE            (ICM_RESERVED+1)
  84 #define ICM_GETINFO             (ICM_RESERVED+2)
  85
  86 #define ICM_CONFIGURE           (ICM_RESERVED+10)
  87 #define ICM_ABOUT               (ICM_RESERVED+11)
  88 /* */
  89
  90 #define ICM_GETDEFAULTQUALITY   (ICM_RESERVED+30)
  91 #define ICM_GETQUALITY          (ICM_RESERVED+31)
  92 #define ICM_SETQUALITY          (ICM_RESERVED+32)
  93
  94 #define ICM_SET                 (ICM_RESERVED+40)
  95 #define ICM_GET                 (ICM_RESERVED+41)
  96
  97 /* 2 constant FOURCC codes */
  98 #define ICM_FRAMERATE           mmioFOURCC('F','r','m','R')
  99 #define ICM_KEYFRAMERATE        mmioFOURCC('K','e','y','R')
 100
 101 #define ICM_COMPRESS_GET_FORMAT         (ICM_USER+4)
 102 #define ICM_COMPRESS_GET_SIZE           (ICM_USER+5)
 103 #define ICM_COMPRESS_QUERY              (ICM_USER+6)
 104 #define ICM_COMPRESS_BEGIN              (ICM_USER+7)
 105 #define ICM_COMPRESS                    (ICM_USER+8)
 106 #define ICM_COMPRESS_END                (ICM_USER+9)
 107
 108 #define ICM_DECOMPRESS_GET_FORMAT       (ICM_USER+10)
 109 #define ICM_DECOMPRESS_QUERY            (ICM_USER+11)
 110 #define ICM_DECOMPRESS_BEGIN            (ICM_USER+12)
 111 #define ICM_DECOMPRESS                  (ICM_USER+13)
 112 #define ICM_DECOMPRESS_END              (ICM_USER+14)
 113 #define ICM_DECOMPRESS_SET_PALETTE      (ICM_USER+29)
 114 #define ICM_DECOMPRESS_GET_PALETTE      (ICM_USER+30)
 115
 116 #define ICM_DRAW_QUERY                  (ICM_USER+31)
 117 #define ICM_DRAW_BEGIN                  (ICM_USER+15)
 118 #define ICM_DRAW_GET_PALETTE            (ICM_USER+16)
 119 #define ICM_DRAW_START                  (ICM_USER+18)
 120 #define ICM_DRAW_STOP                   (ICM_USER+19)
 121 #define ICM_DRAW_END                    (ICM_USER+21)
 122 #define ICM_DRAW_GETTIME                (ICM_USER+32)
 123 #define ICM_DRAW                        (ICM_USER+33)
 124 #define ICM_DRAW_WINDOW                 (ICM_USER+34)
 125 #define ICM_DRAW_SETTIME                (ICM_USER+35)
 126 #define ICM_DRAW_REALIZE                (ICM_USER+36)
 127 #define ICM_DRAW_FLUSH                  (ICM_USER+37)
 128 #define ICM_DRAW_RENDERBUFFER           (ICM_USER+38)
 129
 130 #define ICM_DRAW_START_PLAY             (ICM_USER+39)
 131 #define ICM_DRAW_STOP_PLAY              (ICM_USER+40)
 132
 133 #define ICM_DRAW_SUGGESTFORMAT          (ICM_USER+50)
 134 #define ICM_DRAW_CHANGEPALETTE          (ICM_USER+51)
 135
 136 #define ICM_GETBUFFERSWANTED            (ICM_USER+41)
 137
 138 #define ICM_GETDEFAULTKEYFRAMERATE      (ICM_USER+42)
 139
 140 #define ICM_DECOMPRESSEX_BEGIN          (ICM_USER+60)
 141 #define ICM_DECOMPRESSEX_QUERY          (ICM_USER+61)
 142 #define ICM_DECOMPRESSEX                (ICM_USER+62)
 143 #define ICM_DECOMPRESSEX_END            (ICM_USER+63)
 144
 145 #define ICM_COMPRESS_FRAMES_INFO        (ICM_USER+70)
 146 #define ICM_SET_STATUS_PROC             (ICM_USER+72)
 147
 148 /* structs */
 149
 150 /* NOTE: Only the 16 bit structs are packed. Structs that are packed anyway
 151  * have not been changed. If a structure is later extended, you may need to create
 152  * two versions of it.
 153  */
 154
 155 typedef struct {
 156         DWORD   dwSize;         /* 00: size */
 157         DWORD   fccType;        /* 04: type 'vidc' usually */
 158         DWORD   fccHandler;     /* 08: */
 159         DWORD   dwVersion;      /* 0c: version of compman opening you */
 160         DWORD   dwFlags;        /* 10: LOWORD is type specific */
 161         LRESULT dwError;        /* 14: */
 162         LPVOID  pV1Reserved;    /* 18: */
 163         LPVOID  pV2Reserved;    /* 1c: */
 164         DWORD   dnDevNode;      /* 20: */
 165                                 /* 24: */
 166 } ICOPEN,*LPICOPEN;
 167
 168 #define ICCOMPRESS_KEYFRAME     0x00000001L
 169
 170 typedef struct {
 171     DWORD               dwFlags;
 172     LPBITMAPINFOHEADER  lpbiOutput;
 173     LPVOID              lpOutput;
 174     LPBITMAPINFOHEADER  lpbiInput;
 175     LPVOID              lpInput;
 176     LPDWORD             lpckid;
 177     LPDWORD             lpdwFlags;
 178     LONG                lFrameNum;
 179     DWORD               dwFrameSize;
 180     DWORD               dwQuality;
 181     LPBITMAPINFOHEADER  lpbiPrev;
 182     LPVOID              lpPrev;
 183 } ICCOMPRESS;
 184
 185 DWORD VFWAPIV ICCompress(
 186         HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
 187         LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
 188         LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
 189         LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
 190 );
 191
 192 #define ICCompressGetFormat(hic, lpbiInput, lpbiOutput)                 \
 193         ICSendMessage(                                                  \
 194             hic,ICM_COMPRESS_GET_FORMAT,(DWORD)(LPVOID)(lpbiInput),     \
 195             (DWORD)(LPVOID)(lpbiOutput)                                 \
 196         )
 197
 198 #define ICCompressGetFormatSize(hic,lpbi) ICCompressGetFormat(hic,lpbi,NULL)
 199
 200 #define ICCompressBegin(hic, lpbiInput, lpbiOutput)                     \
 201     ICSendMessage(                                                      \
 202         hic, ICM_COMPRESS_BEGIN, (DWORD)(LPVOID)(lpbiInput),            \
 203         (DWORD)(LPVOID)(lpbiOutput)                                     \
 204     )
 205
 206 #define ICCompressGetSize(hic, lpbiInput, lpbiOutput)                   \
 207     ICSendMessage(                                                      \
 208         hic, ICM_COMPRESS_GET_SIZE, (DWORD)(LPVOID)(lpbiInput),         \
 209         (DWORD)(LPVOID)(lpbiOutput)                                     \
 210     )
 211
 212 #define ICCompressQuery(hic, lpbiInput, lpbiOutput)             \
 213     ICSendMessage(                                              \
 214         hic, ICM_COMPRESS_QUERY, (DWORD)(LPVOID)(lpbiInput),    \
 215         (DWORD)(LPVOID)(lpbiOutput)                             \
 216     )
 217
 218 #define ICCompressEnd(hic) ICSendMessage(hic, ICM_COMPRESS_END, 0, 0)
 219
 220 /* ICCOMPRESSFRAMES.dwFlags */
 221 #define ICCOMPRESSFRAMES_PADDING        0x00000001
 222 typedef struct {
 223     DWORD               dwFlags;
 224     LPBITMAPINFOHEADER  lpbiOutput;
 225     LPARAM              lOutput;
 226     LPBITMAPINFOHEADER  lpbiInput;
 227     LPARAM              lInput;
 228     LONG                lStartFrame;
 229     LONG                lFrameCount;
 230     LONG                lQuality;
 231     LONG                lDataRate;
 232     LONG                lKeyRate;
 233     DWORD               dwRate;
 234     DWORD               dwScale;
 235     DWORD               dwOverheadPerFrame;
 236     DWORD               dwReserved2;
 237     LONG (CALLBACK *GetData)(LPARAM lInput,LONG lFrame,LPVOID lpBits,LONG len);
 238     LONG (CALLBACK *PutData)(LPARAM lOutput,LONG lFrame,LPVOID lpBits,LONG len);
 239 } ICCOMPRESSFRAMES;
 240
 241 typedef struct {
 242     DWORD               dwFlags;
 243     LPARAM              lParam;
 244    /* messages for Status callback */
 245 #define ICSTATUS_START      0
 246 #define ICSTATUS_STATUS     1
 247 #define ICSTATUS_END        2
 248 #define ICSTATUS_ERROR      3
 249 #define ICSTATUS_YIELD      4
 250     /* FIXME: some X11 libs define Status as int... */
 251     /* LONG (CALLBACK *zStatus)(LPARAM lParam, UINT message, LONG l); */
 252     LONG (CALLBACK *zStatus)(LPARAM lParam, UINT message, LONG l);
 253 } ICSETSTATUSPROC;
 254
 255 /* Values for wMode of ICOpen() */
 256 #define ICMODE_COMPRESS         1
 257 #define ICMODE_DECOMPRESS       2
 258 #define ICMODE_FASTDECOMPRESS   3
 259 #define ICMODE_QUERY            4
 260 #define ICMODE_FASTCOMPRESS     5
 261 #define ICMODE_DRAW             8
 262
 263 /* quality flags */
 264 #define ICQUALITY_LOW       0
 265 #define ICQUALITY_HIGH      10000
 266 #define ICQUALITY_DEFAULT   -1
 267
 268 typedef struct {
 269         DWORD   dwSize;         /* 00: */
 270         DWORD   fccType;        /* 04:compressor type     'vidc' 'audc' */
 271         DWORD   fccHandler;     /* 08:compressor sub-type 'rle ' 'jpeg' 'pcm '*/
 272         DWORD   dwFlags;        /* 0c:flags LOWORD is type specific */
 273         DWORD   dwVersion;      /* 10:version of the driver */
 274         DWORD   dwVersionICM;   /* 14:version of the ICM used */
 275         /*
 276          * under Win32, the driver always returns UNICODE strings.
 277          */
 278         WCHAR   szName[16];             /* 18:short name */
 279         WCHAR   szDescription[128];     /* 38:long name */
 280         WCHAR   szDriver[128];          /* 138:driver that contains compressor*/
 281                                         /* 238: */
 282 } ICINFO;
 283
 284 /* ICINFO.dwFlags */
 285 #define VIDCF_QUALITY           0x0001  /* supports quality */
 286 #define VIDCF_CRUNCH            0x0002  /* supports crunching to a frame size */
 287 #define VIDCF_TEMPORAL          0x0004  /* supports inter-frame compress */
 288 #define VIDCF_COMPRESSFRAMES    0x0008  /* wants the compress all frames message */
 289 #define VIDCF_DRAW              0x0010  /* supports drawing */
 290 #define VIDCF_FASTTEMPORALC     0x0020  /* does not need prev frame on compress */
 291 #define VIDCF_FASTTEMPORALD     0x0080  /* does not need prev frame on decompress */
 292 #define VIDCF_QUALITYTIME       0x0040  /* supports temporal quality */
 293
 294 #define VIDCF_FASTTEMPORAL      (VIDCF_FASTTEMPORALC|VIDCF_FASTTEMPORALD)
 295
 296
 297 /* function shortcuts */
 298 /* ICM_ABOUT */
 299 #define ICMF_ABOUT_QUERY         0x00000001
 300
 301 #define ICQueryAbout(hic) \
 302         (ICSendMessage(hic,ICM_ABOUT,(DWORD)-1,ICMF_ABOUT_QUERY)==ICERR_OK)
 303
 304 #define ICAbout(hic, hwnd) ICSendMessage(hic,ICM_ABOUT,(DWORD)(UINT)(hwnd),0)
 305
 306 /* ICM_CONFIGURE */
 307 #define ICMF_CONFIGURE_QUERY    0x00000001
 308 #define ICQueryConfigure(hic) \
 309         (ICSendMessage(hic,ICM_CONFIGURE,(DWORD)-1,ICMF_CONFIGURE_QUERY)==ICERR_OK)
 310
 311 #define ICConfigure(hic,hwnd) \
 312         ICSendMessage(hic,ICM_CONFIGURE,(DWORD)(UINT)(hwnd),0)
 313
 314 /* Decompression stuff */
 315 #define ICDECOMPRESS_HURRYUP            0x80000000      /* don't draw just buffer (hurry up!) */
 316 #define ICDECOMPRESS_UPDATE             0x40000000      /* don't draw just update screen */
 317 #define ICDECOMPRESS_PREROLL            0x20000000      /* this frame is before real start */
 318 #define ICDECOMPRESS_NULLFRAME          0x10000000      /* repeat last frame */
 319 #define ICDECOMPRESS_NOTKEYFRAME        0x08000000      /* this frame is not a key frame */
 320
 321 typedef struct {
 322     DWORD               dwFlags;        /* flags (from AVI index...) */
 323     LPBITMAPINFOHEADER  lpbiInput;      /* BITMAPINFO of compressed data */
 324     LPVOID              lpInput;        /* compressed data */
 325     LPBITMAPINFOHEADER  lpbiOutput;     /* DIB to decompress to */
 326     LPVOID              lpOutput;
 327     DWORD               ckid;           /* ckid from AVI file */
 328 } ICDECOMPRESS;
 329
 330 typedef struct {
 331     DWORD               dwFlags;
 332     LPBITMAPINFOHEADER  lpbiSrc;
 333     LPVOID              lpSrc;
 334     LPBITMAPINFOHEADER  lpbiDst;
 335     LPVOID              lpDst;
 336
 337     /* changed for ICM_DECOMPRESSEX */
 338     INT                 xDst;       /* destination rectangle */
 339     INT                 yDst;
 340     INT                 dxDst;
 341     INT                 dyDst;
 342
 343     INT                 xSrc;       /* source rectangle */
 344     INT                 ySrc;
 345     INT                 dxSrc;
 346     INT                 dySrc;
 347 } ICDECOMPRESSEX;
 348
 349 DWORD VFWAPIV ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits);
 350
 351 #define ICDecompressBegin(hic, lpbiInput, lpbiOutput)   \
 352     ICSendMessage(                                              \
 353         hic, ICM_DECOMPRESS_BEGIN, (DWORD)(LPVOID)(lpbiInput),  \
 354         (DWORD)(LPVOID)(lpbiOutput)                             \
 355     )
 356
 357 #define ICDecompressQuery(hic, lpbiInput, lpbiOutput)   \
 358     ICSendMessage(                                              \
 359         hic,ICM_DECOMPRESS_QUERY, (DWORD)(LPVOID)(lpbiInput),   \
 360         (DWORD) (LPVOID)(lpbiOutput)                            \
 361     )
 362
 363 #define ICDecompressGetFormat(hic, lpbiInput, lpbiOutput)               \
 364     ((LONG)ICSendMessage(                                               \
 365         hic,ICM_DECOMPRESS_GET_FORMAT, (DWORD)(LPVOID)(lpbiInput),      \
 366         (DWORD)(LPVOID)(lpbiOutput)                                     \
 367     ))
 368
 369 #define ICDecompressGetFormatSize(hic, lpbi)                            \
 370         ICDecompressGetFormat(hic, lpbi, NULL)
 371
 372 #define ICDecompressGetPalette(hic, lpbiInput, lpbiOutput)              \
 373     ICSendMessage(                                                      \
 374         hic, ICM_DECOMPRESS_GET_PALETTE, (DWORD)(LPVOID)(lpbiInput),    \
 375         (DWORD)(LPVOID)(lpbiOutput)                                     \
 376     )
 377
 378 #define ICDecompressSetPalette(hic,lpbiPalette) \
 379         ICSendMessage(                          \
 380                 hic,ICM_DECOMPRESS_SET_PALETTE,         \
 381                 (DWORD)(LPVOID)(lpbiPalette),0          \
 382         )
 383
 384 #define ICDecompressEnd(hic) ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0)
 385
 386 LRESULT VFWAPI  ICSendMessage(HIC hic, UINT msg, DWORD dw1, DWORD dw2);
 387
 388 inline static LRESULT VFWAPI ICDecompressEx(HIC hic, DWORD dwFlags,
 389                                             LPBITMAPINFOHEADER lpbiSrc, LPVOID lpSrc,
 390                                             int xSrc, int ySrc, int dxSrc, int dySrc,
 391                                             LPBITMAPINFOHEADER lpbiDst, LPVOID lpDst,
 392                                             int xDst, int yDst, int dxDst, int dyDst)
 393 {
 394     ICDECOMPRESSEX ic;
 395
 396     ic.dwFlags = dwFlags;
 397     ic.lpbiSrc = lpbiSrc;
 398     ic.lpSrc = lpSrc;
 399     ic.xSrc = xSrc;
 400     ic.ySrc = ySrc;
 401     ic.dxSrc = dxSrc;
 402     ic.dySrc = dySrc;
 403     ic.lpbiDst = lpbiDst;
 404     ic.lpDst = lpDst;
 405     ic.xDst = xDst;
 406     ic.yDst = yDst;
 407     ic.dxDst = dxDst;
 408     ic.dyDst = dyDst;
 409     return ICSendMessage(hic, ICM_DECOMPRESSEX, (DWORD)&ic, sizeof(ic));
 410 }
 411
 412 inline static LRESULT VFWAPI ICDecompressExBegin(HIC hic, DWORD dwFlags,
 413                                                  LPBITMAPINFOHEADER lpbiSrc,
 414                                                  LPVOID lpSrc,
 415                                                  int xSrc, int ySrc, int dxSrc, int dySrc,
 416                                                  LPBITMAPINFOHEADER lpbiDst,
 417                                                  LPVOID lpDst,
 418                                                  int xDst,
 419                                                  int yDst,
 420                                                  int dxDst,
 421                                                  int dyDst)
 422 {
 423     ICDECOMPRESSEX ic;
 424
 425     ic.dwFlags = dwFlags;
 426     ic.lpbiSrc = lpbiSrc;
 427     ic.lpSrc = lpSrc;
 428     ic.xSrc = xSrc;
 429     ic.ySrc = ySrc;
 430     ic.dxSrc = dxSrc;
 431     ic.dySrc = dySrc;
 432     ic.lpbiDst = lpbiDst;
 433     ic.lpDst = lpDst;
 434     ic.xDst = xDst;
 435     ic.yDst = yDst;
 436     ic.dxDst = dxDst;
 437     ic.dyDst = dyDst;
 438     return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, (DWORD)&ic, sizeof(ic));
 439 }
 440 inline static LRESULT VFWAPI ICDecompressExQuery(HIC hic, DWORD dwFlags,
 441                                                  LPBITMAPINFOHEADER lpbiSrc,
 442                                                  LPVOID lpSrc,
 443                                                  int xSrc, int ySrc, int dxSrc, int dySrc,
 444                                                  LPBITMAPINFOHEADER lpbiDst,
 445                                                  LPVOID lpDst,
 446                                                  int xDst,
 447                                                  int yDst,
 448                                                  int dxDst,
 449                                                  int dyDst)
 450 {
 451     ICDECOMPRESSEX ic;
 452
 453     ic.dwFlags = dwFlags;
 454     ic.lpbiSrc = lpbiSrc;
 455     ic.lpSrc = lpSrc;
 456     ic.xSrc = xSrc;
 457     ic.ySrc = ySrc;
 458     ic.dxSrc = dxSrc;
 459     ic.dySrc = dySrc;
 460     ic.lpbiDst = lpbiDst;
 461     ic.lpDst = lpDst;
 462     ic.xDst = xDst;
 463     ic.yDst = yDst;
 464     ic.dxDst = dxDst;
 465     ic.dyDst = dyDst;
 466     return ICSendMessage(hic, ICM_DECOMPRESSEX_QUERY, (DWORD)&ic, sizeof(ic));
 467 }
 468
 469 #define ICDecompressExEnd(hic) \
 470     ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0)
 471
 472 #define ICDRAW_QUERY        0x00000001L   /* test for support */
 473 #define ICDRAW_FULLSCREEN   0x00000002L   /* draw to full screen */
 474 #define ICDRAW_HDC          0x00000004L   /* draw to a HDC/HWND */
 475 #define ICDRAW_ANIMATE      0x00000008L   /* expect palette animation */
 476 #define ICDRAW_CONTINUE     0x00000010L   /* draw is a continuation of previous draw */
 477 #define ICDRAW_MEMORYDC     0x00000020L   /* DC is offscreen, by the way */
 478 #define ICDRAW_UPDATING     0x00000040L   /* We're updating, as opposed to playing */
 479 #define ICDRAW_RENDER       0x00000080L   /* used to render data not draw it */
 480 #define ICDRAW_BUFFER       0x00000100L   /* buffer data offscreen, we will need to update it */
 481
 482 #define ICDecompressOpen(fccType, fccHandler, lpbiIn, lpbiOut) \
 483     ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS)
 484
 485 #define ICDrawOpen(fccType, fccHandler, lpbiIn) \
 486     ICLocate(fccType, fccHandler, lpbiIn, NULL, ICMODE_DRAW)
 487
 488 HANDLE VFWAPI ICImageCompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn,
 489                               LPVOID lpBits, LPBITMAPINFO lpbiOut, LONG lQuality,
 490                               LONG* plSize);
 491
 492 HANDLE VFWAPI ICImageDecompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn,
 493                                 LPVOID lpBits, LPBITMAPINFO lpbiOut);
 494
 495 BOOL    VFWAPI  ICInfo(DWORD fccType, DWORD fccHandler, ICINFO * lpicinfo);
 496 BOOL    VFWAPI  ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags);
 497 BOOL    VFWAPI  ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags);
 498 LRESULT VFWAPI  ICGetInfo(HIC hic,ICINFO *picinfo, DWORD cb);
 499 HIC     VFWAPI  ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode);
 500 HIC     VFWAPI  ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler);
 501
 502 LRESULT VFWAPI  ICClose(HIC hic);
 503 HIC     VFWAPI  ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
 504 HIC     VFWAPI  ICGetDisplayFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, int BitDepth, int dx, int dy);
 505
 506 /* Values for wFlags of ICInstall() */
 507 #define ICINSTALL_UNICODE       0x8000
 508 #define ICINSTALL_FUNCTION      0x0001
 509 #define ICINSTALL_DRIVER        0x0002
 510 #define ICINSTALL_HDRV          0x0004
 511 #define ICINSTALL_DRIVERW       0x8002
 512
 513 #define ICGetState(hic, pv, cb) \
 514     ICSendMessage(hic, ICM_GETSTATE, (DWORD)(LPVOID)(pv), (DWORD)(cb))
 515 #define ICSetState(hic, pv, cb) \
 516     ICSendMessage(hic, ICM_SETSTATE, (DWORD)(LPVOID)(pv), (DWORD)(cb))
 517 #define ICGetStateSize(hic) \
 518     ICGetState(hic, NULL, 0)
 519
 520 inline static DWORD ICGetDefaultQuality(HIC hic)
 521 {
 522    DWORD dwICValue;
 523    ICSendMessage(hic, ICM_GETDEFAULTQUALITY, (DWORD)(LPVOID)&dwICValue, sizeof(DWORD));
 524    return dwICValue;
 525 }
 526
 527 inline static DWORD ICGetDefaultKeyFrameRate(HIC hic)
 528 {
 529    DWORD dwICValue;
 530    ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, (DWORD)(LPVOID)&dwICValue, sizeof(DWORD));
 531    return dwICValue;
 532 }
 533
 534 #define ICDrawWindow(hic, prc) \
 535     ICSendMessage(hic, ICM_DRAW_WINDOW, (DWORD)(LPVOID)(prc), sizeof(RECT))
 536
 537 /* As passed to ICM_DRAW_SUGGESTFORMAT */
 538 typedef struct {
 539         DWORD dwFlags;
 540         LPBITMAPINFOHEADER lpbiIn;
 541         LPBITMAPINFOHEADER lpbiSuggest;
 542         INT dxSrc;
 543         INT dySrc;
 544         INT dxDst;
 545         INT dyDst;
 546         HIC hicDecompressor;
 547 } ICDRAWSUGGEST;
 548
 549 typedef struct {
 550     DWORD               dwFlags;
 551     int                 iStart;
 552     int                 iLen;
 553     LPPALETTEENTRY      lppe;
 554 } ICPALETTE;
 555
 556 DWORD   VFWAPIV ICDrawBegin(
 557         HIC                     hic,
 558         DWORD                   dwFlags,/* flags */
 559         HPALETTE                hpal,   /* palette to draw with */
 560         HWND                    hwnd,   /* window to draw to */
 561         HDC                     hdc,    /* HDC to draw to */
 562         INT                     xDst,   /* destination rectangle */
 563         INT                     yDst,
 564         INT                     dxDst,
 565         INT                     dyDst,
 566         LPBITMAPINFOHEADER      lpbi,   /* format of frame to draw */
 567         INT                     xSrc,   /* source rectangle */
 568         INT                     ySrc,
 569         INT                     dxSrc,
 570         INT                     dySrc,
 571         DWORD                   dwRate, /* frames/second = (dwRate/dwScale) */
 572         DWORD                   dwScale
 573 );
 574
 575 /* as passed to ICM_DRAW_BEGIN */
 576 typedef struct {
 577         DWORD           dwFlags;
 578         HPALETTE        hpal;
 579         HWND            hwnd;
 580         HDC             hdc;
 581         INT             xDst;
 582         INT             yDst;
 583         INT             dxDst;
 584         INT             dyDst;
 585         LPBITMAPINFOHEADER      lpbi;
 586         INT             xSrc;
 587         INT             ySrc;
 588         INT             dxSrc;
 589         INT             dySrc;
 590         DWORD           dwRate;
 591         DWORD           dwScale;
 592 } ICDRAWBEGIN;
 593
 594 #define ICDRAW_HURRYUP      0x80000000L   /* don't draw just buffer (hurry up!) */
 595 #define ICDRAW_UPDATE       0x40000000L   /* don't draw just update screen */
 596 #define ICDRAW_PREROLL      0x20000000L   /* this frame is before real start */
 597 #define ICDRAW_NULLFRAME    0x10000000L   /* repeat last frame */
 598 #define ICDRAW_NOTKEYFRAME  0x08000000L   /* this frame is not a key frame */
 599
 600 typedef struct {
 601         DWORD   dwFlags;
 602         LPVOID  lpFormat;
 603         LPVOID  lpData;
 604         DWORD   cbData;
 605         LONG    lTime;
 606 } ICDRAW;
 607
 608 DWORD VFWAPIV ICDraw(HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,LONG lTime);
 609
 610 inline static LRESULT VFWAPI ICDrawSuggestFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn,
 611                                                  LPBITMAPINFOHEADER lpbiOut,
 612                                                  int dxSrc, int dySrc,
 613                                                  int dxDst, int dyDst,
 614                                                  HIC hicDecomp)
 615 {
 616     ICDRAWSUGGEST ic;
 617
 618     ic.lpbiIn = lpbiIn;
 619     ic.lpbiSuggest = lpbiOut;
 620     ic.dxSrc = dxSrc;
 621     ic.dySrc = dySrc;
 622     ic.dxDst = dxDst;
 623     ic.dyDst = dyDst;
 624     ic.hicDecompressor = hicDecomp;
 625     return ICSendMessage(hic, ICM_DRAW_SUGGESTFORMAT, (DWORD)&ic, sizeof(ic));
 626 }
 627
 628 #define ICDrawQuery(hic, lpbiInput) \
 629     ICSendMessage(hic, ICM_DRAW_QUERY, (DWORD)(LPVOID)(lpbiInput), 0L)
 630
 631 #define ICDrawChangePalette(hic, lpbiInput) \
 632     ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, (DWORD)(LPVOID)(lpbiInput), 0L)
 633
 634 #define ICGetBuffersWanted(hic, lpdwBuffers) \
 635     ICSendMessage(hic, ICM_GETBUFFERSWANTED, (DWORD)(LPVOID)(lpdwBuffers), 0)
 636
 637 #define ICDrawEnd(hic) \
 638     ICSendMessage(hic, ICM_DRAW_END, 0, 0)
 639
 640 #define ICDrawStart(hic) \
 641     ICSendMessage(hic, ICM_DRAW_START, 0, 0)
 642
 643 #define ICDrawStartPlay(hic, lFrom, lTo) \
 644     ICSendMessage(hic, ICM_DRAW_START_PLAY, (DWORD)(lFrom), (DWORD)(lTo))
 645
 646 #define ICDrawStop(hic) \
 647     ICSendMessage(hic, ICM_DRAW_STOP, 0, 0)
 648
 649 #define ICDrawStopPlay(hic) \
 650     ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0)
 651
 652 #define ICDrawGetTime(hic, lplTime) \
 653     ICSendMessage(hic, ICM_DRAW_GETTIME, (DWORD)(LPVOID)(lplTime), 0)
 654
 655 #define ICDrawSetTime(hic, lTime) \
 656     ICSendMessage(hic, ICM_DRAW_SETTIME, (DWORD)lTime, 0)
 657
 658 #define ICDrawRealize(hic, hdc, fBackground) \
 659     ICSendMessage(hic, ICM_DRAW_REALIZE, (DWORD)(UINT)(HDC)(hdc), (DWORD)(BOOL)(fBackground))
 660
 661 #define ICDrawFlush(hic) \
 662     ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0)
 663
 664 #define ICDrawRenderBuffer(hic) \
 665     ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0)
 666
 667 inline static LRESULT VFWAPI ICSetStatusProc(HIC hic, DWORD dwFlags, LRESULT lParam,
 668                                              LONG (CALLBACK *fpfnStatus)(LPARAM, UINT, LONG))
 669 {
 670     ICSETSTATUSPROC ic;
 671
 672     ic.dwFlags = dwFlags;
 673     ic.lParam = lParam;
 674     /* FIXME: see comment in ICSETSTATUSPROC definition */
 675     ic.zStatus = fpfnStatus;
 676
 677     return ICSendMessage(hic, ICM_SET_STATUS_PROC, (DWORD)&ic, sizeof(ic));
 678 }
 679
 680 typedef struct {
 681     LONG                cbSize;
 682     DWORD               dwFlags;
 683     HIC                 hic;
 684     DWORD               fccType;
 685     DWORD               fccHandler;
 686     LPBITMAPINFO        lpbiIn;
 687     LPBITMAPINFO        lpbiOut;
 688     LPVOID              lpBitsOut;
 689     LPVOID              lpBitsPrev;
 690     LONG                lFrame;
 691     LONG                lKey;
 692     LONG                lDataRate;
 693     LONG                lQ;
 694     LONG                lKeyCount;
 695     LPVOID              lpState;
 696     LONG                cbState;
 697 } COMPVARS, *PCOMPVARS;
 698
 699 #define ICMF_COMPVARS_VALID     0x00000001
 700
 701 BOOL VFWAPI ICCompressorChoose(HWND hwnd, UINT uiFlags, LPVOID pvIn, LPVOID lpData,
 702                                PCOMPVARS pc, LPSTR lpszTitle);
 703
 704 #define ICMF_CHOOSE_KEYFRAME            0x0001
 705 #define ICMF_CHOOSE_DATARATE            0x0002
 706 #define ICMF_CHOOSE_PREVIEW             0x0004
 707 #define ICMF_CHOOSE_ALLCOMPRESSORS      0x0008
 708
 709 BOOL VFWAPI ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn);
 710 void VFWAPI ICSeqCompressFrameEnd(PCOMPVARS pc);
 711
 712 LPVOID VFWAPI ICSeqCompressFrame(PCOMPVARS pc, UINT uiFlags, LPVOID lpBits,
 713                                  BOOL *pfKey, LONG *plSize);
 714 void VFWAPI ICCompressorFree(PCOMPVARS pc);
 715
 716 /********************* AVIFILE function declarations *************************/
 717
 718 #ifndef mmioFOURCC
 719 #define mmioFOURCC( ch0, ch1, ch2, ch3 )                                \
 720         ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |            \
 721         ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
 722 #endif
 723
 724 #ifndef aviTWOCC
 725 #define aviTWOCC(ch0, ch1) ((WORD)(BYTE)(ch0) | ((WORD)(BYTE)(ch1) << 8))
 726 #endif
 727
 728 typedef WORD TWOCC;
 729
 730 #define ICTYPE_VIDEO            mmioFOURCC('v', 'i', 'd', 'c')
 731 #define ICTYPE_AUDIO            mmioFOURCC('a', 'u', 'd', 'c')
 732
 733 #define formtypeAVI             mmioFOURCC('A', 'V', 'I', ' ')
 734 #define listtypeAVIHEADER       mmioFOURCC('h', 'd', 'r', 'l')
 735 #define ckidAVIMAINHDR          mmioFOURCC('a', 'v', 'i', 'h')
 736 #define listtypeSTREAMHEADER    mmioFOURCC('s', 't', 'r', 'l')
 737 #define ckidSTREAMHEADER        mmioFOURCC('s', 't', 'r', 'h')
 738 #define ckidSTREAMFORMAT        mmioFOURCC('s', 't', 'r', 'f')
 739 #define ckidSTREAMHANDLERDATA   mmioFOURCC('s', 't', 'r', 'd')
 740 #define ckidSTREAMNAME          mmioFOURCC('s', 't', 'r', 'n')
 741
 742 #define listtypeAVIMOVIE        mmioFOURCC('m', 'o', 'v', 'i')
 743 #define listtypeAVIRECORD       mmioFOURCC('r', 'e', 'c', ' ')
 744
 745 #define ckidAVINEWINDEX         mmioFOURCC('i', 'd', 'x', '1')
 746
 747 #define streamtypeANY           0UL
 748 #define streamtypeVIDEO         mmioFOURCC('v', 'i', 'd', 's')
 749 #define streamtypeAUDIO         mmioFOURCC('a', 'u', 'd', 's')
 750 #define streamtypeMIDI          mmioFOURCC('m', 'i', 'd', 's')
 751 #define streamtypeTEXT          mmioFOURCC('t', 'x', 't', 's')
 752
 753 /* Basic chunk types */
 754 #define cktypeDIBbits           aviTWOCC('d', 'b')
 755 #define cktypeDIBcompressed     aviTWOCC('d', 'c')
 756 #define cktypePALchange         aviTWOCC('p', 'c')
 757 #define cktypeWAVEbytes         aviTWOCC('w', 'b')
 758
 759 /* Chunk id to use for extra chunks for padding. */
 760 #define ckidAVIPADDING          mmioFOURCC('J', 'U', 'N', 'K')
 761
 762 #define FromHex(n)              (((n) >= 'A') ? ((n) + 10 - 'A') : ((n) - '0'))
 763 #define StreamFromFOURCC(fcc)   ((WORD)((FromHex(LOBYTE(LOWORD(fcc))) << 4) + \
 764                                         (FromHex(HIBYTE(LOWORD(fcc))))))
 765 #define TWOCCFromFOURCC(fcc)    HIWORD(fcc)
 766 #define ToHex(n)                ((BYTE)(((n) > 9) ? ((n) - 10 + 'A') : ((n) + '0')))
 767 #define MAKEAVICKID(tcc, stream) \
 768                                 MAKELONG((ToHex((stream) & 0x0f) << 8) | \
 769                                          (ToHex(((stream) & 0xf0) >> 4)), tcc)
 770
 771 /* AVIFileHdr.dwFlags */
 772 #define AVIF_HASINDEX           0x00000010      /* Index at end of file? */
 773 #define AVIF_MUSTUSEINDEX       0x00000020
 774 #define AVIF_ISINTERLEAVED      0x00000100
 775 #define AVIF_TRUSTCKTYPE        0x00000800      /* Use CKType to find key frames*/
 776 #define AVIF_WASCAPTUREFILE     0x00010000
 777 #define AVIF_COPYRIGHTED        0x00020000
 778
 779 #define AVI_HEADERSIZE  2048
 780
 781 typedef BOOL (CALLBACK *AVISAVECALLBACK)(INT);
 782
 783 typedef struct _MainAVIHeader
 784 {
 785     DWORD       dwMicroSecPerFrame;
 786     DWORD       dwMaxBytesPerSec;
 787     DWORD       dwPaddingGranularity;
 788     DWORD       dwFlags;
 789     DWORD       dwTotalFrames;
 790     DWORD       dwInitialFrames;
 791     DWORD       dwStreams;
 792     DWORD       dwSuggestedBufferSize;
 793     DWORD       dwWidth;
 794     DWORD       dwHeight;
 795     DWORD       dwReserved[4];
 796 } MainAVIHeader;
 797
 798 /* AVIStreamHeader.dwFlags */
 799 #define AVISF_DISABLED                  0x00000001
 800 #define AVISF_VIDEO_PALCHANGES          0x00010000
 801
 802 typedef struct {
 803     FOURCC      fccType;
 804     FOURCC      fccHandler;
 805     DWORD       dwFlags;        /* AVISF_* */
 806     WORD        wPriority;
 807     WORD        wLanguage;
 808     DWORD       dwInitialFrames;
 809     DWORD       dwScale;
 810     DWORD       dwRate; /* dwRate / dwScale == samples/second */
 811     DWORD       dwStart;
 812     DWORD       dwLength; /* In units above... */
 813     DWORD       dwSuggestedBufferSize;
 814     DWORD       dwQuality;
 815     DWORD       dwSampleSize;
 816     struct { SHORT left, top, right, bottom; } rcFrame; /* word.word - word.word in file */
 817 } AVIStreamHeader;
 818
 819 /* AVIINDEXENTRY.dwFlags */
 820 #define AVIIF_LIST      0x00000001      /* chunk is a 'LIST' */
 821 #define AVIIF_TWOCC     0x00000002
 822 #define AVIIF_KEYFRAME  0x00000010      /* this frame is a key frame. */
 823
 824 #define AVIIF_NOTIME    0x00000100      /* this frame doesn't take any time */
 825 #define AVIIF_COMPUSE   0x0FFF0000
 826
 827 typedef struct _AVIINDEXENTRY {
 828     DWORD       ckid;
 829     DWORD       dwFlags;
 830     DWORD       dwChunkOffset;
 831     DWORD       dwChunkLength;
 832 } AVIINDEXENTRY;
 833
 834 typedef struct _AVIPALCHANGE {
 835     BYTE                bFirstEntry;
 836     BYTE                bNumEntries;
 837     WORD                wFlags;         /* pad */
 838     PALETTEENTRY        peNew[1];
 839 } AVIPALCHANGE;
 840
 841 #define AVIIF_KEYFRAME  0x00000010      /* this frame is a key frame. */
 842
 843 #define AVIGETFRAMEF_BESTDISPLAYFMT     1
 844
 845 typedef struct _AVISTREAMINFOA {
 846     DWORD       fccType;
 847     DWORD       fccHandler;
 848     DWORD       dwFlags;        /* AVIIF_* */
 849     DWORD       dwCaps;
 850     WORD        wPriority;
 851     WORD        wLanguage;
 852     DWORD       dwScale;
 853     DWORD       dwRate;         /* dwRate / dwScale == samples/second */
 854     DWORD       dwStart;
 855     DWORD       dwLength;       /* In units above... */
 856     DWORD       dwInitialFrames;
 857     DWORD       dwSuggestedBufferSize;
 858     DWORD       dwQuality;
 859     DWORD       dwSampleSize;
 860     RECT        rcFrame;
 861     DWORD       dwEditCount;
 862     DWORD       dwFormatChangeCount;
 863     CHAR        szName[64];
 864 } AVISTREAMINFOA, * LPAVISTREAMINFOA, *PAVISTREAMINFOA;
 865
 866 typedef struct _AVISTREAMINFOW {
 867     DWORD       fccType;
 868     DWORD       fccHandler;
 869     DWORD       dwFlags;
 870     DWORD       dwCaps;
 871     WORD        wPriority;
 872     WORD        wLanguage;
 873     DWORD       dwScale;
 874     DWORD       dwRate;         /* dwRate / dwScale == samples/second */
 875     DWORD       dwStart;
 876     DWORD       dwLength;       /* In units above... */
 877     DWORD       dwInitialFrames;
 878     DWORD       dwSuggestedBufferSize;
 879     DWORD       dwQuality;
 880     DWORD       dwSampleSize;
 881     RECT        rcFrame;
 882     DWORD       dwEditCount;
 883     DWORD       dwFormatChangeCount;
 884     WCHAR       szName[64];
 885 } AVISTREAMINFOW, * LPAVISTREAMINFOW, *PAVISTREAMINFOW;
 886 DECL_WINELIB_TYPE_AW(AVISTREAMINFO)
 887 DECL_WINELIB_TYPE_AW(LPAVISTREAMINFO)
 888 DECL_WINELIB_TYPE_AW(PAVISTREAMINFO)
 889
 890 #define AVISTREAMINFO_DISABLED          0x00000001
 891 #define AVISTREAMINFO_FORMATCHANGES     0x00010000
 892
 893 /* AVIFILEINFO.dwFlags */
 894 #define AVIFILEINFO_HASINDEX            0x00000010
 895 #define AVIFILEINFO_MUSTUSEINDEX        0x00000020
 896 #define AVIFILEINFO_ISINTERLEAVED       0x00000100
 897 #define AVIFILEINFO_TRUSTCKTYPE         0x00000800
 898 #define AVIFILEINFO_WASCAPTUREFILE      0x00010000
 899 #define AVIFILEINFO_COPYRIGHTED         0x00020000
 900
 901 /* AVIFILEINFO.dwCaps */
 902 #define AVIFILECAPS_CANREAD             0x00000001
 903 #define AVIFILECAPS_CANWRITE            0x00000002
 904 #define AVIFILECAPS_ALLKEYFRAMES        0x00000010
 905 #define AVIFILECAPS_NOCOMPRESSION       0x00000020
 906
 907 typedef struct _AVIFILEINFOW {
 908     DWORD               dwMaxBytesPerSec;
 909     DWORD               dwFlags;
 910     DWORD               dwCaps;
 911     DWORD               dwStreams;
 912     DWORD               dwSuggestedBufferSize;
 913     DWORD               dwWidth;
 914     DWORD               dwHeight;
 915     DWORD               dwScale;
 916     DWORD               dwRate;
 917     DWORD               dwLength;
 918     DWORD               dwEditCount;
 919     WCHAR               szFileType[64];
 920 } AVIFILEINFOW, * LPAVIFILEINFOW, *PAVIFILEINFOW;
 921 typedef struct _AVIFILEINFOA {
 922     DWORD               dwMaxBytesPerSec;
 923     DWORD               dwFlags;
 924     DWORD               dwCaps;
 925     DWORD               dwStreams;
 926     DWORD               dwSuggestedBufferSize;
 927     DWORD               dwWidth;
 928     DWORD               dwHeight;
 929     DWORD               dwScale;
 930     DWORD               dwRate;
 931     DWORD               dwLength;
 932     DWORD               dwEditCount;
 933     CHAR                szFileType[64];
 934 } AVIFILEINFOA, * LPAVIFILEINFOA, *PAVIFILEINFOA;
 935 DECL_WINELIB_TYPE_AW(AVIFILEINFO)
 936 DECL_WINELIB_TYPE_AW(PAVIFILEINFO)
 937 DECL_WINELIB_TYPE_AW(LPAVIFILEINFO)
 938
 939 /* AVICOMPRESSOPTIONS.dwFlags. determines presence of fields in below struct */
 940 #define AVICOMPRESSF_INTERLEAVE 0x00000001
 941 #define AVICOMPRESSF_DATARATE   0x00000002
 942 #define AVICOMPRESSF_KEYFRAMES  0x00000004
 943 #define AVICOMPRESSF_VALID      0x00000008
 944
 945 typedef struct {
 946     DWORD       fccType;                /* stream type, for consistency */
 947     DWORD       fccHandler;             /* compressor */
 948     DWORD       dwKeyFrameEvery;        /* keyframe rate */
 949     DWORD       dwQuality;              /* compress quality 0-10,000 */
 950     DWORD       dwBytesPerSecond;       /* bytes per second */
 951     DWORD       dwFlags;                /* flags... see below */
 952     LPVOID      lpFormat;               /* save format */
 953     DWORD       cbFormat;
 954     LPVOID      lpParms;                /* compressor options */
 955     DWORD       cbParms;
 956     DWORD       dwInterleaveEvery;      /* for non-video streams only */
 957 } AVICOMPRESSOPTIONS, *LPAVICOMPRESSOPTIONS,*PAVICOMPRESSOPTIONS;
 958
 959 #define FIND_DIR        0x0000000FL     /* direction mask */
 960 #define FIND_NEXT       0x00000001L     /* search forward */
 961 #define FIND_PREV       0x00000004L     /* search backward */
 962 #define FIND_FROM_START 0x00000008L     /* start at the logical beginning */
 963
 964 #define FIND_TYPE       0x000000F0L     /* type mask */
 965 #define FIND_KEY        0x00000010L     /* find a key frame */
 966 #define FIND_ANY        0x00000020L     /* find any (non-empty) sample */
 967 #define FIND_FORMAT     0x00000040L     /* find a formatchange */
 968
 969 #define FIND_RET        0x0000F000L     /* return mask */
 970 #define FIND_POS        0x00000000L     /* return logical position */
 971 #define FIND_LENGTH     0x00001000L     /* return logical size */
 972 #define FIND_OFFSET     0x00002000L     /* return physical position */
 973 #define FIND_SIZE       0x00003000L     /* return physical size */
 974 #define FIND_INDEX      0x00004000L     /* return physical index position */
 975
 976 #include "ole2.h"
 977
 978 #define DEFINE_AVIGUID(name, l, w1, w2) \
 979     DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)
 980
 981 DEFINE_AVIGUID(IID_IAVIFile,            0x00020020, 0, 0);
 982 DEFINE_AVIGUID(IID_IAVIStream,          0x00020021, 0, 0);
 983 DEFINE_AVIGUID(IID_IAVIStreaming,       0x00020022, 0, 0);
 984 DEFINE_AVIGUID(IID_IGetFrame,           0x00020023, 0, 0);
 985 DEFINE_AVIGUID(IID_IAVIEditStream,      0x00020024, 0, 0);
 986
 987 DEFINE_AVIGUID(CLSID_AVIFile,           0x00020000, 0, 0);
 988
 989 /*****************************************************************************
 990  * IAVIStream interface
 991  */
 992 #define INTERFACE IAVIStream
 993 #define IAVIStream_METHODS \
 994     IUnknown_METHODS \
 995     STDMETHOD(Create)(THIS_ LPARAM lParam1, LPARAM lParam2) PURE; \
 996     STDMETHOD(Info)(THIS_ AVISTREAMINFOW *psi, LONG lSize) PURE; \
 997     STDMETHOD_(LONG,FindSample)(THIS_ LONG lPos, LONG lFlags) PURE; \
 998     STDMETHOD(ReadFormat)(THIS_ LONG lPos, LPVOID lpFormat, LONG *lpcbFormat) PURE; \
 999     STDMETHOD(SetFormat)(THIS_ LONG lPos, LPVOID lpFormat, LONG cbFormat) PURE; \
1000     STDMETHOD(Read)(THIS_ LONG lStart, LONG lSamples, LPVOID lpBuffer, LONG cbBuffer, LONG *plBytes, LONG *plSamples) PURE; \
1001     STDMETHOD(Write)(THIS_ LONG lStart, LONG lSamples, LPVOID lpBuffer, LONG cbBuffer, DWORD dwFlags, LONG *plSampWritten, LONG *plBytesWritten) PURE; \
1002     STDMETHOD(Delete)(THIS_ LONG lStart, LONG lSamples) PURE; \
1003     STDMETHOD(ReadData)(THIS_ DWORD fcc, LPVOID lpBuffer, LONG *lpcbBuffer) PURE; \
1004     STDMETHOD(WriteData)(THIS_ DWORD fcc, LPVOID lpBuffer, LONG cbBuffer) PURE; \
1005     STDMETHOD(SetInfo)(THIS_ AVISTREAMINFOW *plInfo, LONG cbInfo) PURE;
1006 ICOM_DEFINE(IAVIStream, IUnknown)
1007 #undef INTERFACE
1008
1009 #ifdef COBJMACROS
1010 /*** IUnknown methods ***/
1011 #define IAVIStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1012 #define IAVIStream_AddRef(p)             (p)->lpVtbl->AddRef(p)
1013 #define IAVIStream_Release(p)            (p)->lpVtbl->Release(p)
1014 /*** IAVIStream methods ***/
1015 #define IAVIStream_Create(p,a,b)          (p)->lpVtbl->Create(p,a,b)
1016 #define IAVIStream_Info(p,a,b)            (p)->lpVtbl->Info(p,a,b)
1017 #define IAVIStream_FindSample(p,a,b)      (p)->lpVtbl->FindSample(p,a,b)
1018 #define IAVIStream_ReadFormat(p,a,b,c)    (p)->lpVtbl->ReadFormat(p,a,b,c)
1019 #define IAVIStream_SetFormat(p,a,b,c)     (p)->lpVtbl->SetFormat(p,a,b,c)
1020 #define IAVIStream_Read(p,a,b,c,d,e,f)    (p)->lpVtbl->Read(p,a,b,c,d,e,f)
1021 #define IAVIStream_Write(p,a,b,c,d,e,f,g) (p)->lpVtbl->Write(p,a,b,c,d,e,f,g)
1022 #define IAVIStream_Delete(p,a,b)          (p)->lpVtbl->Delete(p,a,b)
1023 #define IAVIStream_ReadData(p,a,b,c)      (p)->lpVtbl->ReadData(p,a,b,c)
1024 #define IAVIStream_WriteData(p,a,b,c)     (p)->lpVtbl->WriteData(p,a,b,c)
1025 #define IAVIStream_SetInfo(p,a,b)         (p)->lpVtbl->SetInfo(p,a,b)
1026 #endif
1027
1028 ULONG WINAPI AVIStreamAddRef(PAVISTREAM iface);
1029 ULONG WINAPI AVIStreamRelease(PAVISTREAM iface);
1030 HRESULT WINAPI AVIStreamCreate(PAVISTREAM*,LONG,LONG,CLSID*);
1031 HRESULT WINAPI AVIStreamInfoA(PAVISTREAM iface,AVISTREAMINFOA *asi,LONG size);
1032 HRESULT WINAPI AVIStreamInfoW(PAVISTREAM iface,AVISTREAMINFOW *asi,LONG size);
1033 #define AVIStreamInfo WINELIB_NAME_AW(AVIStreamInfo)
1034 HRESULT WINAPI AVIStreamFindSample(PAVISTREAM pstream, LONG pos, DWORD flags);
1035 HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG *formatsize);
1036 HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG formatsize);
1037 HRESULT WINAPI AVIStreamRead(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread);
1038 HRESULT WINAPI AVIStreamWrite(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
1039 HRESULT WINAPI AVIStreamReadData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG *lpread);
1040 HRESULT WINAPI AVIStreamWriteData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG size);
1041
1042 PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pavi,LPBITMAPINFOHEADER lpbiWanted);
1043 LPVOID  WINAPI AVIStreamGetFrame(PGETFRAME pg,LONG pos);
1044 HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pg);
1045
1046 HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM*ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *lpOptions,CLSID*pclsidHandler);
1047 HRESULT WINAPI AVIMakeFileFromStreams(PAVIFILE *ppfile, int nStreams, PAVISTREAM *ppStreams);
1048
1049 HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM *ppavi, LPCSTR szFile,
1050                                       DWORD fccType, LONG lParam,
1051                                       UINT mode, CLSID *pclsidHandler);
1052 HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM *ppavi, LPCWSTR szFile,
1053                                       DWORD fccType, LONG lParam,
1054                                       UINT mode, CLSID *pclsidHandler);
1055 #define AVIStreamOpenFromFile WINELIB_NAME_AW(AVIStreamOpenFromFile)
1056
1057 HRESULT WINAPI AVIBuildFilterA(LPSTR szFilter, LONG cbFilter, BOOL fSaving);
1058 HRESULT WINAPI AVIBuildFilterW(LPWSTR szFilter, LONG cbFilter, BOOL fSaving);
1059 #define AVIBuildFilter WINELIB_NAME_AW(AVIBuildFilter)
1060
1061 BOOL WINAPI AVISaveOptions(HWND hWnd,UINT uFlags,INT nStream,
1062                            PAVISTREAM *ppavi,LPAVICOMPRESSOPTIONS *ppOptions);
1063 HRESULT WINAPI AVISaveOptionsFree(INT nStreams,LPAVICOMPRESSOPTIONS*ppOptions);
1064
1065 HRESULT WINAPI AVISaveVA(LPCSTR szFile, CLSID *pclsidHandler,
1066                          AVISAVECALLBACK lpfnCallback, int nStream,
1067                          PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *plpOptions);
1068 HRESULT WINAPI AVISaveVW(LPCWSTR szFile, CLSID *pclsidHandler,
1069                          AVISAVECALLBACK lpfnCallback, int nStream,
1070                          PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *plpOptions);
1071 #define AVISaveV WINELIB_NAME_AW(AVISaveV)
1072
1073 LONG WINAPI AVIStreamStart(PAVISTREAM iface);
1074 LONG WINAPI AVIStreamLength(PAVISTREAM iface);
1075 LONG WINAPI AVIStreamSampleToTime(PAVISTREAM pstream, LONG lSample);
1076 LONG WINAPI AVIStreamTimeToSample(PAVISTREAM pstream, LONG lTime);
1077
1078 #define AVIFileClose(pavi) \
1079     AVIFileRelease(pavi)
1080 #define AVIStreamClose(pavi) \
1081     AVIStreamRelease(pavi);
1082 #define AVIStreamEnd(pavi) \
1083     (AVIStreamStart(pavi) + AVIStreamLength(pavi))
1084 #define AVIStreamEndTime(pavi) \
1085     AVIStreamSampleToTime(pavi, AVIStreamEnd(pavi))
1086 #define AVIStreamFormatSize(pavi, lPos, plSize) \
1087     AVIStreamReadFormat(pavi, lPos, NULL, plSize)
1088 #define AVIStreamLengthTime(pavi) \
1089     AVIStreamSampleToTime(pavi, AVIStreamLength(pavi))
1090 #define AVIStreamSampleSize(pavi,pos,psize) \
1091     AVIStreamRead(pavi,pos,1,NULL,0,psize,NULL)
1092 #define AVIStreamSampleToSample(pavi1, pavi2, samp2) \
1093     AVIStreamTimeToSample(pavi1, AVIStreamSampleToTime(pavi2, samp2))
1094 #define AVIStreamStartTime(pavi) \
1095     AVIStreamSampleToTime(pavi, AVIStreamStart(pavi))
1096
1097 /*****************************************************************************
1098  * IAVIEditStream interface
1099  */
1100 #define INTERFACE IAVIEditStream
1101 #define IAVIEditStream_METHODS \
1102     IUnknown_METHODS \
1103     STDMETHOD(Cut)(IAVIEditStream*iface,LONG*plStart,LONG*plLength,PAVISTREAM*ppResult) PURE; \
1104     STDMETHOD(Copy)(IAVIEditStream*iface,LONG*plStart,LONG*plLength,PAVISTREAM*ppResult) PURE; \
1105     STDMETHOD(Paste)(IAVIEditStream*iface,LONG*plStart,LONG*plLength,PAVISTREAM pSource,LONG lStart,LONG lEnd) PURE; \
1106     STDMETHOD(Clone)(IAVIEditStream*iface,PAVISTREAM*ppResult) PURE; \
1107     STDMETHOD(SetInfo)(IAVIEditStream*iface,LPAVISTREAMINFOW asi, LONG size) PURE;
1108 ICOM_DEFINE(IAVIEditStream,IUnknown)
1109 #undef INTERFACE
1110
1111 #ifdef COBJMACROS
1112 /*** IUnknown methods ***/
1113 #define IAVIEditStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1114 #define IAVIEditStream_AddRef(p)             (p)->lpVtbl->AddRef(p)
1115 #define IAVIEditStream_Release(p)            (p)->lpVtbl->Release(p)
1116 /*** IAVIEditStream methods ***/
1117 #define IAVIEditStream_Cut(p,a,b,c)          (p)->lpVtbl->Cut(p,a,b,c)
1118 #define IAVIEditStream_Copy(p,a,b,c)         (p)->lpVtbl->Copy(p,a,b,c)
1119 #define IAVIEditStream_Paste(p,a,b,c,d,e)    (p)->lpVtbl->Paste(p,a,b,c,d,e)
1120 #define IAVIEditStream_Clone(p,a)            (p)->lpVtbl->Clone(p,a)
1121 #define IAVIEditStream_SetInfo(p,a,b)        (p)->lpVtbl->SetInfo(p,a,b)
1122 #endif
1123
1124 HRESULT WINAPI CreateEditableStream(PAVISTREAM *ppEditable,PAVISTREAM pSource);
1125 HRESULT WINAPI EditStreamClone(PAVISTREAM pStream, PAVISTREAM *ppResult);
1126 HRESULT WINAPI EditStreamCopy(PAVISTREAM pStream, LONG *plStart,
1127                               LONG *plLength, PAVISTREAM *ppResult);
1128 HRESULT WINAPI EditStreamCut(PAVISTREAM pStream, LONG *plStart,
1129                              LONG *plLength, PAVISTREAM *ppResult);
1130 HRESULT WINAPI EditStreamPaste(PAVISTREAM pDest, LONG *plStart, LONG *plLength,
1131                                PAVISTREAM pSource, LONG lStart, LONG lEnd);
1132
1133 HRESULT WINAPI EditStreamSetInfoA(PAVISTREAM pstream, LPAVISTREAMINFOA asi,
1134                                   LONG size);
1135 HRESULT WINAPI EditStreamSetInfoW(PAVISTREAM pstream, LPAVISTREAMINFOW asi,
1136                                   LONG size);
1137 #define EditStreamSetInfo WINELIB_NAME_AW(EditStreamSetInfo)
1138
1139 HRESULT WINAPI EditStreamSetNameA(PAVISTREAM pstream, LPCSTR szName);
1140 HRESULT WINAPI EditStreamSetNameW(PAVISTREAM pstream, LPCWSTR szName);
1141 #define EditStreamSetName WINELIB_NAME_AW(EditStreamSetName)
1142
1143 /*****************************************************************************
1144  * IAVIFile interface
1145  */
1146 /* In Win32 this interface uses UNICODE only */
1147 #define INTERFACE IAVIFile
1148 #define IAVIFile_METHODS \
1149     IUnknown_METHODS \
1150     STDMETHOD(Info)(THIS_ AVIFILEINFOW *pfi, LONG lSize) PURE; \
1151     STDMETHOD(GetStream)(THIS_ PAVISTREAM *ppStream, DWORD fccType, LONG lParam) PURE; \
1152     STDMETHOD(CreateStream)(THIS_ PAVISTREAM *ppStream, AVISTREAMINFOW *psi) PURE; \
1153     STDMETHOD(WriteData)(THIS_ DWORD fcc, LPVOID lpBuffer, LONG cbBuffer) PURE; \
1154     STDMETHOD(ReadData)(THIS_ DWORD fcc, LPVOID lpBuffer, LONG *lpcbBuffer) PURE; \
1155     STDMETHOD(EndRecord)(THIS) PURE; \
1156     STDMETHOD(DeleteStream)(THIS_ DWORD fccType, LONG lParam) PURE;
1157 ICOM_DEFINE(IAVIFile,IUnknown)
1158 #undef INTERFACE
1159
1160 #ifdef COBJMACROS
1161 /*** IUnknown methods ***/
1162 #define IAVIFile_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1163 #define IAVIFile_AddRef(p)             (p)->lpVtbl->AddRef(p)
1164 #define IAVIFile_Release(p)            (p)->lpVtbl->Release(p)
1165 /*** IAVIFile methods ***/
1166 #define IAVIFile_Info(p,a,b)         (p)->lpVtbl->Info(p,a,b)
1167 #define IAVIFile_GetStream(p,a,b,c)  (p)->lpVtbl->GetStream(p,a,b,c)
1168 #define IAVIFile_CreateStream(p,a,b) (p)->lpVtbl->CreateStream(p,a,b)
1169 #define IAVIFile_WriteData(p,a,b,c)  (p)->lpVtbl->WriteData(p,a,b,c)
1170 #define IAVIFile_ReadData(p,a,b,c)   (p)->lpVtbl->ReadData(p,a,b,c)
1171 #define IAVIFile_EndRecord(p)        (p)->lpVtbl->EndRecord(p)
1172 #define IAVIFile_DeleteStream(p,a,b) (p)->lpVtbl->DeleteStream(p,a,b)
1173 #endif
1174
1175 void WINAPI AVIFileInit(void);
1176 void WINAPI AVIFileExit(void);
1177
1178 HRESULT WINAPI AVIFileOpenA(PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler);
1179 HRESULT WINAPI AVIFileOpenW(PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler);
1180 #define AVIFileOpen WINELIB_NAME_AW(AVIFileOpen)
1181
1182 ULONG   WINAPI AVIFileAddRef(PAVIFILE pfile);
1183 ULONG   WINAPI AVIFileRelease(PAVIFILE pfile);
1184 HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile,PAVIFILEINFOA pfi,LONG lSize);
1185 HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile,PAVIFILEINFOW pfi,LONG lSize);
1186 #define AVIFileInfo WINELIB_NAME_AW(AVIFileInfo)
1187 HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile,PAVISTREAM* avis,DWORD fccType,LONG lParam);
1188 HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile,PAVISTREAM* ppavi,AVISTREAMINFOA* psi);
1189 HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile,PAVISTREAM* ppavi,AVISTREAMINFOW* psi);
1190 #define AVIFileCreateStream WINELIB_NAME_AW(AVIFileCreateStream)
1191 HRESULT WINAPI AVIFileWriteData(PAVIFILE pfile,DWORD fcc,LPVOID lp,LONG size);
1192 HRESULT WINAPI AVIFileReadData(PAVIFILE pfile,DWORD fcc,LPVOID lp,LPLONG size);
1193 HRESULT WINAPI AVIFileEndRecord(PAVIFILE pfile);
1194
1195 /*****************************************************************************
1196  * IGetFrame interface
1197  */
1198 #define INTERFACE IGetFrame
1199 #define IGetFrame_METHODS \
1200     IUnknown_METHODS \
1201     STDMETHOD_(LPVOID,GetFrame)(THIS_ LONG lPos) PURE; \
1202     STDMETHOD(Begin)(THIS_ LONG lStart, LONG lEnd, LONG lRate) PURE; \
1203     STDMETHOD(End)(THIS) PURE; \
1204     STDMETHOD(SetFormat)(THIS_ LPBITMAPINFOHEADER lpbi, LPVOID lpBits, INT x, INT y, INT dx, INT dy) PURE;
1205 ICOM_DEFINE(IGetFrame,IUnknown)
1206 #undef INTERFACE
1207
1208 #ifdef COBJMACROS
1209 /*** IUnknown methods ***/
1210 #define IGetFrame_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1211 #define IGetFrame_AddRef(p)             (p)->lpVtbl->AddRef(p)
1212 #define IGetFrame_Release(p)            (p)->lpVtbl->Release(p)
1213 /*** IGetFrame methods ***/
1214 #define IGetFrame_GetFrame(p,a)            (p)->lpVtbl->GetFrame(p,a)
1215 #define IGetFrame_Begin(p,a,b,c)           (p)->lpVtbl->Begin(p,a,b,c)
1216 #define IGetFrame_End(p)                   (p)->lpVtbl->End(p)
1217 #define IGetFrame_SetFormat(p,a,b,c,d,e,f) (p)->lpVtbl->SetFormat(p,a,b,c,d,e,f)
1218 #endif
1219
1220 HRESULT WINAPI AVIClearClipboard(void);
1221 HRESULT WINAPI AVIGetFromClipboard(PAVIFILE *ppfile);
1222 HRESULT WINAPI AVIPutFileOnClipboard(PAVIFILE pfile);
1223
1224 #ifdef _WIN32
1225 #ifdef OFN_READONLY
1226 BOOL WINAPI GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn);
1227 BOOL WINAPI GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn);
1228 #define GetOpenFileNamePreview WINELIB_NAME_AW(GetOpenFileNamePreview)
1229
1230 BOOL WINAPI GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn);
1231 BOOL WINAPI GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn);
1232 #define GetSaveFileNamePreview WINELIB_NAME_AW(GetSaveFileNamePreview)
1233
1234 #endif
1235 #endif
1236
1237 #define AVIERR_OK               0
1238 #define MAKE_AVIERR(error)      MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x4000+error)
1239
1240 #define AVIERR_UNSUPPORTED      MAKE_AVIERR(101)
1241 #define AVIERR_BADFORMAT        MAKE_AVIERR(102)
1242 #define AVIERR_MEMORY           MAKE_AVIERR(103)
1243 #define AVIERR_INTERNAL         MAKE_AVIERR(104)
1244 #define AVIERR_BADFLAGS         MAKE_AVIERR(105)
1245 #define AVIERR_BADPARAM         MAKE_AVIERR(106)
1246 #define AVIERR_BADSIZE          MAKE_AVIERR(107)
1247 #define AVIERR_BADHANDLE        MAKE_AVIERR(108)
1248 #define AVIERR_FILEREAD         MAKE_AVIERR(109)
1249 #define AVIERR_FILEWRITE        MAKE_AVIERR(110)
1250 #define AVIERR_FILEOPEN         MAKE_AVIERR(111)
1251 #define AVIERR_COMPRESSOR       MAKE_AVIERR(112)
1252 #define AVIERR_NOCOMPRESSOR     MAKE_AVIERR(113)
1253 #define AVIERR_READONLY         MAKE_AVIERR(114)
1254 #define AVIERR_NODATA           MAKE_AVIERR(115)
1255 #define AVIERR_BUFFERTOOSMALL   MAKE_AVIERR(116)
1256 #define AVIERR_CANTCOMPRESS     MAKE_AVIERR(117)
1257 #define AVIERR_USERABORT        MAKE_AVIERR(198)
1258 #define AVIERR_ERROR            MAKE_AVIERR(199)
1259
1260 HWND        VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCSTR szFile);
1261 HWND        VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCWSTR szFile);
1262 #define     MCIWndCreate WINELIB_NAME_AW(MCIWndCreate)
1263
1264 #define MCIWNDOPENF_NEW                 0x0001
1265
1266 #define MCIWNDF_NOAUTOSIZEWINDOW        0x0001
1267 #define MCIWNDF_NOPLAYBAR               0x0002
1268 #define MCIWNDF_NOAUTOSIZEMOVIE         0x0004
1269 #define MCIWNDF_NOMENU                  0x0008
1270 #define MCIWNDF_SHOWNAME                0x0010
1271 #define MCIWNDF_SHOWPOS                 0x0020
1272 #define MCIWNDF_SHOWMODE                0x0040
1273 #define MCIWNDF_SHOWALL                 0x0070
1274
1275 #define MCIWNDF_NOTIFYMODE              0x0100
1276 #define MCIWNDF_NOTIFYPOS               0x0200
1277 #define MCIWNDF_NOTIFYSIZE              0x0400
1278 #define MCIWNDF_NOTIFYERROR             0x1000
1279 #define MCIWNDF_NOTIFYALL               0x1F00
1280
1281 #define MCIWNDF_NOTIFYANSI              0x0080
1282
1283 #define MCIWNDF_NOTIFYMEDIAA            0x0880
1284 #define MCIWNDF_NOTIFYMEDIAW            0x0800
1285 #define MCIWNDF_NOTIFYMEDIA WINELIB_NAME_AW(MCIWNDF_NOTIFYMEDIA)
1286
1287 #define MCIWNDF_RECORD                  0x2000
1288 #define MCIWNDF_NOERRORDLG              0x4000
1289 #define MCIWNDF_NOOPEN                  0x8000
1290
1291 #ifdef __cplusplus
1292 #define MCIWndSM ::SendMessage
1293 #else
1294 #define MCIWndSM SendMessage
1295 #endif
1296
1297 #define MCIWndCanPlay(hWnd)         (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_PLAY,0,0)
1298 #define MCIWndCanRecord(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_RECORD,0,0)
1299 #define MCIWndCanSave(hWnd)         (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_SAVE,0,0)
1300 #define MCIWndCanWindow(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_WINDOW,0,0)
1301 #define MCIWndCanEject(hWnd)        (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_EJECT,0,0)
1302 #define MCIWndCanConfig(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_CONFIG,0,0)
1303 #define MCIWndPaletteKick(hWnd)     (BOOL)MCIWndSM(hWnd,MCIWNDM_PALETTEKICK,0,0)
1304
1305 #define MCIWndSave(hWnd,szFile)     (LONG)MCIWndSM(hWnd,MCI_SAVE,0,(LPARAM)(LPVOID)(szFile))
1306 #define MCIWndSaveDialog(hWnd)      MCIWndSave(hWnd,-1)
1307
1308 #define MCIWndNew(hWnd,lp)          (LONG)MCIWndSM(hWnd,MCIWNDM_NEW,0,(LPARAM)(LPVOID)(lp))
1309
1310 #define MCIWndRecord(hWnd)          (LONG)MCIWndSM(hWnd,MCI_RECORD,0,0)
1311 #define MCIWndOpen(hWnd,sz,f)       (LONG)MCIWndSM(hWnd,MCIWNDM_OPEN,(WPARAM)(UINT)(f),(LPARAM)(LPVOID)(sz))
1312 #define MCIWndOpenDialog(hWnd)      MCIWndOpen(hWnd,-1,0)
1313 #define MCIWndClose(hWnd)           (LONG)MCIWndSM(hWnd,MCI_CLOSE,0,0)
1314 #define MCIWndPlay(hWnd)            (LONG)MCIWndSM(hWnd,MCI_PLAY,0,0)
1315 #define MCIWndStop(hWnd)            (LONG)MCIWndSM(hWnd,MCI_STOP,0,0)
1316 #define MCIWndPause(hWnd)           (LONG)MCIWndSM(hWnd,MCI_PAUSE,0,0)
1317 #define MCIWndResume(hWnd)          (LONG)MCIWndSM(hWnd,MCI_RESUME,0,0)
1318 #define MCIWndSeek(hWnd,lPos)       (LONG)MCIWndSM(hWnd,MCI_SEEK,0,(LPARAM)(LONG)(lPos))
1319 #define MCIWndEject(hWnd)           (LONG)MCIWndSM(hWnd,MCIWNDM_EJECT,0,0)
1320
1321 #define MCIWndHome(hWnd)            MCIWndSeek(hWnd,MCIWND_START)
1322 #define MCIWndEnd(hWnd)             MCIWndSeek(hWnd,MCIWND_END)
1323
1324 #define MCIWndGetSource(hWnd,prc)   (LONG)MCIWndSM(hWnd,MCIWNDM_GET_SOURCE,0,(LPARAM)(LPRECT)(prc))
1325 #define MCIWndPutSource(hWnd,prc)   (LONG)MCIWndSM(hWnd,MCIWNDM_PUT_SOURCE,0,(LPARAM)(LPRECT)(prc))
1326
1327 #define MCIWndGetDest(hWnd,prc)     (LONG)MCIWndSM(hWnd,MCIWNDM_GET_DEST,0,(LPARAM)(LPRECT)(prc))
1328 #define MCIWndPutDest(hWnd,prc)     (LONG)MCIWndSM(hWnd,MCIWNDM_PUT_DEST,0,(LPARAM)(LPRECT)(prc))
1329
1330 #define MCIWndPlayReverse(hWnd)     (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYREVERSE,0,0)
1331 #define MCIWndPlayFrom(hWnd,lPos)   (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYFROM,0,(LPARAM)(LONG)(lPos))
1332 #define MCIWndPlayTo(hWnd,lPos)     (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYTO,  0,(LPARAM)(LONG)(lPos))
1333 #define MCIWndPlayFromTo(hWnd,lStart,lEnd) (MCIWndSeek(hWnd,lStart),MCIWndPlayTo(hWnd,lEnd))
1334
1335 #define MCIWndGetDeviceID(hWnd)     (UINT)MCIWndSM(hWnd,MCIWNDM_GETDEVICEID,0,0)
1336 #define MCIWndGetAlias(hWnd)        (UINT)MCIWndSM(hWnd,MCIWNDM_GETALIAS,0,0)
1337 #define MCIWndGetMode(hWnd,lp,len)  (LONG)MCIWndSM(hWnd,MCIWNDM_GETMODE,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
1338 #define MCIWndGetPosition(hWnd)     (LONG)MCIWndSM(hWnd,MCIWNDM_GETPOSITION,0,0)
1339 #define MCIWndGetPositionString(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETPOSITION,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
1340 #define MCIWndGetStart(hWnd)        (LONG)MCIWndSM(hWnd,MCIWNDM_GETSTART,0,0)
1341 #define MCIWndGetLength(hWnd)       (LONG)MCIWndSM(hWnd,MCIWNDM_GETLENGTH,0,0)
1342 #define MCIWndGetEnd(hWnd)          (LONG)MCIWndSM(hWnd,MCIWNDM_GETEND,0,0)
1343
1344 #define MCIWndStep(hWnd,n)          (LONG)MCIWndSM(hWnd,MCI_STEP,0,(LPARAM)(long)(n))
1345
1346 #define MCIWndDestroy(hWnd)         (VOID)MCIWndSM(hWnd,WM_CLOSE,0,0)
1347 #define MCIWndSetZoom(hWnd,iZoom)   (VOID)MCIWndSM(hWnd,MCIWNDM_SETZOOM,0,(LPARAM)(UINT)(iZoom))
1348 #define MCIWndGetZoom(hWnd)         (UINT)MCIWndSM(hWnd,MCIWNDM_GETZOOM,0,0)
1349 #define MCIWndSetVolume(hWnd,iVol)  (LONG)MCIWndSM(hWnd,MCIWNDM_SETVOLUME,0,(LPARAM)(UINT)(iVol))
1350 #define MCIWndGetVolume(hWnd)       (LONG)MCIWndSM(hWnd,MCIWNDM_GETVOLUME,0,0)
1351 #define MCIWndSetSpeed(hWnd,iSpeed) (LONG)MCIWndSM(hWnd,MCIWNDM_SETSPEED,0,(LPARAM)(UINT)(iSpeed))
1352 #define MCIWndGetSpeed(hWnd)        (LONG)MCIWndSM(hWnd,MCIWNDM_GETSPEED,0,0)
1353 #define MCIWndSetTimeFormat(hWnd,lp) (LONG)MCIWndSM(hWnd,MCIWNDM_SETTIMEFORMAT,0,(LPARAM)(LPTSTR)(lp))
1354 #define MCIWndGetTimeFormat(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETTIMEFORMAT,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
1355 #define MCIWndValidateMedia(hWnd)   (VOID)MCIWndSM(hWnd,MCIWNDM_VALIDATEMEDIA,0,0)
1356
1357 #define MCIWndSetRepeat(hWnd,f)     (void)MCIWndSM(hWnd,MCIWNDM_SETREPEAT,0,(LPARAM)(BOOL)(f))
1358 #define MCIWndGetRepeat(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_GETREPEAT,0,0)
1359
1360 #define MCIWndUseFrames(hWnd)       MCIWndSetTimeFormat(hWnd,TEXT("frames"))
1361 #define MCIWndUseTime(hWnd)         MCIWndSetTimeFormat(hWnd,TEXT("ms"))
1362
1363 #define MCIWndSetActiveTimer(hWnd,active)                               \
1364         (VOID)MCIWndSM(hWnd,MCIWNDM_SETACTIVETIMER,                     \
1365         (WPARAM)(UINT)(active),0L)
1366 #define MCIWndSetInactiveTimer(hWnd,inactive)                           \
1367         (VOID)MCIWndSM(hWnd,MCIWNDM_SETINACTIVETIMER,                   \
1368         (WPARAM)(UINT)(inactive),0L)
1369 #define MCIWndSetTimers(hWnd,active,inactive)                           \
1370             (VOID)MCIWndSM(hWnd,MCIWNDM_SETTIMERS,(WPARAM)(UINT)(active),\
1371             (LPARAM)(UINT)(inactive))
1372 #define MCIWndGetActiveTimer(hWnd)                                      \
1373         (UINT)MCIWndSM(hWnd,MCIWNDM_GETACTIVETIMER,0,0L);
1374 #define MCIWndGetInactiveTimer(hWnd)                                    \
1375         (UINT)MCIWndSM(hWnd,MCIWNDM_GETINACTIVETIMER,0,0L);
1376
1377 #define MCIWndRealize(hWnd,fBkgnd) (LONG)MCIWndSM(hWnd,MCIWNDM_REALIZE,(WPARAM)(BOOL)(fBkgnd),0)
1378
1379 #define MCIWndSendString(hWnd,sz)  (LONG)MCIWndSM(hWnd,MCIWNDM_SENDSTRING,0,(LPARAM)(LPTSTR)(sz))
1380 #define MCIWndReturnString(hWnd,lp,len)  (LONG)MCIWndSM(hWnd,MCIWNDM_RETURNSTRING,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
1381 #define MCIWndGetError(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETERROR,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
1382
1383 #define MCIWndGetPalette(hWnd)      (HPALETTE)MCIWndSM(hWnd,MCIWNDM_GETPALETTE,0,0)
1384 #define MCIWndSetPalette(hWnd,hpal) (LONG)MCIWndSM(hWnd,MCIWNDM_SETPALETTE,(WPARAM)(HPALETTE)(hpal),0)
1385
1386 #define MCIWndGetFileName(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETFILENAME,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
1387 #define MCIWndGetDevice(hWnd,lp,len)   (LONG)MCIWndSM(hWnd,MCIWNDM_GETDEVICE,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
1388
1389 #define MCIWndGetStyles(hWnd) (UINT)MCIWndSM(hWnd,MCIWNDM_GETSTYLES,0,0L)
1390 #define MCIWndChangeStyles(hWnd,mask,value) (LONG)MCIWndSM(hWnd,MCIWNDM_CHANGESTYLES,(WPARAM)(UINT)(mask),(LPARAM)(LONG)(value))
1391
1392 #define MCIWndOpenInterface(hWnd,pUnk)  (LONG)MCIWndSM(hWnd,MCIWNDM_OPENINTERFACE,0,(LPARAM)(LPUNKNOWN)(pUnk))
1393
1394 #define MCIWndSetOwner(hWnd,hWndP)  (LONG)MCIWndSM(hWnd,MCIWNDM_SETOWNER,(WPARAM)(hWndP),0)
1395
1396 #define MCIWNDM_GETDEVICEID     (WM_USER + 100)
1397 #define MCIWNDM_GETSTART        (WM_USER + 103)
1398 #define MCIWNDM_GETLENGTH       (WM_USER + 104)
1399 #define MCIWNDM_GETEND          (WM_USER + 105)
1400 #define MCIWNDM_EJECT           (WM_USER + 107)
1401 #define MCIWNDM_SETZOOM         (WM_USER + 108)
1402 #define MCIWNDM_GETZOOM         (WM_USER + 109)
1403 #define MCIWNDM_SETVOLUME       (WM_USER + 110)
1404 #define MCIWNDM_GETVOLUME       (WM_USER + 111)
1405 #define MCIWNDM_SETSPEED        (WM_USER + 112)
1406 #define MCIWNDM_GETSPEED        (WM_USER + 113)
1407 #define MCIWNDM_SETREPEAT       (WM_USER + 114)
1408 #define MCIWNDM_GETREPEAT       (WM_USER + 115)
1409 #define MCIWNDM_REALIZE         (WM_USER + 118)
1410 #define MCIWNDM_VALIDATEMEDIA   (WM_USER + 121)
1411 #define MCIWNDM_PLAYFROM        (WM_USER + 122)
1412 #define MCIWNDM_PLAYTO          (WM_USER + 123)
1413 #define MCIWNDM_GETPALETTE      (WM_USER + 126)
1414 #define MCIWNDM_SETPALETTE      (WM_USER + 127)
1415 #define MCIWNDM_SETTIMERS       (WM_USER + 129)
1416 #define MCIWNDM_SETACTIVETIMER  (WM_USER + 130)
1417 #define MCIWNDM_SETINACTIVETIMER (WM_USER + 131)
1418 #define MCIWNDM_GETACTIVETIMER  (WM_USER + 132)
1419 #define MCIWNDM_GETINACTIVETIMER (WM_USER + 133)
1420 #define MCIWNDM_CHANGESTYLES    (WM_USER + 135)
1421 #define MCIWNDM_GETSTYLES       (WM_USER + 136)
1422 #define MCIWNDM_GETALIAS        (WM_USER + 137)
1423 #define MCIWNDM_PLAYREVERSE     (WM_USER + 139)
1424 #define MCIWNDM_GET_SOURCE      (WM_USER + 140)
1425 #define MCIWNDM_PUT_SOURCE      (WM_USER + 141)
1426 #define MCIWNDM_GET_DEST        (WM_USER + 142)
1427 #define MCIWNDM_PUT_DEST        (WM_USER + 143)
1428 #define MCIWNDM_CAN_PLAY        (WM_USER + 144)
1429 #define MCIWNDM_CAN_WINDOW      (WM_USER + 145)
1430 #define MCIWNDM_CAN_RECORD      (WM_USER + 146)
1431 #define MCIWNDM_CAN_SAVE        (WM_USER + 147)
1432 #define MCIWNDM_CAN_EJECT       (WM_USER + 148)
1433 #define MCIWNDM_CAN_CONFIG      (WM_USER + 149)
1434 #define MCIWNDM_PALETTEKICK     (WM_USER + 150)
1435 #define MCIWNDM_OPENINTERFACE   (WM_USER + 151)
1436 #define MCIWNDM_SETOWNER        (WM_USER + 152)
1437
1438 #define MCIWNDM_SENDSTRINGA     (WM_USER + 101)
1439 #define MCIWNDM_GETPOSITIONA    (WM_USER + 102)
1440 #define MCIWNDM_GETMODEA        (WM_USER + 106)
1441 #define MCIWNDM_SETTIMEFORMATA  (WM_USER + 119)
1442 #define MCIWNDM_GETTIMEFORMATA  (WM_USER + 120)
1443 #define MCIWNDM_GETFILENAMEA    (WM_USER + 124)
1444 #define MCIWNDM_GETDEVICEA      (WM_USER + 125)
1445 #define MCIWNDM_GETERRORA       (WM_USER + 128)
1446 #define MCIWNDM_NEWA            (WM_USER + 134)
1447 #define MCIWNDM_RETURNSTRINGA   (WM_USER + 138)
1448 #define MCIWNDM_OPENA           (WM_USER + 153)
1449
1450 #define MCIWNDM_SENDSTRINGW     (WM_USER + 201)
1451 #define MCIWNDM_GETPOSITIONW    (WM_USER + 202)
1452 #define MCIWNDM_GETMODEW        (WM_USER + 206)
1453 #define MCIWNDM_SETTIMEFORMATW  (WM_USER + 219)
1454 #define MCIWNDM_GETTIMEFORMATW  (WM_USER + 220)
1455 #define MCIWNDM_GETFILENAMEW    (WM_USER + 224)
1456 #define MCIWNDM_GETDEVICEW      (WM_USER + 225)
1457 #define MCIWNDM_GETERRORW       (WM_USER + 228)
1458 #define MCIWNDM_NEWW            (WM_USER + 234)
1459 #define MCIWNDM_RETURNSTRINGW   (WM_USER + 238)
1460 #define MCIWNDM_OPENW           (WM_USER + 252)
1461
1462 #define MCIWNDM_SENDSTRING      WINELIB_NAME_AW(MCIWNDM_SENDSTRING)
1463 #define MCIWNDM_GETPOSITION     WINELIB_NAME_AW(MCIWNDM_GETPOSITION)
1464 #define MCIWNDM_GETMODE         WINELIB_NAME_AW(MCIWNDM_GETMODE)
1465 #define MCIWNDM_SETTIMEFORMAT   WINELIB_NAME_AW(MCIWNDM_SETTIMEFORMAT)
1466 #define MCIWNDM_GETTIMEFORMAT   WINELIB_NAME_AW(MCIWNDM_GETTIMEFORMAT)
1467 #define MCIWNDM_GETFILENAME     WINELIB_NAME_AW(MCIWNDM_GETFILENAME)
1468 #define MCIWNDM_GETDEVICE       WINELIB_NAME_AW(MCIWNDM_GETDEVICE)
1469 #define MCIWNDM_GETERROR        WINELIB_NAME_AW(MCIWNDM_GETERROR)
1470 #define MCIWNDM_NEW             WINELIB_NAME_AW(MCIWNDM_NEW)
1471 #define MCIWNDM_RETURNSTRING    WINELIB_NAME_AW(MCIWNDM_RETURNSTRING)
1472 #define MCIWNDM_OPEN            WINELIB_NAME_AW(MCIWNDM_OPEN)
1473
1474 #define MCIWNDM_NOTIFYMODE      (WM_USER + 200)
1475 #define MCIWNDM_NOTIFYPOS       (WM_USER + 201)
1476 #define MCIWNDM_NOTIFYSIZE      (WM_USER + 202)
1477 #define MCIWNDM_NOTIFYMEDIA     (WM_USER + 203)
1478 #define MCIWNDM_NOTIFYERROR     (WM_USER + 205)
1479
1480 #define MCIWND_START                -1
1481 #define MCIWND_END                  -2
1482
1483 /********************************************
1484  * DrawDib declarations
1485  */
1486
1487 HDRAWDIB VFWAPI DrawDibOpen( void );
1488 UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground);
1489
1490 BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd, HDC hdc, INT dxDst, INT dyDst,
1491                          LPBITMAPINFOHEADER lpbi, INT dxSrc, INT dySrc, UINT wFlags);
1492
1493 BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc, INT xDst, INT yDst, INT dxDst, INT dyDst,
1494                         LPBITMAPINFOHEADER lpbi, LPVOID lpBits,
1495                         INT xSrc, INT ySrc, INT dxSrc, INT dySrc, UINT wFlags);
1496
1497 /* DrawDibDraw flags */
1498
1499 #define DDF_UPDATE                      0x0002
1500 #define DDF_SAME_HDC                    0x0004
1501 #define DDF_SAME_DRAW                   0x0008
1502 #define DDF_DONTDRAW                    0x0010
1503 #define DDF_ANIMATE                     0x0020
1504 #define DDF_BUFFER                      0x0040
1505 #define DDF_JUSTDRAWIT                  0x0080
1506 #define DDF_FULLSCREEN                  0x0100
1507 #define DDF_BACKGROUNDPAL               0x0200
1508 #define DDF_NOTKEYFRAME                 0x0400
1509 #define DDF_HURRYUP                     0x0800
1510 #define DDF_HALFTONE                    0x1000
1511
1512 #define DDF_PREROLL                     DDF_DONTDRAW
1513 #define DDF_SAME_DIB                    DDF_SAME_DRAW
1514 #define DDF_SAME_SIZE                   DDF_SAME_DRAW
1515
1516 BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal);
1517 HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd);
1518 BOOL VFWAPI DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe);
1519 LPVOID VFWAPI DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags);
1520
1521 BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate);
1522 BOOL VFWAPI DrawDibStop(HDRAWDIB hdd);
1523 #define DrawDibUpdate(hdd, hdc, x, y) \
1524         DrawDibDraw(hdd, hdc, x, y, 0, 0, NULL, NULL, 0, 0, 0, 0, DDF_UPDATE)
1525
1526 BOOL VFWAPI DrawDibEnd(HDRAWDIB hdd);
1527 BOOL VFWAPI DrawDibClose(HDRAWDIB hdd);
1528
1529 /* display profiling */
1530 #define PD_CAN_DRAW_DIB         0x0001
1531 #define PD_CAN_STRETCHDIB       0x0002
1532 #define PD_STRETCHDIB_1_1_OK    0x0004
1533 #define PD_STRETCHDIB_1_2_OK    0x0008
1534 #define PD_STRETCHDIB_1_N_OK    0x0010
1535
1536 DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi);
1537
1538 #ifdef __cplusplus
1539 }
1540 #endif  /* __cplusplus */
1541
1542 #endif /* __WINE_VFW_H */