vfw.h

Go to the documentation of this file.

/*
 * Copyright (C) the Wine project
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef __WINE_VFW_H
#define __WINE_VFW_H

#include <mmsystem.h>
#include <mmreg.h>
#include <msacm.h>

#define VFWAPI  WINAPI
#define VFWAPIV WINAPIV

#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */

typedef HANDLE HDRAWDIB;

/*****************************************************************************
 * Predeclare the interfaces
 */
typedef struct IAVIStream *PAVISTREAM;
typedef struct IAVIFile *PAVIFILE;
typedef struct IGetFrame *PGETFRAME;
typedef struct IAVIEditStream *PAVIEDITSTREAM;

/* Installable Compressor Manager */

#define ICVERSION 0x0104

DECLARE_HANDLE(HIC);

/* error return codes */
#define ICERR_OK        0
#define ICERR_DONTDRAW      1
#define ICERR_NEWPALETTE    2
#define ICERR_GOTOKEYFRAME  3
#define ICERR_STOPDRAWING   4

#define ICERR_UNSUPPORTED   -1
#define ICERR_BADFORMAT     -2
#define ICERR_MEMORY        -3
#define ICERR_INTERNAL      -4
#define ICERR_BADFLAGS      -5
#define ICERR_BADPARAM      -6
#define ICERR_BADSIZE       -7
#define ICERR_BADHANDLE     -8
#define ICERR_CANTUPDATE    -9
#define ICERR_ABORT     -10
#define ICERR_ERROR     -100
#define ICERR_BADBITDEPTH   -200
#define ICERR_BADIMAGESIZE  -201

#define ICERR_CUSTOM        -400

/* ICM Messages */
#define ICM_USER        (DRV_USER+0x0000)

/* ICM driver message range */
#define ICM_RESERVED_LOW    (DRV_USER+0x1000)
#define ICM_RESERVED_HIGH   (DRV_USER+0x2000)
#define ICM_RESERVED        ICM_RESERVED_LOW

#define ICM_GETSTATE        (ICM_RESERVED+0)
#define ICM_SETSTATE        (ICM_RESERVED+1)
#define ICM_GETINFO     (ICM_RESERVED+2)

#define ICM_CONFIGURE       (ICM_RESERVED+10)
#define ICM_ABOUT       (ICM_RESERVED+11)
/* */

#define ICM_GETDEFAULTQUALITY   (ICM_RESERVED+30)
#define ICM_GETQUALITY      (ICM_RESERVED+31)
#define ICM_SETQUALITY      (ICM_RESERVED+32)

#define ICM_SET         (ICM_RESERVED+40)
#define ICM_GET         (ICM_RESERVED+41)

/* 2 constant FOURCC codes */
#define ICM_FRAMERATE       mmioFOURCC('F','r','m','R')
#define ICM_KEYFRAMERATE    mmioFOURCC('K','e','y','R')

#define ICM_COMPRESS_GET_FORMAT     (ICM_USER+4)
#define ICM_COMPRESS_GET_SIZE       (ICM_USER+5)
#define ICM_COMPRESS_QUERY      (ICM_USER+6)
#define ICM_COMPRESS_BEGIN      (ICM_USER+7)
#define ICM_COMPRESS            (ICM_USER+8)
#define ICM_COMPRESS_END        (ICM_USER+9)

#define ICM_DECOMPRESS_GET_FORMAT   (ICM_USER+10)
#define ICM_DECOMPRESS_QUERY        (ICM_USER+11)
#define ICM_DECOMPRESS_BEGIN        (ICM_USER+12)
#define ICM_DECOMPRESS          (ICM_USER+13)
#define ICM_DECOMPRESS_END      (ICM_USER+14)
#define ICM_DECOMPRESS_SET_PALETTE  (ICM_USER+29)
#define ICM_DECOMPRESS_GET_PALETTE  (ICM_USER+30)

#define ICM_DRAW_QUERY          (ICM_USER+31)
#define ICM_DRAW_BEGIN          (ICM_USER+15)
#define ICM_DRAW_GET_PALETTE        (ICM_USER+16)
#define ICM_DRAW_START          (ICM_USER+18)
#define ICM_DRAW_STOP           (ICM_USER+19)
#define ICM_DRAW_END            (ICM_USER+21)
#define ICM_DRAW_GETTIME        (ICM_USER+32)
#define ICM_DRAW            (ICM_USER+33)
#define ICM_DRAW_WINDOW         (ICM_USER+34)
#define ICM_DRAW_SETTIME        (ICM_USER+35)
#define ICM_DRAW_REALIZE        (ICM_USER+36)
#define ICM_DRAW_FLUSH          (ICM_USER+37)
#define ICM_DRAW_RENDERBUFFER       (ICM_USER+38)

#define ICM_DRAW_START_PLAY     (ICM_USER+39)
#define ICM_DRAW_STOP_PLAY      (ICM_USER+40)

#define ICM_DRAW_SUGGESTFORMAT      (ICM_USER+50)
#define ICM_DRAW_CHANGEPALETTE      (ICM_USER+51)

#define ICM_GETBUFFERSWANTED        (ICM_USER+41)

#define ICM_GETDEFAULTKEYFRAMERATE  (ICM_USER+42)

#define ICM_DECOMPRESSEX_BEGIN      (ICM_USER+60)
#define ICM_DECOMPRESSEX_QUERY      (ICM_USER+61)
#define ICM_DECOMPRESSEX        (ICM_USER+62)
#define ICM_DECOMPRESSEX_END        (ICM_USER+63)

#define ICM_COMPRESS_FRAMES_INFO    (ICM_USER+70)
#define ICM_SET_STATUS_PROC     (ICM_USER+72)

#ifndef comptypeDIB
#define comptypeDIB  mmioFOURCC('D','I','B',' ')
#endif

/* structs */

/* NOTE: Only the 16 bit structs are packed. Structs that are packed anyway
 * have not been changed. If a structure is later extended, you may need to create
 * two versions of it.
 */

typedef struct {
    DWORD   dwSize;     /* 00: size */
    DWORD   fccType;    /* 04: type 'vidc' usually */
    DWORD   fccHandler; /* 08: */
    DWORD   dwVersion;  /* 0c: version of compman opening you */
    DWORD   dwFlags;    /* 10: LOWORD is type specific */
    LRESULT dwError;    /* 14: */
    LPVOID  pV1Reserved;    /* 18: */
    LPVOID  pV2Reserved;    /* 1c: */
    DWORD   dnDevNode;  /* 20: */
                /* 24: */
} ICOPEN,*LPICOPEN;

#define ICCOMPRESS_KEYFRAME     0x00000001L

typedef struct {
  DWORD dwFlags;
  LPBITMAPINFOHEADER lpbiOutput;
  _Field_size_bytes_(lpbiOutput->biSizeImage) LPVOID lpOutput;
  LPBITMAPINFOHEADER lpbiInput;
  _Field_size_bytes_(lpbiInput->biSizeImage) LPVOID lpInput;
  LPDWORD lpckid;
  LPDWORD lpdwFlags;
  LONG lFrameNum;
  DWORD dwFrameSize;
  DWORD dwQuality;
  LPBITMAPINFOHEADER lpbiPrev;
  _Field_size_bytes_(lpbiPrev->biSizeImage) LPVOID lpPrev;
} ICCOMPRESS;

DWORD
VFWAPIV
ICCompress(
  _In_ HIC hic,
  _In_ DWORD dwFlags,
  _In_ LPBITMAPINFOHEADER lpbiOutput,
  _Out_writes_bytes_(lpbiOutput->biSizeImage) LPVOID lpData,
  _In_ LPBITMAPINFOHEADER lpbiInput,
  _In_reads_bytes_(lpbiInput->biSizeImage) LPVOID lpBits,
  _Out_opt_ LPDWORD lpckid,
  _Out_opt_ LPDWORD lpdwFlags,
  _In_ LONG lFrameNum,
  _In_ DWORD dwFrameSize,
  _In_ DWORD dwQuality,
  _In_opt_ LPBITMAPINFOHEADER lpbiPrev,
  _In_reads_bytes_opt_(lpbiPrev->biSizeImage) LPVOID lpPrev);

#define ICCompressGetFormat(hic, lpbiInput, lpbiOutput)         \
    ICSendMessage(                          \
        hic,ICM_COMPRESS_GET_FORMAT,(DWORD_PTR)(LPVOID)(lpbiInput), \
        (DWORD_PTR)(LPVOID)(lpbiOutput)                 \
    )

#define ICCompressGetFormatSize(hic,lpbi) ICCompressGetFormat(hic,lpbi,NULL)

#define ICCompressBegin(hic, lpbiInput, lpbiOutput)             \
    ICSendMessage(                          \
        hic, ICM_COMPRESS_BEGIN, (DWORD_PTR)(LPVOID)(lpbiInput),        \
    (DWORD_PTR)(LPVOID)(lpbiOutput)                 \
    )

#define ICCompressGetSize(hic, lpbiInput, lpbiOutput)           \
    ICSendMessage(                          \
        hic, ICM_COMPRESS_GET_SIZE, (DWORD_PTR)(LPVOID)(lpbiInput),     \
    (DWORD_PTR)(LPVOID)(lpbiOutput)                 \
    )

#define ICCompressQuery(hic, lpbiInput, lpbiOutput)     \
    ICSendMessage(                      \
        hic, ICM_COMPRESS_QUERY, (DWORD_PTR)(LPVOID)(lpbiInput),    \
    (DWORD_PTR)(LPVOID)(lpbiOutput)             \
    )

#define ICCompressEnd(hic) ICSendMessage(hic, ICM_COMPRESS_END, 0, 0)

/* ICCOMPRESSFRAMES.dwFlags */
#define ICCOMPRESSFRAMES_PADDING        0x00000001
typedef struct {
    DWORD               dwFlags;
    LPBITMAPINFOHEADER  lpbiOutput;
    LPARAM              lOutput;
    LPBITMAPINFOHEADER  lpbiInput;
    LPARAM              lInput;
    LONG                lStartFrame;
    LONG                lFrameCount;
    LONG                lQuality;
    LONG                lDataRate;
    LONG                lKeyRate;
    DWORD               dwRate;
    DWORD               dwScale;
    DWORD               dwOverheadPerFrame;
    DWORD               dwReserved2;
    LONG (CALLBACK *GetData)(_In_ LPARAM lInput, _In_ LONG lFrame, _Out_writes_bytes_(len) LPVOID lpBits, _In_ LONG len);
    LONG (CALLBACK *PutData)(_In_ LPARAM lOutput, _In_ LONG lFrame, _In_reads_bytes_(len) LPVOID lpBits, _In_ LONG len);
} ICCOMPRESSFRAMES;

typedef struct {
    DWORD       dwFlags;
    LPARAM      lParam;
   /* messages for Status callback */
#define ICSTATUS_START      0
#define ICSTATUS_STATUS     1
#define ICSTATUS_END        2
#define ICSTATUS_ERROR      3
#define ICSTATUS_YIELD      4
    /* FIXME: some X11 libs define Status as int... */
    /* LONG (CALLBACK *zStatus)(LPARAM lParam, UINT message, LONG l); */
    LONG (CALLBACK *zStatus)(LPARAM lParam, UINT message, LONG l);
} ICSETSTATUSPROC;

/* Values for wMode of ICOpen() */
#define ICMODE_COMPRESS     1
#define ICMODE_DECOMPRESS   2
#define ICMODE_FASTDECOMPRESS   3
#define ICMODE_QUERY        4
#define ICMODE_FASTCOMPRESS 5
#define ICMODE_DRAW     8

/* quality flags */
#define ICQUALITY_LOW       0
#define ICQUALITY_HIGH      10000
#define ICQUALITY_DEFAULT   -1

typedef struct {
    DWORD   dwSize;     /* 00: */
    DWORD   fccType;    /* 04:compressor type     'vidc' 'audc' */
    DWORD   fccHandler; /* 08:compressor sub-type 'rle ' 'jpeg' 'pcm '*/
    DWORD   dwFlags;    /* 0c:flags LOWORD is type specific */
    DWORD   dwVersion;  /* 10:version of the driver */
    DWORD   dwVersionICM;   /* 14:version of the ICM used */
    /*
     * under Win32, the driver always returns UNICODE strings.
     */
    WCHAR   szName[16];     /* 18:short name */
    WCHAR   szDescription[128]; /* 38:long name */
    WCHAR   szDriver[128];      /* 138:driver that contains compressor*/
                    /* 238: */
} ICINFO;

/* ICINFO.dwFlags */
#define VIDCF_QUALITY       0x0001  /* supports quality */
#define VIDCF_CRUNCH        0x0002  /* supports crunching to a frame size */
#define VIDCF_TEMPORAL      0x0004  /* supports inter-frame compress */
#define VIDCF_COMPRESSFRAMES    0x0008  /* wants the compress all frames message */
#define VIDCF_DRAW      0x0010  /* supports drawing */
#define VIDCF_FASTTEMPORALC 0x0020  /* does not need prev frame on compress */
#define VIDCF_FASTTEMPORALD 0x0080  /* does not need prev frame on decompress */
#define VIDCF_QUALITYTIME   0x0040  /* supports temporal quality */

#define VIDCF_FASTTEMPORAL  (VIDCF_FASTTEMPORALC|VIDCF_FASTTEMPORALD)


/* function shortcuts */
/* ICM_ABOUT */
#define ICMF_ABOUT_QUERY         0x00000001

#define ICQueryAbout(hic) \
    (ICSendMessage(hic,ICM_ABOUT,(DWORD_PTR)-1,ICMF_ABOUT_QUERY)==ICERR_OK)

#define ICAbout(hic, hwnd) ICSendMessage(hic,ICM_ABOUT,(DWORD_PTR)(UINT_PTR)(hwnd),0)

/* ICM_CONFIGURE */
#define ICMF_CONFIGURE_QUERY    0x00000001
#define ICQueryConfigure(hic) \
    (ICSendMessage(hic,ICM_CONFIGURE,(DWORD_PTR)-1,ICMF_CONFIGURE_QUERY)==ICERR_OK)

#define ICConfigure(hic,hwnd) \
    ICSendMessage(hic,ICM_CONFIGURE,(DWORD_PTR)(UINT_PTR)(hwnd),0)

/* Decompression stuff */
#define ICDECOMPRESS_HURRYUP        0x80000000  /* don't draw just buffer (hurry up!) */
#define ICDECOMPRESS_UPDATE     0x40000000  /* don't draw just update screen */
#define ICDECOMPRESS_PREROLL        0x20000000  /* this frame is before real start */
#define ICDECOMPRESS_NULLFRAME      0x10000000  /* repeat last frame */
#define ICDECOMPRESS_NOTKEYFRAME    0x08000000  /* this frame is not a key frame */

