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