Artifact 754e428e88f168dc9ba90e01b3aae74c507ebf49
- File
src/win32/vfw.d
-
2015-05-05 06:49:05
- part of checkin
[9b639cf2d6]
on branch trunk
- Working version for update to 2.067.
The problem was __gshared. Replacing it with TLS fixed the issue. Remaining problem is that "hack.d"'s CloseHandle hack is not working anymore.
(user: kinaba) [annotate]
-
2015-05-05 06:49:05
- part of checkin
[9b639cf2d6]
on branch trunk
- Working version for update to 2.067.
/***********************************************************************\
* vfw.d *
* *
* Windows API header module *
* written in the D programming language *
* *
* Placed into public domain *
\***********************************************************************/
module win32.vfw;
pragma(lib, "vfw32");
private import
win32.commdlg,
win32.wingdi,
win32.mmsystem,
win32.unknwn,
win32.w32api,
win32.windef,
win32.winuser;
extern(Windows) {
DWORD VideoForWindowsVersion();
LONG InitVFW();
LONG TermVFW();
}
DWORD MKFOURCC(char ch0, char ch1, char ch2, char ch3) {
return (cast(DWORD)ch0) | ((cast(DWORD)ch1) << 8) | ((cast(DWORD)ch2) << 16) | ((cast(DWORD)ch3) << 24);
}
/**
* COMPMAN - Installable Compression Manager.
*/
const ICVERSION = 0x0104;
alias TypeDef!(HANDLE) HIC;
const BI_1632 = 0x32333631;
template aviTWOCC(char c0, char c1) {
const WORD aviTWOCC = c0 | (c1 << 8);
}
const ICTYPE_VIDEO = mmioFOURCC!('v', 'i', 'd', 'c');
const ICTYPE_AUDIO = mmioFOURCC!('a', 'u', 'd', 'c');
enum {
ICERR_OK = 0,
ICERR_DONTDRAW = 1,
ICERR_NEWPALETTE = 2,
ICERR_GOTOKEYFRAME = 3,
ICERR_STOPDRAWING = 4,
}
const ICERR_UNSUPPORTED = -1;
const ICERR_BADFORMAT = -2;
const ICERR_MEMORY = -3;
const ICERR_INTERNAL = -4;
const ICERR_BADFLAGS = -5;
const ICERR_BADPARAM = -6;
const ICERR_BADSIZE = -7;
const ICERR_BADHANDLE = -8;
const ICERR_CANTUPDATE = -9;
const ICERR_ABORT = -10;
const ICERR_ERROR = -100;
const ICERR_BADBITDEPTH = -200;
const ICERR_BADIMAGESIZE = -201;
const ICERR_CUSTOM = -400;
enum {
ICMODE_COMPRESS = 1,
ICMODE_DECOMPRESS,
ICMODE_FASTDECOMPRESS,
ICMODE_QUERY,
ICMODE_FASTCOMPRESS,
ICMODE_DRAW = 8,
}
const ICMODE_INTERNALF_FUNCTION32 = 0x8000;
const ICMODE_INTERNALF_MASK = 0x8000;
enum {
AVIIF_LIST = 0x00000001,
AVIIF_TWOCC = 0x00000002,
AVIIF_KEYFRAME = 0x00000010,
}
const ICQUALITY_LOW = 0;
const ICQUALITY_HIGH = 10000;
const ICQUALITY_DEFAULT = -1;
enum {
ICM_USER = DRV_USER + 0x0000,
ICM_RESERVED_LOW = DRV_USER + 0x1000,
ICM_RESERVED_HIGH = DRV_USER + 0x2000,
ICM_RESERVED = ICM_RESERVED_LOW,
}
// messages
enum {
ICM_GETSTATE = ICM_RESERVED + 0,
ICM_SETSTATE = ICM_RESERVED + 1,
ICM_GETINFO = ICM_RESERVED + 2,
ICM_CONFIGURE = ICM_RESERVED + 10,
ICM_ABOUT = ICM_RESERVED + 11,
ICM_GETERRORTEXT = ICM_RESERVED + 12,
ICM_GETFORMATNAME = ICM_RESERVED + 20,
ICM_ENUMFORMATS = ICM_RESERVED + 21,
ICM_GETDEFAULTQUALITY = ICM_RESERVED + 30,
ICM_GETQUALITY = ICM_RESERVED + 31,
ICM_SETQUALITY = ICM_RESERVED + 32,
ICM_SET = ICM_RESERVED + 40,
ICM_GET = ICM_RESERVED + 41,
}
const ICM_FRAMERATE = mmioFOURCC!('F','r','m','R');
const ICM_KEYFRAMERATE = mmioFOURCC!('K','e','y','R');
// ICM specific messages.
enum {
ICM_COMPRESS_GET_FORMAT = ICM_USER + 4,
ICM_COMPRESS_GET_SIZE = ICM_USER + 5,
ICM_COMPRESS_QUERY = ICM_USER + 6,
ICM_COMPRESS_BEGIN = ICM_USER + 7,
ICM_COMPRESS = ICM_USER + 8,
ICM_COMPRESS_END = ICM_USER + 9,
ICM_DECOMPRESS_GET_FORMAT = ICM_USER + 10,
ICM_DECOMPRESS_QUERY = ICM_USER + 11,
ICM_DECOMPRESS_BEGIN = ICM_USER + 12,
ICM_DECOMPRESS = ICM_USER + 13,
ICM_DECOMPRESS_END = ICM_USER + 14,
ICM_DECOMPRESS_SET_PALETTE = ICM_USER + 29,
ICM_DECOMPRESS_GET_PALETTE = ICM_USER + 30,
ICM_DRAW_QUERY = ICM_USER + 31,
ICM_DRAW_BEGIN = ICM_USER + 15,
ICM_DRAW_GET_PALETTE = ICM_USER + 16,
ICM_DRAW_UPDATE = ICM_USER + 17,
ICM_DRAW_START = ICM_USER + 18,
ICM_DRAW_STOP = ICM_USER + 19,
ICM_DRAW_BITS = ICM_USER + 20,
ICM_DRAW_END = ICM_USER + 21,
ICM_DRAW_GETTIME = ICM_USER + 32,
ICM_DRAW = ICM_USER + 33,
ICM_DRAW_WINDOW = ICM_USER + 34,
ICM_DRAW_SETTIME = ICM_USER + 35,
ICM_DRAW_REALIZE = ICM_USER + 36,
ICM_DRAW_FLUSH = ICM_USER + 37,
ICM_DRAW_RENDERBUFFER = ICM_USER + 38,
ICM_DRAW_START_PLAY = ICM_USER + 39,
ICM_DRAW_STOP_PLAY = ICM_USER + 40,
ICM_DRAW_SUGGESTFORMAT = ICM_USER + 50,
ICM_DRAW_CHANGEPALETTE = ICM_USER + 51,
ICM_DRAW_IDLE = ICM_USER + 52,
ICM_GETBUFFERSWANTED = ICM_USER + 41,
ICM_GETDEFAULTKEYFRAMERATE = ICM_USER + 42,
ICM_DECOMPRESSEX_BEGIN = ICM_USER + 60,
ICM_DECOMPRESSEX_QUERY = ICM_USER + 61,
ICM_DECOMPRESSEX = ICM_USER + 62,
ICM_DECOMPRESSEX_END = ICM_USER + 63,
ICM_COMPRESS_FRAMES_INFO = ICM_USER + 70,
ICM_COMPRESS_FRAMES = ICM_USER + 71,
ICM_SET_STATUS_PROC = ICM_USER + 72,
}
struct ICOPEN {
DWORD dwSize;
DWORD fccType;
DWORD fccHandler;
DWORD dwVersion;
DWORD dwFlags;
LRESULT dwError;
LPVOID pV1Reserved;
LPVOID pV2Reserved;
DWORD dnDevNode;
}
struct ICINFO {
DWORD dwSize;
DWORD fccType;
DWORD fccHandler;
DWORD dwFlags;
DWORD dwVersion;
DWORD dwVersionICM;
WCHAR[16] szName;
WCHAR[128] szDescription;
WCHAR[128] szDriver;
}
enum {
VIDCF_QUALITY = 0x0001,
VIDCF_CRUNCH = 0x0002,
VIDCF_TEMPORAL = 0x0004,
VIDCF_COMPRESSFRAMES = 0x0008,
VIDCF_DRAW = 0x0010,
VIDCF_FASTTEMPORALC = 0x0020,
VIDCF_FASTTEMPORALD = 0x0080,
}
const ICCOMPRESS_KEYFRAME = 0x00000001L;
struct ICCOMPRESS {
DWORD dwFlags;
LPBITMAPINFOHEADER lpbiOutput;
LPVOID lpOutput;
LPBITMAPINFOHEADER lpbiInput;
LPVOID lpInput;
LPDWORD lpckid;
LPDWORD lpdwFlags;
LONG lFrameNum;
DWORD dwFrameSize;
DWORD dwQuality;
LPBITMAPINFOHEADER lpbiPrev;
LPVOID lpPrev;
}
const ICCOMPRESSFRAMES_PADDING = 0x00000001;
struct ICCOMPRESSFRAMES {
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 function(LPARAM lInput, LONG lFrame, LPVOID lpBits, LONG len) GetData;
LONG function(LPARAM lOutput, LONG lFrame, LPVOID lpBits, LONG len) PutData;
}
enum {
ICSTATUS_START = 0,
ICSTATUS_STATUS = 1,
ICSTATUS_END = 2,
ICSTATUS_ERROR = 3,
ICSTATUS_YIELD = 4,
}
struct ICSETSTATUSPROC {
DWORD dwFlags;
LPARAM lParam;
LONG function(LPARAM lParam, UINT message, LONG l) Status;
}
enum {
ICDECOMPRESS_NOTKEYFRAME = 0x08000000,
ICDECOMPRESS_NULLFRAME = 0x10000000,
ICDECOMPRESS_PREROLL = 0x20000000,
ICDECOMPRESS_UPDATE = 0x40000000,
ICDECOMPRESS_HURRYUP = 0x80000000,
}
struct ICDECOMPRESS {
DWORD dwFlags;
LPBITMAPINFOHEADER lpbiInput;
LPVOID lpInput;
LPBITMAPINFOHEADER lpbiOutput;
LPVOID lpOutput;
DWORD ckid;
}
struct ICDECOMPRESSEX {
DWORD dwFlags;
LPBITMAPINFOHEADER lpbiSrc;
LPVOID lpSrc;
LPBITMAPINFOHEADER lpbiDst;
LPVOID lpDst;
int xDst;
int yDst;
int dxDst;
int dyDst;
int xSrc;
int ySrc;
int dxSrc;
int dySrc;
}
enum {
ICDRAW_QUERY = 0x00000001,
ICDRAW_FULLSCREEN = 0x00000002,
ICDRAW_HDC = 0x00000004,
ICDRAW_ANIMATE = 0x00000008,
ICDRAW_CONTINUE = 0x00000010,
ICDRAW_MEMORYDC = 0x00000020,
ICDRAW_UPDATING = 0x00000040,
ICDRAW_RENDER = 0x00000080,
ICDRAW_BUFFER = 0x00000100,
}
struct ICDRAWBEGIN {
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;
}
enum {
ICDRAW_NOTKEYFRAME = 0x08000000,
ICDRAW_NULLFRAME = 0x10000000,
ICDRAW_PREROLL = 0x20000000,
ICDRAW_UPDATE = 0x40000000,
ICDRAW_HURRYUP = 0x80000000,
}
struct ICDRAW {
DWORD dwFlags;
LPVOID lpFormat;
LPVOID lpData;
DWORD cbData;
LONG lTime;
}
struct ICDRAWSUGGEST {
LPBITMAPINFOHEADER lpbiIn;
LPBITMAPINFOHEADER lpbiSuggest;
int dxSrc;
int dySrc;
int dxDst;
int dyDst;
HIC hicDecompressor;
}
struct ICPALETTE {
DWORD dwFlags;
int iStart;
int iLen;
LPPALETTEENTRY lppe;
}
/**
* ICM function declarations
*/
extern (Windows) {
BOOL ICInfo(DWORD fccType, DWORD fccHandler, ICINFO *lpicinfo);
BOOL ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags);
BOOL ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags);
LRESULT ICGetInfo(HIC hic, ICINFO *picinfo, DWORD cb);
HIC ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode);
HIC ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler);
LRESULT ICClose(HIC hic);
LRESULT ICSendMessage(HIC hic, UINT msg, DWORD_PTR dw1, DWORD_PTR dw2);
}
enum {
ICINSTALL_FUNCTION = 0x0001,
ICINSTALL_DRIVER = 0x0002,
ICINSTALL_HDRV = 0x0004,
ICINSTALL_UNICODE = 0x8000,
ICINSTALL_DRIVERW = 0x8002,
}
// query macros
const ICMF_CONFIGURE_QUERY = 0x00000001;
const ICMF_ABOUT_QUERY = 0x00000001;
DWORD ICQueryAbout(HIC hic) {
return ICSendMessage(hic, ICM_ABOUT, -1, ICMF_ABOUT_QUERY) == ICERR_OK;
}
DWORD ICAbout(HIC hic, HWND hwnd) {
return cast(DWORD) ICSendMessage(hic, ICM_ABOUT, cast(DWORD_PTR) cast(UINT_PTR) hwnd, 0);
}
DWORD ICQueryConfigure(HIC hic) {
return (ICSendMessage(hic, ICM_CONFIGURE, -1, ICMF_CONFIGURE_QUERY) == ICERR_OK);
}
DWORD ICConfigure(HIC hic, HWND hwnd) {
return cast(DWORD) ICSendMessage(hic, ICM_CONFIGURE, cast(DWORD_PTR) cast(UINT_PTR) hwnd, 0);
}
DWORD ICGetState(HIC hic, LPVOID pv, DWORD_PTR cb) {
return cast(DWORD) ICSendMessage(hic, ICM_GETSTATE, cast(DWORD_PTR) pv, cb);
}
DWORD ICSetState(HIC hic, LPVOID pv, DWORD_PTR cb) {
return cast(DWORD) ICSendMessage(hic, ICM_SETSTATE, cast(DWORD_PTR) pv, cb);
}
DWORD ICGetStateSize(HIC hic) {
return ICGetState(hic, null, 0);
}
DWORD dwICValue;
DWORD ICGetDefaultQuality(HIC hic) {
ICSendMessage(hic, ICM_GETDEFAULTQUALITY, cast(DWORD_PTR)&dwICValue, DWORD.sizeof);
return dwICValue;
}
DWORD ICGetDefaultKeyFrameRate(HIC hic) {
ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, cast(DWORD_PTR)&dwICValue, DWORD.sizeof);
return dwICValue;
}
DWORD ICDrawWindow(HIC hic, LPVOID prc) {
return cast(DWORD) ICSendMessage(hic, ICM_DRAW_WINDOW, cast(DWORD_PTR) prc, RECT.sizeof);
}
extern (Windows) {
DWORD ICCompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData,
LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid, LPDWORD lpdwFlags,
LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality, LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev);
}
LRESULT ICCompressBegin(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
return ICSendMessage(hic, ICM_COMPRESS_BEGIN, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
}
LRESULT ICCompressQuery(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
return ICSendMessage(hic, ICM_COMPRESS_QUERY, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
}
LRESULT ICCompressGetFormat(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
return ICSendMessage(hic, ICM_COMPRESS_GET_FORMAT, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
}
DWORD ICCompressGetFormatSize(HIC hic, LPVOID lpbi) {
return cast(DWORD)ICCompressGetFormat(hic, lpbi, null);
}
DWORD ICCompressGetSize(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
return cast(DWORD)ICSendMessage(hic, ICM_COMPRESS_GET_SIZE, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
}
LRESULT ICCompressEnd(HIC hic) {
return ICSendMessage(hic, ICM_COMPRESS_END, 0, 0);
}
extern (Windows) {
DWORD ICDecompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits);
}
LRESULT ICDecompressBegin(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
return ICSendMessage(hic, ICM_DECOMPRESS_BEGIN, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
}
LRESULT ICDecompressQuery(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
return ICSendMessage(hic, ICM_DECOMPRESS_QUERY, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
}
LONG ICDecompressGetFormat(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
return cast(LONG)ICSendMessage(hic, ICM_DECOMPRESS_GET_FORMAT, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
}
LONG ICDecompressGetFormatSize(HIC hic, LPVOID lpbi) {
return ICDecompressGetFormat(hic, lpbi, null);
}
LRESULT ICDecompressGetPalette(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
return ICSendMessage(hic, ICM_DECOMPRESS_GET_PALETTE, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
}
LRESULT ICDecompressSetPalette(HIC hic, LPVOID lpbiPalette) {
return ICSendMessage(hic, ICM_DECOMPRESS_SET_PALETTE, cast(DWORD_PTR)lpbiPalette, 0);
}
LRESULT ICDecompressEnd(HIC hic) {
return ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0);
}
LRESULT ICDecompressEx(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc,
LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst,
LPVOID lpDst, int xDst, int yDst, int dxDst, 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, cast(DWORD_PTR)&ic, ic.sizeof);
}
LRESULT ICDecompressExBegin(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc,
LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst,
LPVOID lpDst, int xDst, int yDst, int dxDst, 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, cast(DWORD_PTR)&ic, ic.sizeof);
}
LRESULT ICDecompressExQuery(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc,
LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst,
LPVOID lpDst, int xDst, int yDst, int dxDst, 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, cast(DWORD_PTR)&ic, ic.sizeof);
}
LRESULT ICDecompressExEnd(HIC hic) {
return ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0);
}
extern (Windows) {
DWORD ICDrawBegin(HIC hic, 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);
}
extern (Windows) {
DWORD ICDraw(HIC hic, DWORD dwFlags, LPVOID lpFormat, LPVOID lpData, DWORD cbData, LONG lTime);
}
LRESULT ICDrawSuggestFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut,
int dxSrc, int dySrc, int dxDst, int dyDst, 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, cast(DWORD_PTR)&ic, ic.sizeof);
}
LRESULT ICDrawQuery(HIC hic, LPVOID lpbiInput) {
return ICSendMessage(hic, ICM_DRAW_QUERY, cast(DWORD_PTR)lpbiInput, 0L);
}
LRESULT ICDrawChangePalette(HIC hic, LPVOID lpbiInput) {
return ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, cast(DWORD_PTR)lpbiInput, 0L);
}
LRESULT ICGetBuffersWanted(HIC hic, LPVOID lpdwBuffers) {
return ICSendMessage(hic, ICM_GETBUFFERSWANTED, cast(DWORD_PTR)lpdwBuffers, 0);
}
LRESULT ICDrawEnd(HIC hic) {
return ICSendMessage(hic, ICM_DRAW_END, 0, 0);
}
LRESULT ICDrawStart(HIC hic) {
return ICSendMessage(hic, ICM_DRAW_START, 0, 0);
}
LRESULT ICDrawStartPlay(HIC hic, DWORD lFrom, DWORD lTo) {
return ICSendMessage(hic, ICM_DRAW_START_PLAY, cast(DWORD_PTR)lFrom, cast(DWORD_PTR)lTo);
}
LRESULT ICDrawStop(HIC hic) {
return ICSendMessage(hic, ICM_DRAW_STOP, 0, 0);
}
LRESULT ICDrawStopPlay(HIC hic) {
return ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0);
}
LRESULT ICDrawGetTime(HIC hic, LPVOID lplTime) {
return ICSendMessage(hic, ICM_DRAW_GETTIME, cast(DWORD_PTR)lplTime, 0);
}
LRESULT ICDrawSetTime(HIC hic, DWORD lTime) {
return ICSendMessage(hic, ICM_DRAW_SETTIME, cast(DWORD_PTR)lTime, 0);
}
LRESULT ICDrawRealize(HIC hic, HDC hdc, BOOL fBackground) {
return ICSendMessage(hic, ICM_DRAW_REALIZE, cast(DWORD_PTR)hdc, cast(DWORD_PTR)fBackground);
}
LRESULT ICDrawFlush(HIC hic) {
return ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0);
}
LRESULT ICDrawRenderBuffer(HIC hic) {
return ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0);
}
LRESULT ICSetStatusProc(HIC hic, DWORD dwFlags, LRESULT lParam, LONG function(LPARAM, UINT, LONG) fpfnStatus) {
ICSETSTATUSPROC ic;
ic.dwFlags = dwFlags;
ic.lParam = lParam;
ic.Status = fpfnStatus;
return ICSendMessage(hic, ICM_SET_STATUS_PROC, cast(DWORD_PTR)&ic, ic.sizeof);
}
HIC ICDecompressOpen(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
return ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS);
}
HIC ICDrawOpen(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn) {
return ICLocate(fccType, fccHandler, lpbiIn, null, ICMODE_DRAW);
}
extern (Windows) {
HIC ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
HIC ICGetDisplayFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, int BitDepth, int dx, int dy);
HANDLE ICImageCompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn, LPVOID lpBits, LPBITMAPINFO lpbiOut, LONG lQuality, LONG* plSize);
HANDLE ICImageDecompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn, LPVOID lpBits, LPBITMAPINFO lpbiOut);
}
struct COMPVARS {
LONG cbSize = this.sizeof;
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;
}
alias COMPVARS* PCOMPVARS;
const ICMF_COMPVARS_VALID = 0x00000001;
extern (Windows) {
BOOL ICCompressorChoose(HWND hwnd, UINT uiFlags, LPVOID pvIn, LPVOID lpData, PCOMPVARS pc, LPSTR lpszTitle);
}
enum {
ICMF_CHOOSE_KEYFRAME = 0x0001,
ICMF_CHOOSE_DATARATE = 0x0002,
ICMF_CHOOSE_PREVIEW = 0x0004,
ICMF_CHOOSE_ALLCOMPRESSORS = 0x0008,
}
extern (Windows) {
BOOL ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn);
void ICSeqCompressFrameEnd(PCOMPVARS pc);
LPVOID ICSeqCompressFrame(PCOMPVARS pc, UINT uiFlags, LPVOID lpBits, BOOL* pfKey, LONG* plSize);
void ICCompressorFree(PCOMPVARS pc);
}
mixin DECLARE_HANDLE!("HDRAWDIB");
enum {
DDF_0001 = 0x0001,
DDF_UPDATE = 0x0002,
DDF_SAME_HDC = 0x0004,
DDF_SAME_DRAW = 0x0008,
DDF_DONTDRAW = 0x0010,
DDF_ANIMATE = 0x0020,
DDF_BUFFER = 0x0040,
DDF_JUSTDRAWIT = 0x0080,
DDF_FULLSCREEN = 0x0100,
DDF_BACKGROUNDPAL = 0x0200,
DDF_NOTKEYFRAME = 0x0400,
DDF_HURRYUP = 0x0800,
DDF_HALFTONE = 0x1000,
DDF_2000 = 0x2000,
DDF_PREROLL = DDF_DONTDRAW,
DDF_SAME_DIB = DDF_SAME_DRAW,
DDF_SAME_SIZE = DDF_SAME_DRAW,
}
extern (Windows) {
BOOL DrawDibInit();
HDRAWDIB DrawDibOpen();
BOOL DrawDibClose(HDRAWDIB hdd);
LPVOID DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags);
UINT DrawDibError(HDRAWDIB hdd);
HPALETTE DrawDibGetPalette(HDRAWDIB hdd);
BOOL DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal);
BOOL DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe);
UINT DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground);
BOOL DrawDibStart(HDRAWDIB hdd, DWORD rate);
BOOL DrawDibStop(HDRAWDIB hdd);
BOOL DrawDibBegin(HDRAWDIB hdd, HDC hdc, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi, int dxSrc, int dySrc, UINT wFlags);
BOOL DrawDibDraw(HDRAWDIB hdd, HDC hdc, int xDst, int yDst, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi,
LPVOID lpBits, int xSrc, int ySrc, int dxSrc, int dySrc, UINT wFlags);
}
BOOL DrawDibUpdate(HDRAWDIB hdd, HDC hdc, int x, int y) {
return DrawDibDraw(hdd, hdc, x, y, 0, 0, null, null, 0, 0, 0, 0, DDF_UPDATE);
}
extern (Windows) {
BOOL DrawDibEnd(HDRAWDIB hdd);
}
struct DRAWDIBTIME {
LONG timeCount;
LONG timeDraw;
LONG timeDecompress;
LONG timeDither;
LONG timeStretch;
LONG timeBlt;
LONG timeSetDIBits;
}
alias DRAWDIBTIME* LPDRAWDIBTIME;
extern (Windows) {
BOOL DrawDibTime(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime);
}
enum {
PD_CAN_DRAW_DIB = 0x0001,
PD_CAN_STRETCHDIB = 0x0002,
PD_STRETCHDIB_1_1_OK = 0x0004,
PD_STRETCHDIB_1_2_OK = 0x0008,
PD_STRETCHDIB_1_N_OK = 0x0010,
}
extern (Windows) {
LRESULT DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi);
void StretchDIB(LPBITMAPINFOHEADER biDst, LPVOID lpDst, int DstX, int DstY,
int DstXE, int DstYE, LPBITMAPINFOHEADER biSrc, LPVOID lpSrc,
int SrcX, int SrcY, int SrcXE, int SrcYE);
}
alias DWORD FOURCC;
alias WORD TWOCC;
const formtypeAVI = mmioFOURCC!('A', 'V', 'I', ' ');
const listtypeAVIHEADER = mmioFOURCC!('h', 'd', 'r', 'l');
const ckidAVIMAINHDR = mmioFOURCC!('a', 'v', 'i', 'h');
const listtypeSTREAMHEADER = mmioFOURCC!('s', 't', 'r', 'l');
const ckidSTREAMHEADER = mmioFOURCC!('s', 't', 'r', 'h');
const ckidSTREAMFORMAT = mmioFOURCC!('s', 't', 'r', 'f');
const ckidSTREAMHANDLERDATA = mmioFOURCC!('s', 't', 'r', 'd');
const ckidSTREAMNAME = mmioFOURCC!('s', 't', 'r', 'n');
const listtypeAVIMOVIE = mmioFOURCC!('m', 'o', 'v', 'i');
const listtypeAVIRECORD = mmioFOURCC!('r', 'e', 'c', ' ');
const ckidAVINEWINDEX = mmioFOURCC!('i', 'd', 'x', '1');
const streamtypeVIDEO = mmioFOURCC!('v', 'i', 'd', 's');
const streamtypeAUDIO = mmioFOURCC!('a', 'u', 'd', 's');
const streamtypeMIDI = mmioFOURCC!('m', 'i', 'd', 's');
const streamtypeTEXT = mmioFOURCC!('t', 'x', 't', 's');
const cktypeDIBbits = aviTWOCC!('d', 'b');
const cktypeDIBcompressed = aviTWOCC!('d', 'c');
const cktypePALchange = aviTWOCC!('p', 'c');
const cktypeWAVEbytes = aviTWOCC!('w', 'b');
const ckidAVIPADDING = mmioFOURCC!('J', 'U', 'N', 'K');
DWORD FromHex(char n) {
return (n >= 'A') ? n + 10 - 'A' : n - '0';
}
WORD StreamFromFOURCC(DWORD fcc) {
return cast(WORD)((FromHex(LOBYTE(LOWORD(fcc))) << 4) + (FromHex(HIBYTE(LOWORD(fcc)))));
}
WORD TWOCCFromFOURCC(DWORD fcc) {
return HIWORD(fcc);
}
BYTE ToHex(DWORD n) {
return cast(BYTE)((n > 9) ? n - 10 + 'A' : n + '0');
}
DWORD MAKEAVICKID(WORD tcc, WORD stream) {
return MAKELONG(cast(WORD)((ToHex(stream & 0x0f) << 8) | (ToHex((stream & 0xf0) >> 4))), tcc);
}
enum {
AVIF_HASINDEX = 0x00000010,
AVIF_MUSTUSEINDEX = 0x00000020,
AVIF_ISINTERLEAVED = 0x00000100,
AVIF_WASCAPTUREFILE = 0x00010000,
AVIF_COPYRIGHTED = 0x00020000,
}
const AVI_HEADERSIZE = 2048;
struct MainAVIHeader {
DWORD dwMicroSecPerFrame;
DWORD dwMaxBytesPerSec;
DWORD dwPaddingGranularity;
DWORD dwFlags;
DWORD dwTotalFrames;
DWORD dwInitialFrames;
DWORD dwStreams;
DWORD dwSuggestedBufferSize;
DWORD dwWidth;
DWORD dwHeight;
DWORD[4] dwReserved;
}
const AVISF_DISABLED = 0x00000001;
const AVISF_VIDEO_PALCHANGES = 0x00010000;
struct AVIStreamHeader {
FOURCC fccType;
FOURCC fccHandler;
DWORD dwFlags;
WORD wPriority;
WORD wLanguage;
DWORD dwInitialFrames;
DWORD dwScale;
DWORD dwRate;
DWORD dwStart;
DWORD dwLength;
DWORD dwSuggestedBufferSize;
DWORD dwQuality;
DWORD dwSampleSize;
RECT rcFrame;
}
enum {
AVIIF_FIRSTPART = 0x00000020L,
AVIIF_LASTPART = 0x00000040L,
AVIIF_MIDPART = (AVIIF_LASTPART|AVIIF_FIRSTPART),
AVIIF_NOTIME = 0x00000100L,
AVIIF_COMPUSE = 0x0FFF0000L,
}
struct AVIINDEXENTRY {
DWORD ckid;
DWORD dwFlags;
DWORD dwChunkOffset;
DWORD dwChunkLength;
}
struct AVIPALCHANGE {
BYTE bFirstEntry;
BYTE bNumEntries;
WORD wFlags;
PALETTEENTRY[1] _peNew;
PALETTEENTRY* peNew() { return _peNew.ptr; }
}
const AVIGETFRAMEF_BESTDISPLAYFMT = 1;
struct AVISTREAMINFOW {
DWORD fccType;
DWORD fccHandler;
DWORD dwFlags;
DWORD dwCaps;
WORD wPriority;
WORD wLanguage;
DWORD dwScale;
DWORD dwRate;
DWORD dwStart;
DWORD dwLength;
DWORD dwInitialFrames;
DWORD dwSuggestedBufferSize;
DWORD dwQuality;
DWORD dwSampleSize;
RECT rcFrame;
DWORD dwEditCount;
DWORD dwFormatChangeCount;
WCHAR[64] szName;
}
alias AVISTREAMINFOW* LPAVISTREAMINFOW;
struct AVISTREAMINFOA {
DWORD fccType;
DWORD fccHandler;
DWORD dwFlags;
DWORD dwCaps;
WORD wPriority;
WORD wLanguage;
DWORD dwScale;
DWORD dwRate;
DWORD dwStart;
DWORD dwLength;
DWORD dwInitialFrames;
DWORD dwSuggestedBufferSize;
DWORD dwQuality;
DWORD dwSampleSize;
RECT rcFrame;
DWORD dwEditCount;
DWORD dwFormatChangeCount;
char[64] szName;
}
alias AVISTREAMINFOA* LPAVISTREAMINFOA;
version(Unicode) {
alias AVISTREAMINFOW AVISTREAMINFO;
alias LPAVISTREAMINFOW LPAVISTREAMINFO;
} else { // Unicode
alias AVISTREAMINFOA AVISTREAMINFO;
alias LPAVISTREAMINFOA LPAVISTREAMINFO;
}
const AVISTREAMINFO_DISABLED = 0x00000001;
const AVISTREAMINFO_FORMATCHANGES = 0x00010000;
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[64] szFileType;
}
alias AVIFILEINFOW* LPAVIFILEINFOW;
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[64] szFileType;
}
alias AVIFILEINFOA* LPAVIFILEINFOA;
version(Unicode) {
alias AVIFILEINFOW AVIFILEINFO;
alias LPAVIFILEINFOW LPAVIFILEINFO;
} else { // Unicode
alias AVIFILEINFOA AVIFILEINFO;
alias LPAVIFILEINFOA LPAVIFILEINFO;
}
enum {
AVIFILEINFO_HASINDEX = 0x00000010,
AVIFILEINFO_MUSTUSEINDEX = 0x00000020,
AVIFILEINFO_ISINTERLEAVED = 0x00000100,
AVIFILEINFO_WASCAPTUREFILE = 0x00010000,
AVIFILEINFO_COPYRIGHTED = 0x00020000,
}
enum {
AVIFILECAPS_CANREAD = 0x00000001,
AVIFILECAPS_CANWRITE = 0x00000002,
AVIFILECAPS_ALLKEYFRAMES = 0x00000010,
AVIFILECAPS_NOCOMPRESSION = 0x00000020,
}
extern (Windows) {
alias BOOL function(int) AVISAVECALLBACK;
}
struct AVICOMPRESSOPTIONS {
DWORD fccType;
DWORD fccHandler;
DWORD dwKeyFrameEvery;
DWORD dwQuality;
DWORD dwBytesPerSecond;
DWORD dwFlags;
LPVOID lpFormat;
DWORD cbFormat;
LPVOID lpParms;
DWORD cbParms;
DWORD dwInterleaveEvery;
}
alias AVICOMPRESSOPTIONS* LPAVICOMPRESSOPTIONS;
enum {
AVICOMPRESSF_INTERLEAVE = 0x00000001,
AVICOMPRESSF_DATARATE = 0x00000002,
AVICOMPRESSF_KEYFRAMES = 0x00000004,
AVICOMPRESSF_VALID = 0x00000008,
}
/+ TODO:
DECLARE_INTERFACE_(IAVIStream, IUnknown)
{
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
STDMETHOD(Create) (THIS_ LPARAM lParam1, LPARAM lParam2) PURE ;
STDMETHOD(Info) (THIS_ AVISTREAMINFOW FAR * psi, LONG lSize) PURE ;
STDMETHOD_(LONG, FindSample)(THIS_ LONG lPos, LONG lFlags) PURE ;
STDMETHOD(ReadFormat) (THIS_ LONG lPos,
LPVOID lpFormat, LONG FAR *lpcbFormat) PURE ;
STDMETHOD(SetFormat) (THIS_ LONG lPos,
LPVOID lpFormat, LONG cbFormat) PURE ;
STDMETHOD(Read) (THIS_ LONG lStart, LONG lSamples,
LPVOID lpBuffer, LONG cbBuffer,
LONG FAR * plBytes, LONG FAR * plSamples) PURE ;
STDMETHOD(Write) (THIS_ LONG lStart, LONG lSamples,
LPVOID lpBuffer, LONG cbBuffer,
DWORD dwFlags,
LONG FAR *plSampWritten,
LONG FAR *plBytesWritten) PURE ;
STDMETHOD(Delete) (THIS_ LONG lStart, LONG lSamples) PURE;
STDMETHOD(ReadData) (THIS_ DWORD fcc, LPVOID lp, LONG FAR *lpcb) PURE ;
STDMETHOD(WriteData) (THIS_ DWORD fcc, LPVOID lp, LONG cb) PURE ;
#ifdef _WIN32
STDMETHOD(SetInfo) (THIS_ AVISTREAMINFOW FAR * lpInfo,
LONG cbInfo) PURE;
#else
STDMETHOD(Reserved1) (THIS) PURE;
STDMETHOD(Reserved2) (THIS) PURE;
STDMETHOD(Reserved3) (THIS) PURE;
STDMETHOD(Reserved4) (THIS) PURE;
STDMETHOD(Reserved5) (THIS) PURE;
#endif
};
alias TypeDef!(IAVIStream FAR*) PAVISTREAM;
#undef INTERFACE
#define INTERFACE IAVIStreaming
DECLARE_INTERFACE_(IAVIStreaming, IUnknown)
{
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
STDMETHOD(Begin) (THIS_
LONG lStart,
LONG lEnd,
LONG lRate) PURE;
STDMETHOD(End) (THIS) PURE;
};
alias TypeDef!(IAVIStreaming FAR*) PAVISTREAMING;
#undef INTERFACE
#define INTERFACE IAVIEditStream
DECLARE_INTERFACE_(IAVIEditStream, IUnknown)
{
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
STDMETHOD(Cut) (THIS_ LONG FAR *plStart,
LONG FAR *plLength,
PAVISTREAM FAR * ppResult) PURE;
STDMETHOD(Copy) (THIS_ LONG FAR *plStart,
LONG FAR *plLength,
PAVISTREAM FAR * ppResult) PURE;
STDMETHOD(Paste) (THIS_ LONG FAR *plPos,
LONG FAR *plLength,
PAVISTREAM pstream,
LONG lStart,
LONG lEnd) PURE;
STDMETHOD(Clone) (THIS_ PAVISTREAM FAR *ppResult) PURE;
STDMETHOD(SetInfo) (THIS_ AVISTREAMINFOW FAR * lpInfo,
LONG cbInfo) PURE;
};
alias TypeDef!(IAVIEditStream FAR*) PAVIEDITSTREAM;
#undef INTERFACE
#define INTERFACE IAVIPersistFile
DECLARE_INTERFACE_(IAVIPersistFile, IPersistFile)
{
STDMETHOD(Reserved1)(THIS) PURE;
};
alias TypeDef!(IAVIPersistFile FAR*) PAVIPERSISTFILE;
#undef INTERFACE
#define INTERFACE IAVIFile
#define PAVIFILE IAVIFile FAR*
DECLARE_INTERFACE_(IAVIFile, IUnknown)
{
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
STDMETHOD(Info) (THIS_
AVIFILEINFOW FAR * pfi,
LONG lSize) PURE;
STDMETHOD(GetStream) (THIS_
PAVISTREAM FAR * ppStream,
DWORD fccType,
LONG lParam) PURE;
STDMETHOD(CreateStream) (THIS_
PAVISTREAM FAR * ppStream,
AVISTREAMINFOW FAR * psi) PURE;
STDMETHOD(WriteData) (THIS_
DWORD ckid,
LPVOID lpData,
LONG cbData) PURE;
STDMETHOD(ReadData) (THIS_
DWORD ckid,
LPVOID lpData,
LONG FAR *lpcbData) PURE;
STDMETHOD(EndRecord) (THIS) PURE;
STDMETHOD(DeleteStream) (THIS_
DWORD fccType,
LONG lParam) PURE;
};
#undef PAVIFILE
alias TypeDef!(IAVIFile FAR*) PAVIFILE;
#undef INTERFACE
#define INTERFACE IGetFrame
#define PGETFRAME IGetFrame FAR*
DECLARE_INTERFACE_(IGetFrame, IUnknown)
{
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
STDMETHOD_(LPVOID,GetFrame) (THIS_ LONG lPos) PURE;
STDMETHOD(Begin) (THIS_ LONG lStart, LONG lEnd, LONG lRate) PURE;
STDMETHOD(End) (THIS) PURE;
STDMETHOD(SetFormat) (THIS_ LPBITMAPINFOHEADER lpbi, LPVOID lpBits, int x, int y, int dx, int dy) PURE;
};
#undef PGETFRAME
alias TypeDef!(IGetFrame FAR*) PGETFRAME;
#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(IID_IAVIPersistFile, 0x00020025, 0, 0);
#ifndef UNICODE
DEFINE_AVIGUID(CLSID_AVISimpleUnMarshal, 0x00020009, 0, 0);
#endif
DEFINE_AVIGUID(CLSID_AVIFile, 0x00020000, 0, 0);
#define AVIFILEHANDLER_CANREAD 0x0001
#define AVIFILEHANDLER_CANWRITE 0x0002
#define AVIFILEHANDLER_CANACCEPTNONRGB 0x0004
STDAPI_(void) AVIFileInit(void);
STDAPI_(void) AVIFileExit(void);
STDAPI_(ULONG) AVIFileAddRef (PAVIFILE pfile);
STDAPI_(ULONG) AVIFileRelease (PAVIFILE pfile);
#ifdef _WIN32
STDAPI AVIFileOpenA (PAVIFILE FAR * ppfile, LPCSTR szFile,
UINT uMode, LPCLSID lpHandler);
STDAPI AVIFileOpenW (PAVIFILE FAR * ppfile, LPCWSTR szFile,
UINT uMode, LPCLSID lpHandler);
#ifdef UNICODE
#define AVIFileOpen AVIFileOpenW
#else
#define AVIFileOpen AVIFileOpenA
#endif
#else
STDAPI AVIFileOpen (PAVIFILE FAR * ppfile, LPCSTR szFile,
UINT uMode, LPCLSID lpHandler);
#define AVIFileOpenW AVIFileOpen
#endif
#ifdef _WIN32
STDAPI AVIFileInfoW (PAVIFILE pfile, LPAVIFILEINFOW pfi, LONG lSize);
STDAPI AVIFileInfoA (PAVIFILE pfile, LPAVIFILEINFOA pfi, LONG lSize);
#ifdef UNICODE
#define AVIFileInfo AVIFileInfoW
#else
#define AVIFileInfo AVIFileInfoA
#endif
#else
STDAPI AVIFileInfo (PAVIFILE pfile, LPAVIFILEINFO pfi, LONG lSize);
#define AVIFileInfoW AVIFileInfo
#endif
STDAPI AVIFileGetStream (PAVIFILE pfile, PAVISTREAM FAR * ppavi, DWORD fccType, LONG lParam);
#ifdef _WIN32
STDAPI AVIFileCreateStreamW (PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFOW FAR * psi);
STDAPI AVIFileCreateStreamA (PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFOA FAR * psi);
#ifdef UNICODE
#define AVIFileCreateStream AVIFileCreateStreamW
#else
#define AVIFileCreateStream AVIFileCreateStreamA
#endif
#else
STDAPI AVIFileCreateStream(PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFO FAR * psi);
#define AVIFileCreateStreamW AVIFileCreateStream
#endif
STDAPI AVIFileWriteData (PAVIFILE pfile,
DWORD ckid,
LPVOID lpData,
LONG cbData);
STDAPI AVIFileReadData (PAVIFILE pfile,
DWORD ckid,
LPVOID lpData,
LONG FAR *lpcbData);
STDAPI AVIFileEndRecord (PAVIFILE pfile);
STDAPI_(ULONG) AVIStreamAddRef (PAVISTREAM pavi);
STDAPI_(ULONG) AVIStreamRelease (PAVISTREAM pavi);
STDAPI AVIStreamInfoW (PAVISTREAM pavi, LPAVISTREAMINFOW psi, LONG lSize);
STDAPI AVIStreamInfoA (PAVISTREAM pavi, LPAVISTREAMINFOA psi, LONG lSize);
#ifdef UNICODE
#define AVIStreamInfo AVIStreamInfoW
#else
#define AVIStreamInfo AVIStreamInfoA
#endif
STDAPI_(LONG) AVIStreamFindSample(PAVISTREAM pavi, LONG lPos, LONG lFlags);
STDAPI AVIStreamReadFormat (PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG FAR *lpcbFormat);
STDAPI AVIStreamSetFormat (PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG cbFormat);
STDAPI AVIStreamReadData (PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG FAR *lpcb);
STDAPI AVIStreamWriteData (PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG cb);
STDAPI AVIStreamRead (PAVISTREAM pavi,
LONG lStart,
LONG lSamples,
LPVOID lpBuffer,
LONG cbBuffer,
LONG FAR * plBytes,
LONG FAR * plSamples);
#define AVISTREAMREAD_CONVENIENT (-1L)
STDAPI AVIStreamWrite (PAVISTREAM pavi,
LONG lStart, LONG lSamples,
LPVOID lpBuffer, LONG cbBuffer, DWORD dwFlags,
LONG FAR *plSampWritten,
LONG FAR *plBytesWritten);
STDAPI_(LONG) AVIStreamStart (PAVISTREAM pavi);
STDAPI_(LONG) AVIStreamLength (PAVISTREAM pavi);
STDAPI_(LONG) AVIStreamTimeToSample (PAVISTREAM pavi, LONG lTime);
STDAPI_(LONG) AVIStreamSampleToTime (PAVISTREAM pavi, LONG lSample);
STDAPI AVIStreamBeginStreaming(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate);
STDAPI AVIStreamEndStreaming(PAVISTREAM pavi);
STDAPI_(PGETFRAME) AVIStreamGetFrameOpen(PAVISTREAM pavi,
LPBITMAPINFOHEADER lpbiWanted);
STDAPI_(LPVOID) AVIStreamGetFrame(PGETFRAME pg, LONG lPos);
STDAPI AVIStreamGetFrameClose(PGETFRAME pg);
STDAPI AVIStreamOpenFromFileA(PAVISTREAM FAR *ppavi, LPCSTR szFile,
DWORD fccType, LONG lParam,
UINT mode, CLSID FAR *pclsidHandler);
STDAPI AVIStreamOpenFromFileW(PAVISTREAM FAR *ppavi, LPCWSTR szFile,
DWORD fccType, LONG lParam,
UINT mode, CLSID FAR *pclsidHandler);
#ifdef UNICODE
#define AVIStreamOpenFromFile AVIStreamOpenFromFileW
#else
#define AVIStreamOpenFromFile AVIStreamOpenFromFileA
#endif
STDAPI AVIStreamCreate(PAVISTREAM FAR *ppavi, LONG lParam1, LONG lParam2,
CLSID FAR *pclsidHandler);
#define FIND_DIR 0x0000000FL
#define FIND_NEXT 0x00000001L
#define FIND_PREV 0x00000004L
#define FIND_FROM_START 0x00000008L
#define FIND_TYPE 0x000000F0L
#define FIND_KEY 0x00000010L
#define FIND_ANY 0x00000020L
#define FIND_FORMAT 0x00000040L
#define FIND_RET 0x0000F000L
#define FIND_POS 0x00000000L
#define FIND_LENGTH 0x00001000L
#define FIND_OFFSET 0x00002000L
#define FIND_SIZE 0x00003000L
#define FIND_INDEX 0x00004000L
#define AVIStreamFindKeyFrame AVIStreamFindSample
#define FindKeyFrame FindSample
#define AVIStreamClose AVIStreamRelease
#define AVIFileClose AVIFileRelease
#define AVIStreamInit AVIFileInit
#define AVIStreamExit AVIFileExit
#define SEARCH_NEAREST FIND_PREV
#define SEARCH_BACKWARD FIND_PREV
#define SEARCH_FORWARD FIND_NEXT
#define SEARCH_KEY FIND_KEY
#define SEARCH_ANY FIND_ANY
#define AVIStreamSampleToSample(pavi1, pavi2, l) AVIStreamTimeToSample(pavi1,AVIStreamSampleToTime(pavi2, l))
#define AVIStreamNextSample(pavi, l) AVIStreamFindSample(pavi,l+1,FIND_NEXT|FIND_ANY)
#define AVIStreamPrevSample(pavi, l) AVIStreamFindSample(pavi,l-1,FIND_PREV|FIND_ANY)
#define AVIStreamNearestSample(pavi, l) AVIStreamFindSample(pavi,l,FIND_PREV|FIND_ANY)
#define AVIStreamNextKeyFrame(pavi,l) AVIStreamFindSample(pavi,l+1,FIND_NEXT|FIND_KEY)
#define AVIStreamPrevKeyFrame(pavi, l) AVIStreamFindSample(pavi,l-1,FIND_PREV|FIND_KEY)
#define AVIStreamNearestKeyFrame(pavi, l) AVIStreamFindSample(pavi,l,FIND_PREV|FIND_KEY)
#define AVIStreamIsKeyFrame(pavi, l) (AVIStreamNearestKeyFrame(pavi,l) == l)
#define AVIStreamPrevSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamPrevSample(pavi,AVIStreamTimeToSample(pavi,t)))
#define AVIStreamNextSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNextSample(pavi,AVIStreamTimeToSample(pavi,t)))
#define AVIStreamNearestSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNearestSample(pavi,AVIStreamTimeToSample(pavi,t)))
#define AVIStreamNextKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNextKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)))
#define AVIStreamPrevKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamPrevKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)))
#define AVIStreamNearestKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNearestKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)))
#define AVIStreamStartTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamStart(pavi))
#define AVIStreamLengthTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamLength(pavi))
#define AVIStreamEnd(pavi) (AVIStreamStart(pavi) + AVIStreamLength(pavi))
#define AVIStreamEndTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamEnd(pavi))
#define AVIStreamSampleSize(pavi, lPos, plSize) AVIStreamRead(pavi,lPos,1,NULL,0,plSize,NULL)
#define AVIStreamFormatSize(pavi, lPos, plSize) AVIStreamReadFormat(pavi,lPos,NULL,plSize)
#define AVIStreamDataSize(pavi, fcc, plSize) AVIStreamReadData(pavi,fcc,NULL,plSize)
#ifndef comptypeDIB
#define comptypeDIB mmioFOURCC('D', 'I', 'B', ' ')
#endif
STDAPI AVIMakeCompressedStream(
PAVISTREAM FAR * ppsCompressed,
PAVISTREAM ppsSource,
AVICOMPRESSOPTIONS FAR * lpOptions,
CLSID FAR *pclsidHandler);
EXTERN_C HRESULT CDECL AVISaveA (LPCSTR szFile,
CLSID FAR *pclsidHandler,
AVISAVECALLBACK lpfnCallback,
int nStreams,
PAVISTREAM pfile,
LPAVICOMPRESSOPTIONS lpOptions,
...);
STDAPI AVISaveVA(LPCSTR szFile,
CLSID FAR *pclsidHandler,
AVISAVECALLBACK lpfnCallback,
int nStreams,
PAVISTREAM FAR * ppavi,
LPAVICOMPRESSOPTIONS FAR *plpOptions);
EXTERN_C HRESULT CDECL AVISaveW (LPCWSTR szFile,
CLSID FAR *pclsidHandler,
AVISAVECALLBACK lpfnCallback,
int nStreams,
PAVISTREAM pfile,
LPAVICOMPRESSOPTIONS lpOptions,
...);
STDAPI AVISaveVW(LPCWSTR szFile,
CLSID FAR *pclsidHandler,
AVISAVECALLBACK lpfnCallback,
int nStreams,
PAVISTREAM FAR * ppavi,
LPAVICOMPRESSOPTIONS FAR *plpOptions);
#ifdef UNICODE
#define AVISave AVISaveW
#define AVISaveV AVISaveVW
#else
#define AVISave AVISaveA
#define AVISaveV AVISaveVA
#endif
STDAPI_(INT_PTR) AVISaveOptions(HWND hwnd,
UINT uiFlags,
int nStreams,
PAVISTREAM FAR *ppavi,
LPAVICOMPRESSOPTIONS FAR *plpOptions);
STDAPI AVISaveOptionsFree(int nStreams,
LPAVICOMPRESSOPTIONS FAR *plpOptions);
STDAPI AVIBuildFilterW(LPWSTR lpszFilter, LONG cbFilter, BOOL fSaving);
STDAPI AVIBuildFilterA(LPSTR lpszFilter, LONG cbFilter, BOOL fSaving);
#ifdef UNICODE
#define AVIBuildFilter AVIBuildFilterW
#else
#define AVIBuildFilter AVIBuildFilterA
#endif
STDAPI AVIMakeFileFromStreams(PAVIFILE FAR * ppfile,
int nStreams,
PAVISTREAM FAR * papStreams);
STDAPI AVIMakeStreamFromClipboard(UINT cfFormat, HANDLE hGlobal, PAVISTREAM FAR *ppstream);
STDAPI AVIPutFileOnClipboard(PAVIFILE pf);
STDAPI AVIGetFromClipboard(PAVIFILE FAR * lppf);
STDAPI AVIClearClipboard(void);
STDAPI CreateEditableStream(
PAVISTREAM FAR * ppsEditable,
PAVISTREAM psSource);
STDAPI EditStreamCut(PAVISTREAM pavi, LONG FAR *plStart, LONG FAR *plLength, PAVISTREAM FAR * ppResult);
STDAPI EditStreamCopy(PAVISTREAM pavi, LONG FAR *plStart, LONG FAR *plLength, PAVISTREAM FAR * ppResult);
STDAPI EditStreamPaste(PAVISTREAM pavi, LONG FAR *plPos, LONG FAR *plLength, PAVISTREAM pstream, LONG lStart, LONG lEnd);
STDAPI EditStreamClone(PAVISTREAM pavi, PAVISTREAM FAR *ppResult);
STDAPI EditStreamSetNameA(PAVISTREAM pavi, LPCSTR lpszName);
STDAPI EditStreamSetNameW(PAVISTREAM pavi, LPCWSTR lpszName);
STDAPI EditStreamSetInfoW(PAVISTREAM pavi, LPAVISTREAMINFOW lpInfo, LONG cbInfo);
STDAPI EditStreamSetInfoA(PAVISTREAM pavi, LPAVISTREAMINFOA lpInfo, LONG cbInfo);
#ifdef UNICODE
#define EditStreamSetInfo EditStreamSetInfoW
#define EditStreamSetName EditStreamSetNameW
#else
#define EditStreamSetInfo EditStreamSetInfoA
#define EditStreamSetName EditStreamSetNameA
#endif
+/
const AVIERR_OK = 0L;
SCODE MAKE_AVIERR(DWORD error) {
return MAKE_SCODE(SEVERITY_ERROR, FACILITY_ITF, 0x4000 + error);
}
const AVIERR_UNSUPPORTED = MAKE_AVIERR(101);
const AVIERR_BADFORMAT = MAKE_AVIERR(102);
const AVIERR_MEMORY = MAKE_AVIERR(103);
const AVIERR_INTERNAL = MAKE_AVIERR(104);
const AVIERR_BADFLAGS = MAKE_AVIERR(105);
const AVIERR_BADPARAM = MAKE_AVIERR(106);
const AVIERR_BADSIZE = MAKE_AVIERR(107);
const AVIERR_BADHANDLE = MAKE_AVIERR(108);
const AVIERR_FILEREAD = MAKE_AVIERR(109);
const AVIERR_FILEWRITE = MAKE_AVIERR(110);
const AVIERR_FILEOPEN = MAKE_AVIERR(111);
const AVIERR_COMPRESSOR = MAKE_AVIERR(112);
const AVIERR_NOCOMPRESSOR = MAKE_AVIERR(113);
const AVIERR_READONLY = MAKE_AVIERR(114);
const AVIERR_NODATA = MAKE_AVIERR(115);
const AVIERR_BUFFERTOOSMALL = MAKE_AVIERR(116);
const AVIERR_CANTCOMPRESS = MAKE_AVIERR(117);
const AVIERR_USERABORT = MAKE_AVIERR(198);
const AVIERR_ERROR = MAKE_AVIERR(199);
const TCHAR[] MCIWND_WINDOW_CLASS = "MCIWndClass";
extern (Windows) {
HWND MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCSTR szFile);
HWND MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCWSTR szFile);
}
version(Unicode) {
alias MCIWndCreateW MCIWndCreate;
} else { // Unicode
alias MCIWndCreateA MCIWndCreate;
}
extern(Windows) {
BOOL MCIWndRegisterClass();
}
enum {
MCIWNDOPENF_NEW = 0x0001,
MCIWNDF_NOAUTOSIZEWINDOW = 0x0001,
MCIWNDF_NOPLAYBAR = 0x0002,
MCIWNDF_NOAUTOSIZEMOVIE = 0x0004,
MCIWNDF_NOMENU = 0x0008,
MCIWNDF_SHOWNAME = 0x0010,
MCIWNDF_SHOWPOS = 0x0020,
MCIWNDF_SHOWMODE = 0x0040,
MCIWNDF_SHOWALL = 0x0070,
MCIWNDF_NOTIFYMODE = 0x0100,
MCIWNDF_NOTIFYPOS = 0x0200,
MCIWNDF_NOTIFYSIZE = 0x0400,
MCIWNDF_NOTIFYERROR = 0x1000,
MCIWNDF_NOTIFYALL = 0x1F00,
MCIWNDF_NOTIFYANSI = 0x0080,
MCIWNDF_NOTIFYMEDIAA = 0x0880,
MCIWNDF_NOTIFYMEDIAW = 0x0800,
}
version(Unicode) {
alias MCIWNDF_NOTIFYMEDIAW MCIWNDF_NOTIFYMEDIA;
} else { // Unicode
alias MCIWNDF_NOTIFYMEDIAA MCIWNDF_NOTIFYMEDIA;
}
enum {
MCIWNDF_RECORD = 0x2000,
MCIWNDF_NOERRORDLG = 0x4000,
MCIWNDF_NOOPEN = 0x8000,
}
// can macros
BOOL MCIWndCanPlay(HWND hwnd)
{ return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_PLAY, 0, 0); }
BOOL MCIWndCanRecord(HWND hwnd)
{ return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_RECORD, 0, 0); }
BOOL MCIWndCanSave(HWND hwnd)
{ return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_SAVE, 0, 0); }
BOOL MCIWndCanWindow(HWND hwnd)
{ return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_WINDOW, 0, 0); }
BOOL MCIWndCanEject(HWND hwnd)
{ return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_EJECT, 0, 0); }
BOOL MCIWndCanConfig(HWND hwnd)
{ return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_CONFIG, 0, 0); }
BOOL MCIWndPaletteKick(HWND hwnd)
{ return cast(BOOL)SendMessage(hwnd, MCIWNDM_PALETTEKICK, 0, 0); }
LONG MCIWndSave(HWND hwnd, LPVOID szFile)
{ return cast(LONG)SendMessage(hwnd, MCI_SAVE, 0, cast(LPARAM)szFile); }
LONG MCIWndSaveDialog(HWND hwnd)
{ return MCIWndSave(hwnd, cast(LPVOID)-1); }
LONG MCIWndNew(HWND hwnd, LPVOID lp)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_NEW, 0, cast(LPARAM)lp); }
LONG MCIWndRecord(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCI_RECORD, 0, 0); }
LONG MCIWndOpen(HWND hwnd, LPVOID sz, UINT f)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_OPEN, cast(WPARAM)f, cast(LPARAM)sz); }
LONG MCIWndOpenDialog(HWND hwnd)
{ return MCIWndOpen(hwnd, cast(LPVOID)-1, 0); }
LONG MCIWndClose(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCI_CLOSE, 0, 0); }
LONG MCIWndPlay(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCI_PLAY, 0, 0); }
LONG MCIWndStop(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCI_STOP, 0, 0); }
LONG MCIWndPause(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCI_PAUSE, 0, 0); }
LONG MCIWndResume(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCI_RESUME, 0, 0); }
LONG MCIWndSeek(HWND hwnd, LONG lPos)
{ return cast(LONG)SendMessage(hwnd, MCI_SEEK, 0, cast(LPARAM)lPos); }
LONG MCIWndHome(HWND hwnd)
{ return MCIWndSeek(hwnd, MCIWND_START); }
LONG MCIWndEnd(HWND hwnd)
{ return MCIWndSeek(hwnd, MCIWND_END); }
LONG MCIWndEject(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_EJECT, 0, 0); }
LONG MCIWndGetSource(HWND hwnd, LPRECT prc)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GET_SOURCE, 0, cast(LPARAM)prc); }
LONG MCIWndPutSource(HWND hwnd, LPRECT prc)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_PUT_SOURCE, 0, cast(LPARAM)prc); }
LONG MCIWndGetDest(HWND hwnd, LPRECT prc)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GET_DEST, 0, cast(LPARAM)prc); }
LONG MCIWndPutDest(HWND hwnd, LPRECT prc)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_PUT_DEST, 0, cast(LPARAM)prc); }
LONG MCIWndPlayReverse(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYREVERSE, 0, 0); }
LONG MCIWndPlayFrom(HWND hwnd, LONG lPos)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYFROM, 0, cast(LPARAM)lPos); }
LONG MCIWndPlayTo(HWND hwnd, LONG lPos)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYTO, 0, cast(LPARAM)lPos); }
LONG MCIWndPlayFromTo(HWND hwnd, LONG lStart, LONG lEnd)
{ MCIWndSeek(hwnd, lStart); return MCIWndPlayTo(hwnd, lEnd); }
UINT MCIWndGetDeviceID(HWND hwnd)
{ return cast(UINT)SendMessage(hwnd, MCIWNDM_GETDEVICEID, 0, 0); }
UINT MCIWndGetAlias(HWND hwnd)
{ return cast(UINT)SendMessage(hwnd, MCIWNDM_GETALIAS, 0, 0); }
LONG MCIWndGetMode(HWND hwnd, LPTSTR lp, UINT len)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETMODE, cast(WPARAM)len, cast(LPARAM)lp); }
LONG MCIWndGetPosition(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETPOSITION, 0, 0); }
LONG MCIWndGetPositionString(HWND hwnd, LPTSTR lp, UINT len)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETPOSITION, cast(WPARAM)len, cast(LPARAM)lp); }
LONG MCIWndGetStart(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETSTART, 0, 0); }
LONG MCIWndGetLength(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETLENGTH, 0, 0); }
LONG MCIWndGetEnd(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETEND, 0, 0); }
LONG MCIWndStep(HWND hwnd, LONG n)
{ return cast(LONG)SendMessage(hwnd, MCI_STEP, 0, cast(LPARAM)n); }
void MCIWndDestroy(HWND hwnd)
{ SendMessage(hwnd, WM_CLOSE, 0, 0); }
void MCIWndSetZoom(HWND hwnd, UINT iZoom)
{ SendMessage(hwnd, MCIWNDM_SETZOOM, 0, cast(LPARAM)iZoom); }
UINT MCIWndGetZoom(HWND hwnd)
{ return cast(UINT)SendMessage(hwnd, MCIWNDM_GETZOOM, 0, 0); }
LONG MCIWndSetVolume(HWND hwnd, UINT iVol)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_SETVOLUME, 0, cast(LPARAM)iVol); }
LONG MCIWndGetVolume(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETVOLUME, 0, 0); }
LONG MCIWndSetSpeed(HWND hwnd, UINT iSpeed)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_SETSPEED, 0, cast(LPARAM)iSpeed); }
LONG MCIWndGetSpeed(HWND hwnd)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETSPEED, 0, 0); }
LONG MCIWndSetTimeFormat(HWND hwnd, LPTSTR lp)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_SETTIMEFORMAT, 0, cast(LPARAM)lp); }
LONG MCIWndUseFrames(HWND hwnd)
{ return MCIWndSetTimeFormat(hwnd, (cast(TCHAR[])"frames").ptr); }
LONG MCIWndUseTime(HWND hwnd)
{ return MCIWndSetTimeFormat(hwnd, (cast(TCHAR[])"ms").ptr); }
LONG MCIWndGetTimeFormat(HWND hwnd, LPTSTR lp, UINT len)
{ return cast(LONG)SendMessage(hwnd, MCIWNDM_GETTIMEFORMAT, cast(WPARAM)len, cast(LPARAM)lp); }
void MCIWndValidateMedia(HWND hwnd)
{ SendMessage(hwnd, MCIWNDM_VALIDATEMEDIA, 0, 0); }
void MCIWndSetRepeat(HWND hwnd, BOOL f)
{ SendMessage(hwnd, MCIWNDM_SETREPEAT, 0, cast(LPARAM)f); }
BOOL MCIWndGetRepeat(HWND hwnd)
{ return cast(BOOL)SendMessage(hwnd, MCIWNDM_GETREPEAT, 0, 0); }
void MCIWndSetActiveTimer(HWND hwnd, UINT active)
{ SendMessage(hwnd, MCIWNDM_SETACTIVETIMER, cast(WPARAM)active, 0); }
void MCIWndSetInactiveTimer(HWND hwnd, UINT inactive)
{ SendMessage(hwnd, MCIWNDM_SETINACTIVETIMER, cast(WPARAM)inactive, 0); }
void MCIWndSetTimers(HWND hwnd, UINT active, UINT inactive)
{ SendMessage(hwnd, MCIWNDM_SETTIMERS, cast(WPARAM)active, cast(LPARAM)inactive); }
UINT MCIWndGetActiveTimer(HWND hwnd)
{ return cast(UINT)SendMessage(hwnd, MCIWNDM_GETACTIVETIMER, 0, 0); }
UINT MCIWndGetInactiveTimer(HWND hwnd)
{ return cast(UINT)SendMessage(hwnd, MCIWNDM_GETINACTIVETIMER, 0, 0); }
LONG MCIWndRealize(HWND hwnd, BOOL fBkgnd)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_REALIZE, cast(WPARAM)fBkgnd, 0); }
LONG MCIWndSendString(HWND hwnd, LPTSTR sz)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_SENDSTRING, 0, cast(LPARAM)sz); }
LONG MCIWndReturnString(HWND hwnd, LPVOID lp, UINT len)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_RETURNSTRING, cast(WPARAM)len, cast(LPARAM)lp); }
LONG MCIWndGetError(HWND hwnd, LPVOID lp, UINT len)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_GETERROR, cast(WPARAM)len, cast(LPARAM)lp); }
HPALETTE MCIWndGetPalette(HWND hwnd)
{ return cast(HPALETTE)SendMessage(hwnd, MCIWNDM_GETPALETTE, 0, 0); }
LONG MCIWndSetPalette(HWND hwnd, HPALETTE hpal)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_SETPALETTE, cast(WPARAM)hpal, 0); }
LONG MCIWndGetFileName(HWND hwnd, LPVOID lp, UINT len)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_GETFILENAME, cast(WPARAM)len, cast(LPARAM)lp); }
LONG MCIWndGetDevice(HWND hwnd, LPVOID lp, UINT len)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_GETDEVICE, cast(WPARAM)len, cast(LPARAM)lp); }
UINT MCIWndGetStyles(HWND hwnd)
{ return cast(UINT) SendMessage(hwnd, MCIWNDM_GETSTYLES, 0, 0); }
LONG MCIWndChangeStyles(HWND hwnd, UINT mask, LONG value)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_CHANGESTYLES, cast(WPARAM)mask, cast(LPARAM)value); }
LONG MCIWndOpenInterface(HWND hwnd, LPUNKNOWN pUnk)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_OPENINTERFACE, 0, cast(LPARAM)cast(void*)pUnk); }
LONG MCIWndSetOwner(HWND hwnd, HWND hwndP)
{ return cast(LONG) SendMessage(hwnd, MCIWNDM_SETOWNER, cast(WPARAM)hwndP, 0); }
enum {
MCIWNDM_GETDEVICEID = WM_USER + 100,
MCIWNDM_SENDSTRINGA = WM_USER + 101,
MCIWNDM_GETPOSITIONA = WM_USER + 102,
MCIWNDM_GETSTART = WM_USER + 103,
MCIWNDM_GETLENGTH = WM_USER + 104,
MCIWNDM_GETEND = WM_USER + 105,
MCIWNDM_GETMODEA = WM_USER + 106,
MCIWNDM_EJECT = WM_USER + 107,
MCIWNDM_SETZOOM = WM_USER + 108,
MCIWNDM_GETZOOM = WM_USER + 109,
MCIWNDM_SETVOLUME = WM_USER + 110,
MCIWNDM_GETVOLUME = WM_USER + 111,
MCIWNDM_SETSPEED = WM_USER + 112,
MCIWNDM_GETSPEED = WM_USER + 113,
MCIWNDM_SETREPEAT = WM_USER + 114,
MCIWNDM_GETREPEAT = WM_USER + 115,
MCIWNDM_REALIZE = WM_USER + 118,
MCIWNDM_SETTIMEFORMATA = WM_USER + 119,
MCIWNDM_GETTIMEFORMATA = WM_USER + 120,
MCIWNDM_VALIDATEMEDIA = WM_USER + 121,
MCIWNDM_PLAYFROM = WM_USER + 122,
MCIWNDM_PLAYTO = WM_USER + 123,
MCIWNDM_GETFILENAMEA = WM_USER + 124,
MCIWNDM_GETDEVICEA = WM_USER + 125,
MCIWNDM_GETPALETTE = WM_USER + 126,
MCIWNDM_SETPALETTE = WM_USER + 127,
MCIWNDM_GETERRORA = WM_USER + 128,
MCIWNDM_SETTIMERS = WM_USER + 129,
MCIWNDM_SETACTIVETIMER = WM_USER + 130,
MCIWNDM_SETINACTIVETIMER = WM_USER + 131,
MCIWNDM_GETACTIVETIMER = WM_USER + 132,
MCIWNDM_GETINACTIVETIMER = WM_USER + 133,
MCIWNDM_NEWA = WM_USER + 134,
MCIWNDM_CHANGESTYLES = WM_USER + 135,
MCIWNDM_GETSTYLES = WM_USER + 136,
MCIWNDM_GETALIAS = WM_USER + 137,
MCIWNDM_RETURNSTRINGA = WM_USER + 138,
MCIWNDM_PLAYREVERSE = WM_USER + 139,
MCIWNDM_GET_SOURCE = WM_USER + 140,
MCIWNDM_PUT_SOURCE = WM_USER + 141,
MCIWNDM_GET_DEST = WM_USER + 142,
MCIWNDM_PUT_DEST = WM_USER + 143,
MCIWNDM_CAN_PLAY = WM_USER + 144,
MCIWNDM_CAN_WINDOW = WM_USER + 145,
MCIWNDM_CAN_RECORD = WM_USER + 146,
MCIWNDM_CAN_SAVE = WM_USER + 147,
MCIWNDM_CAN_EJECT = WM_USER + 148,
MCIWNDM_CAN_CONFIG = WM_USER + 149,
MCIWNDM_PALETTEKICK = WM_USER + 150,
MCIWNDM_OPENINTERFACE = WM_USER + 151,
MCIWNDM_SETOWNER = WM_USER + 152,
MCIWNDM_OPENA = WM_USER + 153,
MCIWNDM_SENDSTRINGW = WM_USER + 201,
MCIWNDM_GETPOSITIONW = WM_USER + 202,
MCIWNDM_GETMODEW = WM_USER + 206,
MCIWNDM_SETTIMEFORMATW = WM_USER + 219,
MCIWNDM_GETTIMEFORMATW = WM_USER + 220,
MCIWNDM_GETFILENAMEW = WM_USER + 224,
MCIWNDM_GETDEVICEW = WM_USER + 225,
MCIWNDM_GETERRORW = WM_USER + 228,
MCIWNDM_NEWW = WM_USER + 234,
MCIWNDM_RETURNSTRINGW = WM_USER + 238,
MCIWNDM_OPENW = WM_USER + 252,
}
version(Unicode) {
alias MCIWNDM_SENDSTRINGW MCIWNDM_SENDSTRING;
alias MCIWNDM_GETPOSITIONW MCIWNDM_GETPOSITION;
alias MCIWNDM_GETMODEW MCIWNDM_GETMODE;
alias MCIWNDM_SETTIMEFORMATW MCIWNDM_SETTIMEFORMAT;
alias MCIWNDM_GETTIMEFORMATW MCIWNDM_GETTIMEFORMAT;
alias MCIWNDM_GETFILENAMEW MCIWNDM_GETFILENAME;
alias MCIWNDM_GETDEVICEW MCIWNDM_GETDEVICE;
alias MCIWNDM_GETERRORW MCIWNDM_GETERROR;
alias MCIWNDM_NEWW MCIWNDM_NEW;
alias MCIWNDM_RETURNSTRINGW MCIWNDM_RETURNSTRING;
alias MCIWNDM_OPENW MCIWNDM_OPEN;
} else { // Unicode
alias MCIWNDM_SENDSTRINGA MCIWNDM_SENDSTRING;
alias MCIWNDM_GETPOSITIONA MCIWNDM_GETPOSITION;
alias MCIWNDM_GETMODEA MCIWNDM_GETMODE;
alias MCIWNDM_SETTIMEFORMATA MCIWNDM_SETTIMEFORMAT;
alias MCIWNDM_GETTIMEFORMATA MCIWNDM_GETTIMEFORMAT;
alias MCIWNDM_GETFILENAMEA MCIWNDM_GETFILENAME;
alias MCIWNDM_GETDEVICEA MCIWNDM_GETDEVICE;
alias MCIWNDM_GETERRORA MCIWNDM_GETERROR;
alias MCIWNDM_NEWA MCIWNDM_NEW;
alias MCIWNDM_RETURNSTRINGA MCIWNDM_RETURNSTRING;
alias MCIWNDM_OPENA MCIWNDM_OPEN;
}
enum {
MCIWNDM_NOTIFYMODE = WM_USER + 200,
MCIWNDM_NOTIFYPOS = WM_USER + 201,
MCIWNDM_NOTIFYSIZE = WM_USER + 202,
MCIWNDM_NOTIFYMEDIA = WM_USER + 203,
MCIWNDM_NOTIFYERROR = WM_USER + 205,
}
const MCIWND_START = -1;
const MCIWND_END = -2;
enum {
MCI_CLOSE = 0x0804,
MCI_PLAY = 0x0806,
MCI_SEEK = 0x0807,
MCI_STOP = 0x0808,
MCI_PAUSE = 0x0809,
MCI_STEP = 0x080E,
MCI_RECORD = 0x080F,
MCI_SAVE = 0x0813,
MCI_CUT = 0x0851,
MCI_COPY = 0x0852,
MCI_PASTE = 0x0853,
MCI_RESUME = 0x0855,
MCI_DELETE = 0x0856,
}
enum {
MCI_MODE_NOT_READY = 524,
MCI_MODE_STOP,
MCI_MODE_PLAY,
MCI_MODE_RECORD,
MCI_MODE_SEEK,
MCI_MODE_PAUSE,
MCI_MODE_OPEN,
}
alias TypeDef!(HANDLE) HVIDEO;
alias HVIDEO* LPHVIDEO;
// Error Return Values
enum {
DV_ERR_OK = 0,
DV_ERR_BASE = 1,
DV_ERR_NONSPECIFIC = DV_ERR_BASE,
DV_ERR_BADFORMAT = DV_ERR_BASE + 1,
DV_ERR_STILLPLAYING = DV_ERR_BASE + 2,
DV_ERR_UNPREPARED = DV_ERR_BASE + 3,
DV_ERR_SYNC = DV_ERR_BASE + 4,
DV_ERR_TOOMANYCHANNELS = DV_ERR_BASE + 5,
DV_ERR_NOTDETECTED = DV_ERR_BASE + 6,
DV_ERR_BADINSTALL = DV_ERR_BASE + 7,
DV_ERR_CREATEPALETTE = DV_ERR_BASE + 8,
DV_ERR_SIZEFIELD = DV_ERR_BASE + 9,
DV_ERR_PARAM1 = DV_ERR_BASE + 10,
DV_ERR_PARAM2 = DV_ERR_BASE + 11,
DV_ERR_CONFIG1 = DV_ERR_BASE + 12,
DV_ERR_CONFIG2 = DV_ERR_BASE + 13,
DV_ERR_FLAGS = DV_ERR_BASE + 14,
DV_ERR_13 = DV_ERR_BASE + 15,
DV_ERR_NOTSUPPORTED = DV_ERR_BASE + 16,
DV_ERR_NOMEM = DV_ERR_BASE + 17,
DV_ERR_ALLOCATED = DV_ERR_BASE + 18,
DV_ERR_BADDEVICEID = DV_ERR_BASE + 19,
DV_ERR_INVALHANDLE = DV_ERR_BASE + 20,
DV_ERR_BADERRNUM = DV_ERR_BASE + 21,
DV_ERR_NO_BUFFERS = DV_ERR_BASE + 22,
DV_ERR_MEM_CONFLICT = DV_ERR_BASE + 23,
DV_ERR_IO_CONFLICT = DV_ERR_BASE + 24,
DV_ERR_DMA_CONFLICT = DV_ERR_BASE + 25,
DV_ERR_INT_CONFLICT = DV_ERR_BASE + 26,
DV_ERR_PROTECT_ONLY = DV_ERR_BASE + 27,
DV_ERR_LASTERROR = DV_ERR_BASE + 27,
DV_ERR_USER_MSG = DV_ERR_BASE + 1000,
}
// Callback Messages
enum {
MM_DRVM_OPEN = 0x3D0,
MM_DRVM_CLOSE,
MM_DRVM_DATA,
MM_DRVM_ERROR,
}
enum {
DV_VM_OPEN = MM_DRVM_OPEN,
DV_VM_CLOSE = MM_DRVM_CLOSE,
DV_VM_DATA = MM_DRVM_DATA,
DV_VM_ERROR = MM_DRVM_ERROR,
}
/**
* Structures
*/
struct VIDEOHDR {
LPBYTE lpData;
DWORD dwBufferLength;
DWORD dwBytesUsed;
DWORD dwTimeCaptured;
DWORD_PTR dwUser;
DWORD dwFlags;
DWORD_PTR[4]dwReserved;
}
alias VIDEOHDR* PVIDEOHDR, LPVIDEOHDR;
enum {
VHDR_DONE = 0x00000001,
VHDR_PREPARED = 0x00000002,
VHDR_INQUEUE = 0x00000004,
VHDR_KEYFRAME = 0x00000008,
VHDR_VALID = 0x0000000F,
}
struct CHANNEL_CAPS {
DWORD dwFlags;
DWORD dwSrcRectXMod;
DWORD dwSrcRectYMod;
DWORD dwSrcRectWidthMod;
DWORD dwSrcRectHeightMod;
DWORD dwDstRectXMod;
DWORD dwDstRectYMod;
DWORD dwDstRectWidthMod;
DWORD dwDstRectHeightMod;
}
alias CHANNEL_CAPS* PCHANNEL_CAPS, LPCHANNEL_CAPS;
enum {
VCAPS_OVERLAY = 0x00000001,
VCAPS_SRC_CAN_CLIP = 0x00000002,
VCAPS_DST_CAN_CLIP = 0x00000004,
VCAPS_CAN_SCALE = 0x00000008,
}
/**
* API Flags
*/
enum {
VIDEO_EXTERNALIN = 0x0001,
VIDEO_EXTERNALOUT = 0x0002,
VIDEO_IN = 0x0004,
VIDEO_OUT = 0x0008,
VIDEO_DLG_QUERY = 0x0010,
}
enum {
VIDEO_CONFIGURE_QUERYSIZE = 0x0001,
VIDEO_CONFIGURE_CURRENT = 0x0010,
VIDEO_CONFIGURE_NOMINAL = 0x0020,
VIDEO_CONFIGURE_MIN = 0x0040,
VIDEO_CONFIGURE_MAX = 0x0080,
VIDEO_CONFIGURE_SET = 0x1000,
VIDEO_CONFIGURE_GET = 0x2000,
VIDEO_CONFIGURE_QUERY = 0x8000,
}
/**
* CONFIGURE MESSAGES
*/
enum {
DVM_USER = 0x4000,
DVM_CONFIGURE_START = 0x1000,
DVM_CONFIGURE_END = 0x1FFF,
DVM_PALETTE = DVM_CONFIGURE_START + 1,
DVM_FORMAT = DVM_CONFIGURE_START + 2,
DVM_PALETTERGB555 = DVM_CONFIGURE_START + 3,
DVM_SRC_RECT = DVM_CONFIGURE_START + 4,
DVM_DST_RECT = DVM_CONFIGURE_START + 5,
}
/**
* AVICap window class
*/
LRESULT AVICapSM(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
if (IsWindow(hWnd)) {
return SendMessage(hWnd, msg, wParam, lParam);
}
return 0;
}
enum {
WM_CAP_START = WM_USER,
WM_CAP_UNICODE_START = WM_USER + 100,
WM_CAP_GET_CAPSTREAMPTR = WM_CAP_START + 1,
WM_CAP_SET_CALLBACK_ERRORA = WM_CAP_START + 2,
WM_CAP_SET_CALLBACK_STATUSA = WM_CAP_START + 3,
WM_CAP_SET_CALLBACK_ERRORW = WM_CAP_UNICODE_START + 2,
WM_CAP_SET_CALLBACK_STATUSW = WM_CAP_UNICODE_START + 3,
}
version(Unicode) {
alias WM_CAP_SET_CALLBACK_ERRORW WM_CAP_SET_CALLBACK_ERROR;
alias WM_CAP_SET_CALLBACK_STATUSW WM_CAP_SET_CALLBACK_STATUS;
} else { // Unicode
alias WM_CAP_SET_CALLBACK_ERRORA WM_CAP_SET_CALLBACK_ERROR;
alias WM_CAP_SET_CALLBACK_STATUSA WM_CAP_SET_CALLBACK_STATUS;
}
enum {
WM_CAP_SET_CALLBACK_YIELD = WM_CAP_START + 4,
WM_CAP_SET_CALLBACK_FRAME = WM_CAP_START + 5,
WM_CAP_SET_CALLBACK_VIDEOSTREAM = WM_CAP_START + 6,
WM_CAP_SET_CALLBACK_WAVESTREAM = WM_CAP_START + 7,
WM_CAP_GET_USER_DATA = WM_CAP_START + 8,
WM_CAP_SET_USER_DATA = WM_CAP_START + 9,
WM_CAP_DRIVER_CONNECT = WM_CAP_START + 10,
WM_CAP_DRIVER_DISCONNECT = WM_CAP_START + 11,
WM_CAP_DRIVER_GET_NAMEA = WM_CAP_START + 12,
WM_CAP_DRIVER_GET_VERSIONA = WM_CAP_START + 13,
WM_CAP_DRIVER_GET_NAMEW = WM_CAP_UNICODE_START + 12,
WM_CAP_DRIVER_GET_VERSIONW = WM_CAP_UNICODE_START + 13,
}
version(Unicode) {
alias WM_CAP_DRIVER_GET_NAMEW WM_CAP_DRIVER_GET_NAME;
alias WM_CAP_DRIVER_GET_VERSIONW WM_CAP_DRIVER_GET_VERSION;
} else { // Unicode
alias WM_CAP_DRIVER_GET_NAMEA WM_CAP_DRIVER_GET_NAME;
alias WM_CAP_DRIVER_GET_VERSIONA WM_CAP_DRIVER_GET_VERSION;
}
enum {
WM_CAP_DRIVER_GET_CAPS = WM_CAP_START + 14,
WM_CAP_FILE_SET_CAPTURE_FILEA = WM_CAP_START + 20,
WM_CAP_FILE_GET_CAPTURE_FILEA = WM_CAP_START + 21,
WM_CAP_FILE_SAVEASA = WM_CAP_START + 23,
WM_CAP_FILE_SAVEDIBA = WM_CAP_START + 25,
WM_CAP_FILE_SET_CAPTURE_FILEW = WM_CAP_UNICODE_START + 20,
WM_CAP_FILE_GET_CAPTURE_FILEW = WM_CAP_UNICODE_START + 21,
WM_CAP_FILE_SAVEASW = WM_CAP_UNICODE_START + 23,
WM_CAP_FILE_SAVEDIBW = WM_CAP_UNICODE_START + 25,
}
version(Unicode) {
alias WM_CAP_FILE_SET_CAPTURE_FILEW WM_CAP_FILE_SET_CAPTURE_FILE;
alias WM_CAP_FILE_GET_CAPTURE_FILEW WM_CAP_FILE_GET_CAPTURE_FILE;
alias WM_CAP_FILE_SAVEASW WM_CAP_FILE_SAVEAS;
alias WM_CAP_FILE_SAVEDIBW WM_CAP_FILE_SAVEDIB;
} else { // Unicode
alias WM_CAP_FILE_SET_CAPTURE_FILEA WM_CAP_FILE_SET_CAPTURE_FILE;
alias WM_CAP_FILE_GET_CAPTURE_FILEA WM_CAP_FILE_GET_CAPTURE_FILE;
alias WM_CAP_FILE_SAVEASA WM_CAP_FILE_SAVEAS;
alias WM_CAP_FILE_SAVEDIBA WM_CAP_FILE_SAVEDIB;
}
enum {
WM_CAP_FILE_ALLOCATE = WM_CAP_START + 22,
WM_CAP_FILE_SET_INFOCHUNK = WM_CAP_START + 24,
WM_CAP_EDIT_COPY = WM_CAP_START + 30,
WM_CAP_SET_AUDIOFORMAT = WM_CAP_START + 35,
WM_CAP_GET_AUDIOFORMAT = WM_CAP_START + 36,
WM_CAP_DLG_VIDEOFORMAT = WM_CAP_START + 41,
WM_CAP_DLG_VIDEOSOURCE = WM_CAP_START + 42,
WM_CAP_DLG_VIDEODISPLAY = WM_CAP_START + 43,
WM_CAP_GET_VIDEOFORMAT = WM_CAP_START + 44,
WM_CAP_SET_VIDEOFORMAT = WM_CAP_START + 45,
WM_CAP_DLG_VIDEOCOMPRESSION = WM_CAP_START + 46,
WM_CAP_SET_PREVIEW = WM_CAP_START + 50,
WM_CAP_SET_OVERLAY = WM_CAP_START + 51,
WM_CAP_SET_PREVIEWRATE = WM_CAP_START + 52,
WM_CAP_SET_SCALE = WM_CAP_START + 53,
WM_CAP_GET_STATUS = WM_CAP_START + 54,
WM_CAP_SET_SCROLL = WM_CAP_START + 55,
WM_CAP_GRAB_FRAME = WM_CAP_START + 60,
WM_CAP_GRAB_FRAME_NOSTOP = WM_CAP_START + 61,
WM_CAP_SEQUENCE = WM_CAP_START + 62,
WM_CAP_SEQUENCE_NOFILE = WM_CAP_START + 63,
WM_CAP_SET_SEQUENCE_SETUP = WM_CAP_START + 64,
WM_CAP_GET_SEQUENCE_SETUP = WM_CAP_START + 65,
WM_CAP_SET_MCI_DEVICEA = WM_CAP_START + 66,
WM_CAP_GET_MCI_DEVICEA = WM_CAP_START + 67,
WM_CAP_SET_MCI_DEVICEW = WM_CAP_UNICODE_START + 66,
WM_CAP_GET_MCI_DEVICEW = WM_CAP_UNICODE_START + 67,
}
version(Unicode) {
alias WM_CAP_SET_MCI_DEVICEW WM_CAP_SET_MCI_DEVICE;
alias WM_CAP_GET_MCI_DEVICEW WM_CAP_GET_MCI_DEVICE;
} else { // Unicode
alias WM_CAP_SET_MCI_DEVICEA WM_CAP_SET_MCI_DEVICE;
alias WM_CAP_GET_MCI_DEVICEA WM_CAP_GET_MCI_DEVICE;
}
enum {
WM_CAP_STOP = WM_CAP_START + 68,
WM_CAP_ABORT = WM_CAP_START + 69,
WM_CAP_SINGLE_FRAME_OPEN = WM_CAP_START + 70,
WM_CAP_SINGLE_FRAME_CLOSE = WM_CAP_START + 71,
WM_CAP_SINGLE_FRAME = WM_CAP_START + 72,
WM_CAP_PAL_OPENA = WM_CAP_START + 80,
WM_CAP_PAL_SAVEA = WM_CAP_START + 81,
WM_CAP_PAL_OPENW = WM_CAP_UNICODE_START + 80,
WM_CAP_PAL_SAVEW = WM_CAP_UNICODE_START + 81,
}
version(Unicode) {
alias WM_CAP_PAL_OPENW WM_CAP_PAL_OPEN;
alias WM_CAP_PAL_SAVEW WM_CAP_PAL_SAVE;
} else { // Unicode
alias WM_CAP_PAL_OPENA WM_CAP_PAL_OPEN;
alias WM_CAP_PAL_SAVEA WM_CAP_PAL_SAVE;
}
enum {
WM_CAP_PAL_PASTE = WM_CAP_START + 82,
WM_CAP_PAL_AUTOCREATE = WM_CAP_START + 83,
WM_CAP_PAL_MANUALCREATE = WM_CAP_START + 84,
WM_CAP_SET_CALLBACK_CAPCONTROL = WM_CAP_START + 85,
WM_CAP_UNICODE_END = WM_CAP_PAL_SAVEW,
WM_CAP_END = WM_CAP_UNICODE_END,
}
/**
* message wrapper
*/
BOOL capSetCallbackOnError(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_ERROR, 0, cast(LPARAM)fpProc); }
BOOL capSetCallbackOnStatus(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_STATUS, 0, cast(LPARAM)fpProc); }
BOOL capSetCallbackOnYield(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_YIELD, 0, cast(LPARAM)fpProc); }
BOOL capSetCallbackOnFrame(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_FRAME, 0, cast(LPARAM)fpProc); }
BOOL capSetCallbackOnVideoStream(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, cast(LPARAM)fpProc); }
BOOL capSetCallbackOnWaveStream(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_WAVESTREAM, 0, cast(LPARAM)fpProc); }
BOOL capSetCallbackOnCapControl(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_CAPCONTROL, 0, cast(LPARAM)fpProc); }
BOOL capSetUserData(HWND hWnd, LPARAM lUser) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_USER_DATA, 0, lUser); }
BOOL capGetUserData(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_USER_DATA, 0, 0); }
BOOL capDriverConnect(HWND hWnd, WPARAM i) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_CONNECT, i, 0); }
BOOL capDriverDisconnect(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_DISCONNECT, 0, 0); }
BOOL capDriverGetName(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_NAME, wSize, cast(LPARAM)szName); }
BOOL capDriverGetVersion(HWND hWnd, LPTSTR szVer, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_VERSION, wSize, cast(LPARAM)szVer); }
BOOL capDriverGetCaps(HWND hWnd, LPCAPDRIVERCAPS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_CAPS, wSize, cast(LPARAM)s); }
BOOL capFileSetCaptureFile(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SET_CAPTURE_FILE, 0, cast(LPARAM)szName); }
BOOL capFileGetCaptureFile(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_GET_CAPTURE_FILE, wSize, cast(LPARAM)szName); }
BOOL capFileAlloc(HWND hWnd, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_ALLOCATE, wSize, 0); }
BOOL capFileSaveAs(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SAVEAS, 0, cast(LPARAM)szName); }
BOOL capFileSetInfoChunk(HWND hWnd, LPCAPINFOCHUNK lpInfoChunk) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SET_INFOCHUNK, 0, cast(LPARAM)lpInfoChunk); }
BOOL capFileSaveDIB(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SAVEDIB, 0, cast(LPARAM)szName); }
BOOL capEditCopy(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_EDIT_COPY, 0, 0); }
BOOL capSetAudioFormat(HWND hWnd, LPWAVEFORMATEX s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_AUDIOFORMAT, wSize, cast(LPARAM)s); }
DWORD capGetAudioFormat(HWND hWnd, LPWAVEFORMATEX s, WPARAM wSize) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_AUDIOFORMAT, wSize, cast(LPARAM)s); }
DWORD capGetAudioFormatSize(HWND hWnd) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_AUDIOFORMAT, 0, 0); }
BOOL capDlgVideoFormat(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOFORMAT, 0, 0); }
BOOL capDlgVideoSource(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOSOURCE, 0, 0); }
BOOL capDlgVideoDisplay(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEODISPLAY, 0, 0); }
BOOL capDlgVideoCompression(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOCOMPRESSION, 0, 0); }
DWORD capGetVideoFormat(HWND hWnd, void* s, WPARAM wSize) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_VIDEOFORMAT, wSize, cast(LPARAM)s); }
DWORD capGetVideoFormatSize(HWND hWnd) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_VIDEOFORMAT, 0, 0); }
BOOL capSetVideoFormat(HWND hWnd, void* s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_VIDEOFORMAT, wSize, cast(LPARAM)s); }
BOOL capPreview(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_PREVIEW, cast(WPARAM)f, 0); }
BOOL capPreviewRate(HWND hWnd, WPARAM wMS) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_PREVIEWRATE, wMS, 0); }
BOOL capOverlay(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_OVERLAY, cast(WPARAM)f, 0); }
BOOL capPreviewScale(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SCALE, cast(WPARAM)f, 0); }
BOOL capGetStatus(HWND hWnd, LPCAPSTATUS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_STATUS, wSize, cast(LPARAM)s); }
BOOL capSetScrollPos(HWND hWnd, LPPOINT lpP) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SCROLL, 0, cast(LPARAM)lpP); }
BOOL capGrabFrame(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GRAB_FRAME, 0, 0); }
BOOL capGrabFrameNoStop(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GRAB_FRAME_NOSTOP, 0, 0); }
BOOL capCaptureSequence(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SEQUENCE, 0, 0); }
BOOL capCaptureSequenceNoFile(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SEQUENCE_NOFILE, 0, 0); }
BOOL capCaptureStop(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_STOP, 0, 0); }
BOOL capCaptureAbort(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_ABORT, 0, 0); }
BOOL capCaptureSingleFrameOpen(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME_OPEN, 0, 0); }
BOOL capCaptureSingleFrameClose(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME_CLOSE, 0, 0); }
BOOL capCaptureSingleFrame(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME, 0, 0); }
BOOL capCaptureGetSetup(HWND hWnd, LPCAPTUREPARMS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_SEQUENCE_SETUP, wSize, cast(LPARAM)s); }
BOOL capCaptureSetSetup(HWND hWnd, LPCAPTUREPARMS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SEQUENCE_SETUP, wSize, cast(LPARAM)s); }
BOOL capSetMCIDeviceName(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_MCI_DEVICE, 0, cast(LPARAM)szName); }
BOOL capGetMCIDeviceName(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_MCI_DEVICE, wSize, cast(LPARAM)szName); }
BOOL capPaletteOpen(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_OPEN, 0, cast(LPARAM)szName); }
BOOL capPaletteSave(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_SAVE, 0, cast(LPARAM)szName); }
BOOL capPalettePaste(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_PASTE, 0, 0); }
BOOL capPaletteAuto(HWND hWnd, WPARAM iFrames, LPARAM iColors) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_AUTOCREATE, iFrames, iColors); }
BOOL capPaletteManual(HWND hWnd, WPARAM fGrab, LPARAM iColors) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_MANUALCREATE, fGrab, iColors); }
/**
* structs
*/
struct CAPDRIVERCAPS {
UINT wDeviceIndex;
BOOL fHasOverlay;
BOOL fHasDlgVideoSource;
BOOL fHasDlgVideoFormat;
BOOL fHasDlgVideoDisplay;
BOOL fCaptureInitialized;
BOOL fDriverSuppliesPalettes;
HANDLE hVideoIn;
HANDLE hVideoOut;
HANDLE hVideoExtIn;
HANDLE hVideoExtOut;
}
alias CAPDRIVERCAPS* PCAPDRIVERCAPS, LPCAPDRIVERCAPS;
struct CAPSTATUS {
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;
}
alias CAPSTATUS* PCAPSTATUS, LPCAPSTATUS;
struct CAPTUREPARMS {
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;
}
alias CAPTUREPARMS* PCAPTUREPARMS, LPCAPTUREPARMS;
const AVSTREAMMASTER_AUDIO = 0;
const AVSTREAMMASTER_NONE = 1;
struct CAPINFOCHUNK {
FOURCC fccInfoID;
LPVOID lpData;
LONG cbData;
}
alias CAPINFOCHUNK* PCAPINFOCHUNK, LPCAPINFOCHUNK;
// Callback Definitions
extern (Windows) {
alias LRESULT function(HWND hWnd) CAPYIELDCALLBACK;
alias LRESULT function(HWND hWnd, int nID, LPCWSTR lpsz) CAPSTATUSCALLBACKW;
alias LRESULT function(HWND hWnd, int nID, LPCWSTR lpsz) CAPERRORCALLBACKW;
alias LRESULT function(HWND hWnd, int nID, LPCSTR lpsz) CAPSTATUSCALLBACKA;
alias LRESULT function(HWND hWnd, int nID, LPCSTR lpsz) CAPERRORCALLBACKA;
}
version(Unicode) {
alias CAPSTATUSCALLBACKW CAPSTATUSCALLBACK;
alias CAPERRORCALLBACKW CAPERRORCALLBACK;
} else { // Unicode
alias CAPSTATUSCALLBACKA CAPSTATUSCALLBACK;
alias CAPERRORCALLBACKA CAPERRORCALLBACK;
}
extern (Windows) {
alias LRESULT function(HWND hWnd, LPVIDEOHDR lpVHdr) CAPVIDEOCALLBACK;
alias LRESULT function(HWND hWnd, LPWAVEHDR lpWHdr) CAPWAVECALLBACK;
alias LRESULT function(HWND hWnd, int nState) CAPCONTROLCALLBACK;
}
// CapControlCallback states
const CONTROLCALLBACK_PREROLL = 1;
const CONTROLCALLBACK_CAPTURING = 2;
extern (Windows) {
HWND capCreateCaptureWindowA(LPCSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID);
BOOL capGetDriverDescriptionA(UINT wDriverIndex, LPSTR lpszName, int cbName, LPSTR lpszVer, int cbVer);
HWND capCreateCaptureWindowW(LPCWSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID);
BOOL capGetDriverDescriptionW(UINT wDriverIndex, LPWSTR lpszName, int cbName, LPWSTR lpszVer, int cbVer);
}
version(Unicode) {
alias capCreateCaptureWindowW capCreateCaptureWindow;
alias capGetDriverDescriptionW capGetDriverDescription;
} else { // Unicode
alias capCreateCaptureWindowA capCreateCaptureWindow;
alias capGetDriverDescriptionA capGetDriverDescription;
}
// New Information chunk IDs
const infotypeDIGITIZATION_TIME = mmioFOURCC!('I', 'D', 'I', 'T');
const infotypeSMPTE_TIME = mmioFOURCC!('I', 'S', 'M', 'P');
// status and error callbacks
enum {
IDS_CAP_BEGIN = 300,
IDS_CAP_END = 301,
IDS_CAP_INFO = 401,
IDS_CAP_OUTOFMEM = 402,
IDS_CAP_FILEEXISTS = 403,
IDS_CAP_ERRORPALOPEN = 404,
IDS_CAP_ERRORPALSAVE = 405,
IDS_CAP_ERRORDIBSAVE = 406,
IDS_CAP_DEFAVIEXT = 407,
IDS_CAP_DEFPALEXT = 408,
IDS_CAP_CANTOPEN = 409,
IDS_CAP_SEQ_MSGSTART = 410,
IDS_CAP_SEQ_MSGSTOP = 411,
IDS_CAP_VIDEDITERR = 412,
IDS_CAP_READONLYFILE = 413,
IDS_CAP_WRITEERROR = 414,
IDS_CAP_NODISKSPACE = 415,
IDS_CAP_SETFILESIZE = 416,
IDS_CAP_SAVEASPERCENT = 417,
IDS_CAP_DRIVER_ERROR = 418,
IDS_CAP_WAVE_OPEN_ERROR = 419,
IDS_CAP_WAVE_ALLOC_ERROR = 420,
IDS_CAP_WAVE_PREPARE_ERROR = 421,
IDS_CAP_WAVE_ADD_ERROR = 422,
IDS_CAP_WAVE_SIZE_ERROR = 423,
IDS_CAP_VIDEO_OPEN_ERROR = 424,
IDS_CAP_VIDEO_ALLOC_ERROR = 425,
IDS_CAP_VIDEO_PREPARE_ERROR = 426,
IDS_CAP_VIDEO_ADD_ERROR = 427,
IDS_CAP_VIDEO_SIZE_ERROR = 428,
IDS_CAP_FILE_OPEN_ERROR = 429,
IDS_CAP_FILE_WRITE_ERROR = 430,
IDS_CAP_RECORDING_ERROR = 431,
IDS_CAP_RECORDING_ERROR2 = 432,
IDS_CAP_AVI_INIT_ERROR = 433,
IDS_CAP_NO_FRAME_CAP_ERROR = 434,
IDS_CAP_NO_PALETTE_WARN = 435,
IDS_CAP_MCI_CONTROL_ERROR = 436,
IDS_CAP_MCI_CANT_STEP_ERROR = 437,
IDS_CAP_NO_AUDIO_CAP_ERROR = 438,
IDS_CAP_AVI_DRAWDIB_ERROR = 439,
IDS_CAP_COMPRESSOR_ERROR = 440,
IDS_CAP_AUDIO_DROP_ERROR = 441,
IDS_CAP_AUDIO_DROP_COMPERROR = 442,
IDS_CAP_STAT_LIVE_MODE = 500,
IDS_CAP_STAT_OVERLAY_MODE = 501,
IDS_CAP_STAT_CAP_INIT = 502,
IDS_CAP_STAT_CAP_FINI = 503,
IDS_CAP_STAT_PALETTE_BUILD = 504,
IDS_CAP_STAT_OPTPAL_BUILD = 505,
IDS_CAP_STAT_I_FRAMES = 506,
IDS_CAP_STAT_L_FRAMES = 507,
IDS_CAP_STAT_CAP_L_FRAMES = 508,
IDS_CAP_STAT_CAP_AUDIO = 509,
IDS_CAP_STAT_VIDEOCURRENT = 510,
IDS_CAP_STAT_VIDEOAUDIO = 511,
IDS_CAP_STAT_VIDEOONLY = 512,
IDS_CAP_STAT_FRAMESDROPPED = 513,
}
/**
* FilePreview dialog.
*/
extern (Windows) {
BOOL GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn);
BOOL GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn);
BOOL GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn);
BOOL GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn);
}
version(Unicode) {
alias GetOpenFileNamePreviewW GetOpenFileNamePreview;
alias GetSaveFileNamePreviewW GetSaveFileNamePreview;
} else { // Unicode
alias GetOpenFileNamePreviewA GetOpenFileNamePreview;
alias GetSaveFileNamePreviewA GetSaveFileNamePreview;
}