typedef struct {
  DWORD dwFlags; /* flags (from AVI index...) */
  LPBITMAPINFOHEADER lpbiInput; /* BITMAPINFO of compressed data */
  _Field_size_bytes_(lpbiInput->biSizeImage) LPVOID lpInput; /* compressed data */
  LPBITMAPINFOHEADER lpbiOutput; /* DIB to decompress to */
  _Field_size_bytes_(lpbiOutput->biSizeImage) LPVOID     lpOutput;
  DWORD ckid; /* ckid from AVI file */
} ICDECOMPRESS;

typedef struct {
    DWORD       dwFlags;
    LPBITMAPINFOHEADER  lpbiSrc;
    LPVOID      lpSrc;
    LPBITMAPINFOHEADER  lpbiDst;
    LPVOID      lpDst;

    /* changed for ICM_DECOMPRESSEX */
    INT         xDst;       /* destination rectangle */
    INT         yDst;
    INT         dxDst;
    INT         dyDst;

    INT         xSrc;       /* source rectangle */
    INT         ySrc;
    INT         dxSrc;
    INT         dySrc;
} ICDECOMPRESSEX;

DWORD
VFWAPIV
ICDecompress(
  _In_ HIC hic,
  _In_ DWORD dwFlags,
  _In_ LPBITMAPINFOHEADER lpbiFormat,
  _In_reads_bytes_(lpbiFormat->biSizeImage) LPVOID lpData,
  _In_ LPBITMAPINFOHEADER lpbi,
  _Out_writes_bytes_(lpbi->biSizeImage) LPVOID lpBits);

#define ICDecompressBegin(hic, lpbiInput, lpbiOutput)   \
    ICSendMessage(                      \
        hic, ICM_DECOMPRESS_BEGIN, (DWORD_PTR)(LPVOID)(lpbiInput),  \
    (DWORD_PTR)(LPVOID)(lpbiOutput)             \
    )

#define ICDecompressQuery(hic, lpbiInput, lpbiOutput)   \
    ICSendMessage(                      \
        hic,ICM_DECOMPRESS_QUERY, (DWORD_PTR)(LPVOID)(lpbiInput),   \
    (DWORD_PTR) (LPVOID)(lpbiOutput)                \
    )

#define ICDecompressGetFormat(hic, lpbiInput, lpbiOutput)       \
    ((LONG)ICSendMessage(                       \
        hic,ICM_DECOMPRESS_GET_FORMAT, (DWORD_PTR)(LPVOID)(lpbiInput),  \
    (DWORD_PTR)(LPVOID)(lpbiOutput)                 \
    ))

#define ICDecompressGetFormatSize(hic, lpbi)                \
    ICDecompressGetFormat(hic, lpbi, NULL)

#define ICDecompressGetPalette(hic, lpbiInput, lpbiOutput)      \
    ICSendMessage(                          \
        hic, ICM_DECOMPRESS_GET_PALETTE, (DWORD_PTR)(LPVOID)(lpbiInput),    \
    (DWORD_PTR)(LPVOID)(lpbiOutput)                 \
    )

#define ICDecompressSetPalette(hic,lpbiPalette) \
        ICSendMessage(              \
        hic,ICM_DECOMPRESS_SET_PALETTE,     \
        (DWORD_PTR)(LPVOID)(lpbiPalette),0      \
    )

#define ICDecompressEnd(hic) ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0)

LRESULT
VFWAPI
ICSendMessage(
  _In_ HIC hic,
  _In_ UINT msg,
  _In_ DWORD_PTR dw1,
  _In_ DWORD_PTR dw2);

static inline
LRESULT
VFWAPI
ICDecompressEx(_In_ HIC hic,
               _In_ DWORD dwFlags,
               _In_ LPBITMAPINFOHEADER lpbiSrc,
               _In_reads_bytes_(lpbiSrc->biSizeImage) LPVOID lpSrc,
               _In_ int xSrc,
               _In_ int ySrc,
               _In_ int dxSrc,
               _In_ int dySrc,
               _In_ LPBITMAPINFOHEADER lpbiDst,
               _Out_writes_bytes_(lpbiDst->biSizeImage) LPVOID lpDst,
               _In_ int xDst,
               _In_ int yDst,
               _In_ int dxDst,
               _In_ int dyDst)
{
    ICDECOMPRESSEX ic;

    ic.dwFlags = dwFlags;
    ic.lpbiSrc = lpbiSrc;
    ic.lpSrc = lpSrc;
    ic.xSrc = xSrc;
    ic.ySrc = ySrc;
    ic.dxSrc = dxSrc;
    ic.dySrc = dySrc;
    ic.lpbiDst = lpbiDst;
    ic.lpDst = lpDst;
    ic.xDst = xDst;
    ic.yDst = yDst;
    ic.dxDst = dxDst;
    ic.dyDst = dyDst;
    return ICSendMessage(hic, ICM_DECOMPRESSEX, (DWORD_PTR)&ic, sizeof(ic));
}

static inline
LRESULT
VFWAPI
ICDecompressExBegin(_In_ HIC hic,
                    _In_ DWORD dwFlags,
                    _In_ LPBITMAPINFOHEADER lpbiSrc,
                    _In_opt_ LPVOID lpSrc,
                    _In_ int xSrc,
                    _In_ int ySrc,
                    _In_ int dxSrc,
                    _In_ int dySrc,
                    _In_ LPBITMAPINFOHEADER lpbiDst,
                    _Out_opt_ LPVOID lpDst,
                    _In_ int xDst,
                    _In_ int yDst,
                    _In_ int dxDst,
                    _In_ int dyDst)
{
    ICDECOMPRESSEX ic;

    ic.dwFlags = dwFlags;
    ic.lpbiSrc = lpbiSrc;
    ic.lpSrc = lpSrc;
    ic.xSrc = xSrc;
    ic.ySrc = ySrc;
    ic.dxSrc = dxSrc;
    ic.dySrc = dySrc;
    ic.lpbiDst = lpbiDst;
    ic.lpDst = lpDst;
    ic.xDst = xDst;
    ic.yDst = yDst;
    ic.dxDst = dxDst;
    ic.dyDst = dyDst;
    return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, (DWORD_PTR)&ic, sizeof(ic));
}

static inline
LRESULT
VFWAPI
ICDecompressExQuery(_In_ HIC hic,
                    _In_ DWORD dwFlags,
                    _In_ LPBITMAPINFOHEADER lpbiSrc,
                    _Reserved_ LPVOID lpSrc,
                    _In_ int xSrc,
                    _In_ int ySrc,
                    _In_ int dxSrc,
                    _In_ int dySrc,
                    _In_opt_ LPBITMAPINFOHEADER lpbiDst,
                    _Out_opt_ LPVOID lpDst,
                    _In_ int xDst,
                    _In_ int yDst,
                    _In_ int dxDst,
                    _In_ int dyDst)
{
    ICDECOMPRESSEX ic;

    ic.dwFlags = dwFlags;
    ic.lpbiSrc = lpbiSrc;
    ic.lpSrc = lpSrc;
    ic.xSrc = xSrc;
    ic.ySrc = ySrc;
    ic.dxSrc = dxSrc;
    ic.dySrc = dySrc;
    ic.lpbiDst = lpbiDst;
    ic.lpDst = lpDst;
    ic.xDst = xDst;
    ic.yDst = yDst;
    ic.dxDst = dxDst;
    ic.dyDst = dyDst;
    return ICSendMessage(hic, ICM_DECOMPRESSEX_QUERY, (DWORD_PTR)&ic, sizeof(ic));
}

#define ICDecompressExEnd(hic) \
    ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0)

#define ICDRAW_QUERY        0x00000001L   /* test for support */
#define ICDRAW_FULLSCREEN   0x00000002L   /* draw to full screen */
#define ICDRAW_HDC          0x00000004L   /* draw to a HDC/HWND */
#define ICDRAW_ANIMATE      0x00000008L   /* expect palette animation */
#define ICDRAW_CONTINUE     0x00000010L   /* draw is a continuation of previous draw */
#define ICDRAW_MEMORYDC     0x00000020L   /* DC is offscreen, by the way */
#define ICDRAW_UPDATING     0x00000040L   /* We're updating, as opposed to playing */
#define ICDRAW_RENDER       0x00000080L   /* used to render data not draw it */
#define ICDRAW_BUFFER       0x00000100L   /* buffer data offscreen, we will need to update it */

#define ICDecompressOpen(fccType, fccHandler, lpbiIn, lpbiOut) \
    ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS)

#define ICDrawOpen(fccType, fccHandler, lpbiIn) \
    ICLocate(fccType, fccHandler, lpbiIn, NULL, ICMODE_DRAW)

HANDLE
VFWAPI
ICImageCompress(
  _In_ HIC hic,
  _In_ UINT uiFlags,
  _In_ LPBITMAPINFO lpbiIn,
  _In_ LPVOID lpBits,
  _In_opt_ LPBITMAPINFO lpbiOut,
  _In_ LONG lQuality,
  _Inout_opt_ LONG* plSize);

HANDLE
VFWAPI
ICImageDecompress(
  _In_opt_ HIC hic,
  _In_ UINT uiFlags,
  _In_ LPBITMAPINFO lpbiIn,
  _In_ LPVOID lpBits,
  _In_opt_ LPBITMAPINFO lpbiOut);

BOOL
VFWAPI
ICInfo(
  _In_ DWORD fccType,
  _In_ DWORD fccHandler,
  _Out_ ICINFO * lpicinfo);

BOOL
VFWAPI
ICInstall(
  _In_ DWORD fccType,
  _In_ DWORD fccHandler,
  _In_ LPARAM lParam,
  _In_ LPSTR szDesc,
  _In_ UINT wFlags);

BOOL
VFWAPI
ICRemove(
  _In_ DWORD fccType,
  _In_ DWORD fccHandler,
  _In_ UINT wFlags);

_Success_(return != 0)
LRESULT
VFWAPI
ICGetInfo(
  _In_ HIC hic,
  _Out_writes_bytes_to_(cb, return) ICINFO *picinfo,
  _In_ DWORD cb);

HIC VFWAPI ICOpen(_In_ DWORD fccType, _In_ DWORD fccHandler, _In_ UINT wMode);

HIC
VFWAPI
ICOpenFunction(
  _In_ DWORD fccType,
  _In_ DWORD fccHandler,
  _In_ UINT wMode,
  _In_ DRIVERPROC lpfnHandler);

LRESULT VFWAPI ICClose(_In_ HIC hic);

HIC
VFWAPI
ICLocate(
  _In_ DWORD fccType,
  _In_ DWORD fccHandler,
  _In_ LPBITMAPINFOHEADER lpbiIn,
  _In_opt_ LPBITMAPINFOHEADER lpbiOut,
  _In_ WORD wFlags);

HIC
VFWAPI
ICGetDisplayFormat(
  _In_opt_ HIC hic,
  _In_ LPBITMAPINFOHEADER lpbiIn,
  _Out_ LPBITMAPINFOHEADER lpbiOut,
  _In_ int BitDepth,
  _In_ int dx,
  _In_ int dy);

/* Values for wFlags of ICInstall() */
#define ICINSTALL_UNICODE       0x8000
#define ICINSTALL_FUNCTION      0x0001
#define ICINSTALL_DRIVER        0x0002
#define ICINSTALL_HDRV          0x0004
#define ICINSTALL_DRIVERW       0x8002

#define ICGetState(hic, pv, cb) \
    ICSendMessage(hic, ICM_GETSTATE, (DWORD_PTR)(LPVOID)(pv), (DWORD_PTR)(cb))
#define ICSetState(hic, pv, cb) \
    ICSendMessage(hic, ICM_SETSTATE, (DWORD_PTR)(LPVOID)(pv), (DWORD_PTR)(cb))
#define ICGetStateSize(hic) \
    ICGetState(hic, NULL, 0)

static inline DWORD ICGetDefaultQuality(HIC hic)
{
   DWORD dwICValue;
   ICSendMessage(hic, ICM_GETDEFAULTQUALITY, (DWORD_PTR)(LPVOID)&dwICValue, sizeof(DWORD));
   return dwICValue;
}

static inline DWORD ICGetDefaultKeyFrameRate(HIC hic)
{
   DWORD dwICValue;
   ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, (DWORD_PTR)(LPVOID)&dwICValue, sizeof(DWORD));
   return dwICValue;
}

#define ICDrawWindow(hic, prc) \
    ICSendMessage(hic, ICM_DRAW_WINDOW, (DWORD_PTR)(LPVOID)(prc), sizeof(RECT))

/* As passed to ICM_DRAW_SUGGESTFORMAT */
typedef struct {
    DWORD dwFlags;
    LPBITMAPINFOHEADER lpbiIn;
    LPBITMAPINFOHEADER lpbiSuggest;
    INT dxSrc;
    INT dySrc;
    INT dxDst;
    INT dyDst;
    HIC hicDecompressor;
} ICDRAWSUGGEST;

typedef struct {
    DWORD               dwFlags;
    int                 iStart;
    int                 iLen;
    LPPALETTEENTRY      lppe;
} ICPALETTE;

DWORD
VFWAPIV
ICDrawBegin(
  _In_ HIC hic,
  _In_ DWORD dwFlags,
  _In_opt_ HPALETTE hpal,
  _In_opt_ HWND hwnd,
  _In_opt_ HDC hdc,
  _In_ INT xDst,
  _In_ INT yDst,
  _In_ INT dxDst,
  _In_ INT dyDst,
  _In_ LPBITMAPINFOHEADER lpbi,
  _In_ INT xSrc,
  _In_ INT ySrc,
  _In_ INT dxSrc,
  _In_ INT dySrc,
  _In_ DWORD dwRate,
  _In_ DWORD dwScale);

/* as passed to ICM_DRAW_BEGIN */
typedef struct {
    DWORD       dwFlags;
    HPALETTE    hpal;
    HWND        hwnd;
    HDC     hdc;
    INT     xDst;
    INT     yDst;
    INT     dxDst;
    INT     dyDst;
    LPBITMAPINFOHEADER  lpbi;
    INT     xSrc;
    INT     ySrc;
    INT     dxSrc;
    INT     dySrc;
    DWORD       dwRate;
    DWORD       dwScale;
} ICDRAWBEGIN;

#define ICDRAW_HURRYUP      0x80000000L   /* don't draw just buffer (hurry up!) */
#define ICDRAW_UPDATE       0x40000000L   /* don't draw just update screen */
#define ICDRAW_PREROLL      0x20000000L   /* this frame is before real start */
#define ICDRAW_NULLFRAME    0x10000000L   /* repeat last frame */
#define ICDRAW_NOTKEYFRAME  0x08000000L   /* this frame is not a key frame */

typedef struct {
    DWORD   dwFlags;
    LPVOID  lpFormat;
    LPVOID  lpData;
    DWORD   cbData;
    LONG    lTime;
} ICDRAW;

DWORD
VFWAPIV
ICDraw(
  _In_ HIC hic,
  _In_ DWORD dwFlags,
  _In_ LPVOID lpFormat,
  _In_reads_bytes_opt_(cbData) LPVOID lpData,
  _In_ DWORD cbData,
  _In_ LONG lTime);

