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