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

   1 #ifndef __WINE_VFW_H
   2 #define __WINE_VFW_H
   3
   4 #include "wintypes.h"
   5 #include "wingdi.h"
   6 #include "driver.h"
   7 #include "objbase.h"
   8
   9 #define VFWAPI  WINAPI
  10 #define VFWAPIV WINAPIV
  11
  12 DWORD VFWAPI VideoForWindowsVersion(void);
  13
  14 #ifndef mmioFOURCC
  15 #define mmioFOURCC( ch0, ch1, ch2, ch3 )                                \
  16         ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |            \
  17         ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
  18 #endif
  19
  20 #ifndef aviTWOCC
  21 #define aviTWOCC(ch0, ch1) ((WORD)(BYTE)(ch0) | ((WORD)(BYTE)(ch1) << 8))
  22 #endif
  23
  24 #define ICTYPE_VIDEO    mmioFOURCC('v', 'i', 'd', 'c')
  25 #define ICTYPE_AUDIO    mmioFOURCC('a', 'u', 'd', 'c')
  26
  27 /* Installable Compressor M? */
  28
  29 /* HIC32 struct (same layout as Win95 one) */
  30 typedef struct tagWINE_HIC {
  31         DWORD           magic;          /* 00: 'Smag' */
  32         HANDLE32        curthread;      /* 04: */
  33         DWORD           type;           /* 08: */
  34         DWORD           handler;        /* 0C: */
  35         HDRVR32         hdrv;           /* 10: */
  36         DWORD           private;        /* 14:(handled by SendDriverMessage32)*/
  37         FARPROC32       driverproc;     /* 18:(handled by SendDriverMessage32)*/
  38         DWORD           x1;             /* 1c: name? */
  39         WORD            x2;             /* 20: */
  40         DWORD           x3;             /* 22: */
  41                                         /* 26: */
  42 } WINE_HIC;
  43
  44 /* error return codes */
  45 #define ICERR_OK                0
  46 #define ICERR_DONTDRAW          1
  47 #define ICERR_NEWPALETTE        2
  48 #define ICERR_GOTOKEYFRAME      3
  49 #define ICERR_STOPDRAWING       4
  50
  51 #define ICERR_UNSUPPORTED       -1
  52 #define ICERR_BADFORMAT         -2
  53 #define ICERR_MEMORY            -3
  54 #define ICERR_INTERNAL          -4
  55 #define ICERR_BADFLAGS          -5
  56 #define ICERR_BADPARAM          -6
  57 #define ICERR_BADSIZE           -7
  58 #define ICERR_BADHANDLE         -8
  59 #define ICERR_CANTUPDATE        -9
  60 #define ICERR_ABORT             -10
  61 #define ICERR_ERROR             -100
  62 #define ICERR_BADBITDEPTH       -200
  63 #define ICERR_BADIMAGESIZE      -201
  64
  65 #define ICERR_CUSTOM            -400
  66
  67 /* ICM Messages */
  68 #define ICM_USER                (DRV_USER+0x0000)
  69
  70 /* ICM driver message range */
  71 #define ICM_RESERVED_LOW        (DRV_USER+0x1000)
  72 #define ICM_RESERVED_HIGH       (DRV_USER+0x2000)
  73 #define ICM_RESERVED            ICM_RESERVED_LOW
  74
  75 #define ICM_GETSTATE            (ICM_RESERVED+0)
  76 #define ICM_SETSTATE            (ICM_RESERVED+1)
  77 #define ICM_GETINFO             (ICM_RESERVED+2)
  78
  79 #define ICM_CONFIGURE           (ICM_RESERVED+10)
  80 #define ICM_ABOUT               (ICM_RESERVED+11)
  81 /* */
  82
  83 #define ICM_GETDEFAULTQUALITY   (ICM_RESERVED+30)
  84 #define ICM_GETQUALITY          (ICM_RESERVED+31)
  85 #define ICM_SETQUALITY          (ICM_RESERVED+32)
  86
  87 #define ICM_SET                 (ICM_RESERVED+40)
  88 #define ICM_GET                 (ICM_RESERVED+41)
  89
  90 /* 2 constant FOURCC codes */
  91 #define ICM_FRAMERATE           mmioFOURCC('F','r','m','R')
  92 #define ICM_KEYFRAMERATE        mmioFOURCC('K','e','y','R')
  93
  94 #define ICM_COMPRESS_GET_FORMAT         (ICM_USER+4)
  95 #define ICM_COMPRESS_GET_SIZE           (ICM_USER+5)
  96 #define ICM_COMPRESS_QUERY              (ICM_USER+6)
  97 #define ICM_COMPRESS_BEGIN              (ICM_USER+7)
  98 #define ICM_COMPRESS                    (ICM_USER+8)
  99 #define ICM_COMPRESS_END                (ICM_USER+9)
 100
 101 #define ICM_DECOMPRESS_GET_FORMAT       (ICM_USER+10)
 102 #define ICM_DECOMPRESS_QUERY            (ICM_USER+11)
 103 #define ICM_DECOMPRESS_BEGIN            (ICM_USER+12)
 104 #define ICM_DECOMPRESS                  (ICM_USER+13)
 105 #define ICM_DECOMPRESS_END              (ICM_USER+14)
 106 #define ICM_DECOMPRESS_SET_PALETTE      (ICM_USER+29)
 107 #define ICM_DECOMPRESS_GET_PALETTE      (ICM_USER+30)
 108
 109 #define ICM_DRAW_QUERY                  (ICM_USER+31)
 110 #define ICM_DRAW_BEGIN                  (ICM_USER+15)
 111 #define ICM_DRAW_GET_PALETTE            (ICM_USER+16)
 112 #define ICM_DRAW_START                  (ICM_USER+18)
 113 #define ICM_DRAW_STOP                   (ICM_USER+19)
 114 #define ICM_DRAW_END                    (ICM_USER+21)
 115 #define ICM_DRAW_GETTIME                (ICM_USER+32)
 116 #define ICM_DRAW                        (ICM_USER+33)
 117 #define ICM_DRAW_WINDOW                 (ICM_USER+34)
 118 #define ICM_DRAW_SETTIME                (ICM_USER+35)
 119 #define ICM_DRAW_REALIZE                (ICM_USER+36)
 120 #define ICM_DRAW_FLUSH                  (ICM_USER+37)
 121 #define ICM_DRAW_RENDERBUFFER           (ICM_USER+38)
 122
 123 #define ICM_DRAW_START_PLAY             (ICM_USER+39)
 124 #define ICM_DRAW_STOP_PLAY              (ICM_USER+40)
 125
 126 #define ICM_DRAW_SUGGESTFORMAT          (ICM_USER+50)
 127 #define ICM_DRAW_CHANGEPALETTE          (ICM_USER+51)
 128
 129 #define ICM_GETBUFFERSWANTED            (ICM_USER+41)
 130
 131 #define ICM_GETDEFAULTKEYFRAMERATE      (ICM_USER+42)
 132
 133 #define ICM_DECOMPRESSEX_BEGIN          (ICM_USER+60)
 134 #define ICM_DECOMPRESSEX_QUERY          (ICM_USER+61)
 135 #define ICM_DECOMPRESSEX                (ICM_USER+62)
 136 #define ICM_DECOMPRESSEX_END            (ICM_USER+63)
 137
 138 #define ICM_COMPRESS_FRAMES_INFO        (ICM_USER+70)
 139 #define ICM_SET_STATUS_PROC             (ICM_USER+72)
 140
 141 /* structs */
 142
 143 typedef struct {
 144         DWORD   dwSize;         /* 00: size */
 145         DWORD   fccType;        /* 04: type 'vidc' usually */
 146         DWORD   fccHandler;     /* 08: */
 147         DWORD   dwVersion;      /* 0c: version of compman opening you */
 148         DWORD   dwFlags;        /* 10: LOWORD is type specific */
 149         LRESULT dwError;        /* 14: */
 150         LPVOID  pV1Reserved;    /* 18: */
 151         LPVOID  pV2Reserved;    /* 1c: */
 152         DWORD   dnDevNode;      /* 20: */
 153                                 /* 24: */
 154 } ICOPEN,*LPICOPEN;
 155
 156 #define ICCOMPRESS_KEYFRAME     0x00000001L
 157
 158 typedef struct {
 159     DWORD               dwFlags;
 160     LPBITMAPINFOHEADER  lpbiOutput;
 161     LPVOID              lpOutput;
 162     LPBITMAPINFOHEADER  lpbiInput;
 163     LPVOID              lpInput;
 164     LPDWORD             lpckid;
 165     LPDWORD             lpdwFlags;
 166     LONG                lFrameNum;
 167     DWORD               dwFrameSize;
 168     DWORD               dwQuality;
 169     LPBITMAPINFOHEADER  lpbiPrev;
 170     LPVOID              lpPrev;
 171 } ICCOMPRESS;
 172
 173 DWORD VFWAPIV ICCompress32(
 174         HIC32 hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
 175         LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
 176         LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
 177         LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
 178 );
 179
 180 #define ICCompressGetFormat32(hic, lpbiInput, lpbiOutput)               \
 181         ICSendMessage32(                                                \
 182             hic,ICM_COMPRESS_GET_FORMAT,(DWORD)(LPVOID)(lpbiInput),     \
 183             (DWORD)(LPVOID)(lpbiOutput)                                 \
 184         )
 185 #define ICCompressGetFormat WINELIB_NAME(ICCompressGetFormat)
 186
 187 #define ICCompressGetFormatSize32(hic,lpbi) ICCompressGetFormat32(hic,lpbi,NULL)
 188 #define ICCompressGetFormatSize WINELIB_NAME(ICCompressGetFormatSize)
 189
 190 #define ICCompressBegin32(hic, lpbiInput, lpbiOutput)                   \
 191     ICSendMessage32(                                                    \
 192         hic, ICM_COMPRESS_BEGIN, (DWORD)(LPVOID)(lpbiInput),            \
 193         (DWORD)(LPVOID)(lpbiOutput)                                     \
 194     )
 195 #define ICCompressBegin WINELIB_NAME(ICCompressBegin)
 196
 197 #define ICCompressGetSize32(hic, lpbiInput, lpbiOutput)                 \
 198     ICSendMessage32(                                                    \
 199         hic, ICM_COMPRESS_GET_SIZE, (DWORD)(LPVOID)(lpbiInput),         \
 200         (DWORD)(LPVOID)(lpbiOutput)                                     \
 201     )
 202 #define ICCompressGetSize WINELIB_NAME(ICCompressGetSize)
 203
 204 #define ICCompressQuery32(hic, lpbiInput, lpbiOutput)           \
 205     ICSendMessage32(                                            \
 206         hic, ICM_COMPRESS_QUERY, (DWORD)(LPVOID)(lpbiInput),    \
 207         (DWORD)(LPVOID)(lpbiOutput)                             \
 208     )
 209 #define ICCompressQuery WINELIB_NAME(ICCompressQuery)
 210
 211
 212 #define ICCompressEnd32(hic) ICSendMessage32(hic, ICM_COMPRESS_END, 0, 0)
 213 #define ICCompressEnd WINELIB_NAME(ICCompressEnd)
 214
 215 /* ICCOMPRESSFRAMES.dwFlags */
 216 #define ICCOMPRESSFRAMES_PADDING        0x00000001
 217 typedef struct {
 218     DWORD               dwFlags;
 219     LPBITMAPINFOHEADER  lpbiOutput;
 220     LPARAM              lOutput;
 221     LPBITMAPINFOHEADER  lpbiInput;
 222     LPARAM              lInput;
 223     LONG                lStartFrame;
 224     LONG                lFrameCount;
 225     LONG                lQuality;
 226     LONG                lDataRate;
 227     LONG                lKeyRate;
 228     DWORD               dwRate;
 229     DWORD               dwScale;
 230     DWORD               dwOverheadPerFrame;
 231     DWORD               dwReserved2;
 232     LONG (CALLBACK *GetData)(LPARAM lInput,LONG lFrame,LPVOID lpBits,LONG len);
 233     LONG (CALLBACK *PutData)(LPARAM lOutput,LONG lFrame,LPVOID lpBits,LONG len);
 234 } ICCOMPRESSFRAMES;
 235
 236 /* Values for wMode of ICOpen() */
 237 #define ICMODE_COMPRESS         1
 238 #define ICMODE_DECOMPRESS       2
 239 #define ICMODE_FASTDECOMPRESS   3
 240 #define ICMODE_QUERY            4
 241 #define ICMODE_FASTCOMPRESS     5
 242 #define ICMODE_DRAW             8
 243
 244 /* quality flags */
 245 #define ICQUALITY_LOW       0
 246 #define ICQUALITY_HIGH      10000
 247 #define ICQUALITY_DEFAULT   -1
 248
 249 typedef struct {
 250         DWORD   dwSize;         /* 00: */
 251         DWORD   fccType;        /* 04:compressor type     'vidc' 'audc' */
 252         DWORD   fccHandler;     /* 08:compressor sub-type 'rle ' 'jpeg' 'pcm '*/
 253         DWORD   dwFlags;        /* 0c:flags LOWORD is type specific */
 254         DWORD   dwVersion;      /* 10:version of the driver */
 255         DWORD   dwVersionICM;   /* 14:version of the ICM used */
 256         /*
 257          * under Win32, the driver always returns UNICODE strings.
 258          */
 259         WCHAR   szName[16];             /* 18:short name */
 260         WCHAR   szDescription[128];     /* 38:long name */
 261         WCHAR   szDriver[128];          /* 138:driver that contains compressor*/
 262                                         /* 238: */
 263 } ICINFO32;
 264 DECL_WINELIB_TYPE(ICINFO)
 265
 266 /* ICINFO.dwFlags */
 267 #define VIDCF_QUALITY           0x0001  /* supports quality */
 268 #define VIDCF_CRUNCH            0x0002  /* supports crunching to a frame size */
 269 #define VIDCF_TEMPORAL          0x0004  /* supports inter-frame compress */
 270 #define VIDCF_COMPRESSFRAMES    0x0008  /* wants the compress all frames message */
 271 #define VIDCF_DRAW              0x0010  /* supports drawing */
 272 #define VIDCF_FASTTEMPORALC     0x0020  /* does not need prev frame on compress */
 273 #define VIDCF_FASTTEMPORALD     0x0080  /* does not need prev frame on decompress */
 274 #define VIDCF_QUALITYTIME       0x0040  /* supports temporal quality */
 275
 276 #define VIDCF_FASTTEMPORAL      (VIDCF_FASTTEMPORALC|VIDCF_FASTTEMPORALD)
 277
 278
 279 /* function shortcuts */
 280 /* ICM_ABOUT */
 281 #define ICMF_ABOUT_QUERY         0x00000001
 282
 283 #define ICQueryAbout32(hic) \
 284         (ICSendMessage32(hic,ICM_ABOUT,(DWORD)-1,ICMF_ABOUT_QUERY)==ICERR_OK)
 285 #define ICQueryAbout WINELIB_NAME(ICQueryAbout)
 286
 287 #define ICAbout32(hic, hwnd) ICSendMessage32(hic,ICM_ABOUT,(DWORD)(UINT)(hwnd),0)
 288 #define ICAbout WINELIB_NAME(ICAbout)
 289
 290 /* ICM_CONFIGURE */
 291 #define ICMF_CONFIGURE_QUERY    0x00000001
 292 #define ICQueryConfigure32(hic) \
 293         (ICSendMessage32(hic,ICM_CONFIGURE,(DWORD)-1,ICMF_CONFIGURE_QUERY)==ICERR_OK)
 294 #define ICQueryConfigure WINELIB_NAME(ICQueryConfigure)
 295
 296 #define ICConfigure32(hic,hwnd) \
 297         ICSendMessage32(hic,ICM_CONFIGURE,(DWORD)(UINT)(hwnd),0)
 298 #define ICConfigure WINELIB_NAME(ICConfigure)
 299
 300 /* Decompression stuff */
 301 #define ICDECOMPRESS_HURRYUP            0x80000000      /* don't draw just buffer (hurry up!) */
 302 #define ICDECOMPRESS_UPDATE             0x40000000      /* don't draw just update screen */
 303 #define ICDECOMPRESS_PREROL             0x20000000      /* this frame is before real start */
 304 #define ICDECOMPRESS_NULLFRAME          0x10000000      /* repeat last frame */
 305 #define ICDECOMPRESS_NOTKEYFRAME        0x08000000      /* this frame is not a key frame */
 306
 307 typedef struct {
 308     DWORD               dwFlags;        /* flags (from AVI index...) */
 309     LPBITMAPINFOHEADER  lpbiInput;      /* BITMAPINFO of compressed data */
 310     LPVOID              lpInput;        /* compressed data */
 311     LPBITMAPINFOHEADER  lpbiOutput;     /* DIB to decompress to */
 312     LPVOID              lpOutput;
 313     DWORD               ckid;           /* ckid from AVI file */
 314 } ICDECOMPRESS;
 315
 316 typedef struct {
 317     DWORD               dwFlags;
 318     LPBITMAPINFOHEADER  lpbiSrc;
 319     LPVOID              lpSrc;
 320     LPBITMAPINFOHEADER  lpbiDst;
 321     LPVOID              lpDst;
 322
 323     /* changed for ICM_DECOMPRESSEX */
 324     INT32               xDst;       /* destination rectangle */
 325     INT32               yDst;
 326     INT32               dxDst;
 327     INT32               dyDst;
 328
 329     INT32               xSrc;       /* source rectangle */
 330     INT32               ySrc;
 331     INT32               dxSrc;
 332     INT32               dySrc;
 333 } ICDECOMPRESSEX;
 334
 335 DWORD VFWAPIV ICDecompress32(HIC32 hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits);
 336 #define ICDecompress WINELIB_NAME(ICDecompress)
 337
 338
 339 #define ICDecompressBegin32(hic, lpbiInput, lpbiOutput)         \
 340     ICSendMessage32(                                            \
 341         hic, ICM_DECOMPRESS_BEGIN, (DWORD)(LPVOID)(lpbiInput),  \
 342         (DWORD)(LPVOID)(lpbiOutput)                             \
 343     )
 344 #define ICDecompressBegin WINELIB_NAME(ICDecompressBegin)
 345
 346 #define ICDecompressQuery32(hic, lpbiInput, lpbiOutput)         \
 347     ICSendMessage32(                                            \
 348         hic,ICM_DECOMPRESS_QUERY, (DWORD)(LPVOID)(lpbiInput),   \
 349         (DWORD) (LPVOID)(lpbiOutput)                            \
 350     )
 351 #define ICDecompressQuery WINELIB_NAME(ICDecompressQuery)
 352
 353 #define ICDecompressGetFormat32(hic, lpbiInput, lpbiOutput)             \
 354     ((LONG)ICSendMessage32(                                             \
 355         hic,ICM_DECOMPRESS_GET_FORMAT, (DWORD)(LPVOID)(lpbiInput),      \
 356         (DWORD)(LPVOID)(lpbiOutput)                                     \
 357     ))
 358 #define ICDecompressGetFormat WINELIB_NAME(ICDecompressGetFormat)
 359
 360 #define ICDecompressGetFormatSize32(hic, lpbi)                          \
 361         ICDecompressGetFormat32(hic, lpbi, NULL)
 362 #define ICDecompressGetFormatSize WINELIB_NAME(ICDecompressGetFormatSize)
 363
 364 #define ICDecompressGetPalette32(hic, lpbiInput, lpbiOutput)            \
 365     ICSendMessage32(                                                    \
 366         hic, ICM_DECOMPRESS_GET_PALETTE, (DWORD)(LPVOID)(lpbiInput),    \
 367         (DWORD)(LPVOID)(lpbiOutput)                                     \
 368     )
 369 #define ICDecompressGetPalette WINELIB_NAME(ICDecompressGetPalette)
 370
 371 #define ICDecompressSetPalette32(hic,lpbiPalette)       \
 372         ICSendMessage32(                                \
 373                 hic,ICM_DECOMPRESS_SET_PALETTE,         \
 374                 (DWORD)(LPVOID)(lpbiPalette),0          \
 375         )
 376 #define ICDecompressSetPalette WINELIB_NAME(ICDecompressSetPalette)
 377
 378 #define ICDecompressEnd32(hic) ICSendMessage32(hic, ICM_DECOMPRESS_END, 0, 0)
 379 #define ICDecompressEnd WINELIB_NAME(ICDecompressEnd)
 380
 381
 382 #define ICDRAW_QUERY        0x00000001L   /* test for support */
 383 #define ICDRAW_FULLSCREEN   0x00000002L   /* draw to full screen */
 384 #define ICDRAW_HDC          0x00000004L   /* draw to a HDC/HWND */
 385
 386 BOOL32  VFWAPI  ICInfo32(DWORD fccType, DWORD fccHandler, ICINFO32 * lpicinfo);
 387 #define ICInfo WINELIB_NAME(ICInfo)
 388 LRESULT VFWAPI  ICGetInfo32(HIC32 hic,ICINFO32 *picinfo, DWORD cb);
 389 #define ICGetInfo WINELIB_NAME(ICGetInfo)
 390 HIC32   VFWAPI  ICOpen32(DWORD fccType, DWORD fccHandler, UINT32 wMode);
 391 #define ICOpen WINELIB_NAME(ICOpen)
 392 LRESULT VFWAPI ICClose32(HIC32 hic);
 393 #define ICClose WINELIB_NAME(ICClose)
 394 LRESULT VFWAPI  ICSendMessage32(HIC32 hic, UINT32 msg, DWORD dw1, DWORD dw2);
 395 #define ICSendMessage WINELIB_NAME(ICSendMessage)
 396 HIC32   VFWAPI ICLocate32(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
 397 #define ICLocate WINELIB_NAME(ICLocate)
 398
 399 DWORD   VFWAPIV ICDrawBegin32(
 400         HIC32                   hic,
 401         DWORD                   dwFlags,/* flags */
 402         HPALETTE32              hpal,   /* palette to draw with */
 403         HWND32                  hwnd,   /* window to draw to */
 404         HDC32                   hdc,    /* HDC to draw to */
 405         INT32                   xDst,   /* destination rectangle */
 406         INT32                   yDst,
 407         INT32                   dxDst,
 408         INT32                   dyDst,
 409         LPBITMAPINFOHEADER      lpbi,   /* format of frame to draw */
 410         INT32                   xSrc,   /* source rectangle */
 411         INT32                   ySrc,
 412         INT32                   dxSrc,
 413         INT32                   dySrc,
 414         DWORD                   dwRate, /* frames/second = (dwRate/dwScale) */
 415         DWORD                   dwScale
 416 );
 417 #define ICDrawBegin WINELIB_NAME(ICDrawBegin)
 418
 419 /********************* AVIFILE function declarations *************************/
 420
 421 #define streamtypeVIDEO         mmioFOURCC('v', 'i', 'd', 's')
 422 #define streamtypeAUDIO         mmioFOURCC('a', 'u', 'd', 's')
 423 #define streamtypeMIDI          mmioFOURCC('m', 'i', 'd', 's')
 424 #define streamtypeTEXT          mmioFOURCC('t', 'x', 't', 's')
 425
 426 /* Basic chunk types */
 427 #define cktypeDIBbits           aviTWOCC('d', 'b')
 428 #define cktypeDIBcompressed     aviTWOCC('d', 'c')
 429 #define cktypePALchange         aviTWOCC('p', 'c')
 430 #define cktypeWAVEbytes         aviTWOCC('w', 'b')
 431
 432 /* Chunk id to use for extra chunks for padding. */
 433 #define ckidAVIPADDING          mmioFOURCC('J', 'U', 'N', 'K')
 434
 435 /* AVIFileHdr.dwFlags */
 436 #define AVIF_HASINDEX           0x00000010      /* Index at end of file? */
 437 #define AVIF_MUSTUSEINDEX       0x00000020
 438 #define AVIF_ISINTERLEAVED      0x00000100
 439 #define AVIF_TRUSTCKTYPE        0x00000800      /* Use CKType to find key frames*/
 440 #define AVIF_WASCAPTUREFILE     0x00010000
 441 #define AVIF_COPYRIGHTED        0x00020000
 442
 443 #define AVI_HEADERSIZE  2048
 444
 445 typedef struct _MainAVIHeader
 446 {
 447     DWORD       dwMicroSecPerFrame;
 448     DWORD       dwMaxBytesPerSec;
 449     DWORD       dwPaddingGranularity;
 450     DWORD       dwFlags;
 451     DWORD       dwTotalFrames;
 452     DWORD       dwInitialFrames;
 453     DWORD       dwStreams;
 454     DWORD       dwSuggestedBufferSize;
 455     DWORD       dwWidth;
 456     DWORD       dwHeight;
 457     DWORD       dwReserved[4];
 458 } MainAVIHeader;
 459
 460 /* AVIStreamHeader.dwFlags */
 461 #define AVISF_DISABLED                  0x00000001
 462 #define AVISF_VIDEO_PALCHANGES          0x00010000
 463
 464 typedef struct {
 465     FOURCC      fccType;
 466     FOURCC      fccHandler;
 467     DWORD       dwFlags;        /* AVISF_* */
 468     WORD        wPriority;
 469     WORD        wLanguage;
 470     DWORD       dwInitialFrames;
 471     DWORD       dwScale;
 472     DWORD       dwRate; /* dwRate / dwScale == samples/second */
 473     DWORD       dwStart;
 474     DWORD       dwLength; /* In units above... */
 475     DWORD       dwSuggestedBufferSize;
 476     DWORD       dwQuality;
 477     DWORD       dwSampleSize;
 478     RECT16      rcFrame;        /* word.word - word.word in file */
 479 } AVIStreamHeader;
 480
 481 /* AVIINDEXENTRY.dwFlags */
 482 #define AVIIF_LIST      0x00000001      /* chunk is a 'LIST' */
 483 #define AVIIF_KEYFRAME  0x00000010      /* this frame is a key frame. */
 484
 485 #define AVIIF_NOTIME    0x00000100      /* this frame doesn't take any time */
 486 #define AVIIF_COMPUSE   0x0FFF0000
 487
 488 typedef struct _AVIINDEXENTRY {
 489     DWORD       ckid;
 490     DWORD       dwFlags;
 491     DWORD       dwChunkOffset;
 492     DWORD       dwChunkLength;
 493 } AVIINDEXENTRY;
 494
 495 typedef struct _AVIPALCHANGE {
 496     BYTE                bFirstEntry;
 497     BYTE                bNumEntries;
 498     WORD                wFlags;         /* pad */
 499     PALETTEENTRY        peNew[1];
 500 } AVIPALCHANGE;
 501
 502 #define AVIIF_KEYFRAME  0x00000010      /* this frame is a key frame. */
 503
 504 #define AVIGETFRAMEF_BESTDISPLAYFMT     1
 505
 506 typedef struct _AVISTREAMINFO32A {
 507     DWORD       fccType;
 508     DWORD       fccHandler;
 509     DWORD       dwFlags;        /* AVIIF_* */
 510     DWORD       dwCaps;
 511     WORD        wPriority;
 512     WORD        wLanguage;
 513     DWORD       dwScale;
 514     DWORD       dwRate;         /* dwRate / dwScale == samples/second */
 515     DWORD       dwStart;
 516     DWORD       dwLength;       /* In units above... */
 517     DWORD       dwInitialFrames;
 518     DWORD       dwSuggestedBufferSize;
 519     DWORD       dwQuality;
 520     DWORD       dwSampleSize;
 521     RECT32      rcFrame;
 522     DWORD       dwEditCount;
 523     DWORD       dwFormatChangeCount;
 524     CHAR        szName[64];
 525 } AVISTREAMINFO32A, * LPAVISTREAMINFO32A, *PAVISTREAMINFO32A;
 526
 527 typedef struct _AVISTREAMINFO32W {
 528     DWORD       fccType;
 529     DWORD       fccHandler;
 530     DWORD       dwFlags;
 531     DWORD       dwCaps;
 532     WORD        wPriority;
 533     WORD        wLanguage;
 534     DWORD       dwScale;
 535     DWORD       dwRate;         /* dwRate / dwScale == samples/second */
 536     DWORD       dwStart;
 537     DWORD       dwLength;       /* In units above... */
 538     DWORD       dwInitialFrames;
 539     DWORD       dwSuggestedBufferSize;
 540     DWORD       dwQuality;
 541     DWORD       dwSampleSize;
 542     RECT32      rcFrame;
 543     DWORD       dwEditCount;
 544     DWORD       dwFormatChangeCount;
 545     WCHAR       szName[64];
 546 } AVISTREAMINFO32W, * LPAVISTREAMINFO32W, *PAVISTREAMINFO32W;
 547 DECL_WINELIB_TYPE_AW(AVISTREAMINFO)
 548 DECL_WINELIB_TYPE_AW(LPAVISTREAMINFO)
 549 DECL_WINELIB_TYPE_AW(PAVISTREAMINFO)
 550
 551 #define AVISTREAMINFO_DISABLED          0x00000001
 552 #define AVISTREAMINFO_FORMATCHANGES     0x00010000
 553
 554 /* AVIFILEINFO.dwFlags */
 555 #define AVIFILEINFO_HASINDEX            0x00000010
 556 #define AVIFILEINFO_MUSTUSEINDEX        0x00000020
 557 #define AVIFILEINFO_ISINTERLEAVED       0x00000100
 558 #define AVIFILEINFO_WASCAPTUREFILE      0x00010000
 559 #define AVIFILEINFO_COPYRIGHTED         0x00020000
 560
 561 /* AVIFILEINFO.dwCaps */
 562 #define AVIFILECAPS_CANREAD             0x00000001
 563 #define AVIFILECAPS_CANWRITE            0x00000002
 564 #define AVIFILECAPS_ALLKEYFRAMES        0x00000010
 565 #define AVIFILECAPS_NOCOMPRESSION       0x00000020
 566
 567 typedef struct _AVIFILEINFO32W {
 568     DWORD               dwMaxBytesPerSec;
 569     DWORD               dwFlags;
 570     DWORD               dwCaps;
 571     DWORD               dwStreams;
 572     DWORD               dwSuggestedBufferSize;
 573     DWORD               dwWidth;
 574     DWORD               dwHeight;
 575     DWORD               dwScale;
 576     DWORD               dwRate;
 577     DWORD               dwLength;
 578     DWORD               dwEditCount;
 579     WCHAR               szFileType[64];
 580 } AVIFILEINFO32W, * LPAVIFILEINFO32W, *PAVIFILEINFO32W;
 581 typedef struct _AVIFILEINFO32A {
 582     DWORD               dwMaxBytesPerSec;
 583     DWORD               dwFlags;
 584     DWORD               dwCaps;
 585     DWORD               dwStreams;
 586     DWORD               dwSuggestedBufferSize;
 587     DWORD               dwWidth;
 588     DWORD               dwHeight;
 589     DWORD               dwScale;
 590     DWORD               dwRate;
 591     DWORD               dwLength;
 592     DWORD               dwEditCount;
 593     CHAR                szFileType[64];
 594 } AVIFILEINFO32A, * LPAVIFILEINFO32A, *PAVIFILEINFO32A;
 595 DECL_WINELIB_TYPE_AW(AVIFILEINFO)
 596 DECL_WINELIB_TYPE_AW(PAVIFILEINFO)
 597 DECL_WINELIB_TYPE_AW(LPAVIFILEINFO)
 598
 599 /* AVICOMPRESSOPTIONS.dwFlags. determines presence of fields in below struct */
 600 #define AVICOMPRESSF_INTERLEAVE 0x00000001
 601 #define AVICOMPRESSF_DATARATE   0x00000002
 602 #define AVICOMPRESSF_KEYFRAMES  0x00000004
 603 #define AVICOMPRESSF_VALID      0x00000008
 604
 605 typedef struct {
 606     DWORD       fccType;                /* stream type, for consistency */
 607     DWORD       fccHandler;             /* compressor */
 608     DWORD       dwKeyFrameEvery;        /* keyframe rate */
 609     DWORD       dwQuality;              /* compress quality 0-10,000 */
 610     DWORD       dwBytesPerSecond;       /* bytes per second */
 611     DWORD       dwFlags;                /* flags... see below */
 612     LPVOID      lpFormat;               /* save format */
 613     DWORD       cbFormat;
 614     LPVOID      lpParms;                /* compressor options */
 615     DWORD       cbParms;
 616     DWORD       dwInterleaveEvery;      /* for non-video streams only */
 617 } AVICOMPRESSOPTIONS, *LPAVICOMPRESSOPTIONS,*PAVICOMPRESSOPTIONS;
 618
 619
 620
 621 #define DEFINE_AVIGUID(name, l, w1, w2) \
 622     DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)
 623
 624 DEFINE_AVIGUID(IID_IAVIFile,            0x00020020, 0, 0);
 625 DEFINE_AVIGUID(IID_IAVIStream,          0x00020021, 0, 0);
 626 DEFINE_AVIGUID(IID_IAVIStreaming,       0x00020022, 0, 0);
 627 DEFINE_AVIGUID(IID_IGetFrame,           0x00020023, 0, 0);
 628 DEFINE_AVIGUID(IID_IAVIEditStream,      0x00020024, 0, 0);
 629
 630 DEFINE_AVIGUID(CLSID_AVIFile,           0x00020000, 0, 0);
 631
 632
 633 /* IAVIStream32 interface. */
 634 #define ICOM_INTERFACE IAVIStream32
 635 typedef struct IAVIStream32 IAVIStream32,*PAVISTREAM32;
 636 ICOM_BEGIN(IAVIStream32, IUnknown)
 637     ICOM_METHOD2(HRESULT,Create,LPARAM,,LPARAM,);
 638     ICOM_METHOD2(HRESULT,Info,AVISTREAMINFO32W*,,LONG,);
 639     ICOM_METHOD2(LONG,FindSample,LONG,,LONG,);
 640     ICOM_METHOD3(HRESULT,ReadFormat,LONG,,LPVOID,,LONG*,);
 641     ICOM_METHOD3(HRESULT,SetFormat,LONG,,LPVOID,,LONG,);
 642     ICOM_METHOD6(HRESULT,Read,LONG,,LONG,,LPVOID,,LONG,,LONG*,,LONG*,);
 643     ICOM_METHOD7(HRESULT,Write,LONG,,LONG,,LPVOID,,LONG,,DWORD,,LONG*,,LONG*,);
 644     ICOM_METHOD2(HRESULT,Delete,LONG,,LONG,);
 645     ICOM_METHOD3(HRESULT,ReadData,DWORD,,LPVOID,,LONG*,);
 646     ICOM_METHOD3(HRESULT,WriteData,DWORD,,LPVOID,,LONG,);
 647     ICOM_METHOD2(HRESULT,SetInfo,AVISTREAMINFO32W*,,LONG,);
 648 ICOM_END(IAVIStream32)
 649 #undef ICOM_INTERFACE
 650
 651 DECL_WINELIB_TYPE(IAVIStream)
 652 DECL_WINELIB_TYPE(PAVISTREAM)
 653
 654 /* IAVIFile32 interface. In Win32 this interface uses UNICODE only */
 655 #define ICOM_INTERFACE IAVIFile32
 656 typedef struct IAVIFile32 IAVIFile32,*PAVIFILE32;
 657 ICOM_BEGIN(IAVIFile32,IUnknown)
 658         ICOM_METHOD2(HRESULT,Info,AVIFILEINFO32W*,,LONG,);
 659         ICOM_METHOD3(HRESULT,GetStream,PAVISTREAM32*,,DWORD,,LONG,);
 660         ICOM_METHOD2(HRESULT,CreateStream,PAVISTREAM32*,,AVISTREAMINFO32W*,);
 661         ICOM_METHOD3(HRESULT,WriteData,DWORD,,LPVOID,,LONG,);
 662         ICOM_METHOD3(HRESULT,ReadData,DWORD,,LPVOID,,LONG*,);
 663         ICOM_METHOD (HRESULT,EndRecord);
 664         ICOM_METHOD2(HRESULT,DeleteStream,DWORD,,LONG,);
 665 ICOM_END(IAVIFile32)
 666 #undef ICOM_INTERFACE
 667
 668 DECL_WINELIB_TYPE(IAVIFile)
 669 DECL_WINELIB_TYPE(PAVIFILE)
 670
 671 /* IGetFrame32 interface */
 672 #define ICOM_INTERFACE IGetFrame32
 673 typedef struct IGetFrame32 IGetFrame32,*PGETFRAME32;
 674 ICOM_BEGIN(IGetFrame32,IUnknown)
 675         ICOM_METHOD1(LPVOID,GetFrame,LONG,);
 676         ICOM_METHOD3(HRESULT,Begin,LONG,,LONG,,LONG,);
 677         ICOM_METHOD (HRESULT,End);
 678         ICOM_METHOD6(HRESULT,SetFormat,LPBITMAPINFOHEADER,,LPVOID,,INT32,,INT32,,INT32,,INT32,);
 679 ICOM_END(IGetFrame32)
 680 #undef ICOM_INTERFACE
 681
 682 DECL_WINELIB_TYPE(IGetFrame)
 683 DECL_WINELIB_TYPE(PGETFRAME)
 684
 685 #define AVIERR_OK               0
 686 #define MAKE_AVIERR(error)      MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x4000+error)
 687
 688 #define AVIERR_UNSUPPORTED      MAKE_AVIERR(101)
 689 #define AVIERR_BADFORMAT        MAKE_AVIERR(102)
 690 #define AVIERR_MEMORY           MAKE_AVIERR(103)
 691 #define AVIERR_INTERNAL         MAKE_AVIERR(104)
 692 #define AVIERR_BADFLAGS         MAKE_AVIERR(105)
 693 #define AVIERR_BADPARAM         MAKE_AVIERR(106)
 694 #define AVIERR_BADSIZE          MAKE_AVIERR(107)
 695 #define AVIERR_BADHANDLE        MAKE_AVIERR(108)
 696 #define AVIERR_FILEREAD         MAKE_AVIERR(109)
 697 #define AVIERR_FILEWRITE        MAKE_AVIERR(110)
 698 #define AVIERR_FILEOPEN         MAKE_AVIERR(111)
 699 #define AVIERR_COMPRESSOR       MAKE_AVIERR(112)
 700 #define AVIERR_NOCOMPRESSOR     MAKE_AVIERR(113)
 701 #define AVIERR_READONLY         MAKE_AVIERR(114)
 702 #define AVIERR_NODATA           MAKE_AVIERR(115)
 703 #define AVIERR_BUFFERTOOSMALL   MAKE_AVIERR(116)
 704 #define AVIERR_CANTCOMPRESS     MAKE_AVIERR(117)
 705 #define AVIERR_USERABORT        MAKE_AVIERR(198)
 706 #define AVIERR_ERROR            MAKE_AVIERR(199)
 707
 708 HRESULT WINAPI AVIMakeCompressedStream32(PAVISTREAM32*ppsCompressed,PAVISTREAM32 ppsSource,AVICOMPRESSOPTIONS *lpOptions,CLSID*pclsidHandler);
 709 #define AVIMakeCompressedStream WINELIB_NAME_AW(AVIMakeCompressedStream)
 710 HRESULT WINAPI AVIStreamSetFormat32(PAVISTREAM32 iface,LONG pos,LPVOID format,LONG formatsize);
 711 #define AVIStreamSetFormat WINELIB_NAME(AVIStreamSetFormat)
 712 HRESULT WINAPI AVIStreamWrite32(PAVISTREAM32 iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
 713 #define AVIStreamWrite WINELIB_NAME(AVIStreamWrite)
 714 ULONG WINAPI AVIStreamRelease32(PAVISTREAM32 iface);
 715 #define AVIStreamRelease WINELIB_NAME(AVIStreamRelease)
 716 LONG WINAPI AVIStreamStart32(PAVISTREAM32 iface);
 717 #define AVIStreamStart WINELIB_NAME(AVIStreamStart)
 718 LONG WINAPI AVIStreamLength32(PAVISTREAM32 iface);
 719 #define AVIStreamLength WINELIB_NAME(AVIStreamLength)
 720 HRESULT WINAPI AVIStreamReadFormat32(PAVISTREAM32 iface,LONG pos,LPVOID format,LONG *formatsize);
 721 #define AVIStreamReadFormat WINELIB_NAME(AVIStreamReadFormat)
 722 HRESULT WINAPI AVIStreamWrite32(PAVISTREAM32 iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
 723 #define AVIStreamWrite WINELIB_NAME(AVIStreamWrite)
 724 HRESULT WINAPI AVIStreamRead32(PAVISTREAM32 iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread);
 725 #define AVIStreamRead WINELIB_NAME(AVIStreamRead)
 726 HRESULT WINAPI AVIStreamWriteData32(PAVISTREAM32 iface,DWORD fcc,LPVOID lp,LONG size);
 727 #define AVIStreamWriteData WINELIB_NAME(AVIStreamWriteData)
 728 HRESULT WINAPI AVIStreamReadData32(PAVISTREAM32 iface,DWORD fcc,LPVOID lp,LONG *lpread);
 729 #define AVIStreamReadData WINELIB_NAME(AVIStreamReadData)
 730 HRESULT WINAPI AVIStreamInfo32A(PAVISTREAM32 iface,AVISTREAMINFO32A *asi,LONG size);
 731 HRESULT WINAPI AVIStreamInfo32W(PAVISTREAM32 iface,AVISTREAMINFO32W *asi,LONG size);
 732 #define AVIStreamInfo WINELIB_NAME_AW(AVIStreamInfo)
 733 PGETFRAME32 WINAPI AVIStreamGetFrameOpen32(PAVISTREAM32 pavi,LPBITMAPINFOHEADER lpbiWanted);
 734 #define AVIStreamGetFrameOpen WINELIB_NAME(AVIStreamGetFrameOpen)
 735 HRESULT WINAPI AVIStreamGetFrameClose32(PGETFRAME32 pg);
 736 #define AVIStreamGetFrameClose WINELIB_NAME(AVIStreamGetFrameClose)
 737 PGETFRAME32 WINAPI AVIStreamGetFrameOpen32(PAVISTREAM32 pavi,LPBITMAPINFOHEADER lpbiWanted);
 738 #define AVIStreamGetFrameOpen WINELIB_NAME(AVIStreamGetFrameOpen)
 739 LPVOID WINAPI AVIStreamGetFrame32(PGETFRAME32 pg,LONG pos);
 740 #define AVIStreamGetFrame WINELIB_NAME(AVIStreamGetFrame)
 741
 742 void WINAPI AVIFileInit32(void);
 743 #define AVIFileInit WINELIB_NAME(AVIFileInit)
 744 HRESULT WINAPI AVIFileOpen32A(PAVIFILE32 * ppfile,LPCSTR szFile,UINT32 uMode,LPCLSID lpHandler);
 745 #define AVIFileOpen WINELIB_NAME_AW(AVIFileOpen)
 746 HRESULT WINAPI AVIFileCreateStream32A(PAVIFILE32 pfile,PAVISTREAM32 *ppavi,AVISTREAMINFO32A * psi);
 747 HRESULT WINAPI AVIFileCreateStream32W(PAVIFILE32 pfile,PAVISTREAM32 *ppavi,AVISTREAMINFO32W * psi);
 748 #define AVIFileCreateStream WINELIB_NAME_AW(AVIFileCreateStream)
 749 ULONG WINAPI AVIFileRelease32(PAVIFILE32 iface);
 750 #define AVIFileRelease WINELIB_NAME(AVIFileRelease)
 751 HRESULT WINAPI AVIFileInfo32A(PAVIFILE32 pfile,PAVIFILEINFO32A,LONG);
 752 HRESULT WINAPI AVIFileInfo32W(PAVIFILE32 pfile,PAVIFILEINFO32W,LONG);
 753 #define AVIFileInfo WINELIB_NAME_AW(AVIFileInfo)
 754 HRESULT WINAPI AVIFileGetStream32(PAVIFILE32 pfile,PAVISTREAM32*avis,DWORD fccType,LONG lParam);
 755 #define AVIFileGetStream WINELIB_NAME(AVIFileGetStream)
 756 void WINAPI AVIFileExit32(void);
 757 #define AVIFileExit WINELIB_NAME(AVIFileExit)
 758
 759 #endif