static inline
LRESULT
VFWAPI
ICDrawSuggestFormat(_In_ HIC hic,
                    _In_ LPBITMAPINFOHEADER lpbiIn,
                    _Out_ LPBITMAPINFOHEADER lpbiOut,
                    _In_ int dxSrc,
                    _In_ int dySrc,
                    _In_ int dxDst,
                    _In_ int dyDst,
                    _In_ HIC hicDecomp)
{
    ICDRAWSUGGEST ic;

    ic.lpbiIn = lpbiIn;
    ic.lpbiSuggest = lpbiOut;
    ic.dxSrc = dxSrc;
    ic.dySrc = dySrc;
    ic.dxDst = dxDst;
    ic.dyDst = dyDst;
    ic.hicDecompressor = hicDecomp;
    return ICSendMessage(hic, ICM_DRAW_SUGGESTFORMAT, (DWORD_PTR)&ic, sizeof(ic));
}

#define ICDrawQuery(hic, lpbiInput) \
    ICSendMessage(hic, ICM_DRAW_QUERY, (DWORD_PTR)(LPVOID)(lpbiInput), 0L)

#define ICDrawChangePalette(hic, lpbiInput) \
    ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, (DWORD_PTR)(LPVOID)(lpbiInput), 0L)

#define ICGetBuffersWanted(hic, lpdwBuffers) \
    ICSendMessage(hic, ICM_GETBUFFERSWANTED, (DWORD_PTR)(LPVOID)(lpdwBuffers), 0)

#define ICDrawEnd(hic) \
    ICSendMessage(hic, ICM_DRAW_END, 0, 0)

#define ICDrawStart(hic) \
    ICSendMessage(hic, ICM_DRAW_START, 0, 0)

#define ICDrawStartPlay(hic, lFrom, lTo) \
    ICSendMessage(hic, ICM_DRAW_START_PLAY, (DWORD_PTR)(lFrom), (DWORD_PTR)(lTo))

#define ICDrawStop(hic) \
    ICSendMessage(hic, ICM_DRAW_STOP, 0, 0)

#define ICDrawStopPlay(hic) \
    ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0)

#define ICDrawGetTime(hic, lplTime) \
    ICSendMessage(hic, ICM_DRAW_GETTIME, (DWORD_PTR)(LPVOID)(lplTime), 0)

#define ICDrawSetTime(hic, lTime) \
    ICSendMessage(hic, ICM_DRAW_SETTIME, (DWORD_PTR)lTime, 0)

#define ICDrawRealize(hic, hdc, fBackground) \
    ICSendMessage(hic, ICM_DRAW_REALIZE, (DWORD_PTR)(UINT_PTR)(HDC)(hdc), (DWORD_PTR)(BOOL)(fBackground))

#define ICDrawFlush(hic) \
    ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0)

#define ICDrawRenderBuffer(hic) \
    ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0)

static inline
LRESULT
VFWAPI
ICSetStatusProc(_In_ HIC hic,
                _In_ DWORD dwFlags,
                _In_ LRESULT lParam,
                _In_ LONG(CALLBACK *fpfnStatus)(_In_ LPARAM, _In_ UINT, _In_ LONG))
{
    ICSETSTATUSPROC ic;

    ic.dwFlags = dwFlags;
    ic.lParam = lParam;
    /* FIXME: see comment in ICSETSTATUSPROC definition */
    ic.zStatus = fpfnStatus;

    return ICSendMessage(hic, ICM_SET_STATUS_PROC, (DWORD_PTR)&ic, sizeof(ic));
}

typedef struct {
    LONG        cbSize;
    DWORD       dwFlags;
    HIC         hic;
    DWORD               fccType;
    DWORD               fccHandler;
    LPBITMAPINFO    lpbiIn;
    LPBITMAPINFO    lpbiOut;
    LPVOID      lpBitsOut;
    LPVOID      lpBitsPrev;
    LONG        lFrame;
    LONG        lKey;
    LONG        lDataRate;
    LONG        lQ;
    LONG        lKeyCount;
    LPVOID      lpState;
    LONG        cbState;
} COMPVARS, *PCOMPVARS;

#define ICMF_COMPVARS_VALID 0x00000001

BOOL
VFWAPI
ICCompressorChoose(
  _In_opt_ HWND hwnd,
  _In_ UINT uiFlags,
  _In_opt_ LPVOID pvIn,
  _In_opt_ LPVOID lpData,
  _Inout_ PCOMPVARS pc,
  _In_opt_ LPSTR lpszTitle);

#define ICMF_CHOOSE_KEYFRAME        0x0001
#define ICMF_CHOOSE_DATARATE        0x0002
#define ICMF_CHOOSE_PREVIEW     0x0004
#define ICMF_CHOOSE_ALLCOMPRESSORS  0x0008

BOOL
VFWAPI
ICSeqCompressFrameStart(
  _In_ PCOMPVARS pc,
  _In_ LPBITMAPINFO lpbiIn);

void VFWAPI ICSeqCompressFrameEnd(_In_ PCOMPVARS pc);

LPVOID
VFWAPI
ICSeqCompressFrame(
  _In_ PCOMPVARS pc,
  _Reserved_ UINT uiFlags,
  _In_ LPVOID lpBits,
  _Out_ BOOL *pfKey,
  _Inout_opt_ LONG *plSize);

void VFWAPI ICCompressorFree(_In_ PCOMPVARS pc);

/********************* AVIFILE function declarations *************************/

#ifndef mmioFOURCC
#define mmioFOURCC( ch0, ch1, ch2, ch3 )                \
    ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |        \
    ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
#endif

#ifndef aviTWOCC
#define aviTWOCC(ch0, ch1) ((WORD)(BYTE)(ch0) | ((WORD)(BYTE)(ch1) << 8))
#endif

typedef WORD TWOCC;

#define ICTYPE_VIDEO        mmioFOURCC('v', 'i', 'd', 'c')
#define ICTYPE_AUDIO        mmioFOURCC('a', 'u', 'd', 'c')

#define formtypeAVI             mmioFOURCC('A', 'V', 'I', ' ')
#define listtypeAVIHEADER       mmioFOURCC('h', 'd', 'r', 'l')
#define ckidAVIMAINHDR          mmioFOURCC('a', 'v', 'i', 'h')
#define listtypeSTREAMHEADER    mmioFOURCC('s', 't', 'r', 'l')
#define ckidSTREAMHEADER        mmioFOURCC('s', 't', 'r', 'h')
#define ckidSTREAMFORMAT        mmioFOURCC('s', 't', 'r', 'f')
#define ckidSTREAMHANDLERDATA   mmioFOURCC('s', 't', 'r', 'd')
#define ckidSTREAMNAME      mmioFOURCC('s', 't', 'r', 'n')

#define listtypeAVIMOVIE        mmioFOURCC('m', 'o', 'v', 'i')
#define listtypeAVIRECORD       mmioFOURCC('r', 'e', 'c', ' ')

#define ckidAVINEWINDEX         mmioFOURCC('i', 'd', 'x', '1')

#define streamtypeANY           0UL
#define streamtypeVIDEO         mmioFOURCC('v', 'i', 'd', 's')
#define streamtypeAUDIO         mmioFOURCC('a', 'u', 'd', 's')
#define streamtypeMIDI          mmioFOURCC('m', 'i', 'd', 's')
#define streamtypeTEXT          mmioFOURCC('t', 'x', 't', 's')

/* Basic chunk types */
#define cktypeDIBbits           aviTWOCC('d', 'b')
#define cktypeDIBcompressed     aviTWOCC('d', 'c')
#define cktypePALchange         aviTWOCC('p', 'c')
#define cktypeWAVEbytes         aviTWOCC('w', 'b')

/* Chunk id to use for extra chunks for padding. */
#define ckidAVIPADDING          mmioFOURCC('J', 'U', 'N', 'K')

#define FromHex(n)      (((n) >= 'A') ? ((n) + 10 - 'A') : ((n) - '0'))
#define StreamFromFOURCC(fcc)   ((WORD)((FromHex(LOBYTE(LOWORD(fcc))) << 4) + \
                    (FromHex(HIBYTE(LOWORD(fcc))))))
#define TWOCCFromFOURCC(fcc)    HIWORD(fcc)
#define ToHex(n)        ((BYTE)(((n) > 9) ? ((n) - 10 + 'A') : ((n) + '0')))
#define MAKEAVICKID(tcc, stream) \
                                MAKELONG((ToHex((stream) & 0x0f) << 8) | \
                             (ToHex(((stream) & 0xf0) >> 4)), tcc)

/* AVIFileHdr.dwFlags */
#define AVIF_HASINDEX       0x00000010  /* Index at end of file? */
#define AVIF_MUSTUSEINDEX   0x00000020
#define AVIF_ISINTERLEAVED  0x00000100
#define AVIF_TRUSTCKTYPE    0x00000800  /* Use CKType to find key frames*/
#define AVIF_WASCAPTUREFILE 0x00010000
#define AVIF_COPYRIGHTED    0x00020000

#define AVI_HEADERSIZE  2048

typedef BOOL (CALLBACK *AVISAVECALLBACK)(INT);

typedef struct _MainAVIHeader
{
    DWORD   dwMicroSecPerFrame;
    DWORD   dwMaxBytesPerSec;
    DWORD   dwPaddingGranularity;
    DWORD   dwFlags;
    DWORD   dwTotalFrames;
    DWORD   dwInitialFrames;
    DWORD   dwStreams;
    DWORD   dwSuggestedBufferSize;
    DWORD   dwWidth;
    DWORD   dwHeight;
    DWORD   dwReserved[4];
} MainAVIHeader;

/* AVIStreamHeader.dwFlags */
#define AVISF_DISABLED                  0x00000001
#define AVISF_VIDEO_PALCHANGES          0x00010000

typedef struct {
    FOURCC  fccType;
    FOURCC  fccHandler;
    DWORD   dwFlags;        /* AVISF_* */
    WORD    wPriority;
    WORD    wLanguage;
    DWORD   dwInitialFrames;
    DWORD   dwScale;
    DWORD   dwRate; /* dwRate / dwScale == samples/second */
    DWORD   dwStart;
    DWORD   dwLength; /* In units above... */
    DWORD   dwSuggestedBufferSize;
    DWORD   dwQuality;
    DWORD   dwSampleSize;
    struct { SHORT left, top, right, bottom; } rcFrame; /* word.word - word.word in file */
} AVIStreamHeader;

/* AVIINDEXENTRY.dwFlags */
#define AVIIF_LIST  0x00000001  /* chunk is a 'LIST' */
#define AVIIF_TWOCC 0x00000002
#define AVIIF_KEYFRAME  0x00000010  /* this frame is a key frame. */
#define AVIIF_FIRSTPART 0x00000020
#define AVIIF_LASTPART  0x00000040
#define AVIIF_MIDPART   (AVIIF_LASTPART|AVIIF_FIRSTPART)
#define AVIIF_NOTIME    0x00000100  /* this frame doesn't take any time */
#define AVIIF_COMPUSE   0x0FFF0000

typedef struct _AVIINDEXENTRY {
    DWORD   ckid;
    DWORD   dwFlags;
    DWORD   dwChunkOffset;
    DWORD   dwChunkLength;
} AVIINDEXENTRY;

typedef struct _AVIPALCHANGE {
    BYTE        bFirstEntry;
    BYTE        bNumEntries;
    WORD        wFlags;     /* pad */
    PALETTEENTRY    peNew[1];
} AVIPALCHANGE;

#define AVIIF_KEYFRAME  0x00000010  /* this frame is a key frame. */

#define AVIGETFRAMEF_BESTDISPLAYFMT 1

typedef struct _AVISTREAMINFOA {
    DWORD   fccType;
    DWORD   fccHandler;
    DWORD   dwFlags;        /* AVIIF_* */
    DWORD   dwCaps;
    WORD    wPriority;
    WORD    wLanguage;
    DWORD   dwScale;
    DWORD   dwRate;     /* dwRate / dwScale == samples/second */
    DWORD   dwStart;
    DWORD   dwLength;   /* In units above... */
    DWORD   dwInitialFrames;
    DWORD   dwSuggestedBufferSize;
    DWORD   dwQuality;
    DWORD   dwSampleSize;
    RECT    rcFrame;
    DWORD   dwEditCount;
    DWORD   dwFormatChangeCount;
    CHAR    szName[64];
} AVISTREAMINFOA, * LPAVISTREAMINFOA, *PAVISTREAMINFOA;

typedef struct _AVISTREAMINFOW {
    DWORD   fccType;
    DWORD   fccHandler;
    DWORD   dwFlags;
    DWORD   dwCaps;
    WORD    wPriority;
    WORD    wLanguage;
    DWORD   dwScale;
    DWORD   dwRate;     /* dwRate / dwScale == samples/second */
    DWORD   dwStart;
    DWORD   dwLength;   /* In units above... */
    DWORD   dwInitialFrames;
    DWORD   dwSuggestedBufferSize;
    DWORD   dwQuality;
    DWORD   dwSampleSize;
    RECT    rcFrame;
    DWORD   dwEditCount;
    DWORD   dwFormatChangeCount;
    WCHAR   szName[64];
} AVISTREAMINFOW, * LPAVISTREAMINFOW, *PAVISTREAMINFOW;
DECL_WINELIB_TYPE_AW(AVISTREAMINFO)
DECL_WINELIB_TYPE_AW(LPAVISTREAMINFO)
DECL_WINELIB_TYPE_AW(PAVISTREAMINFO)

#define AVISTREAMINFO_DISABLED      0x00000001
#define AVISTREAMINFO_FORMATCHANGES 0x00010000

/* AVIFILEINFO.dwFlags */
#define AVIFILEINFO_HASINDEX        0x00000010
#define AVIFILEINFO_MUSTUSEINDEX    0x00000020
#define AVIFILEINFO_ISINTERLEAVED   0x00000100
#define AVIFILEINFO_TRUSTCKTYPE         0x00000800
#define AVIFILEINFO_WASCAPTUREFILE  0x00010000
#define AVIFILEINFO_COPYRIGHTED     0x00020000

/* AVIFILEINFO.dwCaps */
#define AVIFILECAPS_CANREAD     0x00000001
#define AVIFILECAPS_CANWRITE        0x00000002
#define AVIFILECAPS_ALLKEYFRAMES    0x00000010
#define AVIFILECAPS_NOCOMPRESSION   0x00000020

