/* * 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 #include #include #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 #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 */