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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef __WINE_VFW_H
  20 #define __WINE_VFW_H
  21
  22 #include <mmsystem.h>
  23 #include <mmreg.h>
  24 #include <msacm.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 /*****************************************************************************
  36  * Predeclare the interfaces
  37  */
  38 typedef struct IAVIStream *PAVISTREAM;
  39 typedef struct IAVIFile *PAVIFILE;
  40 typedef struct IGetFrame *PGETFRAME;
  41 typedef struct IAVIEditStream *PAVIEDITSTREAM;
  42
  43 /* Installable Compressor Manager */
  44
  45 #define ICVERSION 0x0104
  46
  47 DECLARE_HANDLE(HIC);
  48
  49 /* error return codes */
  50 #define ICERR_OK                0
  51 #define ICERR_DONTDRAW          1
  52 #define ICERR_NEWPALETTE        2
  53 #define ICERR_GOTOKEYFRAME      3
  54 #define ICERR_STOPDRAWING       4
  55
  56 #define ICERR_UNSUPPORTED       -1
  57 #define ICERR_BADFORMAT         -2
  58 #define ICERR_MEMORY            -3
  59 #define ICERR_INTERNAL          -4
  60 #define ICERR_BADFLAGS          -5
  61 #define ICERR_BADPARAM          -6
  62 #define ICERR_BADSIZE           -7
  63 #define ICERR_BADHANDLE         -8
  64 #define ICERR_CANTUPDATE        -9
  65 #define ICERR_ABORT             -10
  66 #define ICERR_ERROR             -100
  67 #define ICERR_BADBITDEPTH       -200
  68 #define ICERR_BADIMAGESIZE      -201
  69
  70 #define ICERR_CUSTOM            -400
  71
  72 /* ICM Messages */
  73 #define ICM_USER                (DRV_USER+0x0000)
  74
  75 /* ICM driver message range */
  76 #define ICM_RESERVED_LOW        (DRV_USER+0x1000)
  77 #define ICM_RESERVED_HIGH       (DRV_USER+0x2000)
  78 #define ICM_RESERVED            ICM_RESERVED_LOW
  79
  80 #define ICM_GETSTATE            (ICM_RESERVED+0)
  81 #define ICM_SETSTATE            (ICM_RESERVED+1)
  82 #define ICM_GETINFO             (ICM_RESERVED+2)
  83
  84 #define ICM_CONFIGURE           (ICM_RESERVED+10)
  85 #define ICM_ABOUT               (ICM_RESERVED+11)
  86 /* */
  87
  88 #define ICM_GETDEFAULTQUALITY   (ICM_RESERVED+30)
  89 #define ICM_GETQUALITY          (ICM_RESERVED+31)
  90 #define ICM_SETQUALITY          (ICM_RESERVED+32)
  91
  92 #define ICM_SET                 (ICM_RESERVED+40)
  93 #define ICM_GET                 (ICM_RESERVED+41)
  94
  95 /* 2 constant FOURCC codes */
  96 #define ICM_FRAMERATE           mmioFOURCC('F','r','m','R')
  97 #define ICM_KEYFRAMERATE        mmioFOURCC('K','e','y','R')
  98
  99 #define ICM_COMPRESS_GET_FORMAT         (ICM_USER+4)
 100 #define ICM_COMPRESS_GET_SIZE           (ICM_USER+5)
 101 #define ICM_COMPRESS_QUERY              (ICM_USER+6)
 102 #define ICM_COMPRESS_BEGIN              (ICM_USER+7)
 103 #define ICM_COMPRESS                    (ICM_USER+8)
 104 #define ICM_COMPRESS_END                (ICM_USER+9)
 105
 106 #define ICM_DECOMPRESS_GET_FORMAT       (ICM_USER+10)
 107 #define ICM_DECOMPRESS_QUERY            (ICM_USER+11)
 108 #define ICM_DECOMPRESS_BEGIN            (ICM_USER+12)
 109 #define ICM_DECOMPRESS                  (ICM_USER+13)
 110 #define ICM_DECOMPRESS_END              (ICM_USER+14)
 111 #define ICM_DECOMPRESS_SET_PALETTE      (ICM_USER+29)
 112 #define ICM_DECOMPRESS_GET_PALETTE      (ICM_USER+30)
 113
 114 #define ICM_DRAW_QUERY                  (ICM_USER+31)
 115 #define ICM_DRAW_BEGIN                  (ICM_USER+15)
 116 #define ICM_DRAW_GET_PALETTE            (ICM_USER+16)
 117 #define ICM_DRAW_START                  (ICM_USER+18)
 118 #define ICM_DRAW_STOP                   (ICM_USER+19)
 119 #define ICM_DRAW_END                    (ICM_USER+21)
 120 #define ICM_DRAW_GETTIME                (ICM_USER+32)
 121 #define ICM_DRAW                        (ICM_USER+33)
 122 #define ICM_DRAW_WINDOW                 (ICM_USER+34)
 123 #define ICM_DRAW_SETTIME                (ICM_USER+35)
 124 #define ICM_DRAW_REALIZE                (ICM_USER+36)
 125 #define ICM_DRAW_FLUSH                  (ICM_USER+37)
 126 #define ICM_DRAW_RENDERBUFFER           (ICM_USER+38)
 127
 128 #define ICM_DRAW_START_PLAY             (ICM_USER+39)
 129 #define ICM_DRAW_STOP_PLAY              (ICM_USER+40)
 130
 131 #define ICM_DRAW_SUGGESTFORMAT          (ICM_USER+50)
 132 #define ICM_DRAW_CHANGEPALETTE          (ICM_USER+51)
 133
 134 #define ICM_GETBUFFERSWANTED            (ICM_USER+41)
 135
 136 #define ICM_GETDEFAULTKEYFRAMERATE      (ICM_USER+42)
 137
 138 #define ICM_DECOMPRESSEX_BEGIN          (ICM_USER+60)
 139 #define ICM_DECOMPRESSEX_QUERY          (ICM_USER+61)
 140 #define ICM_DECOMPRESSEX                (ICM_USER+62)
 141 #define ICM_DECOMPRESSEX_END            (ICM_USER+63)
 142
 143 #define ICM_COMPRESS_FRAMES_INFO        (ICM_USER+70)
 144 #define ICM_SET_STATUS_PROC             (ICM_USER+72)
 145
 146 #ifndef comptypeDIB
 147 #define comptypeDIB  mmioFOURCC('D','I','B',' ')
 148 #endif
 149
 150 /* structs */
 151
 152 /* NOTE: Only the 16 bit structs are packed. Structs that are packed anyway
 153  * have not been changed. If a structure is later extended, you may need to create
 154  * two versions of it.
 155  */
 156
 157 typedef struct {
 158         DWORD   dwSize;         /* 00: size */
 159         DWORD   fccType;        /* 04: type 'vidc' usually */
 160         DWORD   fccHandler;     /* 08: */
 161         DWORD   dwVersion;      /* 0c: version of compman opening you */
 162         DWORD   dwFlags;        /* 10: LOWORD is type specific */
 163         LRESULT dwError;        /* 14: */
 164         LPVOID  pV1Reserved;    /* 18: */
 165         LPVOID  pV2Reserved;    /* 1c: */
 166         DWORD   dnDevNode;      /* 20: */
 167                                 /* 24: */
 168 } ICOPEN,*LPICOPEN;
 169
 170 #define ICCOMPRESS_KEYFRAME     0x00000001L
 171
 172 typedef struct {
 173     DWORD               dwFlags;
 174     LPBITMAPINFOHEADER  lpbiOutput;
 175     LPVOID              lpOutput;
 176     LPBITMAPINFOHEADER  lpbiInput;
 177     LPVOID              lpInput;
 178     LPDWORD             lpckid;
 179     LPDWORD             lpdwFlags;
 180     LONG                lFrameNum;
 181     DWORD               dwFrameSize;
 182     DWORD               dwQuality;
 183     LPBITMAPINFOHEADER  lpbiPrev;
 184     LPVOID              lpPrev;
 185 } ICCOMPRESS;
 186
 187 DWORD VFWAPIV ICCompress(
 188         HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
 189         LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
 190         LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
 191         LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
 192 );
 193
 194 #define ICCompressGetFormat(hic, lpbiInput, lpbiOutput)                 \
 195         ICSendMessage(                                                  \
 196             hic,ICM_COMPRESS_GET_FORMAT,(DWORD_PTR)(LPVOID)(lpbiInput), \
 197             (DWORD_PTR)(LPVOID)(lpbiOutput)                                     \
 198         )
 199
 200 #define ICCompressGetFormatSize(hic,lpbi) ICCompressGetFormat(hic,lpbi,NULL)
 201
 202 #define ICCompressBegin(hic, lpbiInput, lpbiOutput)                     \
 203     ICSendMessage(                                                      \
 204         hic, ICM_COMPRESS_BEGIN, (DWORD_PTR)(LPVOID)(lpbiInput),                \
 205         (DWORD_PTR)(LPVOID)(lpbiOutput)                                 \
 206     )
 207
 208 #define ICCompressGetSize(hic, lpbiInput, lpbiOutput)                   \
 209     ICSendMessage(                                                      \
 210         hic, ICM_COMPRESS_GET_SIZE, (DWORD_PTR)(LPVOID)(lpbiInput),     \
 211         (DWORD_PTR)(LPVOID)(lpbiOutput)                                 \
 212     )
 213
 214 #define ICCompressQuery(hic, lpbiInput, lpbiOutput)             \
 215     ICSendMessage(                                              \
 216         hic, ICM_COMPRESS_QUERY, (DWORD_PTR)(LPVOID)(lpbiInput),        \
 217         (DWORD_PTR)(LPVOID)(lpbiOutput)                         \
 218     )
 219
 220 #define ICCompressEnd(hic) ICSendMessage(hic, ICM_COMPRESS_END, 0, 0)
 221
 222 /* ICCOMPRESSFRAMES.dwFlags */
 223 #define ICCOMPRESSFRAMES_PADDING        0x00000001
 224 typedef struct {
 225     DWORD               dwFlags;
 226     LPBITMAPINFOHEADER  lpbiOutput;
 227     LPARAM              lOutput;
 228     LPBITMAPINFOHEADER  lpbiInput;
 229     LPARAM              lInput;
 230     LONG                lStartFrame;
 231     LONG                lFrameCount;
 232     LONG                lQuality;
 233     LONG                lDataRate;
 234     LONG                lKeyRate;
 235     DWORD               dwRate;
 236     DWORD               dwScale;
 237     DWORD               dwOverheadPerFrame;
 238     DWORD               dwReserved2;
 239     LONG (CALLBACK *GetData)(LPARAM lInput,LONG lFrame,LPVOID lpBits,LONG len);
 240     LONG (CALLBACK *PutData)(LPARAM lOutput,LONG lFrame,LPVOID lpBits,LONG len);
 241 } ICCOMPRESSFRAMES;
 242
 243 typedef struct {
 244     DWORD               dwFlags;
 245     LPARAM              lParam;
 246    /* messages for Status callback */
 247 #define ICSTATUS_START      0
 248 #define ICSTATUS_STATUS     1
 249 #define ICSTATUS_END        2
 250 #define ICSTATUS_ERROR      3
 251 #define ICSTATUS_YIELD      4
 252     /* FIXME: some X11 libs define Status as int... */
 253     /* LONG (CALLBACK *zStatus)(LPARAM lParam, UINT message, LONG l); */
 254     LONG (CALLBACK *zStatus)(LPARAM lParam, UINT message, LONG l);
 255 } ICSETSTATUSPROC;
 256
 257 /* Values for wMode of ICOpen() */
 258 #define ICMODE_COMPRESS         1
 259 #define ICMODE_DECOMPRESS       2
 260 #define ICMODE_FASTDECOMPRESS   3
 261 #define ICMODE_QUERY            4
 262 #define ICMODE_FASTCOMPRESS     5
 263 #define ICMODE_DRAW             8
 264
 265 /* quality flags */
 266 #define ICQUALITY_LOW       0
 267 #define ICQUALITY_HIGH      10000
 268 #define ICQUALITY_DEFAULT   -1
 269
 270 typedef struct {
 271         DWORD   dwSize;         /* 00: */
 272         DWORD   fccType;        /* 04:compressor type     'vidc' 'audc' */
 273         DWORD   fccHandler;     /* 08:compressor sub-type 'rle ' 'jpeg' 'pcm '*/
 274         DWORD   dwFlags;        /* 0c:flags LOWORD is type specific */
 275         DWORD   dwVersion;      /* 10:version of the driver */
 276         DWORD   dwVersionICM;   /* 14:version of the ICM used */
 277         /*
 278          * under Win32, the driver always returns UNICODE strings.
 279          */
 280         WCHAR   szName[16];             /* 18:short name */
 281         WCHAR   szDescription[128];     /* 38:long name */
 282         WCHAR   szDriver[128];          /* 138:driver that contains compressor*/
 283                                         /* 238: */
 284 } ICINFO;
 285
 286 /* ICINFO.dwFlags */
 287 #define VIDCF_QUALITY           0x0001  /* supports quality */
 288 #define VIDCF_CRUNCH            0x0002  /* supports crunching to a frame size */
 289 #define VIDCF_TEMPORAL          0x0004  /* supports inter-frame compress */
 290 #define VIDCF_COMPRESSFRAMES    0x0008  /* wants the compress all frames message */
 291 #define VIDCF_DRAW              0x0010  /* supports drawing */
 292 #define VIDCF_FASTTEMPORALC     0x0020  /* does not need prev frame on compress */
 293 #define VIDCF_FASTTEMPORALD     0x0080  /* does not need prev frame on decompress */
 294 #define VIDCF_QUALITYTIME       0x0040  /* supports temporal quality */
 295
 296 #define VIDCF_FASTTEMPORAL      (VIDCF_FASTTEMPORALC|VIDCF_FASTTEMPORALD)
 297
 298
 299 /* function shortcuts */
 300 /* ICM_ABOUT */
 301 #define ICMF_ABOUT_QUERY         0x00000001
 302
 303 #define ICQueryAbout(hic) \
 304         (ICSendMessage(hic,ICM_ABOUT,(DWORD_PTR)-1,ICMF_ABOUT_QUERY)==ICERR_OK)
 305
 306 #define ICAbout(hic, hwnd) ICSendMessage(hic,ICM_ABOUT,(DWORD_PTR)(UINT_PTR)(hwnd),0)
 307
 308 /* ICM_CONFIGURE */
 309 #define ICMF_CONFIGURE_QUERY    0x00000001
 310 #define ICQueryConfigure(hic) \
 311         (ICSendMessage(hic,ICM_CONFIGURE,(DWORD_PTR)-1,ICMF_CONFIGURE_QUERY)==ICERR_OK)
 312
 313 #define ICConfigure(hic,hwnd) \
 314         ICSendMessage(hic,ICM_CONFIGURE,(DWORD_PTR)(UINT_PTR)(hwnd),0)
 315
 316 /* Decompression stuff */
 317 #define ICDECOMPRESS_HURRYUP            0x80000000      /* don't draw just buffer (hurry up!) */
 318 #define ICDECOMPRESS_UPDATE             0x40000000      /* don't draw just update screen */
 319 #define ICDECOMPRESS_PREROLL            0x20000000      /* this frame is before real start */
 320 #define ICDECOMPRESS_NULLFRAME          0x10000000      /* repeat last frame */
 321 #define ICDECOMPRESS_NOTKEYFRAME        0x08000000      /* this frame is not a key frame */
 322
 323 typedef struct {
 324     DWORD               dwFlags;        /* flags (from AVI index...) */
 325     LPBITMAPINFOHEADER  lpbiInput;      /* BITMAPINFO of compressed data */
 326     LPVOID              lpInput;        /* compressed data */
 327     LPBITMAPINFOHEADER  lpbiOutput;     /* DIB to decompress to */
 328     LPVOID              lpOutput;
 329     DWORD               ckid;           /* ckid from AVI file */
 330 } ICDECOMPRESS;
 331
 332 typedef struct {
 333     DWORD               dwFlags;
 334     LPBITMAPINFOHEADER  lpbiSrc;
 335     LPVOID              lpSrc;
 336     LPBITMAPINFOHEADER  lpbiDst;
 337     LPVOID              lpDst;
 338
 339     /* changed for ICM_DECOMPRESSEX */
 340     INT                 xDst;       /* destination rectangle */
 341     INT                 yDst;
 342     INT                 dxDst;
 343     INT                 dyDst;
 344
 345     INT                 xSrc;       /* source rectangle */
 346     INT                 ySrc;
 347     INT                 dxSrc;
 348     INT                 dySrc;
 349 } ICDECOMPRESSEX;
 350
 351 DWORD VFWAPIV ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits);
 352
 353 #define ICDecompressBegin(hic, lpbiInput, lpbiOutput)   \
 354     ICSendMessage(                                              \
 355         hic, ICM_DECOMPRESS_BEGIN, (DWORD_PTR)(LPVOID)(lpbiInput),      \
 356         (DWORD_PTR)(LPVOID)(lpbiOutput)                         \
 357     )
 358
 359 #define ICDecompressQuery(hic, lpbiInput, lpbiOutput)   \
 360     ICSendMessage(                                              \
 361         hic,ICM_DECOMPRESS_QUERY, (DWORD_PTR)(LPVOID)(lpbiInput),       \
 362         (DWORD_PTR) (LPVOID)(lpbiOutput)                                \
 363     )
 364
 365 #define ICDecompressGetFormat(hic, lpbiInput, lpbiOutput)               \
 366     ((LONG)ICSendMessage(                                               \
 367         hic,ICM_DECOMPRESS_GET_FORMAT, (DWORD_PTR)(LPVOID)(lpbiInput),  \
 368         (DWORD_PTR)(LPVOID)(lpbiOutput)                                 \
 369     ))
 370
 371 #define ICDecompressGetFormatSize(hic, lpbi)                            \
 372         ICDecompressGetFormat(hic, lpbi, NULL)
 373
 374 #define ICDecompressGetPalette(hic, lpbiInput, lpbiOutput)              \
 375     ICSendMessage(                                                      \
 376         hic, ICM_DECOMPRESS_GET_PALETTE, (DWORD_PTR)(LPVOID)(lpbiInput),        \
 377         (DWORD_PTR)(LPVOID)(lpbiOutput)                                 \
 378     )
 379
 380 #define ICDecompressSetPalette(hic,lpbiPalette) \
 381         ICSendMessage(                          \
 382                 hic,ICM_DECOMPRESS_SET_PALETTE,         \
 383                 (DWORD_PTR)(LPVOID)(lpbiPalette),0              \
 384         )
 385
 386 #define ICDecompressEnd(hic) ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0)
 387
 388 LRESULT VFWAPI  ICSendMessage(HIC hic, UINT msg, DWORD_PTR dw1, DWORD_PTR dw2);
 389
 390 static inline LRESULT VFWAPI ICDecompressEx(HIC hic, DWORD dwFlags,
 391                                             LPBITMAPINFOHEADER lpbiSrc, LPVOID lpSrc,
 392                                             int xSrc, int ySrc, int dxSrc, int dySrc,
 393                                             LPBITMAPINFOHEADER lpbiDst, LPVOID lpDst,
 394                                             int xDst, int yDst, int dxDst, int dyDst)
 395 {
 396     ICDECOMPRESSEX ic;
 397
 398     ic.dwFlags = dwFlags;
 399     ic.lpbiSrc = lpbiSrc;
 400     ic.lpSrc = lpSrc;
 401     ic.xSrc = xSrc;
 402     ic.ySrc = ySrc;
 403     ic.dxSrc = dxSrc;
 404     ic.dySrc = dySrc;
 405     ic.lpbiDst = lpbiDst;
 406     ic.lpDst = lpDst;
 407     ic.xDst = xDst;
 408     ic.yDst = yDst;
 409     ic.dxDst = dxDst;
 410     ic.dyDst = dyDst;
 411     return ICSendMessage(hic, ICM_DECOMPRESSEX, (DWORD_PTR)&ic, sizeof(ic));
 412 }
 413
 414 static inline LRESULT VFWAPI ICDecompressExBegin(HIC hic, DWORD dwFlags,
 415                                                  LPBITMAPINFOHEADER lpbiSrc,
 416                                                  LPVOID lpSrc,
 417                                                  int xSrc, int ySrc, int dxSrc, int dySrc,
 418                                                  LPBITMAPINFOHEADER lpbiDst,
 419                                                  LPVOID lpDst,
 420                                                  int xDst,
 421                                                  int yDst,
 422                                                  int dxDst,
 423                                                  int dyDst)
 424 {
 425     ICDECOMPRESSEX ic;
 426
 427     ic.dwFlags = dwFlags;
 428     ic.lpbiSrc = lpbiSrc;
 429     ic.lpSrc = lpSrc;
 430     ic.xSrc = xSrc;
 431     ic.ySrc = ySrc;
 432     ic.dxSrc = dxSrc;
 433     ic.dySrc = dySrc;
 434     ic.lpbiDst = lpbiDst;
 435     ic.lpDst = lpDst;
 436     ic.xDst = xDst;
 437     ic.yDst = yDst;
 438     ic.dxDst = dxDst;
 439     ic.dyDst = dyDst;
 440     return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, (DWORD_PTR)&ic, sizeof(ic));
 441 }
 442 static inline LRESULT VFWAPI ICDecompressExQuery(HIC hic, DWORD dwFlags,
 443                                                  LPBITMAPINFOHEADER lpbiSrc,
 444                                                  LPVOID lpSrc,
 445                                                  int xSrc, int ySrc, int dxSrc, int dySrc,
 446                                                  LPBITMAPINFOHEADER lpbiDst,
 447                                                  LPVOID lpDst,
 448                                                  int xDst,
 449                                                  int yDst,
 450                                                  int dxDst,
 451                                                  int dyDst)
 452 {
 453     ICDECOMPRESSEX ic;
 454
 455     ic.dwFlags = dwFlags;
 456     ic.lpbiSrc = lpbiSrc;
 457     ic.lpSrc = lpSrc;
 458     ic.xSrc = xSrc;
 459     ic.ySrc = ySrc;
 460     ic.dxSrc = dxSrc;
 461     ic.dySrc = dySrc;
 462     ic.lpbiDst = lpbiDst;
 463     ic.lpDst = lpDst;
 464     ic.xDst = xDst;
 465     ic.yDst = yDst;
 466     ic.dxDst = dxDst;
 467     ic.dyDst = dyDst;
 468     return ICSendMessage(hic, ICM_DECOMPRESSEX_QUERY, (DWORD_PTR)&ic, sizeof(ic));
 469 }
 470
 471 #define ICDecompressExEnd(hic) \
 472     ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0)
 473
 474 #define ICDRAW_QUERY        0x00000001L   /* test for support */
 475 #define ICDRAW_FULLSCREEN   0x00000002L   /* draw to full screen */
 476 #define ICDRAW_HDC          0x00000004L   /* draw to a HDC/HWND */
 477 #define ICDRAW_ANIMATE      0x00000008L   /* expect palette animation */
 478 #define ICDRAW_CONTINUE     0x00000010L   /* draw is a continuation of previous draw */
 479 #define ICDRAW_MEMORYDC     0x00000020L   /* DC is offscreen, by the way */
 480 #define ICDRAW_UPDATING     0x00000040L   /* We're updating, as opposed to playing */
 481 #define ICDRAW_RENDER       0x00000080L   /* used to render data not draw it */
 482 #define ICDRAW_BUFFER       0x00000100L   /* buffer data offscreen, we will need to update it */
 483
 484 #define ICDecompressOpen(fccType, fccHandler, lpbiIn, lpbiOut) \
 485     ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS)
 486
 487 #define ICDrawOpen(fccType, fccHandler, lpbiIn) \
 488     ICLocate(fccType, fccHandler, lpbiIn, NULL, ICMODE_DRAW)
 489
 490 HANDLE VFWAPI ICImageCompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn,
 491                               LPVOID lpBits, LPBITMAPINFO lpbiOut, LONG lQuality,
 492                               LONG* plSize);
 493
 494 HANDLE VFWAPI ICImageDecompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn,
 495                                 LPVOID lpBits, LPBITMAPINFO lpbiOut);
 496
 497 BOOL    VFWAPI  ICInfo(DWORD fccType, DWORD fccHandler, ICINFO * lpicinfo);
 498 BOOL    VFWAPI  ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags);
 499 BOOL    VFWAPI  ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags);
 500 LRESULT VFWAPI  ICGetInfo(HIC hic,ICINFO *picinfo, DWORD cb);
 501 HIC     VFWAPI  ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode);
 502 HIC     VFWAPI  ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler);
 503
 504 LRESULT VFWAPI  ICClose(HIC hic);
 505 HIC     VFWAPI  ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
 506 HIC     VFWAPI  ICGetDisplayFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, int BitDepth, int dx, int dy);
 507
 508 /* Values for wFlags of ICInstall() */
 509 #define ICINSTALL_UNICODE       0x8000
 510 #define ICINSTALL_FUNCTION      0x0001
 511 #define ICINSTALL_DRIVER        0x0002
 512 #define ICINSTALL_HDRV          0x0004
 513 #define ICINSTALL_DRIVERW       0x8002
 514
 515 #define ICGetState(hic, pv, cb) \
 516     ICSendMessage(hic, ICM_GETSTATE, (DWORD_PTR)(LPVOID)(pv), (DWORD_PTR)(cb))
 517 #define ICSetState(hic, pv, cb) \
 518     ICSendMessage(hic, ICM_SETSTATE, (DWORD_PTR)(LPVOID)(pv), (DWORD_PTR)(cb))
 519 #define ICGetStateSize(hic) \
 520     ICGetState(hic, NULL, 0)
 521
 522 static inline DWORD ICGetDefaultQuality(HIC hic)
 523 {
 524    DWORD dwICValue;
 525    ICSendMessage(hic, ICM_GETDEFAULTQUALITY, (DWORD_PTR)(LPVOID)&dwICValue, sizeof(DWORD));
 526    return dwICValue;
 527 }
 528
 529 static inline DWORD ICGetDefaultKeyFrameRate(HIC hic)
 530 {
 531    DWORD dwICValue;
 532    ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, (DWORD_PTR)(LPVOID)&dwICValue, sizeof(DWORD));
 533    return dwICValue;
 534 }
 535
 536 #define ICDrawWindow(hic, prc) \
 537     ICSendMessage(hic, ICM_DRAW_WINDOW, (DWORD_PTR)(LPVOID)(prc), sizeof(RECT))
 538
 539 /* As passed to ICM_DRAW_SUGGESTFORMAT */
 540 typedef struct {
 541         DWORD dwFlags;
 542         LPBITMAPINFOHEADER lpbiIn;
 543         LPBITMAPINFOHEADER lpbiSuggest;
 544         INT dxSrc;
 545         INT dySrc;
 546         INT dxDst;
 547         INT dyDst;
 548         HIC hicDecompressor;
 549 } ICDRAWSUGGEST;
 550
 551 typedef struct {
 552     DWORD               dwFlags;
 553     int                 iStart;
 554     int                 iLen;
 555     LPPALETTEENTRY      lppe;
 556 } ICPALETTE;
 557
 558 DWORD   VFWAPIV ICDrawBegin(
 559         HIC                     hic,
 560         DWORD                   dwFlags,/* flags */
 561         HPALETTE                hpal,   /* palette to draw with */
 562         HWND                    hwnd,   /* window to draw to */
 563         HDC                     hdc,    /* HDC to draw to */
 564         INT                     xDst,   /* destination rectangle */
 565         INT                     yDst,
 566         INT                     dxDst,
 567         INT                     dyDst,
 568         LPBITMAPINFOHEADER      lpbi,   /* format of frame to draw */
 569         INT                     xSrc,   /* source rectangle */
 570         INT                     ySrc,
 571         INT                     dxSrc,
 572         INT                     dySrc,
 573         DWORD                   dwRate, /* frames/second = (dwRate/dwScale) */
 574         DWORD                   dwScale
 575 );
 576
 577 /* as passed to ICM_DRAW_BEGIN */
 578 typedef struct {
 579         DWORD           dwFlags;
 580         HPALETTE        hpal;
 581         HWND            hwnd;
 582         HDC             hdc;
 583         INT             xDst;
 584         INT             yDst;
 585         INT             dxDst;
 586         INT             dyDst;
 587         LPBITMAPINFOHEADER      lpbi;
 588         INT             xSrc;
 589         INT             ySrc;
 590         INT             dxSrc;
 591         INT             dySrc;
 592         DWORD           dwRate;
 593         DWORD           dwScale;
 594 } ICDRAWBEGIN;
 595
 596 #define ICDRAW_HURRYUP      0x80000000L   /* don't draw just buffer (hurry up!) */
 597 #define ICDRAW_UPDATE       0x40000000L   /* don't draw just update screen */
 598 #define ICDRAW_PREROLL      0x20000000L   /* this frame is before real start */
 599 #define ICDRAW_NULLFRAME    0x10000000L   /* repeat last frame */
 600 #define ICDRAW_NOTKEYFRAME  0x08000000L   /* this frame is not a key frame */
 601
 602 typedef struct {
 603         DWORD   dwFlags;
 604         LPVOID  lpFormat;
 605         LPVOID  lpData;
 606         DWORD   cbData;
 607         LONG    lTime;
 608 } ICDRAW;
 609
 610 DWORD VFWAPIV ICDraw(HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,LONG lTime);
 611
 612 static inline LRESULT VFWAPI ICDrawSuggestFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn,
 613                                                  LPBITMAPINFOHEADER lpbiOut,
 614                                                  int dxSrc, int dySrc,
 615                                                  int dxDst, int dyDst,
 616                                                  HIC hicDecomp)
 617 {
 618     ICDRAWSUGGEST ic;
 619
 620     ic.lpbiIn = lpbiIn;
 621     ic.lpbiSuggest = lpbiOut;
 622     ic.dxSrc = dxSrc;
 623     ic.dySrc = dySrc;
 624     ic.dxDst = dxDst;
 625     ic.dyDst = dyDst;
 626     ic.hicDecompressor = hicDecomp;
 627     return ICSendMessage(hic, ICM_DRAW_SUGGESTFORMAT, (DWORD_PTR)&ic, sizeof(ic));
 628 }
 629
 630 #define ICDrawQuery(hic, lpbiInput) \
 631     ICSendMessage(hic, ICM_DRAW_QUERY, (DWORD_PTR)(LPVOID)(lpbiInput), 0L)
 632
 633 #define ICDrawChangePalette(hic, lpbiInput) \
 634     ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, (DWORD_PTR)(LPVOID)(lpbiInput), 0L)
 635
 636 #define ICGetBuffersWanted(hic, lpdwBuffers) \
 637     ICSendMessage(hic, ICM_GETBUFFERSWANTED, (DWORD_PTR)(LPVOID)(lpdwBuffers), 0)
 638
 639 #define ICDrawEnd(hic) \
 640     ICSendMessage(hic, ICM_DRAW_END, 0, 0)
 641
 642 #define ICDrawStart(hic) \
 643     ICSendMessage(hic, ICM_DRAW_START, 0, 0)
 644
 645 #define ICDrawStartPlay(hic, lFrom, lTo) \
 646     ICSendMessage(hic, ICM_DRAW_START_PLAY, (DWORD_PTR)(lFrom), (DWORD_PTR)(lTo))
 647
 648 #define ICDrawStop(hic) \
 649     ICSendMessage(hic, ICM_DRAW_STOP, 0, 0)
 650
 651 #define ICDrawStopPlay(hic) \
 652     ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0)
 653
 654 #define ICDrawGetTime(hic, lplTime) \
 655     ICSendMessage(hic, ICM_DRAW_GETTIME, (DWORD_PTR)(LPVOID)(lplTime), 0)
 656
 657 #define ICDrawSetTime(hic, lTime) \
 658     ICSendMessage(hic, ICM_DRAW_SETTIME, (DWORD_PTR)lTime, 0)
 659
 660 #define ICDrawRealize(hic, hdc, fBackground) \
 661     ICSendMessage(hic, ICM_DRAW_REALIZE, (DWORD_PTR)(UINT_PTR)(HDC)(hdc), (DWORD_PTR)(BOOL)(fBackground))
 662
 663 #define ICDrawFlush(hic) \
 664     ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0)
 665
 666 #define ICDrawRenderBuffer(hic) \
 667     ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0)
 668
 669 static inline LRESULT VFWAPI ICSetStatusProc(HIC hic, DWORD dwFlags, LRESULT lParam,
 670                                              LONG (CALLBACK *fpfnStatus)(LPARAM, UINT, LONG))
 671 {
 672     ICSETSTATUSPROC ic;
 673
 674     ic.dwFlags = dwFlags;
 675     ic.lParam = lParam;
 676     /* FIXME: see comment in ICSETSTATUSPROC definition */
 677     ic.zStatus = fpfnStatus;
 678
 679     return ICSendMessage(hic, ICM_SET_STATUS_PROC, (DWORD_PTR)&ic, sizeof(ic));
 680 }
 681
 682 typedef struct {
 683     LONG                cbSize;
 684     DWORD               dwFlags;
 685     HIC                 hic;
 686     DWORD               fccType;
 687     DWORD               fccHandler;
 688     LPBITMAPINFO        lpbiIn;
 689     LPBITMAPINFO        lpbiOut;
 690     LPVOID              lpBitsOut;
 691     LPVOID              lpBitsPrev;
 692     LONG                lFrame;
 693     LONG                lKey;
 694     LONG                lDataRate;
 695     LONG                lQ;
 696     LONG                lKeyCount;
 697     LPVOID              lpState;
 698     LONG                cbState;
 699 } COMPVARS, *PCOMPVARS;
 700
 701 #define ICMF_COMPVARS_VALID     0x00000001
 702
 703 BOOL VFWAPI ICCompressorChoose(HWND hwnd, UINT uiFlags, LPVOID pvIn, LPVOID lpData,
 704                                PCOMPVARS pc, LPSTR lpszTitle);
 705
 706 #define ICMF_CHOOSE_KEYFRAME            0x0001
 707 #define ICMF_CHOOSE_DATARATE            0x0002
 708 #define ICMF_CHOOSE_PREVIEW             0x0004
 709 #define ICMF_CHOOSE_ALLCOMPRESSORS      0x0008
 710
 711 BOOL VFWAPI ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn);
 712 void VFWAPI ICSeqCompressFrameEnd(PCOMPVARS pc);
 713
 714 LPVOID VFWAPI ICSeqCompressFrame(PCOMPVARS pc, UINT uiFlags, LPVOID lpBits,
 715                                  BOOL *pfKey, LONG *plSize);
 716 void VFWAPI ICCompressorFree(PCOMPVARS pc);
 717
 718 /********************* AVIFILE function declarations *************************/
 719
 720 #ifndef mmioFOURCC
 721 #define mmioFOURCC( ch0, ch1, ch2, ch3 )                                \
 722         ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |            \
 723         ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
 724 #endif
 725
 726 #ifndef aviTWOCC
 727 #define aviTWOCC(ch0, ch1) ((WORD)(BYTE)(ch0) | ((WORD)(BYTE)(ch1) << 8))
 728 #endif
 729
 730 typedef WORD TWOCC;
 731
 732 #define ICTYPE_VIDEO            mmioFOURCC('v', 'i', 'd', 'c')
 733 #define ICTYPE_AUDIO            mmioFOURCC('a', 'u', 'd', 'c')
 734
 735 #define formtypeAVI             mmioFOURCC('A', 'V', 'I', ' ')
 736 #define listtypeAVIHEADER       mmioFOURCC('h', 'd', 'r', 'l')
 737 #define ckidAVIMAINHDR          mmioFOURCC('a', 'v', 'i', 'h')
 738 #define listtypeSTREAMHEADER    mmioFOURCC('s', 't', 'r', 'l')
 739 #define ckidSTREAMHEADER        mmioFOURCC('s', 't', 'r', 'h')
 740 #define ckidSTREAMFORMAT        mmioFOURCC('s', 't', 'r', 'f')
 741 #define ckidSTREAMHANDLERDATA   mmioFOURCC('s', 't', 'r', 'd')
 742 #define ckidSTREAMNAME          mmioFOURCC('s', 't', 'r', 'n')
 743
 744 #define listtypeAVIMOVIE        mmioFOURCC('m', 'o', 'v', 'i')
 745 #define listtypeAVIRECORD       mmioFOURCC('r', 'e', 'c', ' ')
 746
 747 #define ckidAVINEWINDEX         mmioFOURCC('i', 'd', 'x', '1')
 748
 749 #define streamtypeANY           0UL
 750 #define streamtypeVIDEO         mmioFOURCC('v', 'i', 'd', 's')
 751 #define streamtypeAUDIO         mmioFOURCC('a', 'u', 'd', 's')
 752 #define streamtypeMIDI          mmioFOURCC('m', 'i', 'd', 's')
 753 #define streamtypeTEXT          mmioFOURCC('t', 'x', 't', 's')
 754
 755 /* Basic chunk types */
 756 #define cktypeDIBbits           aviTWOCC('d', 'b')
 757 #define cktypeDIBcompressed     aviTWOCC('d', 'c')
 758 #define cktypePALchange         aviTWOCC('p', 'c')
 759 #define cktypeWAVEbytes         aviTWOCC('w', 'b')
 760
 761 /* Chunk id to use for extra chunks for padding. */
 762 #define ckidAVIPADDING          mmioFOURCC('J', 'U', 'N', 'K')
 763
 764 #define FromHex(n)              (((n) >= 'A') ? ((n) + 10 - 'A') : ((n) - '0'))
 765 #define StreamFromFOURCC(fcc)   ((WORD)((FromHex(LOBYTE(LOWORD(fcc))) << 4) + \
 766                                         (FromHex(HIBYTE(LOWORD(fcc))))))
 767 #define TWOCCFromFOURCC(fcc)    HIWORD(fcc)
 768 #define ToHex(n)                ((BYTE)(((n) > 9) ? ((n) - 10 + 'A') : ((n) + '0')))
 769 #define MAKEAVICKID(tcc, stream) \
 770                                 MAKELONG((ToHex((stream) & 0x0f) << 8) | \
 771                                          (ToHex(((stream) & 0xf0) >> 4)), tcc)
 772
 773 /* AVIFileHdr.dwFlags */
 774 #define AVIF_HASINDEX           0x00000010      /* Index at end of file? */
 775 #define AVIF_MUSTUSEINDEX       0x00000020
 776 #define AVIF_ISINTERLEAVED      0x00000100
 777 #define AVIF_TRUSTCKTYPE        0x00000800      /* Use CKType to find key frames*/
 778 #define AVIF_WASCAPTUREFILE     0x00010000
 779 #define AVIF_COPYRIGHTED        0x00020000
 780
 781 #define AVI_HEADERSIZE  2048
 782
 783 typedef BOOL (CALLBACK *AVISAVECALLBACK)(INT);
 784
 785 typedef struct _MainAVIHeader
 786 {
 787     DWORD       dwMicroSecPerFrame;
 788     DWORD       dwMaxBytesPerSec;
 789     DWORD       dwPaddingGranularity;
 790     DWORD       dwFlags;
 791     DWORD       dwTotalFrames;
 792     DWORD       dwInitialFrames;
 793     DWORD       dwStreams;
 794     DWORD       dwSuggestedBufferSize;
 795     DWORD       dwWidth;
 796     DWORD       dwHeight;
 797     DWORD       dwReserved[4];
 798 } MainAVIHeader;
 799
 800 /* AVIStreamHeader.dwFlags */
 801 #define AVISF_DISABLED                  0x00000001
 802 #define AVISF_VIDEO_PALCHANGES          0x00010000
 803
 804 typedef struct {
 805     FOURCC      fccType;
 806     FOURCC      fccHandler;
 807     DWORD       dwFlags;        /* AVISF_* */
 808     WORD        wPriority;
 809     WORD        wLanguage;
 810     DWORD       dwInitialFrames;
 811     DWORD       dwScale;
 812     DWORD       dwRate; /* dwRate / dwScale == samples/second */
 813     DWORD       dwStart;
 814     DWORD       dwLength; /* In units above... */
 815     DWORD       dwSuggestedBufferSize;
 816     DWORD       dwQuality;
 817     DWORD       dwSampleSize;
 818     struct { SHORT left, top, right, bottom; } rcFrame; /* word.word - word.word in file */
 819 } AVIStreamHeader;
 820
 821 /* AVIINDEXENTRY.dwFlags */
 822 #define AVIIF_LIST      0x00000001      /* chunk is a 'LIST' */
 823 #define AVIIF_TWOCC     0x00000002
 824 #define AVIIF_KEYFRAME  0x00000010      /* this frame is a key frame. */
 825
 826 #define AVIIF_NOTIME    0x00000100      /* this frame doesn't take any time */
 827 #define AVIIF_COMPUSE   0x0FFF0000
 828
 829 typedef struct _AVIINDEXENTRY {
 830     DWORD       ckid;
 831     DWORD       dwFlags;
 832     DWORD       dwChunkOffset;
 833     DWORD       dwChunkLength;
 834 } AVIINDEXENTRY;
 835
 836 typedef struct _AVIPALCHANGE {
 837     BYTE                bFirstEntry;
 838     BYTE                bNumEntries;
 839     WORD                wFlags;         /* pad */
 840     PALETTEENTRY        peNew[1];
 841 } AVIPALCHANGE;
 842
 843 #define AVIIF_KEYFRAME  0x00000010      /* this frame is a key frame. */
 844
 845 #define AVIGETFRAMEF_BESTDISPLAYFMT     1
 846
 847 typedef struct _AVISTREAMINFOA {
 848     DWORD       fccType;
 849     DWORD       fccHandler;
 850     DWORD       dwFlags;        /* AVIIF_* */
 851     DWORD       dwCaps;
 852     WORD        wPriority;
 853     WORD        wLanguage;
 854     DWORD       dwScale;
 855     DWORD       dwRate;         /* dwRate / dwScale == samples/second */
 856     DWORD       dwStart;
 857     DWORD       dwLength;       /* In units above... */
 858     DWORD       dwInitialFrames;
 859     DWORD       dwSuggestedBufferSize;
 860     DWORD       dwQuality;
 861     DWORD       dwSampleSize;
 862     RECT        rcFrame;
 863     DWORD       dwEditCount;
 864     DWORD       dwFormatChangeCount;
 865     CHAR        szName[64];
 866 } AVISTREAMINFOA, * LPAVISTREAMINFOA, *PAVISTREAMINFOA;
 867
 868 typedef struct _AVISTREAMINFOW {
 869     DWORD       fccType;
 870     DWORD       fccHandler;
 871     DWORD       dwFlags;
 872     DWORD       dwCaps;
 873     WORD        wPriority;
 874     WORD        wLanguage;
 875     DWORD       dwScale;
 876     DWORD       dwRate;         /* dwRate / dwScale == samples/second */
 877     DWORD       dwStart;
 878     DWORD       dwLength;       /* In units above... */
 879     DWORD       dwInitialFrames;
 880     DWORD       dwSuggestedBufferSize;
 881     DWORD       dwQuality;
 882     DWORD       dwSampleSize;
 883     RECT        rcFrame;
 884     DWORD       dwEditCount;
 885     DWORD       dwFormatChangeCount;
 886     WCHAR       szName[64];
 887 } AVISTREAMINFOW, * LPAVISTREAMINFOW, *PAVISTREAMINFOW;
 888 DECL_WINELIB_TYPE_AW(AVISTREAMINFO)
 889 DECL_WINELIB_TYPE_AW(LPAVISTREAMINFO)
 890 DECL_WINELIB_TYPE_AW(PAVISTREAMINFO)
 891
 892 #define AVISTREAMINFO_DISABLED          0x00000001
 893 #define AVISTREAMINFO_FORMATCHANGES     0x00010000
 894
 895 /* AVIFILEINFO.dwFlags */
 896 #define AVIFILEINFO_HASINDEX            0x00000010
 897 #define AVIFILEINFO_MUSTUSEINDEX        0x00000020
 898 #define AVIFILEINFO_ISINTERLEAVED       0x00000100
 899 #define AVIFILEINFO_TRUSTCKTYPE         0x00000800
 900 #define AVIFILEINFO_WASCAPTUREFILE      0x00010000
 901 #define AVIFILEINFO_COPYRIGHTED         0x00020000
 902
 903 /* AVIFILEINFO.dwCaps */
 904 #define AVIFILECAPS_CANREAD             0x00000001
 905 #define AVIFILECAPS_CANWRITE            0x00000002
 906 #define AVIFILECAPS_ALLKEYFRAMES        0x00000010
 907 #define AVIFILECAPS_NOCOMPRESSION       0x00000020
 908
 909 typedef struct _AVIFILEINFOW {
 910     DWORD               dwMaxBytesPerSec;
 911     DWORD               dwFlags;
 912     DWORD               dwCaps;
 913     DWORD               dwStreams;
 914     DWORD               dwSuggestedBufferSize;
 915     DWORD               dwWidth;
 916     DWORD               dwHeight;
 917     DWORD               dwScale;
 918     DWORD               dwRate;
 919     DWORD               dwLength;
 920     DWORD               dwEditCount;
 921     WCHAR               szFileType[64];
 922 } AVIFILEINFOW, * LPAVIFILEINFOW, *PAVIFILEINFOW;
 923 typedef struct _AVIFILEINFOA {
 924     DWORD               dwMaxBytesPerSec;
 925     DWORD               dwFlags;
 926     DWORD               dwCaps;
 927     DWORD               dwStreams;
 928     DWORD               dwSuggestedBufferSize;
 929     DWORD               dwWidth;
 930     DWORD               dwHeight;
 931     DWORD               dwScale;
 932     DWORD               dwRate;
 933     DWORD               dwLength;
 934     DWORD               dwEditCount;
 935     CHAR                szFileType[64];
 936 } AVIFILEINFOA, * LPAVIFILEINFOA, *PAVIFILEINFOA;
 937 DECL_WINELIB_TYPE_AW(AVIFILEINFO)
 938 DECL_WINELIB_TYPE_AW(PAVIFILEINFO)
 939 DECL_WINELIB_TYPE_AW(LPAVIFILEINFO)
 940
 941 /* AVICOMPRESSOPTIONS.dwFlags. determines presence of fields in below struct */
 942 #define AVICOMPRESSF_INTERLEAVE 0x00000001
 943 #define AVICOMPRESSF_DATARATE   0x00000002
 944 #define AVICOMPRESSF_KEYFRAMES  0x00000004
 945 #define AVICOMPRESSF_VALID      0x00000008
 946
 947 typedef struct {
 948     DWORD       fccType;                /* stream type, for consistency */
 949     DWORD       fccHandler;             /* compressor */
 950     DWORD       dwKeyFrameEvery;        /* keyframe rate */
 951     DWORD       dwQuality;              /* compress quality 0-10,000 */
 952     DWORD       dwBytesPerSecond;       /* bytes per second */
 953     DWORD       dwFlags;                /* flags... see below */
 954     LPVOID      lpFormat;               /* save format */
 955     DWORD       cbFormat;
 956     LPVOID      lpParms;                /* compressor options */
 957     DWORD       cbParms;
 958     DWORD       dwInterleaveEvery;      /* for non-video streams only */
 959 } AVICOMPRESSOPTIONS, *LPAVICOMPRESSOPTIONS,*PAVICOMPRESSOPTIONS;
 960
 961 #define FIND_DIR        0x0000000FL     /* direction mask */
 962 #define FIND_NEXT       0x00000001L     /* search forward */
 963 #define FIND_PREV       0x00000004L     /* search backward */
 964 #define FIND_FROM_START 0x00000008L     /* start at the logical beginning */
 965
 966 #define FIND_TYPE       0x000000F0L     /* type mask */
 967 #define FIND_KEY        0x00000010L     /* find a key frame */
 968 #define FIND_ANY        0x00000020L     /* find any (non-empty) sample */
 969 #define FIND_FORMAT     0x00000040L     /* find a formatchange */
 970
 971 #define FIND_RET        0x0000F000L     /* return mask */
 972 #define FIND_POS        0x00000000L     /* return logical position */
 973 #define FIND_LENGTH     0x00001000L     /* return logical size */
 974 #define FIND_OFFSET     0x00002000L     /* return physical position */
 975 #define FIND_SIZE       0x00003000L     /* return physical size */
 976 #define FIND_INDEX      0x00004000L     /* return physical index position */
 977
 978 #include <ole2.h>
 979
 980 #define DEFINE_AVIGUID(name, l, w1, w2) \
 981     DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)
 982
 983 DEFINE_AVIGUID(IID_IAVIFile,            0x00020020, 0, 0);
 984 DEFINE_AVIGUID(IID_IAVIStream,          0x00020021, 0, 0);
 985 DEFINE_AVIGUID(IID_IAVIStreaming,       0x00020022, 0, 0);
 986 DEFINE_AVIGUID(IID_IGetFrame,           0x00020023, 0, 0);
 987 DEFINE_AVIGUID(IID_IAVIEditStream,      0x00020024, 0, 0);
 988
 989 DEFINE_AVIGUID(CLSID_AVISimpleUnMarshal,0x00020009, 0, 0);
 990 DEFINE_AVIGUID(CLSID_AVIFile,           0x00020000, 0, 0);
 991
 992 /*****************************************************************************
 993  * IAVIStream interface
 994  */
 995 #define INTERFACE IAVIStream
 996 DECLARE_INTERFACE_(IAVIStream,IUnknown)
 997 {
 998     /*** IUnknown methods ***/
 999     STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
1000     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
1001     STDMETHOD_(ULONG,Release)(THIS) PURE;
1002     /*** IAVIStream methods ***/
1003     STDMETHOD(Create)(THIS_ LPARAM lParam1, LPARAM lParam2) PURE;
1004     STDMETHOD(Info)(THIS_ AVISTREAMINFOW *psi, LONG lSize) PURE;
1005     STDMETHOD_(LONG,FindSample)(THIS_ LONG lPos, LONG lFlags) PURE;
1006     STDMETHOD(ReadFormat)(THIS_ LONG lPos, LPVOID lpFormat, LONG *lpcbFormat) PURE;
1007     STDMETHOD(SetFormat)(THIS_ LONG lPos, LPVOID lpFormat, LONG cbFormat) PURE;
1008     STDMETHOD(Read)(THIS_ LONG lStart, LONG lSamples, LPVOID lpBuffer, LONG cbBuffer, LONG *plBytes, LONG *plSamples) PURE;
1009     STDMETHOD(Write)(THIS_ LONG lStart, LONG lSamples, LPVOID lpBuffer, LONG cbBuffer, DWORD dwFlags, LONG *plSampWritten, LONG *plBytesWritten) PURE;
1010     STDMETHOD(Delete)(THIS_ LONG lStart, LONG lSamples) PURE;
1011     STDMETHOD(ReadData)(THIS_ DWORD fcc, LPVOID lpBuffer, LONG *lpcbBuffer) PURE;
1012     STDMETHOD(WriteData)(THIS_ DWORD fcc, LPVOID lpBuffer, LONG cbBuffer) PURE;
1013     STDMETHOD(SetInfo)(THIS_ AVISTREAMINFOW *plInfo, LONG cbInfo) PURE;
1014 };
1015 #undef INTERFACE
1016
1017 #if !defined(__cplusplus) || defined(CINTERFACE)
1018 /*** IUnknown methods ***/
1019 #define IAVIStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1020 #define IAVIStream_AddRef(p)             (p)->lpVtbl->AddRef(p)
1021 #define IAVIStream_Release(p)            (p)->lpVtbl->Release(p)
1022 /*** IAVIStream methods ***/
1023 #define IAVIStream_Create(p,a,b)          (p)->lpVtbl->Create(p,a,b)
1024 #define IAVIStream_Info(p,a,b)            (p)->lpVtbl->Info(p,a,b)
1025 #define IAVIStream_FindSample(p,a,b)      (p)->lpVtbl->FindSample(p,a,b)
1026 #define IAVIStream_ReadFormat(p,a,b,c)    (p)->lpVtbl->ReadFormat(p,a,b,c)
1027 #define IAVIStream_SetFormat(p,a,b,c)     (p)->lpVtbl->SetFormat(p,a,b,c)
1028 #define IAVIStream_Read(p,a,b,c,d,e,f)    (p)->lpVtbl->Read(p,a,b,c,d,e,f)
1029 #define IAVIStream_Write(p,a,b,c,d,e,f,g) (p)->lpVtbl->Write(p,a,b,c,d,e,f,g)
1030 #define IAVIStream_Delete(p,a,b)          (p)->lpVtbl->Delete(p,a,b)
1031 #define IAVIStream_ReadData(p,a,b,c)      (p)->lpVtbl->ReadData(p,a,b,c)
1032 #define IAVIStream_WriteData(p,a,b,c)     (p)->lpVtbl->WriteData(p,a,b,c)
1033 #define IAVIStream_SetInfo(p,a,b)         (p)->lpVtbl->SetInfo(p,a,b)
1034 #endif
1035
1036 #define AVISTREAMREAD_CONVENIENT          (-1L)
1037
1038 ULONG WINAPI AVIStreamAddRef(PAVISTREAM iface);
1039 ULONG WINAPI AVIStreamRelease(PAVISTREAM iface);
1040 HRESULT WINAPI AVIStreamCreate(PAVISTREAM*,LONG,LONG,CLSID*);
1041 HRESULT WINAPI AVIStreamInfoA(PAVISTREAM iface,AVISTREAMINFOA *asi,LONG size);
1042 HRESULT WINAPI AVIStreamInfoW(PAVISTREAM iface,AVISTREAMINFOW *asi,LONG size);
1043 #define AVIStreamInfo WINELIB_NAME_AW(AVIStreamInfo)
1044 LONG WINAPI AVIStreamFindSample(PAVISTREAM pstream, LONG pos, LONG flags);
1045 HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG *formatsize);
1046 HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG formatsize);
1047 HRESULT WINAPI AVIStreamRead(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread);
1048 HRESULT WINAPI AVIStreamWrite(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
1049 HRESULT WINAPI AVIStreamReadData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG *lpread);
1050 HRESULT WINAPI AVIStreamWriteData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG size);
1051
1052 PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pavi,LPBITMAPINFOHEADER lpbiWanted);
1053 LPVOID  WINAPI AVIStreamGetFrame(PGETFRAME pg,LONG pos);
1054 HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pg);
1055
1056 HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM*ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *lpOptions,CLSID*pclsidHandler);
1057 HRESULT WINAPI AVIMakeFileFromStreams(PAVIFILE *ppfile, int nStreams, PAVISTREAM *ppStreams);
1058 HRESULT WINAPI AVIMakeStreamFromClipboard(UINT cfFormat, HANDLE hGlobal, PAVISTREAM * ppstream);
1059
1060 HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM *ppavi, LPCSTR szFile,
1061                                       DWORD fccType, LONG lParam,
1062                                       UINT mode, CLSID *pclsidHandler);
1063 HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM *ppavi, LPCWSTR szFile,
1064                                       DWORD fccType, LONG lParam,
1065                                       UINT mode, CLSID *pclsidHandler);
1066 #define AVIStreamOpenFromFile WINELIB_NAME_AW(AVIStreamOpenFromFile)
1067
1068 LONG WINAPI AVIStreamBeginStreaming(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate);
1069 LONG WINAPI AVIStreamEndStreaming(PAVISTREAM pavi);
1070
1071 HRESULT WINAPI AVIBuildFilterA(LPSTR szFilter, LONG cbFilter, BOOL fSaving);
1072 HRESULT WINAPI AVIBuildFilterW(LPWSTR szFilter, LONG cbFilter, BOOL fSaving);
1073 #define AVIBuildFilter WINELIB_NAME_AW(AVIBuildFilter)
1074
1075 BOOL WINAPI AVISaveOptions(HWND hWnd,UINT uFlags,INT nStream,
1076                            PAVISTREAM *ppavi,LPAVICOMPRESSOPTIONS *ppOptions);
1077 HRESULT WINAPI AVISaveOptionsFree(INT nStreams,LPAVICOMPRESSOPTIONS*ppOptions);
1078
1079 HRESULT CDECL AVISaveA(LPCSTR szFile, CLSID *pclsidHandler,
1080              AVISAVECALLBACK lpfnCallback, int nStreams,
1081              PAVISTREAM pavi, LPAVICOMPRESSOPTIONS lpOptions, ...);
1082 HRESULT CDECL AVISaveW(LPCWSTR szFile, CLSID *pclsidHandler,
1083              AVISAVECALLBACK lpfnCallback, int nStreams,
1084              PAVISTREAM pavi, LPAVICOMPRESSOPTIONS lpOptions, ...);
1085 #define AVISave WINELIB_NAME_AW(AVISave)
1086
1087 HRESULT WINAPI AVISaveVA(LPCSTR szFile, CLSID *pclsidHandler,
1088                          AVISAVECALLBACK lpfnCallback, int nStream,
1089                          PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *plpOptions);
1090 HRESULT WINAPI AVISaveVW(LPCWSTR szFile, CLSID *pclsidHandler,
1091                          AVISAVECALLBACK lpfnCallback, int nStream,
1092                          PAVISTREAM *ppavi, LPAVICOMPRESSOPTIONS *plpOptions);
1093 #define AVISaveV WINELIB_NAME_AW(AVISaveV)
1094
1095 LONG WINAPI AVIStreamStart(PAVISTREAM iface);
1096 LONG WINAPI AVIStreamLength(PAVISTREAM iface);
1097 LONG WINAPI AVIStreamSampleToTime(PAVISTREAM pstream, LONG lSample);
1098 LONG WINAPI AVIStreamTimeToSample(PAVISTREAM pstream, LONG lTime);
1099
1100 #define AVIFileClose(pavi) \
1101     AVIFileRelease(pavi)
1102 #define AVIStreamClose(pavi) \
1103     AVIStreamRelease(pavi);
1104 #define AVIStreamEnd(pavi) \
1105     (AVIStreamStart(pavi) + AVIStreamLength(pavi))
1106 #define AVIStreamEndTime(pavi) \
1107     AVIStreamSampleToTime(pavi, AVIStreamEnd(pavi))
1108 #define AVIStreamFormatSize(pavi, lPos, plSize) \
1109     AVIStreamReadFormat(pavi, lPos, NULL, plSize)
1110 #define AVIStreamLengthTime(pavi) \
1111     AVIStreamSampleToTime(pavi, AVIStreamLength(pavi))
1112 #define AVIStreamSampleSize(pavi,pos,psize) \
1113     AVIStreamRead(pavi,pos,1,NULL,0,psize,NULL)
1114 #define AVIStreamSampleToSample(pavi1, pavi2, samp2) \
1115     AVIStreamTimeToSample(pavi1, AVIStreamSampleToTime(pavi2, samp2))
1116 #define AVIStreamStartTime(pavi) \
1117     AVIStreamSampleToTime(pavi, AVIStreamStart(pavi))
1118
1119 #define AVIStreamNextSample(pavi, pos) \
1120     AVIStreamFindSample(pavi, pos + 1, FIND_NEXT | FIND_ANY)
1121 #define AVIStreamPrevSample(pavi, pos) \
1122     AVIStreamFindSample(pavi, pos - 1, FIND_PREV | FIND_ANY)
1123 #define AVIStreamNearestSample(pavi, pos) \
1124     AVIStreamFindSample(pavi, pos, FIND_PREV | FIND_ANY)
1125 #define AVStreamNextKeyFrame(pavi,pos) \
1126     AVIStreamFindSample(pavi, pos + 1, FIND_NEXT | FIND_KEY)
1127 #define AVStreamPrevKeyFrame(pavi,pos) \
1128     AVIStreamFindSample(pavi, pos - 1, FIND_NEXT | FIND_KEY)
1129 #define AVIStreamNearestKeyFrame(pavi,pos) \
1130     AVIStreamFindSample(pavi, pos, FIND_PREV | FIND_KEY)
1131 #define AVIStreamIsKeyFrame(pavi, pos) \
1132     (AVIStreamNearestKeyFrame(pavi, pos) == pos)
1133
1134 /*****************************************************************************
1135  * IAVIStreaming interface
1136  */
1137 #define INTERFACE IAVIStreaming
1138 DECLARE_INTERFACE_(IAVIStreaming,IUnknown)
1139 {
1140     /*** IUnknown methods ***/
1141     STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
1142     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
1143     STDMETHOD_(ULONG,Release)(THIS) PURE;
1144     /*** IAVIStreaming methods ***/
1145     STDMETHOD(Begin)(IAVIStreaming*iface,LONG lStart,LONG lEnd,LONG lRate) PURE;
1146     STDMETHOD(End)(IAVIStreaming*iface) PURE;
1147 };
1148 #undef INTERFACE
1149
1150 #if !defined(__cplusplus) || defined(CINTERFACE)
1151 /*** IUnknown methods ***/
1152 #define IAVIStreaming_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1153 #define IAVIStreaming_AddRef(p)             (p)->lpVtbl->AddRef(p)
1154 #define IAVIStreaming_Release(p)            (p)->lpVtbl->Release(p)
1155 /*** IAVIStreaming methods ***/
1156 #define IAVIStreaming_Begin(p,a,b,c)        (p)->lpVtbl->Begin(p,a,b,c)
1157 #define IAVIStreaming_End(p)                (p)->lpVtbl->End(p)
1158 #endif
1159
1160 /*****************************************************************************
1161  * IAVIEditStream interface
1162  */
1163 #define INTERFACE IAVIEditStream
1164 DECLARE_INTERFACE_(IAVIEditStream,IUnknown)
1165 {
1166     /*** IUnknown methods ***/
1167     STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
1168     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
1169     STDMETHOD_(ULONG,Release)(THIS) PURE;
1170     /*** IAVIEditStream methods ***/
1171     STDMETHOD(Cut)(IAVIEditStream*iface,LONG*plStart,LONG*plLength,PAVISTREAM*ppResult) PURE;
1172     STDMETHOD(Copy)(IAVIEditStream*iface,LONG*plStart,LONG*plLength,PAVISTREAM*ppResult) PURE;
1173     STDMETHOD(Paste)(IAVIEditStream*iface,LONG*plStart,LONG*plLength,PAVISTREAM pSource,LONG lStart,LONG lEnd) PURE;
1174     STDMETHOD(Clone)(IAVIEditStream*iface,PAVISTREAM*ppResult) PURE;
1175     STDMETHOD(SetInfo)(IAVIEditStream*iface,LPAVISTREAMINFOW asi, LONG size) PURE;
1176 };
1177 #undef INTERFACE
1178
1179 #if !defined(__cplusplus) || defined(CINTERFACE)
1180 /*** IUnknown methods ***/
1181 #define IAVIEditStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1182 #define IAVIEditStream_AddRef(p)             (p)->lpVtbl->AddRef(p)
1183 #define IAVIEditStream_Release(p)            (p)->lpVtbl->Release(p)
1184 /*** IAVIEditStream methods ***/
1185 #define IAVIEditStream_Cut(p,a,b,c)          (p)->lpVtbl->Cut(p,a,b,c)
1186 #define IAVIEditStream_Copy(p,a,b,c)         (p)->lpVtbl->Copy(p,a,b,c)
1187 #define IAVIEditStream_Paste(p,a,b,c,d,e)    (p)->lpVtbl->Paste(p,a,b,c,d,e)
1188 #define IAVIEditStream_Clone(p,a)            (p)->lpVtbl->Clone(p,a)
1189 #define IAVIEditStream_SetInfo(p,a,b)        (p)->lpVtbl->SetInfo(p,a,b)
1190 #endif
1191
1192 HRESULT WINAPI CreateEditableStream(PAVISTREAM *ppEditable,PAVISTREAM pSource);
1193 HRESULT WINAPI EditStreamClone(PAVISTREAM pStream, PAVISTREAM *ppResult);
1194 HRESULT WINAPI EditStreamCopy(PAVISTREAM pStream, LONG *plStart,
1195                               LONG *plLength, PAVISTREAM *ppResult);
1196 HRESULT WINAPI EditStreamCut(PAVISTREAM pStream, LONG *plStart,
1197                              LONG *plLength, PAVISTREAM *ppResult);
1198 HRESULT WINAPI EditStreamPaste(PAVISTREAM pDest, LONG *plStart, LONG *plLength,
1199                                PAVISTREAM pSource, LONG lStart, LONG lEnd);
1200
1201 HRESULT WINAPI EditStreamSetInfoA(PAVISTREAM pstream, LPAVISTREAMINFOA asi,
1202                                   LONG size);
1203 HRESULT WINAPI EditStreamSetInfoW(PAVISTREAM pstream, LPAVISTREAMINFOW asi,
1204                                   LONG size);
1205 #define EditStreamSetInfo WINELIB_NAME_AW(EditStreamSetInfo)
1206
1207 HRESULT WINAPI EditStreamSetNameA(PAVISTREAM pstream, LPCSTR szName);
1208 HRESULT WINAPI EditStreamSetNameW(PAVISTREAM pstream, LPCWSTR szName);
1209 #define EditStreamSetName WINELIB_NAME_AW(EditStreamSetName)
1210
1211 /*****************************************************************************
1212  * IAVIFile interface
1213  */
1214 /* In Win32 this interface uses UNICODE only */
1215 #define INTERFACE IAVIFile
1216 DECLARE_INTERFACE_(IAVIFile,IUnknown)
1217 {
1218     /*** IUnknown methods ***/
1219     STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
1220     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
1221     STDMETHOD_(ULONG,Release)(THIS) PURE;
1222     /*** IAVIFile methods ***/
1223     STDMETHOD(Info)(THIS_ AVIFILEINFOW *pfi, LONG lSize) PURE;
1224     STDMETHOD(GetStream)(THIS_ PAVISTREAM *ppStream, DWORD fccType, LONG lParam) PURE;
1225     STDMETHOD(CreateStream)(THIS_ PAVISTREAM *ppStream, AVISTREAMINFOW *psi) PURE;
1226     STDMETHOD(WriteData)(THIS_ DWORD fcc, LPVOID lpBuffer, LONG cbBuffer) PURE;
1227     STDMETHOD(ReadData)(THIS_ DWORD fcc, LPVOID lpBuffer, LONG *lpcbBuffer) PURE;
1228     STDMETHOD(EndRecord)(THIS) PURE;
1229     STDMETHOD(DeleteStream)(THIS_ DWORD fccType, LONG lParam) PURE;
1230 };
1231 #undef INTERFACE
1232
1233 #if !defined(__cplusplus) || defined(CINTERFACE)
1234 /*** IUnknown methods ***/
1235 #define IAVIFile_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1236 #define IAVIFile_AddRef(p)             (p)->lpVtbl->AddRef(p)
1237 #define IAVIFile_Release(p)            (p)->lpVtbl->Release(p)
1238 /*** IAVIFile methods ***/
1239 #define IAVIFile_Info(p,a,b)         (p)->lpVtbl->Info(p,a,b)
1240 #define IAVIFile_GetStream(p,a,b,c)  (p)->lpVtbl->GetStream(p,a,b,c)
1241 #define IAVIFile_CreateStream(p,a,b) (p)->lpVtbl->CreateStream(p,a,b)
1242 #define IAVIFile_WriteData(p,a,b,c)  (p)->lpVtbl->WriteData(p,a,b,c)
1243 #define IAVIFile_ReadData(p,a,b,c)   (p)->lpVtbl->ReadData(p,a,b,c)
1244 #define IAVIFile_EndRecord(p)        (p)->lpVtbl->EndRecord(p)
1245 #define IAVIFile_DeleteStream(p,a,b) (p)->lpVtbl->DeleteStream(p,a,b)
1246 #endif
1247
1248 void WINAPI AVIFileInit(void);
1249 void WINAPI AVIFileExit(void);
1250
1251 HRESULT WINAPI AVIFileOpenA(PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler);
1252 HRESULT WINAPI AVIFileOpenW(PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler);
1253 #define AVIFileOpen WINELIB_NAME_AW(AVIFileOpen)
1254
1255 ULONG   WINAPI AVIFileAddRef(PAVIFILE pfile);
1256 ULONG   WINAPI AVIFileRelease(PAVIFILE pfile);
1257 HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile,PAVIFILEINFOA pfi,LONG lSize);
1258 HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile,PAVIFILEINFOW pfi,LONG lSize);
1259 #define AVIFileInfo WINELIB_NAME_AW(AVIFileInfo)
1260 HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile,PAVISTREAM* avis,DWORD fccType,LONG lParam);
1261 HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile,PAVISTREAM* ppavi,AVISTREAMINFOA* psi);
1262 HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile,PAVISTREAM* ppavi,AVISTREAMINFOW* psi);
1263 #define AVIFileCreateStream WINELIB_NAME_AW(AVIFileCreateStream)
1264 HRESULT WINAPI AVIFileWriteData(PAVIFILE pfile,DWORD fcc,LPVOID lp,LONG size);
1265 HRESULT WINAPI AVIFileReadData(PAVIFILE pfile,DWORD fcc,LPVOID lp,LPLONG size);
1266 HRESULT WINAPI AVIFileEndRecord(PAVIFILE pfile);
1267
1268 /*****************************************************************************
1269  * IGetFrame interface
1270  */
1271 #define INTERFACE IGetFrame
1272 DECLARE_INTERFACE_(IGetFrame,IUnknown)
1273 {
1274     /*** IUnknown methods ***/
1275     STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
1276     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
1277     STDMETHOD_(ULONG,Release)(THIS) PURE;
1278     /*** IGetFrame methods ***/
1279     STDMETHOD_(LPVOID,GetFrame)(THIS_ LONG lPos) PURE;
1280     STDMETHOD(Begin)(THIS_ LONG lStart, LONG lEnd, LONG lRate) PURE;
1281     STDMETHOD(End)(THIS) PURE;
1282     STDMETHOD(SetFormat)(THIS_ LPBITMAPINFOHEADER lpbi, LPVOID lpBits, INT x, INT y, INT dx, INT dy) PURE;
1283 };
1284 #undef INTERFACE
1285
1286 #if !defined(__cplusplus) || defined(CINTERFACE)
1287 /*** IUnknown methods ***/
1288 #define IGetFrame_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
1289 #define IGetFrame_AddRef(p)             (p)->lpVtbl->AddRef(p)
1290 #define IGetFrame_Release(p)            (p)->lpVtbl->Release(p)
1291 /*** IGetFrame methods ***/
1292 #define IGetFrame_GetFrame(p,a)            (p)->lpVtbl->GetFrame(p,a)
1293 #define IGetFrame_Begin(p,a,b,c)           (p)->lpVtbl->Begin(p,a,b,c)
1294 #define IGetFrame_End(p)                   (p)->lpVtbl->End(p)
1295 #define IGetFrame_SetFormat(p,a,b,c,d,e,f) (p)->lpVtbl->SetFormat(p,a,b,c,d,e,f)
1296 #endif
1297
1298 HRESULT WINAPI AVIClearClipboard(void);
1299 HRESULT WINAPI AVIGetFromClipboard(PAVIFILE *ppfile);
1300 HRESULT WINAPI AVIPutFileOnClipboard(PAVIFILE pfile);
1301
1302 #ifdef OFN_READONLY
1303 BOOL WINAPI GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn);
1304 BOOL WINAPI GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn);
1305 #define GetOpenFileNamePreview WINELIB_NAME_AW(GetOpenFileNamePreview)
1306 BOOL WINAPI GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn);
1307 BOOL WINAPI GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn);
1308 #define GetSaveFileNamePreview WINELIB_NAME_AW(GetSaveFileNamePreview)
1309 #endif
1310
1311 #define AVIERR_OK               0
1312 #define MAKE_AVIERR(error)      MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x4000+error)
1313
1314 #define AVIERR_UNSUPPORTED      MAKE_AVIERR(101)
1315 #define AVIERR_BADFORMAT        MAKE_AVIERR(102)
1316 #define AVIERR_MEMORY           MAKE_AVIERR(103)
1317 #define AVIERR_INTERNAL         MAKE_AVIERR(104)
1318 #define AVIERR_BADFLAGS         MAKE_AVIERR(105)
1319 #define AVIERR_BADPARAM         MAKE_AVIERR(106)
1320 #define AVIERR_BADSIZE          MAKE_AVIERR(107)
1321 #define AVIERR_BADHANDLE        MAKE_AVIERR(108)
1322 #define AVIERR_FILEREAD         MAKE_AVIERR(109)
1323 #define AVIERR_FILEWRITE        MAKE_AVIERR(110)
1324 #define AVIERR_FILEOPEN         MAKE_AVIERR(111)
1325 #define AVIERR_COMPRESSOR       MAKE_AVIERR(112)
1326 #define AVIERR_NOCOMPRESSOR     MAKE_AVIERR(113)
1327 #define AVIERR_READONLY         MAKE_AVIERR(114)
1328 #define AVIERR_NODATA           MAKE_AVIERR(115)
1329 #define AVIERR_BUFFERTOOSMALL   MAKE_AVIERR(116)
1330 #define AVIERR_CANTCOMPRESS     MAKE_AVIERR(117)
1331 #define AVIERR_USERABORT        MAKE_AVIERR(198)
1332 #define AVIERR_ERROR            MAKE_AVIERR(199)
1333
1334 BOOL VFWAPIV MCIWndRegisterClass(void);
1335
1336 HWND VFWAPIV MCIWndCreateA(HWND, HINSTANCE, DWORD, LPCSTR);
1337 HWND VFWAPIV MCIWndCreateW(HWND, HINSTANCE, DWORD, LPCWSTR);
1338 #define     MCIWndCreate WINELIB_NAME_AW(MCIWndCreate)
1339
1340 #define MCIWNDOPENF_NEW                 0x0001
1341
1342 #define MCIWNDF_NOAUTOSIZEWINDOW        0x0001
1343 #define MCIWNDF_NOPLAYBAR               0x0002
1344 #define MCIWNDF_NOAUTOSIZEMOVIE         0x0004
1345 #define MCIWNDF_NOMENU                  0x0008
1346 #define MCIWNDF_SHOWNAME                0x0010
1347 #define MCIWNDF_SHOWPOS                 0x0020
1348 #define MCIWNDF_SHOWMODE                0x0040
1349 #define MCIWNDF_SHOWALL                 0x0070
1350
1351 #define MCIWNDF_NOTIFYMODE              0x0100
1352 #define MCIWNDF_NOTIFYPOS               0x0200
1353 #define MCIWNDF_NOTIFYSIZE              0x0400
1354 #define MCIWNDF_NOTIFYERROR             0x1000
1355 #define MCIWNDF_NOTIFYALL               0x1F00
1356
1357 #define MCIWNDF_NOTIFYANSI              0x0080
1358
1359 #define MCIWNDF_NOTIFYMEDIAA            0x0880
1360 #define MCIWNDF_NOTIFYMEDIAW            0x0800
1361 #define MCIWNDF_NOTIFYMEDIA WINELIB_NAME_AW(MCIWNDF_NOTIFYMEDIA)
1362
1363 #define MCIWNDF_RECORD                  0x2000
1364 #define MCIWNDF_NOERRORDLG              0x4000
1365 #define MCIWNDF_NOOPEN                  0x8000
1366
1367 #ifdef __cplusplus
1368 #define MCIWndSM ::SendMessage
1369 #else
1370 #define MCIWndSM SendMessage
1371 #endif
1372
1373 #define MCIWndCanPlay(hWnd)         (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_PLAY,0,0)
1374 #define MCIWndCanRecord(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_RECORD,0,0)
1375 #define MCIWndCanSave(hWnd)         (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_SAVE,0,0)
1376 #define MCIWndCanWindow(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_WINDOW,0,0)
1377 #define MCIWndCanEject(hWnd)        (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_EJECT,0,0)
1378 #define MCIWndCanConfig(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_CONFIG,0,0)
1379 #define MCIWndPaletteKick(hWnd)     (BOOL)MCIWndSM(hWnd,MCIWNDM_PALETTEKICK,0,0)
1380
1381 #define MCIWndSave(hWnd,szFile)     (LONG)MCIWndSM(hWnd,MCI_SAVE,0,(LPARAM)(LPVOID)(szFile))
1382 #define MCIWndSaveDialog(hWnd)      MCIWndSave(hWnd,-1)
1383
1384 #define MCIWndNew(hWnd,lp)          (LONG)MCIWndSM(hWnd,MCIWNDM_NEW,0,(LPARAM)(LPVOID)(lp))
1385
1386 #define MCIWndRecord(hWnd)          (LONG)MCIWndSM(hWnd,MCI_RECORD,0,0)
1387 #define MCIWndOpen(hWnd,sz,f)       (LONG)MCIWndSM(hWnd,MCIWNDM_OPEN,(WPARAM)(UINT)(f),(LPARAM)(LPVOID)(sz))
1388 #define MCIWndOpenDialog(hWnd)      MCIWndOpen(hWnd,-1,0)
1389 #define MCIWndClose(hWnd)           (LONG)MCIWndSM(hWnd,MCI_CLOSE,0,0)
1390 #define MCIWndPlay(hWnd)            (LONG)MCIWndSM(hWnd,MCI_PLAY,0,0)
1391 #define MCIWndStop(hWnd)            (LONG)MCIWndSM(hWnd,MCI_STOP,0,0)
1392 #define MCIWndPause(hWnd)           (LONG)MCIWndSM(hWnd,MCI_PAUSE,0,0)
1393 #define MCIWndResume(hWnd)          (LONG)MCIWndSM(hWnd,MCI_RESUME,0,0)
1394 #define MCIWndSeek(hWnd,lPos)       (LONG)MCIWndSM(hWnd,MCI_SEEK,0,(LPARAM)(LONG)(lPos))
1395 #define MCIWndEject(hWnd)           (LONG)MCIWndSM(hWnd,MCIWNDM_EJECT,0,0)
1396
1397 #define MCIWndHome(hWnd)            MCIWndSeek(hWnd,MCIWND_START)
1398 #define MCIWndEnd(hWnd)             MCIWndSeek(hWnd,MCIWND_END)
1399
1400 #define MCIWndGetSource(hWnd,prc)   (LONG)MCIWndSM(hWnd,MCIWNDM_GET_SOURCE,0,(LPARAM)(LPRECT)(prc))
1401 #define MCIWndPutSource(hWnd,prc)   (LONG)MCIWndSM(hWnd,MCIWNDM_PUT_SOURCE,0,(LPARAM)(LPRECT)(prc))
1402
1403 #define MCIWndGetDest(hWnd,prc)     (LONG)MCIWndSM(hWnd,MCIWNDM_GET_DEST,0,(LPARAM)(LPRECT)(prc))
1404 #define MCIWndPutDest(hWnd,prc)     (LONG)MCIWndSM(hWnd,MCIWNDM_PUT_DEST,0,(LPARAM)(LPRECT)(prc))
1405
1406 #define MCIWndPlayReverse(hWnd)     (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYREVERSE,0,0)
1407 #define MCIWndPlayFrom(hWnd,lPos)   (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYFROM,0,(LPARAM)(LONG)(lPos))
1408 #define MCIWndPlayTo(hWnd,lPos)     (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYTO,  0,(LPARAM)(LONG)(lPos))
1409 #define MCIWndPlayFromTo(hWnd,lStart,lEnd) (MCIWndSeek(hWnd,lStart),MCIWndPlayTo(hWnd,lEnd))
1410
1411 #define MCIWndGetDeviceID(hWnd)     (UINT)MCIWndSM(hWnd,MCIWNDM_GETDEVICEID,0,0)
1412 #define MCIWndGetAlias(hWnd)        (UINT)MCIWndSM(hWnd,MCIWNDM_GETALIAS,0,0)
1413 #define MCIWndGetMode(hWnd,lp,len)  (LONG)MCIWndSM(hWnd,MCIWNDM_GETMODE,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
1414 #define MCIWndGetPosition(hWnd)     (LONG)MCIWndSM(hWnd,MCIWNDM_GETPOSITION,0,0)
1415 #define MCIWndGetPositionString(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETPOSITION,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
1416 #define MCIWndGetStart(hWnd)        (LONG)MCIWndSM(hWnd,MCIWNDM_GETSTART,0,0)
1417 #define MCIWndGetLength(hWnd)       (LONG)MCIWndSM(hWnd,MCIWNDM_GETLENGTH,0,0)
1418 #define MCIWndGetEnd(hWnd)          (LONG)MCIWndSM(hWnd,MCIWNDM_GETEND,0,0)
1419
1420 #define MCIWndStep(hWnd,n)          (LONG)MCIWndSM(hWnd,MCI_STEP,0,(LPARAM)(long)(n))
1421
1422 #define MCIWndDestroy(hWnd)         (VOID)MCIWndSM(hWnd,WM_CLOSE,0,0)
1423 #define MCIWndSetZoom(hWnd,iZoom)   (VOID)MCIWndSM(hWnd,MCIWNDM_SETZOOM,0,(LPARAM)(UINT)(iZoom))
1424 #define MCIWndGetZoom(hWnd)         (UINT)MCIWndSM(hWnd,MCIWNDM_GETZOOM,0,0)
1425 #define MCIWndSetVolume(hWnd,iVol)  (LONG)MCIWndSM(hWnd,MCIWNDM_SETVOLUME,0,(LPARAM)(UINT)(iVol))
1426 #define MCIWndGetVolume(hWnd)       (LONG)MCIWndSM(hWnd,MCIWNDM_GETVOLUME,0,0)
1427 #define MCIWndSetSpeed(hWnd,iSpeed) (LONG)MCIWndSM(hWnd,MCIWNDM_SETSPEED,0,(LPARAM)(UINT)(iSpeed))
1428 #define MCIWndGetSpeed(hWnd)        (LONG)MCIWndSM(hWnd,MCIWNDM_GETSPEED,0,0)
1429 #define MCIWndSetTimeFormat(hWnd,lp) (LONG)MCIWndSM(hWnd,MCIWNDM_SETTIMEFORMAT,0,(LPARAM)(LPTSTR)(lp))
1430 #define MCIWndGetTimeFormat(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETTIMEFORMAT,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
1431 #define MCIWndValidateMedia(hWnd)   (VOID)MCIWndSM(hWnd,MCIWNDM_VALIDATEMEDIA,0,0)
1432
1433 #define MCIWndSetRepeat(hWnd,f)     (void)MCIWndSM(hWnd,MCIWNDM_SETREPEAT,0,(LPARAM)(BOOL)(f))
1434 #define MCIWndGetRepeat(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_GETREPEAT,0,0)
1435
1436 #define MCIWndUseFrames(hWnd)       MCIWndSetTimeFormat(hWnd,TEXT("frames"))
1437 #define MCIWndUseTime(hWnd)         MCIWndSetTimeFormat(hWnd,TEXT("ms"))
1438
1439 #define MCIWndSetActiveTimer(hWnd,active)                               \
1440         (VOID)MCIWndSM(hWnd,MCIWNDM_SETACTIVETIMER,                     \
1441         (WPARAM)(UINT)(active),0L)
1442 #define MCIWndSetInactiveTimer(hWnd,inactive)                           \
1443         (VOID)MCIWndSM(hWnd,MCIWNDM_SETINACTIVETIMER,                   \
1444         (WPARAM)(UINT)(inactive),0L)
1445 #define MCIWndSetTimers(hWnd,active,inactive)                           \
1446             (VOID)MCIWndSM(hWnd,MCIWNDM_SETTIMERS,(WPARAM)(UINT)(active),\
1447             (LPARAM)(UINT)(inactive))
1448 #define MCIWndGetActiveTimer(hWnd)                                      \
1449         (UINT)MCIWndSM(hWnd,MCIWNDM_GETACTIVETIMER,0,0L);
1450 #define MCIWndGetInactiveTimer(hWnd)                                    \
1451         (UINT)MCIWndSM(hWnd,MCIWNDM_GETINACTIVETIMER,0,0L);
1452
1453 #define MCIWndRealize(hWnd,fBkgnd) (LONG)MCIWndSM(hWnd,MCIWNDM_REALIZE,(WPARAM)(BOOL)(fBkgnd),0)
1454
1455 #define MCIWndSendString(hWnd,sz)  (LONG)MCIWndSM(hWnd,MCIWNDM_SENDSTRING,0,(LPARAM)(LPTSTR)(sz))
1456 #define MCIWndReturnString(hWnd,lp,len)  (LONG)MCIWndSM(hWnd,MCIWNDM_RETURNSTRING,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
1457 #define MCIWndGetError(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETERROR,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
1458
1459 #define MCIWndGetPalette(hWnd)      (HPALETTE)MCIWndSM(hWnd,MCIWNDM_GETPALETTE,0,0)
1460 #define MCIWndSetPalette(hWnd,hpal) (LONG)MCIWndSM(hWnd,MCIWNDM_SETPALETTE,(WPARAM)(HPALETTE)(hpal),0)
1461
1462 #define MCIWndGetFileName(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETFILENAME,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
1463 #define MCIWndGetDevice(hWnd,lp,len)   (LONG)MCIWndSM(hWnd,MCIWNDM_GETDEVICE,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
1464
1465 #define MCIWndGetStyles(hWnd) (UINT)MCIWndSM(hWnd,MCIWNDM_GETSTYLES,0,0L)
1466 #define MCIWndChangeStyles(hWnd,mask,value) (LONG)MCIWndSM(hWnd,MCIWNDM_CHANGESTYLES,(WPARAM)(UINT)(mask),(LPARAM)(LONG)(value))
1467
1468 #define MCIWndOpenInterface(hWnd,pUnk)  (LONG)MCIWndSM(hWnd,MCIWNDM_OPENINTERFACE,0,(LPARAM)(LPUNKNOWN)(pUnk))
1469
1470 #define MCIWndSetOwner(hWnd,hWndP)  (LONG)MCIWndSM(hWnd,MCIWNDM_SETOWNER,(WPARAM)(hWndP),0)
1471
1472 #define MCIWNDM_GETDEVICEID     (WM_USER + 100)
1473 #define MCIWNDM_GETSTART        (WM_USER + 103)
1474 #define MCIWNDM_GETLENGTH       (WM_USER + 104)
1475 #define MCIWNDM_GETEND          (WM_USER + 105)
1476 #define MCIWNDM_EJECT           (WM_USER + 107)
1477 #define MCIWNDM_SETZOOM         (WM_USER + 108)
1478 #define MCIWNDM_GETZOOM         (WM_USER + 109)
1479 #define MCIWNDM_SETVOLUME       (WM_USER + 110)
1480 #define MCIWNDM_GETVOLUME       (WM_USER + 111)
1481 #define MCIWNDM_SETSPEED        (WM_USER + 112)
1482 #define MCIWNDM_GETSPEED        (WM_USER + 113)
1483 #define MCIWNDM_SETREPEAT       (WM_USER + 114)
1484 #define MCIWNDM_GETREPEAT       (WM_USER + 115)
1485 #define MCIWNDM_REALIZE         (WM_USER + 118)
1486 #define MCIWNDM_VALIDATEMEDIA   (WM_USER + 121)
1487 #define MCIWNDM_PLAYFROM        (WM_USER + 122)
1488 #define MCIWNDM_PLAYTO          (WM_USER + 123)
1489 #define MCIWNDM_GETPALETTE      (WM_USER + 126)
1490 #define MCIWNDM_SETPALETTE      (WM_USER + 127)
1491 #define MCIWNDM_SETTIMERS       (WM_USER + 129)
1492 #define MCIWNDM_SETACTIVETIMER  (WM_USER + 130)
1493 #define MCIWNDM_SETINACTIVETIMER (WM_USER + 131)
1494 #define MCIWNDM_GETACTIVETIMER  (WM_USER + 132)
1495 #define MCIWNDM_GETINACTIVETIMER (WM_USER + 133)
1496 #define MCIWNDM_CHANGESTYLES    (WM_USER + 135)
1497 #define MCIWNDM_GETSTYLES       (WM_USER + 136)
1498 #define MCIWNDM_GETALIAS        (WM_USER + 137)
1499 #define MCIWNDM_PLAYREVERSE     (WM_USER + 139)
1500 #define MCIWNDM_GET_SOURCE      (WM_USER + 140)
1501 #define MCIWNDM_PUT_SOURCE      (WM_USER + 141)
1502 #define MCIWNDM_GET_DEST        (WM_USER + 142)
1503 #define MCIWNDM_PUT_DEST        (WM_USER + 143)
1504 #define MCIWNDM_CAN_PLAY        (WM_USER + 144)
1505 #define MCIWNDM_CAN_WINDOW      (WM_USER + 145)
1506 #define MCIWNDM_CAN_RECORD      (WM_USER + 146)
1507 #define MCIWNDM_CAN_SAVE        (WM_USER + 147)
1508 #define MCIWNDM_CAN_EJECT       (WM_USER + 148)
1509 #define MCIWNDM_CAN_CONFIG      (WM_USER + 149)
1510 #define MCIWNDM_PALETTEKICK     (WM_USER + 150)
1511 #define MCIWNDM_OPENINTERFACE   (WM_USER + 151)
1512 #define MCIWNDM_SETOWNER        (WM_USER + 152)
1513
1514 #define MCIWNDM_SENDSTRINGA     (WM_USER + 101)
1515 #define MCIWNDM_GETPOSITIONA    (WM_USER + 102)
1516 #define MCIWNDM_GETMODEA        (WM_USER + 106)
1517 #define MCIWNDM_SETTIMEFORMATA  (WM_USER + 119)
1518 #define MCIWNDM_GETTIMEFORMATA  (WM_USER + 120)
1519 #define MCIWNDM_GETFILENAMEA    (WM_USER + 124)
1520 #define MCIWNDM_GETDEVICEA      (WM_USER + 125)
1521 #define MCIWNDM_GETERRORA       (WM_USER + 128)
1522 #define MCIWNDM_NEWA            (WM_USER + 134)
1523 #define MCIWNDM_RETURNSTRINGA   (WM_USER + 138)
1524 #define MCIWNDM_OPENA           (WM_USER + 153)
1525
1526 #define MCIWNDM_SENDSTRINGW     (WM_USER + 201)
1527 #define MCIWNDM_GETPOSITIONW    (WM_USER + 202)
1528 #define MCIWNDM_GETMODEW        (WM_USER + 206)
1529 #define MCIWNDM_SETTIMEFORMATW  (WM_USER + 219)
1530 #define MCIWNDM_GETTIMEFORMATW  (WM_USER + 220)
1531 #define MCIWNDM_GETFILENAMEW    (WM_USER + 224)
1532 #define MCIWNDM_GETDEVICEW      (WM_USER + 225)
1533 #define MCIWNDM_GETERRORW       (WM_USER + 228)
1534 #define MCIWNDM_NEWW            (WM_USER + 234)
1535 #define MCIWNDM_RETURNSTRINGW   (WM_USER + 238)
1536 #define MCIWNDM_OPENW           (WM_USER + 252)
1537
1538 #define MCIWNDM_SENDSTRING      WINELIB_NAME_AW(MCIWNDM_SENDSTRING)
1539 #define MCIWNDM_GETPOSITION     WINELIB_NAME_AW(MCIWNDM_GETPOSITION)
1540 #define MCIWNDM_GETMODE         WINELIB_NAME_AW(MCIWNDM_GETMODE)
1541 #define MCIWNDM_SETTIMEFORMAT   WINELIB_NAME_AW(MCIWNDM_SETTIMEFORMAT)
1542 #define MCIWNDM_GETTIMEFORMAT   WINELIB_NAME_AW(MCIWNDM_GETTIMEFORMAT)
1543 #define MCIWNDM_GETFILENAME     WINELIB_NAME_AW(MCIWNDM_GETFILENAME)
1544 #define MCIWNDM_GETDEVICE       WINELIB_NAME_AW(MCIWNDM_GETDEVICE)
1545 #define MCIWNDM_GETERROR        WINELIB_NAME_AW(MCIWNDM_GETERROR)
1546 #define MCIWNDM_NEW             WINELIB_NAME_AW(MCIWNDM_NEW)
1547 #define MCIWNDM_RETURNSTRING    WINELIB_NAME_AW(MCIWNDM_RETURNSTRING)
1548 #define MCIWNDM_OPEN            WINELIB_NAME_AW(MCIWNDM_OPEN)
1549
1550 #define MCIWNDM_NOTIFYMODE      (WM_USER + 200)
1551 #define MCIWNDM_NOTIFYPOS       (WM_USER + 201)
1552 #define MCIWNDM_NOTIFYSIZE      (WM_USER + 202)
1553 #define MCIWNDM_NOTIFYMEDIA     (WM_USER + 203)
1554 #define MCIWNDM_NOTIFYERROR     (WM_USER + 205)
1555
1556 #define MCIWND_START                -1
1557 #define MCIWND_END                  -2
1558
1559 /********************************************
1560  * DrawDib declarations
1561  */
1562
1563 typedef struct
1564 {
1565     LONG    timeCount;
1566     LONG    timeDraw;
1567     LONG    timeDecompress;
1568     LONG    timeDither;
1569     LONG    timeStretch;
1570     LONG    timeBlt;
1571     LONG    timeSetDIBits;
1572 } DRAWDIBTIME, *LPDRAWDIBTIME;
1573
1574 HDRAWDIB VFWAPI DrawDibOpen( void );
1575 UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground);
1576
1577 BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd, HDC hdc, INT dxDst, INT dyDst,
1578                          LPBITMAPINFOHEADER lpbi, INT dxSrc, INT dySrc, UINT wFlags);
1579
1580 BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc, INT xDst, INT yDst, INT dxDst, INT dyDst,
1581                         LPBITMAPINFOHEADER lpbi, LPVOID lpBits,
1582                         INT xSrc, INT ySrc, INT dxSrc, INT dySrc, UINT wFlags);
1583
1584 /* DrawDibDraw flags */
1585
1586 #define DDF_UPDATE                      0x0002
1587 #define DDF_SAME_HDC                    0x0004
1588 #define DDF_SAME_DRAW                   0x0008
1589 #define DDF_DONTDRAW                    0x0010
1590 #define DDF_ANIMATE                     0x0020
1591 #define DDF_BUFFER                      0x0040
1592 #define DDF_JUSTDRAWIT                  0x0080
1593 #define DDF_FULLSCREEN                  0x0100
1594 #define DDF_BACKGROUNDPAL               0x0200
1595 #define DDF_NOTKEYFRAME                 0x0400
1596 #define DDF_HURRYUP                     0x0800
1597 #define DDF_HALFTONE                    0x1000
1598
1599 #define DDF_PREROLL                     DDF_DONTDRAW
1600 #define DDF_SAME_DIB                    DDF_SAME_DRAW
1601 #define DDF_SAME_SIZE                   DDF_SAME_DRAW
1602
1603 BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal);
1604 HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd);
1605 BOOL VFWAPI DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe);
1606 LPVOID VFWAPI DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags);
1607
1608 BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate);
1609 BOOL VFWAPI DrawDibStop(HDRAWDIB hdd);
1610 #define DrawDibUpdate(hdd, hdc, x, y) \
1611         DrawDibDraw(hdd, hdc, x, y, 0, 0, NULL, NULL, 0, 0, 0, 0, DDF_UPDATE)
1612
1613 BOOL VFWAPI DrawDibEnd(HDRAWDIB hdd);
1614 BOOL VFWAPI DrawDibClose(HDRAWDIB hdd);
1615 BOOL VFWAPI DrawDibTime(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime);
1616
1617 /* display profiling */
1618 #define PD_CAN_DRAW_DIB         0x0001
1619 #define PD_CAN_STRETCHDIB       0x0002
1620 #define PD_STRETCHDIB_1_1_OK    0x0004
1621 #define PD_STRETCHDIB_1_2_OK    0x0008
1622 #define PD_STRETCHDIB_1_N_OK    0x0010
1623
1624 DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi);
1625
1626 DECLARE_HANDLE(HVIDEO);
1627 typedef HVIDEO *LPHVIDEO;
1628
1629 DWORD VFWAPI VideoForWindowsVersion(void);
1630
1631 LONG  VFWAPI InitVFW(void);
1632 LONG  VFWAPI TermVFW(void);
1633
1634 #define DV_ERR_OK            (0)
1635 #define DV_ERR_BASE          (1)
1636 #define DV_ERR_NONSPECIFIC   (DV_ERR_BASE)
1637 #define DV_ERR_BADFORMAT     (DV_ERR_BASE + 1)
1638 #define DV_ERR_STILLPLAYING  (DV_ERR_BASE + 2)
1639 #define DV_ERR_UNPREPARED    (DV_ERR_BASE + 3)
1640 #define DV_ERR_SYNC          (DV_ERR_BASE + 4)
1641 #define DV_ERR_TOOMANYCHANNELS (DV_ERR_BASE + 5)
1642 #define DV_ERR_NOTDETECTED   (DV_ERR_BASE + 6)
1643 #define DV_ERR_BADINSTALL    (DV_ERR_BASE + 7)
1644 #define DV_ERR_CREATEPALETTE (DV_ERR_BASE + 8)
1645 #define DV_ERR_SIZEFIELD     (DV_ERR_BASE + 9)
1646 #define DV_ERR_PARAM1        (DV_ERR_BASE + 10)
1647 #define DV_ERR_PARAM2        (DV_ERR_BASE + 11)
1648 #define DV_ERR_CONFIG1       (DV_ERR_BASE + 12)
1649 #define DV_ERR_CONFIG2       (DV_ERR_BASE + 13)
1650 #define DV_ERR_FLAGS         (DV_ERR_BASE + 14)
1651 #define DV_ERR_13            (DV_ERR_BASE + 15)
1652
1653 #define DV_ERR_NOTSUPPORTED  (DV_ERR_BASE + 16)
1654 #define DV_ERR_NOMEM         (DV_ERR_BASE + 17)
1655 #define DV_ERR_ALLOCATED     (DV_ERR_BASE + 18)
1656 #define DV_ERR_BADDEVICEID   (DV_ERR_BASE + 19)
1657 #define DV_ERR_INVALHANDLE   (DV_ERR_BASE + 20)
1658 #define DV_ERR_BADERRNUM     (DV_ERR_BASE + 21)
1659 #define DV_ERR_NO_BUFFERS    (DV_ERR_BASE + 22)
1660
1661 #define DV_ERR_MEM_CONFLICT  (DV_ERR_BASE + 23)
1662 #define DV_ERR_IO_CONFLICT   (DV_ERR_BASE + 24)
1663 #define DV_ERR_DMA_CONFLICT  (DV_ERR_BASE + 25)
1664 #define DV_ERR_INT_CONFLICT  (DV_ERR_BASE + 26)
1665 #define DV_ERR_PROTECT_ONLY  (DV_ERR_BASE + 27)
1666 #define DV_ERR_LASTERROR     (DV_ERR_BASE + 27)
1667
1668 #define DV_ERR_USER_MSG      (DV_ERR_BASE + 1000)
1669
1670 #ifndef MM_DRVM_OPEN
1671 #define MM_DRVM_OPEN       0x3D0
1672 #define MM_DRVM_CLOSE      0x3D1
1673 #define MM_DRVM_DATA       0x3D2
1674 #define MM_DRVM_ERROR      0x3D3
1675
1676 #define DV_VM_OPEN         MM_DRVM_OPEN
1677 #define DV_VM_CLOSE        MM_DRVM_CLOSE
1678 #define DV_VM_DATA         MM_DRVM_DATA
1679 #define DV_VM_ERROR        MM_DRVM_ERROR
1680 #endif
1681
1682 typedef struct videohdr_tag {
1683     LPBYTE      lpData;
1684     DWORD       dwBufferLength;
1685     DWORD       dwBytesUsed;
1686     DWORD       dwTimeCaptured;
1687     DWORD       dwUser;
1688     DWORD       dwFlags;
1689     DWORD       dwReserved[4];
1690 } VIDEOHDR, *PVIDEOHDR, *LPVIDEOHDR;
1691
1692 #define VHDR_DONE       0x00000001
1693 #define VHDR_PREPARED   0x00000002
1694 #define VHDR_INQUEUE    0x00000004
1695 #define VHDR_KEYFRAME   0x00000008
1696
1697 typedef struct channel_caps_tag {
1698     DWORD       dwFlags;
1699     DWORD       dwSrcRectXMod;
1700     DWORD       dwSrcRectYMod;
1701     DWORD       dwSrcRectWidthMod;
1702     DWORD       dwSrcRectHeightMod;
1703     DWORD       dwDstRectXMod;
1704     DWORD       dwDstRectYMod;
1705     DWORD       dwDstRectWidthMod;
1706     DWORD       dwDstRectHeightMod;
1707 } CHANNEL_CAPS, *PCHANNEL_CAPS, *LPCHANNEL_CAPS;
1708
1709 #define VCAPS_OVERLAY       0x00000001
1710 #define VCAPS_SRC_CAN_CLIP  0x00000002
1711 #define VCAPS_DST_CAN_CLIP  0x00000004
1712 #define VCAPS_CAN_SCALE     0x00000008
1713
1714 #define VIDEO_EXTERNALIN        0x0001
1715 #define VIDEO_EXTERNALOUT       0x0002
1716 #define VIDEO_IN                0x0004
1717 #define VIDEO_OUT               0x0008
1718
1719 #define VIDEO_DLG_QUERY         0x0010
1720
1721 #define VIDEO_CONFIGURE_QUERY   0x8000
1722
1723 #define VIDEO_CONFIGURE_SET     0x1000
1724
1725 #define VIDEO_CONFIGURE_GET     0x2000
1726 #define VIDEO_CONFIGURE_QUERYSIZE 0x0001
1727
1728 #define VIDEO_CONFIGURE_CURRENT 0x0010
1729 #define VIDEO_CONFIGURE_NOMINAL 0x0020
1730 #define VIDEO_CONFIGURE_MIN     0x0040
1731 #define VIDEO_CONFIGURE_MAX     0x0080
1732
1733 #define DVM_USER                0x4000
1734
1735 #define DVM_CONFIGURE_START     0x1000
1736 #define DVM_CONFIGURE_END       0x1FFF
1737
1738 #define DVM_PALETTE             (DVM_CONFIGURE_START + 1)
1739 #define DVM_FORMAT              (DVM_CONFIGURE_START + 2)
1740 #define DVM_PALETTERGB555       (DVM_CONFIGURE_START + 3)
1741 #define DVM_SRC_RECT            (DVM_CONFIGURE_START + 4)
1742 #define DVM_DST_RECT            (DVM_CONFIGURE_START + 5)
1743
1744 #define AVICapSM(hwnd,m,w,l) ((IsWindow(hwnd)) ? SendMessage(hwnd,m,w,l) : 0)
1745
1746 #define WM_CAP_START                    WM_USER
1747
1748 #define WM_CAP_UNICODE_START            WM_USER+100
1749
1750 #define WM_CAP_GET_CAPSTREAMPTR         (WM_CAP_START + 1)
1751
1752 #define WM_CAP_SET_CALLBACK_ERRORW      (WM_CAP_UNICODE_START + 2)
1753 #define WM_CAP_SET_CALLBACK_STATUSW     (WM_CAP_UNICODE_START + 3)
1754 #define WM_CAP_SET_CALLBACK_ERRORA      (WM_CAP_START + 2)
1755 #define WM_CAP_SET_CALLBACK_STATUSA     (WM_CAP_START+ 3)
1756
1757 #define WM_CAP_SET_CALLBACK_ERROR       WINELIB_NAME_AW(WM_CAP_SET_CALLBACK_ERROR)
1758 #define WM_CAP_SET_CALLBACK_STATUS      WINELIB_NAME_AW(WM_CAP_SET_CALLBACK_STATUS)
1759
1760 #define WM_CAP_SET_CALLBACK_YIELD       (WM_CAP_START +  4)
1761 #define WM_CAP_SET_CALLBACK_FRAME       (WM_CAP_START +  5)
1762 #define WM_CAP_SET_CALLBACK_VIDEOSTREAM (WM_CAP_START +  6)
1763 #define WM_CAP_SET_CALLBACK_WAVESTREAM  (WM_CAP_START +  7)
1764 #define WM_CAP_GET_USER_DATA            (WM_CAP_START +  8)
1765 #define WM_CAP_SET_USER_DATA            (WM_CAP_START +  9)
1766
1767 #define WM_CAP_DRIVER_CONNECT           (WM_CAP_START +  10)
1768 #define WM_CAP_DRIVER_DISCONNECT        (WM_CAP_START +  11)
1769
1770 #define WM_CAP_DRIVER_GET_NAMEA         (WM_CAP_START +  12)
1771 #define WM_CAP_DRIVER_GET_VERSIONA      (WM_CAP_START +  13)
1772 #define WM_CAP_DRIVER_GET_NAMEW         (WM_CAP_UNICODE_START +  12)
1773 #define WM_CAP_DRIVER_GET_VERSIONW      (WM_CAP_UNICODE_START +  13)
1774
1775 #define WM_CAP_DRIVER_GET_NAME          WINELIB_NAME_AW(WM_CAP_DRIVER_GET_NAME)
1776 #define WM_CAP_DRIVER_GET_VERSION       WINELIB_NAME_AW(WM_CAP_DRIVER_GET_VERSION)
1777
1778 #define WM_CAP_DRIVER_GET_CAPS          (WM_CAP_START +  14)
1779
1780 #define WM_CAP_FILE_SET_CAPTURE_FILEA   (WM_CAP_START +  20)
1781 #define WM_CAP_FILE_GET_CAPTURE_FILEA   (WM_CAP_START +  21)
1782 #define WM_CAP_FILE_ALLOCATE            (WM_CAP_START +  22)
1783 #define WM_CAP_FILE_SAVEASA             (WM_CAP_START +  23)
1784 #define WM_CAP_FILE_SET_INFOCHUNK       (WM_CAP_START +  24)
1785 #define WM_CAP_FILE_SAVEDIBA            (WM_CAP_START +  25)
1786 #define WM_CAP_FILE_SET_CAPTURE_FILEW   (WM_CAP_UNICODE_START +  20)
1787 #define WM_CAP_FILE_GET_CAPTURE_FILEW   (WM_CAP_UNICODE_START +  21)
1788 #define WM_CAP_FILE_SAVEASW             (WM_CAP_UNICODE_START +  23)
1789 #define WM_CAP_FILE_SAVEDIBW            (WM_CAP_UNICODE_START +  25)
1790
1791 #define WM_CAP_FILE_SET_CAPTURE_FILE    WINELIB_NAME_AW(WM_CAP_FILE_SET_CAPTURE_FILE)
1792 #define WM_CAP_FILE_GET_CAPTURE_FILE    WINELIB_NAME_AW(WM_CAP_FILE_GET_CAPTURE_FILE)
1793 #define WM_CAP_FILE_SAVEAS              WINELIB_NAME_AW(WM_CAP_FILE_SAVEAS)
1794 #define WM_CAP_FILE_SAVEDIB             WINELIB_NAME_AW(WM_CAP_FILE_SAVEDIB)
1795
1796 #define WM_CAP_EDIT_COPY                (WM_CAP_START +  30)
1797
1798 #define WM_CAP_SET_AUDIOFORMAT          (WM_CAP_START +  35)
1799 #define WM_CAP_GET_AUDIOFORMAT          (WM_CAP_START +  36)
1800
1801 #define WM_CAP_DLG_VIDEOFORMAT          (WM_CAP_START +  41)
1802 #define WM_CAP_DLG_VIDEOSOURCE          (WM_CAP_START +  42)
1803 #define WM_CAP_DLG_VIDEODISPLAY         (WM_CAP_START +  43)
1804 #define WM_CAP_GET_VIDEOFORMAT          (WM_CAP_START +  44)
1805 #define WM_CAP_SET_VIDEOFORMAT          (WM_CAP_START +  45)
1806 #define WM_CAP_DLG_VIDEOCOMPRESSION     (WM_CAP_START +  46)
1807
1808 #define WM_CAP_SET_PREVIEW              (WM_CAP_START +  50)
1809 #define WM_CAP_SET_OVERLAY              (WM_CAP_START +  51)
1810 #define WM_CAP_SET_PREVIEWRATE          (WM_CAP_START +  52)
1811 #define WM_CAP_SET_SCALE                (WM_CAP_START +  53)
1812 #define WM_CAP_GET_STATUS               (WM_CAP_START +  54)
1813 #define WM_CAP_SET_SCROLL               (WM_CAP_START +  55)
1814
1815 #define WM_CAP_GRAB_FRAME               (WM_CAP_START +  60)
1816 #define WM_CAP_GRAB_FRAME_NOSTOP        (WM_CAP_START +  61)
1817
1818 #define WM_CAP_SEQUENCE                 (WM_CAP_START +  62)
1819 #define WM_CAP_SEQUENCE_NOFILE          (WM_CAP_START +  63)
1820 #define WM_CAP_SET_SEQUENCE_SETUP       (WM_CAP_START +  64)
1821 #define WM_CAP_GET_SEQUENCE_SETUP       (WM_CAP_START +  65)
1822
1823 #define WM_CAP_SET_MCI_DEVICEA          (WM_CAP_START +  66)
1824 #define WM_CAP_GET_MCI_DEVICEA          (WM_CAP_START +  67)
1825 #define WM_CAP_SET_MCI_DEVICEW          (WM_CAP_UNICODE_START +  66)
1826 #define WM_CAP_GET_MCI_DEVICEW          (WM_CAP_UNICODE_START +  67)
1827
1828 #define WM_CAP_SET_MCI_DEVICE           WINELIB_NAME_AW(WM_CAP_SET_MCI_DEVICE)
1829 #define WM_CAP_GET_MCI_DEVICE           WINELIB_NAME_AW(WM_CAP_GET_MCI_DEVICE)
1830
1831 #define WM_CAP_STOP                     (WM_CAP_START +  68)
1832 #define WM_CAP_ABORT                    (WM_CAP_START +  69)
1833
1834 #define WM_CAP_SINGLE_FRAME_OPEN        (WM_CAP_START +  70)
1835 #define WM_CAP_SINGLE_FRAME_CLOSE       (WM_CAP_START +  71)
1836 #define WM_CAP_SINGLE_FRAME             (WM_CAP_START +  72)
1837
1838 #define WM_CAP_PAL_OPENA                (WM_CAP_START +  80)
1839 #define WM_CAP_PAL_SAVEA                (WM_CAP_START +  81)
1840 #define WM_CAP_PAL_OPENW                (WM_CAP_UNICODE_START +  80)
1841 #define WM_CAP_PAL_SAVEW                (WM_CAP_UNICODE_START +  81)
1842
1843 #define WM_CAP_PAL_OPEN                 WINELIB_NAME_AW(WM_CAP_PAL_OPEN)
1844 #define WM_CAP_PAL_SAVE                 WINELIB_NAME_AW(WM_CAP_PAL_SAVE)
1845
1846 #define WM_CAP_PAL_PASTE                (WM_CAP_START +  82)
1847 #define WM_CAP_PAL_AUTOCREATE           (WM_CAP_START +  83)
1848 #define WM_CAP_PAL_MANUALCREATE         (WM_CAP_START +  84)
1849
1850 #define WM_CAP_SET_CALLBACK_CAPCONTROL  (WM_CAP_START +  85)
1851
1852 #define WM_CAP_UNICODE_END              WM_CAP_PAL_SAVEW
1853 #define WM_CAP_END                      WM_CAP_UNICODE_END
1854
1855 typedef struct tagCapDriverCaps {
1856     UINT        wDeviceIndex;
1857     BOOL        fHasOverlay;
1858     BOOL        fHasDlgVideoSource;
1859     BOOL        fHasDlgVideoFormat;
1860     BOOL        fHasDlgVideoDisplay;
1861     BOOL        fCaptureInitialized;
1862     BOOL        fDriverSuppliesPalettes;
1863     HANDLE      hVideoIn;
1864     HANDLE      hVideoOut;
1865     HANDLE      hVideoExtIn;
1866     HANDLE      hVideoExtOut;
1867 } CAPDRIVERCAPS, *PCAPDRIVERCAPS, *LPCAPDRIVERCAPS;
1868
1869 typedef struct tagCapStatus {
1870     UINT        uiImageWidth;
1871     UINT        uiImageHeight;
1872     BOOL        fLiveWindow;
1873     BOOL        fOverlayWindow;
1874     BOOL        fScale;
1875     POINT       ptScroll;
1876     BOOL        fUsingDefaultPalette;
1877     BOOL        fAudioHardware;
1878     BOOL        fCapFileExists;
1879     DWORD       dwCurrentVideoFrame;
1880     DWORD       dwCurrentVideoFramesDropped;
1881     DWORD       dwCurrentWaveSamples;
1882     DWORD       dwCurrentTimeElapsedMS;
1883     HPALETTE    hPalCurrent;
1884     BOOL        fCapturingNow;
1885     DWORD       dwReturn;
1886     UINT        wNumVideoAllocated;
1887     UINT        wNumAudioAllocated;
1888 } CAPSTATUS, *PCAPSTATUS, *LPCAPSTATUS;
1889
1890
1891 typedef struct tagCaptureParms {
1892     DWORD       dwRequestMicroSecPerFrame;
1893     BOOL        fMakeUserHitOKToCapture;
1894     UINT        wPercentDropForError;
1895     BOOL        fYield;
1896     DWORD       dwIndexSize;
1897     UINT        wChunkGranularity;
1898     BOOL        fUsingDOSMemory;
1899     UINT        wNumVideoRequested;
1900     BOOL        fCaptureAudio;
1901     UINT        wNumAudioRequested;
1902     UINT        vKeyAbort;
1903     BOOL        fAbortLeftMouse;
1904     BOOL        fAbortRightMouse;
1905     BOOL        fLimitEnabled;
1906     UINT        wTimeLimit;
1907     BOOL        fMCIControl;
1908     BOOL        fStepMCIDevice;
1909     DWORD       dwMCIStartTime;
1910     DWORD       dwMCIStopTime;
1911     BOOL        fStepCaptureAt2x;
1912     UINT        wStepCaptureAverageFrames;
1913     DWORD       dwAudioBufferSize;
1914     BOOL        fDisableWriteCache;
1915     UINT        AVStreamMaster;
1916 } CAPTUREPARMS, *PCAPTUREPARMS, *LPCAPTUREPARMS;
1917
1918 typedef LRESULT (CALLBACK* CAPYIELDCALLBACK)  (HWND hWnd);
1919 typedef LRESULT (CALLBACK* CAPSTATUSCALLBACKW) (HWND hWnd, int nID, LPCWSTR lpsz);
1920 typedef LRESULT (CALLBACK* CAPERRORCALLBACKW)  (HWND hWnd, int nID, LPCWSTR lpsz);
1921 typedef LRESULT (CALLBACK* CAPSTATUSCALLBACKA) (HWND hWnd, int nID, LPCSTR lpsz);
1922 typedef LRESULT (CALLBACK* CAPERRORCALLBACKA)  (HWND hWnd, int nID, LPCSTR lpsz);
1923 typedef LRESULT (CALLBACK* CAPVIDEOCALLBACK)  (HWND hWnd, LPVIDEOHDR lpVHdr);
1924 typedef LRESULT (CALLBACK* CAPWAVECALLBACK)   (HWND hWnd, LPWAVEHDR lpWHdr);
1925 typedef LRESULT (CALLBACK* CAPCONTROLCALLBACK)(HWND hWnd, int nState);
1926
1927 HWND VFWAPI capCreateCaptureWindowA(LPCSTR,DWORD,INT,INT,INT,INT,HWND,INT);
1928 HWND VFWAPI capCreateCaptureWindowW(LPCWSTR,DWORD,INT,INT,INT,INT,HWND,INT);
1929 #define     capCreateCaptureWindow WINELIB_NAME_AW(capCreateCaptureWindow)
1930 BOOL VFWAPI capGetDriverDescriptionA(WORD,LPSTR,INT,LPSTR,INT);
1931 BOOL VFWAPI capGetDriverDescriptionW(WORD,LPWSTR,INT,LPWSTR,INT);
1932 #define     capGetDriverDescription WINELIB_NAME_AW(capGetDriverDescription)
1933
1934 #ifdef __cplusplus
1935 }
1936 #endif  /* __cplusplus */
1937
1938 #endif /* __WINE_VFW_H */