typedef struct _AVIFILEINFOW {
    DWORD               dwMaxBytesPerSec;
    DWORD               dwFlags;
    DWORD               dwCaps;
    DWORD               dwStreams;
    DWORD               dwSuggestedBufferSize;
    DWORD               dwWidth;
    DWORD               dwHeight;
    DWORD               dwScale;
    DWORD               dwRate;
    DWORD               dwLength;
    DWORD               dwEditCount;
    WCHAR               szFileType[64];
} AVIFILEINFOW, * LPAVIFILEINFOW, *PAVIFILEINFOW;
typedef struct _AVIFILEINFOA {
    DWORD               dwMaxBytesPerSec;
    DWORD               dwFlags;
    DWORD               dwCaps;
    DWORD               dwStreams;
    DWORD               dwSuggestedBufferSize;
    DWORD               dwWidth;
    DWORD               dwHeight;
    DWORD               dwScale;
    DWORD               dwRate;
    DWORD               dwLength;
    DWORD               dwEditCount;
    CHAR        szFileType[64];
} AVIFILEINFOA, * LPAVIFILEINFOA, *PAVIFILEINFOA;
DECL_WINELIB_TYPE_AW(AVIFILEINFO)
DECL_WINELIB_TYPE_AW(PAVIFILEINFO)
DECL_WINELIB_TYPE_AW(LPAVIFILEINFO)

/* AVICOMPRESSOPTIONS.dwFlags. determines presence of fields in below struct */
#define AVICOMPRESSF_INTERLEAVE 0x00000001
#define AVICOMPRESSF_DATARATE   0x00000002
#define AVICOMPRESSF_KEYFRAMES  0x00000004
#define AVICOMPRESSF_VALID  0x00000008

typedef struct {
    DWORD   fccType;        /* stream type, for consistency */
    DWORD   fccHandler;     /* compressor */
    DWORD   dwKeyFrameEvery;    /* keyframe rate */
    DWORD   dwQuality;      /* compress quality 0-10,000 */
    DWORD   dwBytesPerSecond;   /* bytes per second */
    DWORD   dwFlags;        /* flags... see below */
    LPVOID  lpFormat;       /* save format */
    DWORD   cbFormat;
    LPVOID  lpParms;        /* compressor options */
    DWORD   cbParms;
    DWORD   dwInterleaveEvery;  /* for non-video streams only */
} AVICOMPRESSOPTIONS, *LPAVICOMPRESSOPTIONS,*PAVICOMPRESSOPTIONS;

#define FIND_DIR        0x0000000FL     /* direction mask */
#define FIND_NEXT       0x00000001L     /* search forward */
#define FIND_PREV       0x00000004L     /* search backward */
#define FIND_FROM_START 0x00000008L     /* start at the logical beginning */

#define FIND_TYPE       0x000000F0L     /* type mask */
#define FIND_KEY        0x00000010L     /* find a key frame */
#define FIND_ANY        0x00000020L     /* find any (non-empty) sample */
#define FIND_FORMAT     0x00000040L     /* find a formatchange */

#define FIND_RET        0x0000F000L     /* return mask */
#define FIND_POS        0x00000000L     /* return logical position */
#define FIND_LENGTH     0x00001000L     /* return logical size */
#define FIND_OFFSET     0x00002000L     /* return physical position */
#define FIND_SIZE       0x00003000L     /* return physical size */
#define FIND_INDEX      0x00004000L     /* return physical index position */

#include <ole2.h>

#define DEFINE_AVIGUID(name, l, w1, w2) \
    DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)

DEFINE_AVIGUID(IID_IAVIFile,            0x00020020, 0, 0);
DEFINE_AVIGUID(IID_IAVIStream,          0x00020021, 0, 0);
DEFINE_AVIGUID(IID_IAVIStreaming,       0x00020022, 0, 0);
DEFINE_AVIGUID(IID_IGetFrame,           0x00020023, 0, 0);
DEFINE_AVIGUID(IID_IAVIEditStream,      0x00020024, 0, 0);

DEFINE_AVIGUID(CLSID_AVISimpleUnMarshal,0x00020009, 0, 0);
DEFINE_AVIGUID(CLSID_AVIFile,           0x00020000, 0, 0);

/*****************************************************************************
 * IAVIStream interface
 */
#define INTERFACE IAVIStream
DECLARE_INTERFACE_(IAVIStream,IUnknown)
{
    /*** IUnknown methods ***/
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, _Outptr_ void** ppvObject) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
    /*** IAVIStream methods ***/
    STDMETHOD(Create)(THIS_ LPARAM lParam1, LPARAM lParam2) PURE;
    STDMETHOD(Info)(THIS_ _Out_writes_bytes_(lSize) AVISTREAMINFOW *psi, _In_ LONG lSize) PURE;
    STDMETHOD_(LONG,FindSample)(THIS_ _In_ LONG lPos, _In_ LONG lFlags) PURE;
    STDMETHOD(ReadFormat)(THIS_ _In_ LONG lPos, _Out_writes_bytes_to_opt_(*lpcbFormat, *lpcbFormat) LPVOID lpFormat, _Inout_ LONG *lpcbFormat) PURE;
    STDMETHOD(SetFormat)(THIS_ _In_ LONG lPos, _In_reads_bytes_(cbFormat) LPVOID lpFormat, _In_ LONG cbFormat) PURE;
    STDMETHOD(Read)(THIS_ _In_ LONG lStart, _In_ LONG lSamples, _Out_writes_bytes_opt_(cbBuffer) LPVOID lpBuffer, _In_ LONG cbBuffer, _Out_opt_ LONG *plBytes, _Out_opt_ LONG *plSamples) PURE;
    STDMETHOD(Write)(THIS_ _In_ LONG lStart, _In_ LONG lSamples, _In_reads_bytes_(cbBuffer) LPVOID lpBuffer, _In_ LONG cbBuffer, _In_ DWORD dwFlags, _Out_opt_ LONG *plSampWritten, _Out_opt_ LONG *plBytesWritten) PURE;
    STDMETHOD(Delete)(THIS_ _In_ LONG lStart, _In_ LONG lSamples) PURE;
    STDMETHOD(ReadData)(THIS_ _In_ DWORD fcc, _Out_writes_bytes_to_opt_(*lpcbBuffer, *lpcbBuffer) LPVOID lpBuffer, _Inout_ LONG *lpcbBuffer) PURE;
    STDMETHOD(WriteData)(THIS_ _In_ DWORD fcc, _In_reads_bytes_(cbBuffer) LPVOID lpBuffer, _In_ LONG cbBuffer) PURE;
    STDMETHOD(SetInfo)(THIS_ _In_reads_bytes_(cbInfo) AVISTREAMINFOW *plInfo, _In_ LONG cbInfo) PURE;
};
#undef INTERFACE

#if !defined(__cplusplus) || defined(CINTERFACE)
/*** IUnknown methods ***/
#define IAVIStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAVIStream_AddRef(p)             (p)->lpVtbl->AddRef(p)
#define IAVIStream_Release(p)            (p)->lpVtbl->Release(p)
/*** IAVIStream methods ***/
#define IAVIStream_Create(p,a,b)          (p)->lpVtbl->Create(p,a,b)
#define IAVIStream_Info(p,a,b)            (p)->lpVtbl->Info(p,a,b)
#define IAVIStream_FindSample(p,a,b)      (p)->lpVtbl->FindSample(p,a,b)
#define IAVIStream_ReadFormat(p,a,b,c)    (p)->lpVtbl->ReadFormat(p,a,b,c)
#define IAVIStream_SetFormat(p,a,b,c)     (p)->lpVtbl->SetFormat(p,a,b,c)
#define IAVIStream_Read(p,a,b,c,d,e,f)    (p)->lpVtbl->Read(p,a,b,c,d,e,f)
#define IAVIStream_Write(p,a,b,c,d,e,f,g) (p)->lpVtbl->Write(p,a,b,c,d,e,f,g)
#define IAVIStream_Delete(p,a,b)          (p)->lpVtbl->Delete(p,a,b)
#define IAVIStream_ReadData(p,a,b,c)      (p)->lpVtbl->ReadData(p,a,b,c)
#define IAVIStream_WriteData(p,a,b,c)     (p)->lpVtbl->WriteData(p,a,b,c)
#define IAVIStream_SetInfo(p,a,b)         (p)->lpVtbl->SetInfo(p,a,b)
#endif

#define AVISTREAMREAD_CONVENIENT      (-1L)

ULONG WINAPI AVIStreamAddRef(PAVISTREAM iface);
ULONG WINAPI AVIStreamRelease(PAVISTREAM iface);

HRESULT
WINAPI
AVIStreamCreate(
  _Outptr_ PAVISTREAM*,
  _In_ LONG,
  _In_ LONG,
  _In_opt_ CLSID*);

HRESULT
WINAPI
AVIStreamInfoA(
  _In_ PAVISTREAM iface,
  _Out_writes_bytes_(size) AVISTREAMINFOA *asi,
  _In_ LONG size);

HRESULT
WINAPI
AVIStreamInfoW(
  _In_ PAVISTREAM iface,
  _Out_writes_bytes_(size) AVISTREAMINFOW *asi,
  _In_ LONG size);

#define AVIStreamInfo WINELIB_NAME_AW(AVIStreamInfo)

LONG
WINAPI
AVIStreamFindSample(
  _In_ PAVISTREAM pstream,
  _In_ LONG pos,
  _In_ LONG flags);

HRESULT
WINAPI
AVIStreamReadFormat(
  _In_ PAVISTREAM iface,
  _In_ LONG pos,
  _Out_writes_bytes_to_opt_(*formatsize, *formatsize) LPVOID format,
  _Inout_ LONG *formatsize);

HRESULT
WINAPI
AVIStreamSetFormat(
  _In_ PAVISTREAM iface,
  _In_ LONG pos,
  _In_reads_bytes_(formatsize) LPVOID format,
  _In_ LONG formatsize);

HRESULT
WINAPI
AVIStreamRead(
  _In_ PAVISTREAM iface,
  _In_ LONG start,
  _In_ LONG samples,
  _Out_writes_bytes_opt_(buffersize) LPVOID buffer,
  _In_ LONG buffersize,
  _Out_opt_ LONG *bytesread,
  _Out_opt_ LONG *samplesread);

HRESULT
WINAPI
AVIStreamWrite(
  _In_ PAVISTREAM iface,
  _In_ LONG start,
  _In_ LONG samples,
  _In_reads_bytes_(buffersize) LPVOID buffer,
  _In_ LONG buffersize,
  _In_ DWORD flags,
  _Out_opt_ LONG *sampwritten,
  _Out_opt_ LONG *byteswritten);

HRESULT
WINAPI
AVIStreamReadData(
  _In_ PAVISTREAM iface,
  _In_ DWORD fcc,
  _Out_writes_bytes_to_opt_(*lpread, *lpread) LPVOID lp,
  _Inout_ LONG *lpread);

HRESULT
WINAPI
AVIStreamWriteData(
  _In_ PAVISTREAM iface,
  _In_ DWORD fcc,
  _In_reads_bytes_(size) LPVOID lp,
  _In_ LONG size);

PGETFRAME
WINAPI
AVIStreamGetFrameOpen(
  _In_ PAVISTREAM pavi,
  _In_opt_ LPBITMAPINFOHEADER lpbiWanted);

LPVOID  WINAPI AVIStreamGetFrame(_In_ PGETFRAME pg, _In_ LONG pos);
HRESULT WINAPI AVIStreamGetFrameClose(_In_ PGETFRAME pg);

HRESULT
WINAPI
AVIMakeCompressedStream(
  _Outptr_ PAVISTREAM *ppsCompressed,
  _In_ PAVISTREAM ppsSource,
  _In_ AVICOMPRESSOPTIONS *lpOptions,
  _In_opt_ CLSID *pclsidHandler);

HRESULT
WINAPI
AVIMakeFileFromStreams(
  _Outptr_ PAVIFILE *ppfile,
  _In_ int nStreams,
  _In_reads_(nStreams) PAVISTREAM *ppStreams);

HRESULT
WINAPI
AVIMakeStreamFromClipboard(
  UINT cfFormat,
  _In_ HANDLE hGlobal,
  _Outptr_ PAVISTREAM * ppstream);

HRESULT
WINAPI
AVIStreamOpenFromFileA(
  _Outptr_ PAVISTREAM *ppavi,
  _In_ LPCSTR szFile,
  _In_ DWORD fccType,
  _In_ LONG lParam,
  _In_ UINT mode,
  _In_opt_ CLSID *pclsidHandler);

HRESULT
WINAPI
AVIStreamOpenFromFileW(
  _Outptr_ PAVISTREAM *ppavi,
  _In_ LPCWSTR szFile,
  _In_ DWORD fccType,
  _In_ LONG lParam,
  _In_ UINT mode,
  _In_opt_ CLSID *pclsidHandler);

#define AVIStreamOpenFromFile WINELIB_NAME_AW(AVIStreamOpenFromFile)

LONG
WINAPI
AVIStreamBeginStreaming(
  _In_ PAVISTREAM pavi,
  _In_ LONG lStart,
  _In_ LONG lEnd,
  _In_ LONG lRate);

LONG WINAPI AVIStreamEndStreaming(_In_ PAVISTREAM pavi);

HRESULT
WINAPI
AVIBuildFilterA(
  _Out_writes_(cbFilter) LPSTR szFilter,
  _In_ LONG cbFilter,
  _In_ BOOL fSaving);

HRESULT
WINAPI
AVIBuildFilterW(
  _Out_writes_(cbFilter) LPWSTR szFilter,
  _In_ LONG cbFilter,
  _In_ BOOL fSaving);

#define AVIBuildFilter WINELIB_NAME_AW(AVIBuildFilter)

BOOL
WINAPI
AVISaveOptions(
  _In_ HWND hWnd,
  _In_ UINT uFlags,
  _In_ INT nStream,
  _In_reads_(nStream) PAVISTREAM *ppavi,
  _Inout_updates_(nStream) LPAVICOMPRESSOPTIONS *ppOptions);

HRESULT
WINAPI
AVISaveOptionsFree(
  INT nStreams,
  _In_reads_(nStreams) LPAVICOMPRESSOPTIONS *ppOptions);

HRESULT
CDECL
AVISaveA(
  LPCSTR szFile,
  _In_opt_ CLSID *pclsidHandler,
  _In_ AVISAVECALLBACK lpfnCallback,
  _In_ int nStreams,
  _In_ PAVISTREAM pavi,
  _In_ LPAVICOMPRESSOPTIONS lpOptions,
  ...);

HRESULT
CDECL
AVISaveW(
  LPCWSTR szFile,
  _In_opt_ CLSID *pclsidHandler,
  _In_ AVISAVECALLBACK lpfnCallback,
  _In_ int nStreams,
  _In_ PAVISTREAM pavi,
  _In_ LPAVICOMPRESSOPTIONS lpOptions,
  ...);

#define AVISave WINELIB_NAME_AW(AVISave)

HRESULT
WINAPI
AVISaveVA(
  LPCSTR szFile,
  _In_opt_ CLSID *pclsidHandler,
  _In_ AVISAVECALLBACK lpfnCallback,
  _In_ int nStream,
  _In_reads_(nStream) PAVISTREAM *ppavi,
  _In_reads_(nStream) LPAVICOMPRESSOPTIONS *plpOptions);

