git.oblomov.eu Git - wine/blob - include/vfw.h

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