HRESULT
WINAPI
AVISaveVW(
  LPCWSTR szFile,
  _In_opt_ CLSID *pclsidHandler,
  _In_ AVISAVECALLBACK lpfnCallback,
  _In_ int nStream,
  _In_reads_(nStream) PAVISTREAM *ppavi,
  _In_reads_(nStream) LPAVICOMPRESSOPTIONS *plpOptions);

#define AVISaveV WINELIB_NAME_AW(AVISaveV)

LONG WINAPI AVIStreamStart(_In_ PAVISTREAM iface);
LONG WINAPI AVIStreamLength(_In_ PAVISTREAM iface);
LONG WINAPI AVIStreamSampleToTime(_In_ PAVISTREAM pstream, _In_ LONG lSample);
LONG WINAPI AVIStreamTimeToSample(_In_ PAVISTREAM pstream, _In_ LONG lTime);

#define AVIFileClose(pavi) \
    AVIFileRelease(pavi)
#define AVIStreamClose(pavi) \
    AVIStreamRelease(pavi);
#define AVIStreamEnd(pavi) \
    (AVIStreamStart(pavi) + AVIStreamLength(pavi))
#define AVIStreamEndTime(pavi) \
    AVIStreamSampleToTime(pavi, AVIStreamEnd(pavi))
#define AVIStreamFormatSize(pavi, lPos, plSize) \
    AVIStreamReadFormat(pavi, lPos, NULL, plSize)
#define AVIStreamLengthTime(pavi) \
    AVIStreamSampleToTime(pavi, AVIStreamLength(pavi))
#define AVIStreamSampleSize(pavi,pos,psize) \
    AVIStreamRead(pavi,pos,1,NULL,0,psize,NULL)
#define AVIStreamSampleToSample(pavi1, pavi2, samp2) \
    AVIStreamTimeToSample(pavi1, AVIStreamSampleToTime(pavi2, samp2))
#define AVIStreamStartTime(pavi) \
    AVIStreamSampleToTime(pavi, AVIStreamStart(pavi))

#define AVIStreamNextSample(pavi, pos) \
    AVIStreamFindSample(pavi, pos + 1, FIND_NEXT | FIND_ANY)
#define AVIStreamPrevSample(pavi, pos) \
    AVIStreamFindSample(pavi, pos - 1, FIND_PREV | FIND_ANY)
#define AVIStreamNearestSample(pavi, pos) \
    AVIStreamFindSample(pavi, pos, FIND_PREV | FIND_ANY)
#define AVStreamNextKeyFrame(pavi,pos) \
    AVIStreamFindSample(pavi, pos + 1, FIND_NEXT | FIND_KEY)
#define AVStreamPrevKeyFrame(pavi,pos) \
    AVIStreamFindSample(pavi, pos - 1, FIND_NEXT | FIND_KEY)
#define AVIStreamNearestKeyFrame(pavi,pos) \
    AVIStreamFindSample(pavi, pos, FIND_PREV | FIND_KEY)
#define AVIStreamIsKeyFrame(pavi, pos) \
    (AVIStreamNearestKeyFrame(pavi, pos) == pos)

/*****************************************************************************
 * IAVIStreaming interface
 */
#define INTERFACE IAVIStreaming
DECLARE_INTERFACE_(IAVIStreaming,IUnknown)
{
    /*** IUnknown methods ***/
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, _Outptr_ void** ppvObject) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
    /*** IAVIStreaming methods ***/
    STDMETHOD(Begin)(IAVIStreaming *iface, _In_ LONG lStart, _In_ LONG lEnd, _In_ LONG lRate) PURE;
    STDMETHOD(End)(IAVIStreaming *iface) PURE;
};
#undef INTERFACE

#if !defined(__cplusplus) || defined(CINTERFACE)
/*** IUnknown methods ***/
#define IAVIStreaming_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAVIStreaming_AddRef(p)             (p)->lpVtbl->AddRef(p)
#define IAVIStreaming_Release(p)            (p)->lpVtbl->Release(p)
/*** IAVIStreaming methods ***/
#define IAVIStreaming_Begin(p,a,b,c)        (p)->lpVtbl->Begin(p,a,b,c)
#define IAVIStreaming_End(p)                (p)->lpVtbl->End(p)
#endif

/*****************************************************************************
 * IAVIEditStream interface
 */
#define INTERFACE IAVIEditStream
DECLARE_INTERFACE_(IAVIEditStream,IUnknown)
{
    /*** IUnknown methods ***/
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, _Outptr_ void** ppvObject) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
    /*** IAVIEditStream methods ***/
    STDMETHOD(Cut)(IAVIEditStream *iface, _Inout_ LONG *plStart, _Inout_ LONG *plLength, _Outptr_ PAVISTREAM *ppResult) PURE;
    STDMETHOD(Copy)(IAVIEditStream *iface, _Inout_ LONG *plStart, _Inout_ LONG *plLength, _Outptr_ PAVISTREAM *ppResult) PURE;
    STDMETHOD(Paste)(IAVIEditStream *iface, _Inout_ LONG *plStart, _Inout_ LONG *plLength, _Inout_ PAVISTREAM pSource, _In_ LONG lStart, _In_ LONG lEnd) PURE;
    STDMETHOD(Clone)(IAVIEditStream *iface, _Outptr_ PAVISTREAM *ppResult) PURE;
    STDMETHOD(SetInfo)(IAVIEditStream *iface, _In_reads_bytes_(size) LPAVISTREAMINFOW asi, _In_ LONG size) PURE;
};
#undef INTERFACE

#if !defined(__cplusplus) || defined(CINTERFACE)
/*** IUnknown methods ***/
#define IAVIEditStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAVIEditStream_AddRef(p)             (p)->lpVtbl->AddRef(p)
#define IAVIEditStream_Release(p)            (p)->lpVtbl->Release(p)
/*** IAVIEditStream methods ***/
#define IAVIEditStream_Cut(p,a,b,c)      (p)->lpVtbl->Cut(p,a,b,c)
#define IAVIEditStream_Copy(p,a,b,c)         (p)->lpVtbl->Copy(p,a,b,c)
#define IAVIEditStream_Paste(p,a,b,c,d,e)    (p)->lpVtbl->Paste(p,a,b,c,d,e)
#define IAVIEditStream_Clone(p,a)        (p)->lpVtbl->Clone(p,a)
#define IAVIEditStream_SetInfo(p,a,b)        (p)->lpVtbl->SetInfo(p,a,b)
#endif

HRESULT
WINAPI
CreateEditableStream(
  _Outptr_ PAVISTREAM *ppEditable,
  _In_ PAVISTREAM pSource);

HRESULT
WINAPI
EditStreamClone(
  _In_ PAVISTREAM pStream,
  _Outptr_ PAVISTREAM *ppResult);

HRESULT
WINAPI
EditStreamCopy(
  _In_ PAVISTREAM pStream,
  _Inout_ LONG *plStart,
  _Inout_ LONG *plLength,
  _Outptr_ PAVISTREAM *ppResult);

HRESULT
WINAPI
EditStreamCut(
  _In_ PAVISTREAM pStream,
  _Inout_ LONG *plStart,
  _Inout_ LONG *plLength,
  _Outptr_ PAVISTREAM *ppResult);

HRESULT
WINAPI
EditStreamPaste(
  _In_ PAVISTREAM pDest,
  _Inout_ LONG *plStart,
  _Inout_ LONG *plLength,
  _In_ PAVISTREAM pSource,
  _In_ LONG lStart,
  _In_ LONG lEnd);

HRESULT
WINAPI
EditStreamSetInfoA(
  _In_ PAVISTREAM pstream,
  _In_reads_bytes_(size) LPAVISTREAMINFOA asi,
  _In_ LONG size);

HRESULT
WINAPI
EditStreamSetInfoW(
  _In_ PAVISTREAM pstream,
  _In_reads_bytes_(size) LPAVISTREAMINFOW asi,
  _In_ LONG size);

#define EditStreamSetInfo WINELIB_NAME_AW(EditStreamSetInfo)

HRESULT WINAPI EditStreamSetNameA(_In_ PAVISTREAM pstream, _In_ LPCSTR szName);
HRESULT WINAPI EditStreamSetNameW(_In_ PAVISTREAM pstream, _In_ LPCWSTR szName);
#define EditStreamSetName WINELIB_NAME_AW(EditStreamSetName)

/*****************************************************************************
 * IAVIFile interface
 */
/* In Win32 this interface uses UNICODE only */
#define INTERFACE IAVIFile
DECLARE_INTERFACE_(IAVIFile,IUnknown)
{
    /*** IUnknown methods ***/
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, _Outptr_ void** ppvObject) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
    /*** IAVIFile methods ***/
    STDMETHOD(Info)(THIS_ _Out_writes_bytes_(lSize) AVIFILEINFOW *pfi, _In_ LONG lSize) PURE;
    STDMETHOD(GetStream)(THIS_ _Outptr_ PAVISTREAM *ppStream, _In_ DWORD fccType, _In_ LONG lParam) PURE;
    STDMETHOD(CreateStream)(THIS_ _Outptr_ PAVISTREAM *ppStream, _In_ AVISTREAMINFOW *psi) PURE;
    STDMETHOD(WriteData)(THIS_ _In_ DWORD fcc, _In_reads_bytes_(cbBuffer) LPVOID lpBuffer, _In_ LONG cbBuffer) PURE;
    STDMETHOD(ReadData)(THIS_ _In_ DWORD fcc, _Out_writes_bytes_to_(*lpcbBuffer, *lpcbBuffer) LPVOID lpBuffer, _Inout_ LONG *lpcbBuffer) PURE;
    STDMETHOD(EndRecord)(THIS) PURE;
    STDMETHOD(DeleteStream)(THIS_ _In_ DWORD fccType, _In_ LONG lParam) PURE;
};
#undef INTERFACE

#if !defined(__cplusplus) || defined(CINTERFACE)
/*** IUnknown methods ***/
#define IAVIFile_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAVIFile_AddRef(p)             (p)->lpVtbl->AddRef(p)
#define IAVIFile_Release(p)            (p)->lpVtbl->Release(p)
/*** IAVIFile methods ***/
#define IAVIFile_Info(p,a,b)         (p)->lpVtbl->Info(p,a,b)
#define IAVIFile_GetStream(p,a,b,c)  (p)->lpVtbl->GetStream(p,a,b,c)
#define IAVIFile_CreateStream(p,a,b) (p)->lpVtbl->CreateStream(p,a,b)
#define IAVIFile_WriteData(p,a,b,c)  (p)->lpVtbl->WriteData(p,a,b,c)
#define IAVIFile_ReadData(p,a,b,c)   (p)->lpVtbl->ReadData(p,a,b,c)
#define IAVIFile_EndRecord(p)        (p)->lpVtbl->EndRecord(p)
#define IAVIFile_DeleteStream(p,a,b) (p)->lpVtbl->DeleteStream(p,a,b)
#endif

void WINAPI AVIFileInit(void);
void WINAPI AVIFileExit(void);

HRESULT
WINAPI
AVIFileOpenA(
  _Outptr_ PAVIFILE* ppfile,
  _In_ LPCSTR szFile,
  UINT uMode,
  _In_opt_ LPCLSID lpHandler);

HRESULT
WINAPI
AVIFileOpenW(
  _Outptr_ PAVIFILE* ppfile,
  _In_ LPCWSTR szFile,
  UINT uMode,
  _In_opt_ LPCLSID lpHandler);

#define AVIFileOpen WINELIB_NAME_AW(AVIFileOpen)

ULONG   WINAPI AVIFileAddRef(PAVIFILE pfile);
ULONG   WINAPI AVIFileRelease(PAVIFILE pfile);

HRESULT
WINAPI
AVIFileInfoA(
  _In_ PAVIFILE pfile,
  _Out_writes_bytes_(lSize) PAVIFILEINFOA pfi,
  _In_ LONG lSize);

HRESULT
WINAPI
AVIFileInfoW(
  _In_ PAVIFILE pfile,
  _Out_writes_bytes_(lSize) PAVIFILEINFOW pfi,
  _In_ LONG lSize);

#define AVIFileInfo WINELIB_NAME_AW(AVIFileInfo)

HRESULT
WINAPI
AVIFileGetStream(
  _In_ PAVIFILE pfile,
  _Outptr_ PAVISTREAM* avis,
  _In_ DWORD fccType,
  _In_ LONG lParam);

HRESULT
WINAPI
AVIFileCreateStreamA(
  _In_ PAVIFILE pfile,
  _Outptr_ PAVISTREAM* ppavi,
  _In_ AVISTREAMINFOA* psi);

HRESULT
WINAPI
AVIFileCreateStreamW(
  _In_ PAVIFILE pfile,
  _Outptr_ PAVISTREAM* ppavi,
  _In_ AVISTREAMINFOW* psi);

#define AVIFileCreateStream WINELIB_NAME_AW(AVIFileCreateStream)

HRESULT
WINAPI
AVIFileWriteData(
  _In_ PAVIFILE pfile,
  _In_ DWORD fcc,
  _In_reads_bytes_(size) LPVOID lp,
  _In_ LONG size);

HRESULT
WINAPI
AVIFileReadData(
  _In_ PAVIFILE pfile,
  _In_ DWORD fcc,
  _Out_writes_bytes_to_(*size, *size) LPVOID lp,
  _Inout_ LPLONG size);

HRESULT WINAPI AVIFileEndRecord(_In_ PAVIFILE pfile);

/*****************************************************************************
 * IGetFrame interface
 */
#define INTERFACE IGetFrame
DECLARE_INTERFACE_(IGetFrame,IUnknown)
{
    /*** IUnknown methods ***/
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, _Outptr_ void** ppvObject) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
    /*** IGetFrame methods ***/
    STDMETHOD_(LPVOID,GetFrame)(THIS_ _In_ LONG lPos) PURE;
    STDMETHOD(Begin)(THIS_ _In_ LONG lStart, _In_ LONG lEnd, _In_ LONG lRate) PURE;
    STDMETHOD(End)(THIS) PURE;
    STDMETHOD(SetFormat)(THIS_ _In_ LPBITMAPINFOHEADER lpbi, _In_opt_ LPVOID lpBits, _In_ INT x, _In_ INT y, _In_ INT dx, _In_ INT dy) PURE;
};
#undef INTERFACE

#if !defined(__cplusplus) || defined(CINTERFACE)
/*** IUnknown methods ***/
#define IGetFrame_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IGetFrame_AddRef(p)             (p)->lpVtbl->AddRef(p)
#define IGetFrame_Release(p)            (p)->lpVtbl->Release(p)
/*** IGetFrame methods ***/
#define IGetFrame_GetFrame(p,a)            (p)->lpVtbl->GetFrame(p,a)
#define IGetFrame_Begin(p,a,b,c)           (p)->lpVtbl->Begin(p,a,b,c)
#define IGetFrame_End(p)                   (p)->lpVtbl->End(p)
#define IGetFrame_SetFormat(p,a,b,c,d,e,f) (p)->lpVtbl->SetFormat(p,a,b,c,d,e,f)
#endif

HRESULT WINAPI AVIClearClipboard(void);
HRESULT WINAPI AVIGetFromClipboard(_Outptr_ PAVIFILE *ppfile);
HRESULT WINAPI AVIPutFileOnClipboard(_In_ PAVIFILE pfile);

#ifdef OFN_READONLY
BOOL WINAPI GetOpenFileNamePreviewA(_Inout_ LPOPENFILENAMEA lpofn);
BOOL WINAPI GetOpenFileNamePreviewW(_Inout_ LPOPENFILENAMEW lpofn);
#define GetOpenFileNamePreview WINELIB_NAME_AW(GetOpenFileNamePreview)
BOOL WINAPI GetSaveFileNamePreviewA(_Inout_ LPOPENFILENAMEA lpofn);
BOOL WINAPI GetSaveFileNamePreviewW(_Inout_ LPOPENFILENAMEW lpofn);
#define GetSaveFileNamePreview WINELIB_NAME_AW(GetSaveFileNamePreview)
#endif

#define AVIERR_OK       0
#define MAKE_AVIERR(error)  MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x4000+error)

#define AVIERR_UNSUPPORTED  MAKE_AVIERR(101)
#define AVIERR_BADFORMAT    MAKE_AVIERR(102)
#define AVIERR_MEMORY       MAKE_AVIERR(103)
#define AVIERR_INTERNAL     MAKE_AVIERR(104)
#define AVIERR_BADFLAGS     MAKE_AVIERR(105)
#define AVIERR_BADPARAM     MAKE_AVIERR(106)
#define AVIERR_BADSIZE      MAKE_AVIERR(107)
#define AVIERR_BADHANDLE    MAKE_AVIERR(108)
#define AVIERR_FILEREAD     MAKE_AVIERR(109)
#define AVIERR_FILEWRITE    MAKE_AVIERR(110)
#define AVIERR_FILEOPEN     MAKE_AVIERR(111)
#define AVIERR_COMPRESSOR   MAKE_AVIERR(112)
#define AVIERR_NOCOMPRESSOR MAKE_AVIERR(113)
#define AVIERR_READONLY     MAKE_AVIERR(114)
#define AVIERR_NODATA       MAKE_AVIERR(115)
#define AVIERR_BUFFERTOOSMALL   MAKE_AVIERR(116)
#define AVIERR_CANTCOMPRESS MAKE_AVIERR(117)
#define AVIERR_USERABORT    MAKE_AVIERR(198)
#define AVIERR_ERROR        MAKE_AVIERR(199)

BOOL VFWAPIV MCIWndRegisterClass(void);

HWND
VFWAPIV
MCIWndCreateA(
  _In_opt_ HWND,
  _In_opt_ HINSTANCE,
  _In_ DWORD,
  _In_opt_ LPCSTR);

HWND
VFWAPIV
MCIWndCreateW(
  _In_opt_ HWND,
  _In_opt_ HINSTANCE,
  _In_ DWORD,
  _In_opt_ LPCWSTR);

#define MCIWndCreate WINELIB_NAME_AW(MCIWndCreate)

#define MCIWNDOPENF_NEW         0x0001

#define MCIWNDF_NOAUTOSIZEWINDOW    0x0001
#define MCIWNDF_NOPLAYBAR       0x0002
#define MCIWNDF_NOAUTOSIZEMOVIE     0x0004
#define MCIWNDF_NOMENU          0x0008
#define MCIWNDF_SHOWNAME        0x0010
#define MCIWNDF_SHOWPOS         0x0020
#define MCIWNDF_SHOWMODE        0x0040
#define MCIWNDF_SHOWALL         0x0070

#define MCIWNDF_NOTIFYMODE      0x0100
#define MCIWNDF_NOTIFYPOS       0x0200
#define MCIWNDF_NOTIFYSIZE      0x0400
#define MCIWNDF_NOTIFYERROR     0x1000
#define MCIWNDF_NOTIFYALL       0x1F00

#define MCIWNDF_NOTIFYANSI      0x0080

#define MCIWNDF_NOTIFYMEDIAA        0x0880
#define MCIWNDF_NOTIFYMEDIAW        0x0800
#define MCIWNDF_NOTIFYMEDIA WINELIB_NAME_AW(MCIWNDF_NOTIFYMEDIA)

#define MCIWNDF_RECORD          0x2000
#define MCIWNDF_NOERRORDLG      0x4000
#define MCIWNDF_NOOPEN          0x8000

#ifdef __cplusplus
#define MCIWndSM ::SendMessage
#else
#define MCIWndSM SendMessage
#endif

#define MCIWndCanPlay(hWnd)         (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_PLAY,0,0)
#define MCIWndCanRecord(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_RECORD,0,0)
#define MCIWndCanSave(hWnd)         (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_SAVE,0,0)
#define MCIWndCanWindow(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_WINDOW,0,0)
#define MCIWndCanEject(hWnd)        (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_EJECT,0,0)
#define MCIWndCanConfig(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_CAN_CONFIG,0,0)
#define MCIWndPaletteKick(hWnd)     (BOOL)MCIWndSM(hWnd,MCIWNDM_PALETTEKICK,0,0)

#define MCIWndSave(hWnd,szFile)     (LONG)MCIWndSM(hWnd,MCI_SAVE,0,(LPARAM)(LPVOID)(szFile))
#define MCIWndSaveDialog(hWnd)      MCIWndSave(hWnd,-1)

#define MCIWndNew(hWnd,lp)          (LONG)MCIWndSM(hWnd,MCIWNDM_NEW,0,(LPARAM)(LPVOID)(lp))

#define MCIWndRecord(hWnd)          (LONG)MCIWndSM(hWnd,MCI_RECORD,0,0)
#define MCIWndOpen(hWnd,sz,f)       (LONG)MCIWndSM(hWnd,MCIWNDM_OPEN,(WPARAM)(UINT)(f),(LPARAM)(LPVOID)(sz))
#define MCIWndOpenDialog(hWnd)      MCIWndOpen(hWnd,-1,0)
#define MCIWndClose(hWnd)           (LONG)MCIWndSM(hWnd,MCI_CLOSE,0,0)
#define MCIWndPlay(hWnd)            (LONG)MCIWndSM(hWnd,MCI_PLAY,0,0)
#define MCIWndStop(hWnd)            (LONG)MCIWndSM(hWnd,MCI_STOP,0,0)
#define MCIWndPause(hWnd)           (LONG)MCIWndSM(hWnd,MCI_PAUSE,0,0)
#define MCIWndResume(hWnd)          (LONG)MCIWndSM(hWnd,MCI_RESUME,0,0)
#define MCIWndSeek(hWnd,lPos)       (LONG)MCIWndSM(hWnd,MCI_SEEK,0,(LPARAM)(LONG)(lPos))
#define MCIWndEject(hWnd)           (LONG)MCIWndSM(hWnd,MCIWNDM_EJECT,0,0)

#define MCIWndHome(hWnd)            MCIWndSeek(hWnd,MCIWND_START)
#define MCIWndEnd(hWnd)             MCIWndSeek(hWnd,MCIWND_END)

#define MCIWndGetSource(hWnd,prc)   (LONG)MCIWndSM(hWnd,MCIWNDM_GET_SOURCE,0,(LPARAM)(LPRECT)(prc))
#define MCIWndPutSource(hWnd,prc)   (LONG)MCIWndSM(hWnd,MCIWNDM_PUT_SOURCE,0,(LPARAM)(LPRECT)(prc))

#define MCIWndGetDest(hWnd,prc)     (LONG)MCIWndSM(hWnd,MCIWNDM_GET_DEST,0,(LPARAM)(LPRECT)(prc))
#define MCIWndPutDest(hWnd,prc)     (LONG)MCIWndSM(hWnd,MCIWNDM_PUT_DEST,0,(LPARAM)(LPRECT)(prc))

#define MCIWndPlayReverse(hWnd)     (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYREVERSE,0,0)
#define MCIWndPlayFrom(hWnd,lPos)   (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYFROM,0,(LPARAM)(LONG)(lPos))
#define MCIWndPlayTo(hWnd,lPos)     (LONG)MCIWndSM(hWnd,MCIWNDM_PLAYTO,  0,(LPARAM)(LONG)(lPos))
#define MCIWndPlayFromTo(hWnd,lStart,lEnd) (MCIWndSeek(hWnd,lStart),MCIWndPlayTo(hWnd,lEnd))

#define MCIWndGetDeviceID(hWnd)     (UINT)MCIWndSM(hWnd,MCIWNDM_GETDEVICEID,0,0)
#define MCIWndGetAlias(hWnd)        (UINT)MCIWndSM(hWnd,MCIWNDM_GETALIAS,0,0)
#define MCIWndGetMode(hWnd,lp,len)  (LONG)MCIWndSM(hWnd,MCIWNDM_GETMODE,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
#define MCIWndGetPosition(hWnd)     (LONG)MCIWndSM(hWnd,MCIWNDM_GETPOSITION,0,0)
#define MCIWndGetPositionString(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETPOSITION,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
#define MCIWndGetStart(hWnd)        (LONG)MCIWndSM(hWnd,MCIWNDM_GETSTART,0,0)
#define MCIWndGetLength(hWnd)       (LONG)MCIWndSM(hWnd,MCIWNDM_GETLENGTH,0,0)
#define MCIWndGetEnd(hWnd)          (LONG)MCIWndSM(hWnd,MCIWNDM_GETEND,0,0)

#define MCIWndStep(hWnd,n)          (LONG)MCIWndSM(hWnd,MCI_STEP,0,(LPARAM)(LONG)(n))

#define MCIWndDestroy(hWnd)         (VOID)MCIWndSM(hWnd,WM_CLOSE,0,0)
#define MCIWndSetZoom(hWnd,iZoom)   (VOID)MCIWndSM(hWnd,MCIWNDM_SETZOOM,0,(LPARAM)(UINT)(iZoom))
#define MCIWndGetZoom(hWnd)         (UINT)MCIWndSM(hWnd,MCIWNDM_GETZOOM,0,0)
#define MCIWndSetVolume(hWnd,iVol)  (LONG)MCIWndSM(hWnd,MCIWNDM_SETVOLUME,0,(LPARAM)(UINT)(iVol))
#define MCIWndGetVolume(hWnd)       (LONG)MCIWndSM(hWnd,MCIWNDM_GETVOLUME,0,0)
#define MCIWndSetSpeed(hWnd,iSpeed) (LONG)MCIWndSM(hWnd,MCIWNDM_SETSPEED,0,(LPARAM)(UINT)(iSpeed))
#define MCIWndGetSpeed(hWnd)        (LONG)MCIWndSM(hWnd,MCIWNDM_GETSPEED,0,0)
#define MCIWndSetTimeFormat(hWnd,lp) (LONG)MCIWndSM(hWnd,MCIWNDM_SETTIMEFORMAT,0,(LPARAM)(LPTSTR)(lp))
#define MCIWndGetTimeFormat(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETTIMEFORMAT,(WPARAM)(UINT)(len),(LPARAM)(LPTSTR)(lp))
#define MCIWndValidateMedia(hWnd)   (VOID)MCIWndSM(hWnd,MCIWNDM_VALIDATEMEDIA,0,0)

#define MCIWndSetRepeat(hWnd,f)     (void)MCIWndSM(hWnd,MCIWNDM_SETREPEAT,0,(LPARAM)(BOOL)(f))
#define MCIWndGetRepeat(hWnd)       (BOOL)MCIWndSM(hWnd,MCIWNDM_GETREPEAT,0,0)

#define MCIWndUseFrames(hWnd)       MCIWndSetTimeFormat(hWnd,TEXT("frames"))
#define MCIWndUseTime(hWnd)         MCIWndSetTimeFormat(hWnd,TEXT("ms"))

#define MCIWndSetActiveTimer(hWnd,active)               \
    (VOID)MCIWndSM(hWnd,MCIWNDM_SETACTIVETIMER,         \
    (WPARAM)(UINT)(active),0L)
#define MCIWndSetInactiveTimer(hWnd,inactive)               \
    (VOID)MCIWndSM(hWnd,MCIWNDM_SETINACTIVETIMER,           \
    (WPARAM)(UINT)(inactive),0L)
#define MCIWndSetTimers(hWnd,active,inactive)               \
        (VOID)MCIWndSM(hWnd,MCIWNDM_SETTIMERS,(WPARAM)(UINT)(active),\
        (LPARAM)(UINT)(inactive))
#define MCIWndGetActiveTimer(hWnd)                  \
    (UINT)MCIWndSM(hWnd,MCIWNDM_GETACTIVETIMER,0,0L);
#define MCIWndGetInactiveTimer(hWnd)                    \
    (UINT)MCIWndSM(hWnd,MCIWNDM_GETINACTIVETIMER,0,0L);

#define MCIWndRealize(hWnd,fBkgnd) (LONG)MCIWndSM(hWnd,MCIWNDM_REALIZE,(WPARAM)(BOOL)(fBkgnd),0)

#define MCIWndSendString(hWnd,sz)  (LONG)MCIWndSM(hWnd,MCIWNDM_SENDSTRING,0,(LPARAM)(LPTSTR)(sz))
#define MCIWndReturnString(hWnd,lp,len)  (LONG)MCIWndSM(hWnd,MCIWNDM_RETURNSTRING,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
#define MCIWndGetError(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETERROR,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))

#define MCIWndGetPalette(hWnd)      (HPALETTE)MCIWndSM(hWnd,MCIWNDM_GETPALETTE,0,0)
#define MCIWndSetPalette(hWnd,hpal) (LONG)MCIWndSM(hWnd,MCIWNDM_SETPALETTE,(WPARAM)(HPALETTE)(hpal),0)

#define MCIWndGetFileName(hWnd,lp,len) (LONG)MCIWndSM(hWnd,MCIWNDM_GETFILENAME,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))
#define MCIWndGetDevice(hWnd,lp,len)   (LONG)MCIWndSM(hWnd,MCIWNDM_GETDEVICE,(WPARAM)(UINT)(len),(LPARAM)(LPVOID)(lp))

#define MCIWndGetStyles(hWnd) (UINT)MCIWndSM(hWnd,MCIWNDM_GETSTYLES,0,0L)
#define MCIWndChangeStyles(hWnd,mask,value) (LONG)MCIWndSM(hWnd,MCIWNDM_CHANGESTYLES,(WPARAM)(UINT)(mask),(LPARAM)(LONG)(value))

#define MCIWndOpenInterface(hWnd,pUnk)  (LONG)MCIWndSM(hWnd,MCIWNDM_OPENINTERFACE,0,(LPARAM)(LPUNKNOWN)(pUnk))

#define MCIWndSetOwner(hWnd,hWndP)  (LONG)MCIWndSM(hWnd,MCIWNDM_SETOWNER,(WPARAM)(hWndP),0)

#define MCIWNDM_GETDEVICEID (WM_USER + 100)
#define MCIWNDM_GETSTART    (WM_USER + 103)
#define MCIWNDM_GETLENGTH   (WM_USER + 104)
#define MCIWNDM_GETEND      (WM_USER + 105)
#define MCIWNDM_EJECT       (WM_USER + 107)
#define MCIWNDM_SETZOOM     (WM_USER + 108)
#define MCIWNDM_GETZOOM         (WM_USER + 109)
#define MCIWNDM_SETVOLUME   (WM_USER + 110)
#define MCIWNDM_GETVOLUME   (WM_USER + 111)
#define MCIWNDM_SETSPEED    (WM_USER + 112)
#define MCIWNDM_GETSPEED    (WM_USER + 113)
#define MCIWNDM_SETREPEAT   (WM_USER + 114)
#define MCIWNDM_GETREPEAT   (WM_USER + 115)
#define MCIWNDM_REALIZE         (WM_USER + 118)
#define MCIWNDM_VALIDATEMEDIA   (WM_USER + 121)
#define MCIWNDM_PLAYFROM    (WM_USER + 122)
#define MCIWNDM_PLAYTO          (WM_USER + 123)
#define MCIWNDM_GETPALETTE      (WM_USER + 126)
#define MCIWNDM_SETPALETTE      (WM_USER + 127)
#define MCIWNDM_SETTIMERS   (WM_USER + 129)
#define MCIWNDM_SETACTIVETIMER  (WM_USER + 130)
#define MCIWNDM_SETINACTIVETIMER (WM_USER + 131)
#define MCIWNDM_GETACTIVETIMER  (WM_USER + 132)
#define MCIWNDM_GETINACTIVETIMER (WM_USER + 133)
#define MCIWNDM_CHANGESTYLES    (WM_USER + 135)
#define MCIWNDM_GETSTYLES   (WM_USER + 136)
#define MCIWNDM_GETALIAS    (WM_USER + 137)
#define MCIWNDM_PLAYREVERSE (WM_USER + 139)
#define MCIWNDM_GET_SOURCE      (WM_USER + 140)
#define MCIWNDM_PUT_SOURCE      (WM_USER + 141)
#define MCIWNDM_GET_DEST        (WM_USER + 142)
#define MCIWNDM_PUT_DEST        (WM_USER + 143)
#define MCIWNDM_CAN_PLAY        (WM_USER + 144)
#define MCIWNDM_CAN_WINDOW      (WM_USER + 145)
#define MCIWNDM_CAN_RECORD      (WM_USER + 146)
#define MCIWNDM_CAN_SAVE        (WM_USER + 147)
#define MCIWNDM_CAN_EJECT       (WM_USER + 148)
#define MCIWNDM_CAN_CONFIG      (WM_USER + 149)
#define MCIWNDM_PALETTEKICK     (WM_USER + 150)
#define MCIWNDM_OPENINTERFACE   (WM_USER + 151)
#define MCIWNDM_SETOWNER    (WM_USER + 152)

#define MCIWNDM_SENDSTRINGA (WM_USER + 101)
#define MCIWNDM_GETPOSITIONA    (WM_USER + 102)
#define MCIWNDM_GETMODEA    (WM_USER + 106)
#define MCIWNDM_SETTIMEFORMATA  (WM_USER + 119)
#define MCIWNDM_GETTIMEFORMATA  (WM_USER + 120)
#define MCIWNDM_GETFILENAMEA    (WM_USER + 124)
#define MCIWNDM_GETDEVICEA      (WM_USER + 125)
#define MCIWNDM_GETERRORA       (WM_USER + 128)
#define MCIWNDM_NEWA        (WM_USER + 134)
#define MCIWNDM_RETURNSTRINGA   (WM_USER + 138)
#define MCIWNDM_OPENA       (WM_USER + 153)

#define MCIWNDM_SENDSTRINGW (WM_USER + 201)
#define MCIWNDM_GETPOSITIONW    (WM_USER + 202)
#define MCIWNDM_GETMODEW    (WM_USER + 206)
#define MCIWNDM_SETTIMEFORMATW  (WM_USER + 219)
#define MCIWNDM_GETTIMEFORMATW  (WM_USER + 220)
#define MCIWNDM_GETFILENAMEW    (WM_USER + 224)
#define MCIWNDM_GETDEVICEW      (WM_USER + 225)
#define MCIWNDM_GETERRORW       (WM_USER + 228)
#define MCIWNDM_NEWW        (WM_USER + 234)
#define MCIWNDM_RETURNSTRINGW   (WM_USER + 238)
#define MCIWNDM_OPENW       (WM_USER + 252)

#define MCIWNDM_SENDSTRING  WINELIB_NAME_AW(MCIWNDM_SENDSTRING)
#define MCIWNDM_GETPOSITION WINELIB_NAME_AW(MCIWNDM_GETPOSITION)
#define MCIWNDM_GETMODE     WINELIB_NAME_AW(MCIWNDM_GETMODE)
#define MCIWNDM_SETTIMEFORMAT   WINELIB_NAME_AW(MCIWNDM_SETTIMEFORMAT)
#define MCIWNDM_GETTIMEFORMAT   WINELIB_NAME_AW(MCIWNDM_GETTIMEFORMAT)
#define MCIWNDM_GETFILENAME WINELIB_NAME_AW(MCIWNDM_GETFILENAME)
#define MCIWNDM_GETDEVICE   WINELIB_NAME_AW(MCIWNDM_GETDEVICE)
#define MCIWNDM_GETERROR    WINELIB_NAME_AW(MCIWNDM_GETERROR)
#define MCIWNDM_NEW     WINELIB_NAME_AW(MCIWNDM_NEW)
#define MCIWNDM_RETURNSTRING    WINELIB_NAME_AW(MCIWNDM_RETURNSTRING)
#define MCIWNDM_OPEN        WINELIB_NAME_AW(MCIWNDM_OPEN)

#define MCIWNDM_NOTIFYMODE      (WM_USER + 200)
#define MCIWNDM_NOTIFYPOS   (WM_USER + 201)
#define MCIWNDM_NOTIFYSIZE  (WM_USER + 202)
#define MCIWNDM_NOTIFYMEDIA     (WM_USER + 203)
#define MCIWNDM_NOTIFYERROR     (WM_USER + 205)

#define MCIWND_START                -1
#define MCIWND_END                  -2

/********************************************
 * DrawDib declarations
 */

typedef struct
{ 
    LONG    timeCount; 
    LONG    timeDraw; 
    LONG    timeDecompress; 
    LONG    timeDither; 
    LONG    timeStretch; 
    LONG    timeBlt; 
    LONG    timeSetDIBits; 
} DRAWDIBTIME, *LPDRAWDIBTIME; 

HDRAWDIB VFWAPI DrawDibOpen( void );

UINT
VFWAPI
DrawDibRealize(
  _In_ HDRAWDIB hdd,
  _In_ HDC hdc,
  _In_ BOOL fBackground);

BOOL
VFWAPI
DrawDibBegin(
  _In_ HDRAWDIB hdd,
  _In_opt_ HDC hdc,
  _In_ INT dxDst,
  _In_ INT dyDst,
  _In_ LPBITMAPINFOHEADER lpbi,
  _In_ INT dxSrc,
  _In_ INT dySrc,
  _In_ UINT wFlags);

BOOL
VFWAPI
DrawDibDraw(
  _In_ HDRAWDIB hdd,
  _In_ HDC hdc,
  _In_ INT xDst,
  _In_ INT yDst,
  _In_ INT dxDst,
  _In_ INT dyDst,
  _In_opt_ LPBITMAPINFOHEADER lpbi,
  _In_opt_ LPVOID lpBits,
  _In_ INT xSrc,
  _In_ INT ySrc,
  _In_ INT dxSrc,
  _In_ INT dySrc,
  _In_ UINT wFlags);

/* DrawDibDraw flags */

#define DDF_UPDATE          0x0002
#define DDF_SAME_HDC            0x0004
#define DDF_SAME_DRAW           0x0008
#define DDF_DONTDRAW            0x0010
#define DDF_ANIMATE         0x0020
#define DDF_BUFFER          0x0040
#define DDF_JUSTDRAWIT          0x0080
#define DDF_FULLSCREEN          0x0100
#define DDF_BACKGROUNDPAL       0x0200
#define DDF_NOTKEYFRAME         0x0400
#define DDF_HURRYUP         0x0800
#define DDF_HALFTONE            0x1000

#define DDF_PREROLL                 DDF_DONTDRAW
#define DDF_SAME_DIB                DDF_SAME_DRAW
#define DDF_SAME_SIZE               DDF_SAME_DRAW

BOOL VFWAPI DrawDibSetPalette(_In_ HDRAWDIB hdd, _In_opt_ HPALETTE hpal);
HPALETTE VFWAPI DrawDibGetPalette(_In_ HDRAWDIB hdd);

BOOL
VFWAPI
DrawDibChangePalette(
  _In_ HDRAWDIB hdd,
  _In_ int iStart,
  _In_ int iLen,
  _In_reads_(iLen) LPPALETTEENTRY lppe);

LPVOID
VFWAPI
DrawDibGetBuffer(
  _In_ HDRAWDIB hdd,
  _Out_ LPBITMAPINFOHEADER lpbi,
  _In_ DWORD dwSize,
  _In_ DWORD dwFlags);

BOOL VFWAPI DrawDibStart(_In_ HDRAWDIB hdd, _In_ DWORD rate);
BOOL VFWAPI DrawDibStop(_In_ HDRAWDIB hdd);

#define DrawDibUpdate(hdd, hdc, x, y) \
        DrawDibDraw(hdd, hdc, x, y, 0, 0, NULL, NULL, 0, 0, 0, 0, DDF_UPDATE)

BOOL VFWAPI DrawDibEnd(_In_ HDRAWDIB hdd);
BOOL VFWAPI DrawDibClose(_In_ HDRAWDIB hdd);
BOOL VFWAPI DrawDibTime(_In_ HDRAWDIB hdd, _Out_ LPDRAWDIBTIME lpddtime);

/* display profiling */
#define PD_CAN_DRAW_DIB         0x0001
#define PD_CAN_STRETCHDIB       0x0002
#define PD_STRETCHDIB_1_1_OK    0x0004
#define PD_STRETCHDIB_1_2_OK    0x0008
#define PD_STRETCHDIB_1_N_OK    0x0010

DWORD VFWAPI DrawDibProfileDisplay(_In_ LPBITMAPINFOHEADER lpbi);

DECLARE_HANDLE(HVIDEO);
typedef HVIDEO *LPHVIDEO;

DWORD VFWAPI VideoForWindowsVersion(void);

LONG  VFWAPI InitVFW(void);
LONG  VFWAPI TermVFW(void);

#define DV_ERR_OK            (0)
#define DV_ERR_BASE          (1)
#define DV_ERR_NONSPECIFIC   (DV_ERR_BASE)
#define DV_ERR_BADFORMAT     (DV_ERR_BASE + 1)
#define DV_ERR_STILLPLAYING  (DV_ERR_BASE + 2)
#define DV_ERR_UNPREPARED    (DV_ERR_BASE + 3)
#define DV_ERR_SYNC          (DV_ERR_BASE + 4)
#define DV_ERR_TOOMANYCHANNELS (DV_ERR_BASE + 5)
#define DV_ERR_NOTDETECTED   (DV_ERR_BASE + 6)
#define DV_ERR_BADINSTALL    (DV_ERR_BASE + 7)
#define DV_ERR_CREATEPALETTE (DV_ERR_BASE + 8)
#define DV_ERR_SIZEFIELD     (DV_ERR_BASE + 9)
#define DV_ERR_PARAM1        (DV_ERR_BASE + 10)
#define DV_ERR_PARAM2        (DV_ERR_BASE + 11)
#define DV_ERR_CONFIG1       (DV_ERR_BASE + 12)
#define DV_ERR_CONFIG2       (DV_ERR_BASE + 13)
#define DV_ERR_FLAGS         (DV_ERR_BASE + 14)
#define DV_ERR_13            (DV_ERR_BASE + 15)

#define DV_ERR_NOTSUPPORTED  (DV_ERR_BASE + 16)
#define DV_ERR_NOMEM         (DV_ERR_BASE + 17)
#define DV_ERR_ALLOCATED     (DV_ERR_BASE + 18)
#define DV_ERR_BADDEVICEID   (DV_ERR_BASE + 19)
#define DV_ERR_INVALHANDLE   (DV_ERR_BASE + 20)
#define DV_ERR_BADERRNUM     (DV_ERR_BASE + 21)
#define DV_ERR_NO_BUFFERS    (DV_ERR_BASE + 22)

#define DV_ERR_MEM_CONFLICT  (DV_ERR_BASE + 23)
#define DV_ERR_IO_CONFLICT   (DV_ERR_BASE + 24)
#define DV_ERR_DMA_CONFLICT  (DV_ERR_BASE + 25)
#define DV_ERR_INT_CONFLICT  (DV_ERR_BASE + 26)
#define DV_ERR_PROTECT_ONLY  (DV_ERR_BASE + 27)
#define DV_ERR_LASTERROR     (DV_ERR_BASE + 27)

#define DV_ERR_USER_MSG      (DV_ERR_BASE + 1000)

#ifndef MM_DRVM_OPEN
#define MM_DRVM_OPEN       0x3D0
#define MM_DRVM_CLOSE      0x3D1
#define MM_DRVM_DATA       0x3D2
#define MM_DRVM_ERROR      0x3D3

#define DV_VM_OPEN         MM_DRVM_OPEN
#define DV_VM_CLOSE        MM_DRVM_CLOSE
#define DV_VM_DATA         MM_DRVM_DATA
#define DV_VM_ERROR        MM_DRVM_ERROR
#endif

typedef struct videohdr_tag {
    LPBYTE      lpData;
    DWORD       dwBufferLength;
    DWORD       dwBytesUsed;
    DWORD       dwTimeCaptured;
    DWORD_PTR   dwUser;
    DWORD       dwFlags;
    DWORD_PTR   dwReserved[4];
} VIDEOHDR, *PVIDEOHDR, *LPVIDEOHDR;

#define VHDR_DONE       0x00000001
#define VHDR_PREPARED   0x00000002
#define VHDR_INQUEUE    0x00000004
#define VHDR_KEYFRAME   0x00000008

typedef struct channel_caps_tag {
    DWORD       dwFlags;
    DWORD       dwSrcRectXMod;
    DWORD       dwSrcRectYMod;
    DWORD       dwSrcRectWidthMod;
    DWORD       dwSrcRectHeightMod;
    DWORD       dwDstRectXMod;
    DWORD       dwDstRectYMod;
    DWORD       dwDstRectWidthMod;
    DWORD       dwDstRectHeightMod;
} CHANNEL_CAPS, *PCHANNEL_CAPS, *LPCHANNEL_CAPS;

#define VCAPS_OVERLAY       0x00000001
#define VCAPS_SRC_CAN_CLIP  0x00000002
#define VCAPS_DST_CAN_CLIP  0x00000004
#define VCAPS_CAN_SCALE     0x00000008

#define VIDEO_EXTERNALIN        0x0001
#define VIDEO_EXTERNALOUT       0x0002
#define VIDEO_IN                0x0004
#define VIDEO_OUT               0x0008

#define VIDEO_DLG_QUERY         0x0010

#define VIDEO_CONFIGURE_QUERY   0x8000

#define VIDEO_CONFIGURE_SET     0x1000

#define VIDEO_CONFIGURE_GET     0x2000
#define VIDEO_CONFIGURE_QUERYSIZE 0x0001

#define VIDEO_CONFIGURE_CURRENT 0x0010
#define VIDEO_CONFIGURE_NOMINAL 0x0020
#define VIDEO_CONFIGURE_MIN     0x0040
#define VIDEO_CONFIGURE_MAX     0x0080

#define DVM_USER                0x4000

#define DVM_CONFIGURE_START     0x1000
#define DVM_CONFIGURE_END       0x1FFF

#define DVM_PALETTE             (DVM_CONFIGURE_START + 1)
#define DVM_FORMAT              (DVM_CONFIGURE_START + 2)
#define DVM_PALETTERGB555       (DVM_CONFIGURE_START + 3)
#define DVM_SRC_RECT            (DVM_CONFIGURE_START + 4)
#define DVM_DST_RECT            (DVM_CONFIGURE_START + 5)

#define AVICapSM(hwnd,m,w,l) ((IsWindow(hwnd)) ? SendMessage(hwnd,m,w,l) : 0)

#define WM_CAP_START                    WM_USER

#define WM_CAP_UNICODE_START            WM_USER+100

#define WM_CAP_GET_CAPSTREAMPTR         (WM_CAP_START + 1)

#define WM_CAP_SET_CALLBACK_ERRORW      (WM_CAP_UNICODE_START + 2)
#define WM_CAP_SET_CALLBACK_STATUSW     (WM_CAP_UNICODE_START + 3)
#define WM_CAP_SET_CALLBACK_ERRORA      (WM_CAP_START + 2)
#define WM_CAP_SET_CALLBACK_STATUSA     (WM_CAP_START+ 3)

#define WM_CAP_SET_CALLBACK_ERROR       WINELIB_NAME_AW(WM_CAP_SET_CALLBACK_ERROR)
#define WM_CAP_SET_CALLBACK_STATUS      WINELIB_NAME_AW(WM_CAP_SET_CALLBACK_STATUS)

#define WM_CAP_SET_CALLBACK_YIELD       (WM_CAP_START +  4)
#define WM_CAP_SET_CALLBACK_FRAME       (WM_CAP_START +  5)
#define WM_CAP_SET_CALLBACK_VIDEOSTREAM (WM_CAP_START +  6)
#define WM_CAP_SET_CALLBACK_WAVESTREAM  (WM_CAP_START +  7)
#define WM_CAP_GET_USER_DATA            (WM_CAP_START +  8)
#define WM_CAP_SET_USER_DATA            (WM_CAP_START +  9)

#define WM_CAP_DRIVER_CONNECT           (WM_CAP_START +  10)
#define WM_CAP_DRIVER_DISCONNECT        (WM_CAP_START +  11)

#define WM_CAP_DRIVER_GET_NAMEA         (WM_CAP_START +  12)
#define WM_CAP_DRIVER_GET_VERSIONA      (WM_CAP_START +  13)
#define WM_CAP_DRIVER_GET_NAMEW         (WM_CAP_UNICODE_START +  12)
#define WM_CAP_DRIVER_GET_VERSIONW      (WM_CAP_UNICODE_START +  13)

#define WM_CAP_DRIVER_GET_NAME          WINELIB_NAME_AW(WM_CAP_DRIVER_GET_NAME)
#define WM_CAP_DRIVER_GET_VERSION       WINELIB_NAME_AW(WM_CAP_DRIVER_GET_VERSION)

#define WM_CAP_DRIVER_GET_CAPS          (WM_CAP_START +  14)

#define WM_CAP_FILE_SET_CAPTURE_FILEA   (WM_CAP_START +  20)
#define WM_CAP_FILE_GET_CAPTURE_FILEA   (WM_CAP_START +  21)
#define WM_CAP_FILE_ALLOCATE            (WM_CAP_START +  22)
#define WM_CAP_FILE_SAVEASA             (WM_CAP_START +  23)
#define WM_CAP_FILE_SET_INFOCHUNK       (WM_CAP_START +  24)
#define WM_CAP_FILE_SAVEDIBA            (WM_CAP_START +  25)
#define WM_CAP_FILE_SET_CAPTURE_FILEW   (WM_CAP_UNICODE_START +  20)
#define WM_CAP_FILE_GET_CAPTURE_FILEW   (WM_CAP_UNICODE_START +  21)
#define WM_CAP_FILE_SAVEASW             (WM_CAP_UNICODE_START +  23)
#define WM_CAP_FILE_SAVEDIBW            (WM_CAP_UNICODE_START +  25)

#define WM_CAP_FILE_SET_CAPTURE_FILE    WINELIB_NAME_AW(WM_CAP_FILE_SET_CAPTURE_FILE)
#define WM_CAP_FILE_GET_CAPTURE_FILE    WINELIB_NAME_AW(WM_CAP_FILE_GET_CAPTURE_FILE)
#define WM_CAP_FILE_SAVEAS              WINELIB_NAME_AW(WM_CAP_FILE_SAVEAS)
#define WM_CAP_FILE_SAVEDIB             WINELIB_NAME_AW(WM_CAP_FILE_SAVEDIB)

#define WM_CAP_EDIT_COPY                (WM_CAP_START +  30)

#define WM_CAP_SET_AUDIOFORMAT          (WM_CAP_START +  35)
#define WM_CAP_GET_AUDIOFORMAT          (WM_CAP_START +  36)

#define WM_CAP_DLG_VIDEOFORMAT          (WM_CAP_START +  41)
#define WM_CAP_DLG_VIDEOSOURCE          (WM_CAP_START +  42)
#define WM_CAP_DLG_VIDEODISPLAY         (WM_CAP_START +  43)
#define WM_CAP_GET_VIDEOFORMAT          (WM_CAP_START +  44)
#define WM_CAP_SET_VIDEOFORMAT          (WM_CAP_START +  45)
#define WM_CAP_DLG_VIDEOCOMPRESSION     (WM_CAP_START +  46)

#define WM_CAP_SET_PREVIEW              (WM_CAP_START +  50)
#define WM_CAP_SET_OVERLAY              (WM_CAP_START +  51)
#define WM_CAP_SET_PREVIEWRATE          (WM_CAP_START +  52)
#define WM_CAP_SET_SCALE                (WM_CAP_START +  53)
#define WM_CAP_GET_STATUS               (WM_CAP_START +  54)
#define WM_CAP_SET_SCROLL               (WM_CAP_START +  55)

#define WM_CAP_GRAB_FRAME               (WM_CAP_START +  60)
#define WM_CAP_GRAB_FRAME_NOSTOP        (WM_CAP_START +  61)

#define WM_CAP_SEQUENCE                 (WM_CAP_START +  62)
#define WM_CAP_SEQUENCE_NOFILE          (WM_CAP_START +  63)
#define WM_CAP_SET_SEQUENCE_SETUP       (WM_CAP_START +  64)
#define WM_CAP_GET_SEQUENCE_SETUP       (WM_CAP_START +  65)

#define WM_CAP_SET_MCI_DEVICEA          (WM_CAP_START +  66)
#define WM_CAP_GET_MCI_DEVICEA          (WM_CAP_START +  67)
#define WM_CAP_SET_MCI_DEVICEW          (WM_CAP_UNICODE_START +  66)
#define WM_CAP_GET_MCI_DEVICEW          (WM_CAP_UNICODE_START +  67)

#define WM_CAP_SET_MCI_DEVICE           WINELIB_NAME_AW(WM_CAP_SET_MCI_DEVICE)
#define WM_CAP_GET_MCI_DEVICE           WINELIB_NAME_AW(WM_CAP_GET_MCI_DEVICE)

#define WM_CAP_STOP                     (WM_CAP_START +  68)
#define WM_CAP_ABORT                    (WM_CAP_START +  69)

#define WM_CAP_SINGLE_FRAME_OPEN        (WM_CAP_START +  70)
#define WM_CAP_SINGLE_FRAME_CLOSE       (WM_CAP_START +  71)
#define WM_CAP_SINGLE_FRAME             (WM_CAP_START +  72)

#define WM_CAP_PAL_OPENA                (WM_CAP_START +  80)
#define WM_CAP_PAL_SAVEA                (WM_CAP_START +  81)
#define WM_CAP_PAL_OPENW                (WM_CAP_UNICODE_START +  80)
#define WM_CAP_PAL_SAVEW                (WM_CAP_UNICODE_START +  81)

#define WM_CAP_PAL_OPEN                 WINELIB_NAME_AW(WM_CAP_PAL_OPEN)
#define WM_CAP_PAL_SAVE                 WINELIB_NAME_AW(WM_CAP_PAL_SAVE)

#define WM_CAP_PAL_PASTE                (WM_CAP_START +  82)
#define WM_CAP_PAL_AUTOCREATE           (WM_CAP_START +  83)
#define WM_CAP_PAL_MANUALCREATE         (WM_CAP_START +  84)

#define WM_CAP_SET_CALLBACK_CAPCONTROL  (WM_CAP_START +  85)

#define WM_CAP_UNICODE_END              WM_CAP_PAL_SAVEW
#define WM_CAP_END                      WM_CAP_UNICODE_END

typedef struct tagCapDriverCaps {
    UINT        wDeviceIndex;
    BOOL        fHasOverlay;
    BOOL        fHasDlgVideoSource;
    BOOL        fHasDlgVideoFormat;
    BOOL        fHasDlgVideoDisplay;
    BOOL        fCaptureInitialized;
    BOOL        fDriverSuppliesPalettes;
    HANDLE      hVideoIn;
    HANDLE      hVideoOut;
    HANDLE      hVideoExtIn;
    HANDLE      hVideoExtOut;
} CAPDRIVERCAPS, *PCAPDRIVERCAPS, *LPCAPDRIVERCAPS;

typedef struct tagCapStatus {
    UINT        uiImageWidth;
    UINT        uiImageHeight;
    BOOL        fLiveWindow;
    BOOL        fOverlayWindow;
    BOOL        fScale;
    POINT       ptScroll;
    BOOL        fUsingDefaultPalette;
    BOOL        fAudioHardware;
    BOOL        fCapFileExists;
    DWORD       dwCurrentVideoFrame;
    DWORD       dwCurrentVideoFramesDropped;
    DWORD       dwCurrentWaveSamples;
    DWORD       dwCurrentTimeElapsedMS;
    HPALETTE    hPalCurrent;
    BOOL        fCapturingNow;
    DWORD       dwReturn;
    UINT        wNumVideoAllocated;
    UINT        wNumAudioAllocated;
} CAPSTATUS, *PCAPSTATUS, *LPCAPSTATUS;


typedef struct tagCaptureParms {
    DWORD       dwRequestMicroSecPerFrame;
    BOOL        fMakeUserHitOKToCapture;
    UINT        wPercentDropForError;
    BOOL        fYield;
    DWORD       dwIndexSize;
    UINT        wChunkGranularity;
    BOOL        fUsingDOSMemory;
    UINT        wNumVideoRequested;
    BOOL        fCaptureAudio;
    UINT        wNumAudioRequested;
    UINT        vKeyAbort;
    BOOL        fAbortLeftMouse;
    BOOL        fAbortRightMouse;
    BOOL        fLimitEnabled;
    UINT        wTimeLimit;
    BOOL        fMCIControl;
    BOOL        fStepMCIDevice;
    DWORD       dwMCIStartTime;
    DWORD       dwMCIStopTime;
    BOOL        fStepCaptureAt2x;
    UINT        wStepCaptureAverageFrames;
    DWORD       dwAudioBufferSize;
    BOOL        fDisableWriteCache;
    UINT        AVStreamMaster;
} CAPTUREPARMS, *PCAPTUREPARMS, *LPCAPTUREPARMS;

typedef LRESULT (CALLBACK* CAPYIELDCALLBACK)(_In_ HWND hWnd);

typedef LRESULT
(CALLBACK* CAPSTATUSCALLBACKW)(
  _In_ HWND hWnd,
  _In_ int nID,
  _In_ LPCWSTR lpsz);

typedef LRESULT
(CALLBACK* CAPERRORCALLBACKW)(
  _In_ HWND hWnd,
  _In_ int nID,
  LPCWSTR lpsz);

typedef LRESULT
(CALLBACK* CAPSTATUSCALLBACKA)(
  _In_ HWND hWnd,
  _In_ int nID,
  LPCSTR lpsz);

typedef LRESULT
(CALLBACK* CAPERRORCALLBACKA)(
  _In_ HWND hWnd,
  _In_ int nID,
  LPCSTR lpsz);

typedef LRESULT
(CALLBACK* CAPVIDEOCALLBACK)(
  _In_ HWND hWnd,
  _In_ LPVIDEOHDR lpVHdr);

typedef LRESULT
(CALLBACK* CAPWAVECALLBACK)(
  _In_ HWND hWnd,
  _In_ LPWAVEHDR lpWHdr);

typedef LRESULT
(CALLBACK* CAPCONTROLCALLBACK)(
  _In_ HWND hWnd,
  _In_ int nState);

HWND
VFWAPI
capCreateCaptureWindowA(
  LPCSTR,
  _In_ DWORD,
  _In_ INT,
  _In_ INT,
  _In_ INT,
  _In_ INT,
  _In_opt_ HWND,
  _In_ INT);

HWND
VFWAPI
capCreateCaptureWindowW(
  LPCWSTR,
  _In_ DWORD,
  _In_ INT,
  _In_ INT,
  _In_ INT,
  _In_ INT,
  _In_opt_ HWND,
  _In_ INT);

#define capCreateCaptureWindow WINELIB_NAME_AW(capCreateCaptureWindow)

BOOL
VFWAPI
capGetDriverDescriptionA(
  WORD,
  _Out_writes_(cbName) LPSTR,
  _In_ INT cbName,
  _Out_writes_(cbVer) LPSTR,
  _In_ INT cbVer);

BOOL
VFWAPI
capGetDriverDescriptionW(
  WORD,
  _Out_writes_(cbName) LPWSTR,
  _In_ INT cbName,
  _Out_writes_(cbVer) LPWSTR,
  _In_ INT cbVer);

#define capGetDriverDescription WINELIB_NAME_AW(capGetDriverDescription)

#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif /* __WINE_VFW_H */