1 /**
2 * Windows API header module
3 *
4 * written in the D programming language
5 *
6 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
7 * Source: $(DRUNTIMESRC src/core/sys/windows/_vfw.d)
8 */
9
10 module core.sys.windows.vfw;
version(Windows)11 version (Windows):
12 @system:
13
14 version (ANSI) {} else version = Unicode;
15 pragma(lib, "vfw32");
16
17 private import
18 core.sys.windows.commdlg,
19 core.sys.windows.wingdi,
20 core.sys.windows.mmsystem,
21 core.sys.windows.unknwn,
22 core.sys.windows.w32api,
23 core.sys.windows.windef,
24 core.sys.windows.winuser;
25
26 extern(Windows) {
27 DWORD VideoForWindowsVersion();
28 LONG InitVFW();
29 LONG TermVFW();
30 }
31
MKFOURCC(char ch0,char ch1,char ch2,char ch3)32 DWORD MKFOURCC(char ch0, char ch1, char ch2, char ch3) {
33 return (cast(DWORD)ch0) | ((cast(DWORD)ch1) << 8) | ((cast(DWORD)ch2) << 16) | ((cast(DWORD)ch3) << 24);
34 }
35
36 /**
37 * COMPMAN - Installable Compression Manager.
38 */
39
40 enum ICVERSION = 0x0104;
41
42 alias TypeDef!(HANDLE) HIC;
43
44 enum BI_1632 = 0x32333631;
45
aviTWOCC(char c0,char c1)46 template aviTWOCC(char c0, char c1) {
47 enum WORD aviTWOCC = c0 | (c1 << 8);
48 }
49
50 enum ICTYPE_VIDEO = mmioFOURCC!('v', 'i', 'd', 'c');
51 enum ICTYPE_AUDIO = mmioFOURCC!('a', 'u', 'd', 'c');
52
53 enum {
54 ICERR_OK = 0,
55 ICERR_DONTDRAW = 1,
56 ICERR_NEWPALETTE = 2,
57 ICERR_GOTOKEYFRAME = 3,
58 ICERR_STOPDRAWING = 4,
59 }
60
61 enum ICERR_UNSUPPORTED = -1;
62 enum ICERR_BADFORMAT = -2;
63 enum ICERR_MEMORY = -3;
64 enum ICERR_INTERNAL = -4;
65 enum ICERR_BADFLAGS = -5;
66 enum ICERR_BADPARAM = -6;
67 enum ICERR_BADSIZE = -7;
68 enum ICERR_BADHANDLE = -8;
69 enum ICERR_CANTUPDATE = -9;
70 enum ICERR_ABORT = -10;
71 enum ICERR_ERROR = -100;
72 enum ICERR_BADBITDEPTH = -200;
73 enum ICERR_BADIMAGESIZE = -201;
74
75 enum ICERR_CUSTOM = -400;
76
77 enum {
78 ICMODE_COMPRESS = 1,
79 ICMODE_DECOMPRESS,
80 ICMODE_FASTDECOMPRESS,
81 ICMODE_QUERY,
82 ICMODE_FASTCOMPRESS,
83 ICMODE_DRAW = 8,
84 }
85
86 enum ICMODE_INTERNALF_FUNCTION32 = 0x8000;
87 enum ICMODE_INTERNALF_MASK = 0x8000;
88
89 enum {
90 AVIIF_LIST = 0x00000001,
91 AVIIF_TWOCC = 0x00000002,
92 AVIIF_KEYFRAME = 0x00000010,
93 }
94
95 enum ICQUALITY_LOW = 0;
96 enum ICQUALITY_HIGH = 10000;
97 enum ICQUALITY_DEFAULT = -1;
98
99 enum {
100 ICM_USER = DRV_USER + 0x0000,
101 ICM_RESERVED_LOW = DRV_USER + 0x1000,
102 ICM_RESERVED_HIGH = DRV_USER + 0x2000,
103 ICM_RESERVED = ICM_RESERVED_LOW,
104 }
105
106 // messages
107
108 enum {
109 ICM_GETSTATE = ICM_RESERVED + 0,
110 ICM_SETSTATE = ICM_RESERVED + 1,
111 ICM_GETINFO = ICM_RESERVED + 2,
112 ICM_CONFIGURE = ICM_RESERVED + 10,
113 ICM_ABOUT = ICM_RESERVED + 11,
114 ICM_GETERRORTEXT = ICM_RESERVED + 12,
115 ICM_GETFORMATNAME = ICM_RESERVED + 20,
116 ICM_ENUMFORMATS = ICM_RESERVED + 21,
117 ICM_GETDEFAULTQUALITY = ICM_RESERVED + 30,
118 ICM_GETQUALITY = ICM_RESERVED + 31,
119 ICM_SETQUALITY = ICM_RESERVED + 32,
120 ICM_SET = ICM_RESERVED + 40,
121 ICM_GET = ICM_RESERVED + 41,
122 }
123
124 enum ICM_FRAMERATE = mmioFOURCC!('F','r','m','R');
125 enum ICM_KEYFRAMERATE = mmioFOURCC!('K','e','y','R');
126
127 // ICM specific messages.
128
129 enum {
130 ICM_COMPRESS_GET_FORMAT = ICM_USER + 4,
131 ICM_COMPRESS_GET_SIZE = ICM_USER + 5,
132 ICM_COMPRESS_QUERY = ICM_USER + 6,
133 ICM_COMPRESS_BEGIN = ICM_USER + 7,
134 ICM_COMPRESS = ICM_USER + 8,
135 ICM_COMPRESS_END = ICM_USER + 9,
136 ICM_DECOMPRESS_GET_FORMAT = ICM_USER + 10,
137 ICM_DECOMPRESS_QUERY = ICM_USER + 11,
138 ICM_DECOMPRESS_BEGIN = ICM_USER + 12,
139 ICM_DECOMPRESS = ICM_USER + 13,
140 ICM_DECOMPRESS_END = ICM_USER + 14,
141 ICM_DECOMPRESS_SET_PALETTE = ICM_USER + 29,
142 ICM_DECOMPRESS_GET_PALETTE = ICM_USER + 30,
143 ICM_DRAW_QUERY = ICM_USER + 31,
144 ICM_DRAW_BEGIN = ICM_USER + 15,
145 ICM_DRAW_GET_PALETTE = ICM_USER + 16,
146 ICM_DRAW_UPDATE = ICM_USER + 17,
147 ICM_DRAW_START = ICM_USER + 18,
148 ICM_DRAW_STOP = ICM_USER + 19,
149 ICM_DRAW_BITS = ICM_USER + 20,
150 ICM_DRAW_END = ICM_USER + 21,
151 ICM_DRAW_GETTIME = ICM_USER + 32,
152 ICM_DRAW = ICM_USER + 33,
153 ICM_DRAW_WINDOW = ICM_USER + 34,
154 ICM_DRAW_SETTIME = ICM_USER + 35,
155 ICM_DRAW_REALIZE = ICM_USER + 36,
156 ICM_DRAW_FLUSH = ICM_USER + 37,
157 ICM_DRAW_RENDERBUFFER = ICM_USER + 38,
158 ICM_DRAW_START_PLAY = ICM_USER + 39,
159 ICM_DRAW_STOP_PLAY = ICM_USER + 40,
160 ICM_DRAW_SUGGESTFORMAT = ICM_USER + 50,
161 ICM_DRAW_CHANGEPALETTE = ICM_USER + 51,
162 ICM_DRAW_IDLE = ICM_USER + 52,
163 ICM_GETBUFFERSWANTED = ICM_USER + 41,
164 ICM_GETDEFAULTKEYFRAMERATE = ICM_USER + 42,
165 ICM_DECOMPRESSEX_BEGIN = ICM_USER + 60,
166 ICM_DECOMPRESSEX_QUERY = ICM_USER + 61,
167 ICM_DECOMPRESSEX = ICM_USER + 62,
168 ICM_DECOMPRESSEX_END = ICM_USER + 63,
169 ICM_COMPRESS_FRAMES_INFO = ICM_USER + 70,
170 ICM_COMPRESS_FRAMES = ICM_USER + 71,
171 ICM_SET_STATUS_PROC = ICM_USER + 72,
172 }
173
174 struct ICOPEN {
175 DWORD dwSize;
176 DWORD fccType;
177 DWORD fccHandler;
178 DWORD dwVersion;
179 DWORD dwFlags;
180 LRESULT dwError;
181 LPVOID pV1Reserved;
182 LPVOID pV2Reserved;
183 DWORD dnDevNode;
184 }
185
186 struct ICINFO {
187 DWORD dwSize;
188 DWORD fccType;
189 DWORD fccHandler;
190 DWORD dwFlags;
191 DWORD dwVersion;
192 DWORD dwVersionICM;
193 WCHAR[16] szName = 0;
194 WCHAR[128] szDescription = 0;
195 WCHAR[128] szDriver = 0;
196 }
197
198 enum {
199 VIDCF_QUALITY = 0x0001,
200 VIDCF_CRUNCH = 0x0002,
201 VIDCF_TEMPORAL = 0x0004,
202 VIDCF_COMPRESSFRAMES = 0x0008,
203 VIDCF_DRAW = 0x0010,
204 VIDCF_FASTTEMPORALC = 0x0020,
205 VIDCF_FASTTEMPORALD = 0x0080,
206 }
207
208 enum ICCOMPRESS_KEYFRAME = 0x00000001L;
209
210 struct ICCOMPRESS {
211 DWORD dwFlags;
212 LPBITMAPINFOHEADER lpbiOutput;
213 LPVOID lpOutput;
214 LPBITMAPINFOHEADER lpbiInput;
215 LPVOID lpInput;
216 LPDWORD lpckid;
217 LPDWORD lpdwFlags;
218 LONG lFrameNum;
219 DWORD dwFrameSize;
220 DWORD dwQuality;
221 LPBITMAPINFOHEADER lpbiPrev;
222 LPVOID lpPrev;
223 }
224
225 enum ICCOMPRESSFRAMES_PADDING = 0x00000001;
226
227 struct ICCOMPRESSFRAMES {
228 DWORD dwFlags;
229 LPBITMAPINFOHEADER lpbiOutput;
230 LPARAM lOutput;
231 LPBITMAPINFOHEADER lpbiInput;
232 LPARAM lInput;
233 LONG lStartFrame;
234 LONG lFrameCount;
235 LONG lQuality;
236 LONG lDataRate;
237 LONG lKeyRate;
238 DWORD dwRate;
239 DWORD dwScale; DWORD dwOverheadPerFrame;
240 DWORD dwReserved2;
241 extern (Windows):
242 LONG function(LPARAM lInput, LONG lFrame, LPVOID lpBits, LONG len) GetData;
243 LONG function(LPARAM lOutput, LONG lFrame, LPVOID lpBits, LONG len) PutData;
244 }
245
246 enum {
247 ICSTATUS_START = 0,
248 ICSTATUS_STATUS = 1,
249 ICSTATUS_END = 2,
250 ICSTATUS_ERROR = 3,
251 ICSTATUS_YIELD = 4,
252 }
253
254 struct ICSETSTATUSPROC {
255 DWORD dwFlags;
256 LPARAM lParam;
257 extern (Windows)
258 LONG function(LPARAM lParam, UINT message, LONG l) Status;
259 }
260
261 enum {
262 ICDECOMPRESS_NOTKEYFRAME = 0x08000000,
263 ICDECOMPRESS_NULLFRAME = 0x10000000,
264 ICDECOMPRESS_PREROLL = 0x20000000,
265 ICDECOMPRESS_UPDATE = 0x40000000,
266 ICDECOMPRESS_HURRYUP = 0x80000000,
267 }
268
269 struct ICDECOMPRESS {
270 DWORD dwFlags;
271 LPBITMAPINFOHEADER lpbiInput;
272 LPVOID lpInput;
273 LPBITMAPINFOHEADER lpbiOutput;
274 LPVOID lpOutput;
275 DWORD ckid;
276 }
277
278 struct ICDECOMPRESSEX {
279 DWORD dwFlags;
280 LPBITMAPINFOHEADER lpbiSrc;
281 LPVOID lpSrc;
282 LPBITMAPINFOHEADER lpbiDst;
283 LPVOID lpDst;
284 int xDst;
285 int yDst;
286 int dxDst;
287 int dyDst;
288 int xSrc;
289 int ySrc;
290 int dxSrc;
291 int dySrc;
292 }
293
294 enum {
295 ICDRAW_QUERY = 0x00000001,
296 ICDRAW_FULLSCREEN = 0x00000002,
297 ICDRAW_HDC = 0x00000004,
298 ICDRAW_ANIMATE = 0x00000008,
299 ICDRAW_CONTINUE = 0x00000010,
300 ICDRAW_MEMORYDC = 0x00000020,
301 ICDRAW_UPDATING = 0x00000040,
302 ICDRAW_RENDER = 0x00000080,
303 ICDRAW_BUFFER = 0x00000100,
304 }
305
306 struct ICDRAWBEGIN {
307 DWORD dwFlags;
308 HPALETTE hpal;
309 HWND hwnd;
310 HDC hdc;
311 int xDst;
312 int yDst;
313 int dxDst;
314 int dyDst;
315 LPBITMAPINFOHEADER lpbi;
316 int xSrc;
317 int ySrc;
318 int dxSrc;
319 int dySrc;
320 DWORD dwRate;
321 DWORD dwScale;
322 }
323
324 enum {
325 ICDRAW_NOTKEYFRAME = 0x08000000,
326 ICDRAW_NULLFRAME = 0x10000000,
327 ICDRAW_PREROLL = 0x20000000,
328 ICDRAW_UPDATE = 0x40000000,
329 ICDRAW_HURRYUP = 0x80000000,
330 }
331
332 struct ICDRAW {
333 DWORD dwFlags;
334 LPVOID lpFormat;
335 LPVOID lpData;
336 DWORD cbData;
337 LONG lTime;
338 }
339
340 struct ICDRAWSUGGEST {
341 LPBITMAPINFOHEADER lpbiIn;
342 LPBITMAPINFOHEADER lpbiSuggest;
343 int dxSrc;
344 int dySrc;
345 int dxDst;
346 int dyDst;
347 HIC hicDecompressor;
348 }
349
350 struct ICPALETTE {
351 DWORD dwFlags;
352 int iStart;
353 int iLen;
354 LPPALETTEENTRY lppe;
355 }
356
357
358 /**
359 * ICM function declarations
360 */
361
362 extern (Windows) {
363 BOOL ICInfo(DWORD fccType, DWORD fccHandler, ICINFO *lpicinfo);
364 BOOL ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags);
365 BOOL ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags);
366 LRESULT ICGetInfo(HIC hic, ICINFO *picinfo, DWORD cb);
367 HIC ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode);
368 HIC ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler);
369 LRESULT ICClose(HIC hic);
370 LRESULT ICSendMessage(HIC hic, UINT msg, DWORD_PTR dw1, DWORD_PTR dw2);
371 }
372
373 enum {
374 ICINSTALL_FUNCTION = 0x0001,
375 ICINSTALL_DRIVER = 0x0002,
376 ICINSTALL_HDRV = 0x0004,
377 ICINSTALL_UNICODE = 0x8000,
378 ICINSTALL_DRIVERW = 0x8002,
379 }
380
381 // query macros
382
383 enum ICMF_CONFIGURE_QUERY = 0x00000001;
384 enum ICMF_ABOUT_QUERY = 0x00000001;
385
ICQueryAbout(HIC hic)386 DWORD ICQueryAbout(HIC hic) {
387 return ICSendMessage(hic, ICM_ABOUT, -1, ICMF_ABOUT_QUERY) == ICERR_OK;
388 }
389
ICAbout(HIC hic,HWND hwnd)390 DWORD ICAbout(HIC hic, HWND hwnd) {
391 return cast(DWORD) ICSendMessage(hic, ICM_ABOUT, cast(DWORD_PTR) cast(UINT_PTR) hwnd, 0);
392 }
393
ICQueryConfigure(HIC hic)394 DWORD ICQueryConfigure(HIC hic) {
395 return (ICSendMessage(hic, ICM_CONFIGURE, -1, ICMF_CONFIGURE_QUERY) == ICERR_OK);
396 }
397
ICConfigure(HIC hic,HWND hwnd)398 DWORD ICConfigure(HIC hic, HWND hwnd) {
399 return cast(DWORD) ICSendMessage(hic, ICM_CONFIGURE, cast(DWORD_PTR) cast(UINT_PTR) hwnd, 0);
400 }
401
ICGetState(HIC hic,LPVOID pv,DWORD_PTR cb)402 DWORD ICGetState(HIC hic, LPVOID pv, DWORD_PTR cb) {
403 return cast(DWORD) ICSendMessage(hic, ICM_GETSTATE, cast(DWORD_PTR) pv, cb);
404 }
405
ICSetState(HIC hic,LPVOID pv,DWORD_PTR cb)406 DWORD ICSetState(HIC hic, LPVOID pv, DWORD_PTR cb) {
407 return cast(DWORD) ICSendMessage(hic, ICM_SETSTATE, cast(DWORD_PTR) pv, cb);
408 }
409
ICGetStateSize(HIC hic)410 DWORD ICGetStateSize(HIC hic) {
411 return ICGetState(hic, null, 0);
412 }
413
414 DWORD dwICValue;
415
ICGetDefaultQuality(HIC hic)416 DWORD ICGetDefaultQuality(HIC hic) {
417 ICSendMessage(hic, ICM_GETDEFAULTQUALITY, cast(DWORD_PTR)&dwICValue, DWORD.sizeof);
418 return dwICValue;
419 }
420
ICGetDefaultKeyFrameRate(HIC hic)421 DWORD ICGetDefaultKeyFrameRate(HIC hic) {
422 ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, cast(DWORD_PTR)&dwICValue, DWORD.sizeof);
423 return dwICValue;
424 }
425
ICDrawWindow(HIC hic,LPVOID prc)426 DWORD ICDrawWindow(HIC hic, LPVOID prc) {
427 return cast(DWORD) ICSendMessage(hic, ICM_DRAW_WINDOW, cast(DWORD_PTR) prc, RECT.sizeof);
428 }
429
430 extern (Windows) {
431 DWORD ICCompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData,
432 LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid, LPDWORD lpdwFlags,
433 LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality, LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev);
434 }
435
ICCompressBegin(HIC hic,LPVOID lpbiInput,LPVOID lpbiOutput)436 LRESULT ICCompressBegin(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
437 return ICSendMessage(hic, ICM_COMPRESS_BEGIN, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
438 }
ICCompressQuery(HIC hic,LPVOID lpbiInput,LPVOID lpbiOutput)439 LRESULT ICCompressQuery(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
440 return ICSendMessage(hic, ICM_COMPRESS_QUERY, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
441 }
ICCompressGetFormat(HIC hic,LPVOID lpbiInput,LPVOID lpbiOutput)442 LRESULT ICCompressGetFormat(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
443 return ICSendMessage(hic, ICM_COMPRESS_GET_FORMAT, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
444 }
ICCompressGetFormatSize(HIC hic,LPVOID lpbi)445 DWORD ICCompressGetFormatSize(HIC hic, LPVOID lpbi) {
446 return cast(DWORD)ICCompressGetFormat(hic, lpbi, null);
447 }
ICCompressGetSize(HIC hic,LPVOID lpbiInput,LPVOID lpbiOutput)448 DWORD ICCompressGetSize(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
449 return cast(DWORD)ICSendMessage(hic, ICM_COMPRESS_GET_SIZE, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
450 }
ICCompressEnd(HIC hic)451 LRESULT ICCompressEnd(HIC hic) {
452 return ICSendMessage(hic, ICM_COMPRESS_END, 0, 0);
453 }
454
455 extern (Windows) {
456 DWORD ICDecompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits);
457 }
458
ICDecompressBegin(HIC hic,LPVOID lpbiInput,LPVOID lpbiOutput)459 LRESULT ICDecompressBegin(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
460 return ICSendMessage(hic, ICM_DECOMPRESS_BEGIN, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
461 }
ICDecompressQuery(HIC hic,LPVOID lpbiInput,LPVOID lpbiOutput)462 LRESULT ICDecompressQuery(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
463 return ICSendMessage(hic, ICM_DECOMPRESS_QUERY, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
464 }
ICDecompressGetFormat(HIC hic,LPVOID lpbiInput,LPVOID lpbiOutput)465 LONG ICDecompressGetFormat(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
466 return cast(LONG)ICSendMessage(hic, ICM_DECOMPRESS_GET_FORMAT, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
467 }
ICDecompressGetFormatSize(HIC hic,LPVOID lpbi)468 LONG ICDecompressGetFormatSize(HIC hic, LPVOID lpbi) {
469 return ICDecompressGetFormat(hic, lpbi, null);
470 }
ICDecompressGetPalette(HIC hic,LPVOID lpbiInput,LPVOID lpbiOutput)471 LRESULT ICDecompressGetPalette(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) {
472 return ICSendMessage(hic, ICM_DECOMPRESS_GET_PALETTE, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput);
473 }
ICDecompressSetPalette(HIC hic,LPVOID lpbiPalette)474 LRESULT ICDecompressSetPalette(HIC hic, LPVOID lpbiPalette) {
475 return ICSendMessage(hic, ICM_DECOMPRESS_SET_PALETTE, cast(DWORD_PTR)lpbiPalette, 0);
476 }
ICDecompressEnd(HIC hic)477 LRESULT ICDecompressEnd(HIC hic) {
478 return ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0);
479 }
480
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)481 LRESULT ICDecompressEx(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc,
482 LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst,
483 LPVOID lpDst, int xDst, int yDst, int dxDst, int dyDst) {
484 ICDECOMPRESSEX ic;
485
486 ic.dwFlags = dwFlags;
487 ic.lpbiSrc = lpbiSrc;
488 ic.lpSrc = lpSrc;
489 ic.xSrc = xSrc;
490 ic.ySrc = ySrc;
491 ic.dxSrc = dxSrc;
492 ic.dySrc = dySrc;
493 ic.lpbiDst = lpbiDst;
494 ic.lpDst = lpDst;
495 ic.xDst = xDst;
496 ic.yDst = yDst;
497 ic.dxDst = dxDst;
498 ic.dyDst = dyDst;
499
500 return ICSendMessage(hic, ICM_DECOMPRESSEX, cast(DWORD_PTR)&ic, ic.sizeof);
501 }
502
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)503 LRESULT ICDecompressExBegin(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc,
504 LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst,
505 LPVOID lpDst, int xDst, int yDst, int dxDst, int dyDst) {
506 ICDECOMPRESSEX ic;
507
508 ic.dwFlags = dwFlags;
509 ic.lpbiSrc = lpbiSrc;
510 ic.lpSrc = lpSrc;
511 ic.xSrc = xSrc;
512 ic.ySrc = ySrc;
513 ic.dxSrc = dxSrc;
514 ic.dySrc = dySrc;
515 ic.lpbiDst = lpbiDst;
516 ic.lpDst = lpDst;
517 ic.xDst = xDst;
518 ic.yDst = yDst;
519 ic.dxDst = dxDst;
520 ic.dyDst = dyDst;
521
522 return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, cast(DWORD_PTR)&ic, ic.sizeof);
523 }
524
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)525 LRESULT ICDecompressExQuery(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc,
526 LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst,
527 LPVOID lpDst, int xDst, int yDst, int dxDst, int dyDst) {
528 ICDECOMPRESSEX ic;
529
530 ic.dwFlags = dwFlags;
531 ic.lpbiSrc = lpbiSrc;
532 ic.lpSrc = lpSrc;
533 ic.xSrc = xSrc;
534 ic.ySrc = ySrc;
535 ic.dxSrc = dxSrc;
536 ic.dySrc = dySrc;
537 ic.lpbiDst = lpbiDst;
538 ic.lpDst = lpDst;
539 ic.xDst = xDst;
540 ic.yDst = yDst;
541 ic.dxDst = dxDst;
542 ic.dyDst = dyDst;
543
544 return ICSendMessage(hic, ICM_DECOMPRESSEX_QUERY, cast(DWORD_PTR)&ic, ic.sizeof);
545 }
546
ICDecompressExEnd(HIC hic)547 LRESULT ICDecompressExEnd(HIC hic) {
548 return ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0);
549 }
550
551 extern (Windows) {
552 DWORD ICDrawBegin(HIC hic, DWORD dwFlags, HPALETTE hpal, HWND hwnd, HDC hdc,
553 int xDst, int yDst, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi,
554 int xSrc, int ySrc, int dxSrc, int dySrc, DWORD dwRate, DWORD dwScale);
555 }
556
557 extern (Windows) {
558 DWORD ICDraw(HIC hic, DWORD dwFlags, LPVOID lpFormat, LPVOID lpData, DWORD cbData, LONG lTime);
559 }
560
ICDrawSuggestFormat(HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,int dxSrc,int dySrc,int dxDst,int dyDst,HIC hicDecomp)561 LRESULT ICDrawSuggestFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut,
562 int dxSrc, int dySrc, int dxDst, int dyDst, HIC hicDecomp) {
563 ICDRAWSUGGEST ic;
564
565 ic.lpbiIn = lpbiIn;
566 ic.lpbiSuggest = lpbiOut;
567 ic.dxSrc = dxSrc;
568 ic.dySrc = dySrc;
569 ic.dxDst = dxDst;
570 ic.dyDst = dyDst;
571 ic.hicDecompressor = hicDecomp;
572
573 return ICSendMessage(hic, ICM_DRAW_SUGGESTFORMAT, cast(DWORD_PTR)&ic, ic.sizeof);
574 }
575
ICDrawQuery(HIC hic,LPVOID lpbiInput)576 LRESULT ICDrawQuery(HIC hic, LPVOID lpbiInput) {
577 return ICSendMessage(hic, ICM_DRAW_QUERY, cast(DWORD_PTR)lpbiInput, 0L);
578 }
ICDrawChangePalette(HIC hic,LPVOID lpbiInput)579 LRESULT ICDrawChangePalette(HIC hic, LPVOID lpbiInput) {
580 return ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, cast(DWORD_PTR)lpbiInput, 0L);
581 }
ICGetBuffersWanted(HIC hic,LPVOID lpdwBuffers)582 LRESULT ICGetBuffersWanted(HIC hic, LPVOID lpdwBuffers) {
583 return ICSendMessage(hic, ICM_GETBUFFERSWANTED, cast(DWORD_PTR)lpdwBuffers, 0);
584 }
ICDrawEnd(HIC hic)585 LRESULT ICDrawEnd(HIC hic) {
586 return ICSendMessage(hic, ICM_DRAW_END, 0, 0);
587 }
ICDrawStart(HIC hic)588 LRESULT ICDrawStart(HIC hic) {
589 return ICSendMessage(hic, ICM_DRAW_START, 0, 0);
590 }
ICDrawStartPlay(HIC hic,DWORD lFrom,DWORD lTo)591 LRESULT ICDrawStartPlay(HIC hic, DWORD lFrom, DWORD lTo) {
592 return ICSendMessage(hic, ICM_DRAW_START_PLAY, cast(DWORD_PTR)lFrom, cast(DWORD_PTR)lTo);
593 }
ICDrawStop(HIC hic)594 LRESULT ICDrawStop(HIC hic) {
595 return ICSendMessage(hic, ICM_DRAW_STOP, 0, 0);
596 }
ICDrawStopPlay(HIC hic)597 LRESULT ICDrawStopPlay(HIC hic) {
598 return ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0);
599 }
ICDrawGetTime(HIC hic,LPVOID lplTime)600 LRESULT ICDrawGetTime(HIC hic, LPVOID lplTime) {
601 return ICSendMessage(hic, ICM_DRAW_GETTIME, cast(DWORD_PTR)lplTime, 0);
602 }
ICDrawSetTime(HIC hic,DWORD lTime)603 LRESULT ICDrawSetTime(HIC hic, DWORD lTime) {
604 return ICSendMessage(hic, ICM_DRAW_SETTIME, cast(DWORD_PTR)lTime, 0);
605 }
ICDrawRealize(HIC hic,HDC hdc,BOOL fBackground)606 LRESULT ICDrawRealize(HIC hic, HDC hdc, BOOL fBackground) {
607 return ICSendMessage(hic, ICM_DRAW_REALIZE, cast(DWORD_PTR)hdc, cast(DWORD_PTR)fBackground);
608 }
ICDrawFlush(HIC hic)609 LRESULT ICDrawFlush(HIC hic) {
610 return ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0);
611 }
ICDrawRenderBuffer(HIC hic)612 LRESULT ICDrawRenderBuffer(HIC hic) {
613 return ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0);
614 }
615
616 extern (Windows)
ICSetStatusProc(HIC hic,DWORD dwFlags,LRESULT lParam,LONG function (LPARAM,UINT,LONG)fpfnStatus)617 LRESULT ICSetStatusProc(HIC hic, DWORD dwFlags, LRESULT lParam, LONG function(LPARAM, UINT, LONG) fpfnStatus) {
618 ICSETSTATUSPROC ic;
619
620 ic.dwFlags = dwFlags;
621 ic.lParam = lParam;
622 ic.Status = fpfnStatus;
623
624 return ICSendMessage(hic, ICM_SET_STATUS_PROC, cast(DWORD_PTR)&ic, ic.sizeof);
625 }
626
ICDecompressOpen(DWORD fccType,DWORD fccHandler,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut)627 HIC ICDecompressOpen(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
628 return ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS);
629 }
630
ICDrawOpen(DWORD fccType,DWORD fccHandler,LPBITMAPINFOHEADER lpbiIn)631 HIC ICDrawOpen(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn) {
632 return ICLocate(fccType, fccHandler, lpbiIn, null, ICMODE_DRAW);
633 }
634
635 extern (Windows) {
636 HIC ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
637 HIC ICGetDisplayFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, int BitDepth, int dx, int dy);
638 HANDLE ICImageCompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn, LPVOID lpBits, LPBITMAPINFO lpbiOut, LONG lQuality, LONG* plSize);
639 HANDLE ICImageDecompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn, LPVOID lpBits, LPBITMAPINFO lpbiOut);
640 }
641
642 struct COMPVARS {
643 LONG cbSize = this.sizeof;
644 DWORD dwFlags;
645 HIC hic;
646 DWORD fccType;
647 DWORD fccHandler;
648 LPBITMAPINFO lpbiIn;
649 LPBITMAPINFO lpbiOut;
650 LPVOID lpBitsOut;
651 LPVOID lpBitsPrev;
652 LONG lFrame;
653 LONG lKey;
654 LONG lDataRate;
655 LONG lQ;
656 LONG lKeyCount;
657 LPVOID lpState;
658 LONG cbState;
659 }
660 alias COMPVARS* PCOMPVARS;
661
662 enum ICMF_COMPVARS_VALID = 0x00000001;
663
664 extern (Windows) {
665 BOOL ICCompressorChoose(HWND hwnd, UINT uiFlags, LPVOID pvIn, LPVOID lpData, PCOMPVARS pc, LPSTR lpszTitle);
666 }
667
668 enum {
669 ICMF_CHOOSE_KEYFRAME = 0x0001,
670 ICMF_CHOOSE_DATARATE = 0x0002,
671 ICMF_CHOOSE_PREVIEW = 0x0004,
672 ICMF_CHOOSE_ALLCOMPRESSORS = 0x0008,
673 }
674
675 extern (Windows) {
676 BOOL ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn);
677 void ICSeqCompressFrameEnd(PCOMPVARS pc);
678 LPVOID ICSeqCompressFrame(PCOMPVARS pc, UINT uiFlags, LPVOID lpBits, BOOL* pfKey, LONG* plSize);
679 void ICCompressorFree(PCOMPVARS pc);
680 }
681
682 mixin DECLARE_HANDLE!("HDRAWDIB");
683
684 enum {
685 DDF_0001 = 0x0001,
686 DDF_UPDATE = 0x0002,
687 DDF_SAME_HDC = 0x0004,
688 DDF_SAME_DRAW = 0x0008,
689 DDF_DONTDRAW = 0x0010,
690 DDF_ANIMATE = 0x0020,
691 DDF_BUFFER = 0x0040,
692 DDF_JUSTDRAWIT = 0x0080,
693 DDF_FULLSCREEN = 0x0100,
694 DDF_BACKGROUNDPAL = 0x0200,
695 DDF_NOTKEYFRAME = 0x0400,
696 DDF_HURRYUP = 0x0800,
697 DDF_HALFTONE = 0x1000,
698 DDF_2000 = 0x2000,
699 DDF_PREROLL = DDF_DONTDRAW,
700 DDF_SAME_DIB = DDF_SAME_DRAW,
701 DDF_SAME_SIZE = DDF_SAME_DRAW,
702 }
703
704 extern (Windows) {
705 BOOL DrawDibInit();
706 HDRAWDIB DrawDibOpen();
707 BOOL DrawDibClose(HDRAWDIB hdd);
708 LPVOID DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags);
709 UINT DrawDibError(HDRAWDIB hdd);
710 HPALETTE DrawDibGetPalette(HDRAWDIB hdd);
711 BOOL DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal);
712 BOOL DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe);
713 UINT DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground);
714 BOOL DrawDibStart(HDRAWDIB hdd, DWORD rate);
715 BOOL DrawDibStop(HDRAWDIB hdd);
716 BOOL DrawDibBegin(HDRAWDIB hdd, HDC hdc, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi, int dxSrc, int dySrc, UINT wFlags);
717 BOOL DrawDibDraw(HDRAWDIB hdd, HDC hdc, int xDst, int yDst, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi,
718 LPVOID lpBits, int xSrc, int ySrc, int dxSrc, int dySrc, UINT wFlags);
719 }
720
DrawDibUpdate(HDRAWDIB hdd,HDC hdc,int x,int y)721 BOOL DrawDibUpdate(HDRAWDIB hdd, HDC hdc, int x, int y) {
722 return DrawDibDraw(hdd, hdc, x, y, 0, 0, null, null, 0, 0, 0, 0, DDF_UPDATE);
723 }
724
725 extern (Windows) {
726 BOOL DrawDibEnd(HDRAWDIB hdd);
727 }
728
729 struct DRAWDIBTIME {
730 LONG timeCount;
731 LONG timeDraw;
732 LONG timeDecompress;
733 LONG timeDither;
734 LONG timeStretch;
735 LONG timeBlt;
736 LONG timeSetDIBits;
737 }
738 alias DRAWDIBTIME* LPDRAWDIBTIME;
739
740 extern (Windows) {
741 BOOL DrawDibTime(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime);
742 }
743
744 enum {
745 PD_CAN_DRAW_DIB = 0x0001,
746 PD_CAN_STRETCHDIB = 0x0002,
747 PD_STRETCHDIB_1_1_OK = 0x0004,
748 PD_STRETCHDIB_1_2_OK = 0x0008,
749 PD_STRETCHDIB_1_N_OK = 0x0010,
750 }
751
752 extern (Windows) {
753 LRESULT DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi);
754 void StretchDIB(LPBITMAPINFOHEADER biDst, LPVOID lpDst, int DstX, int DstY,
755 int DstXE, int DstYE, LPBITMAPINFOHEADER biSrc, LPVOID lpSrc,
756 int SrcX, int SrcY, int SrcXE, int SrcYE);
757 }
758
759 alias DWORD FOURCC;
760
761 alias WORD TWOCC;
762
763 enum formtypeAVI = mmioFOURCC!('A', 'V', 'I', ' ');
764 enum listtypeAVIHEADER = mmioFOURCC!('h', 'd', 'r', 'l');
765 enum ckidAVIMAINHDR = mmioFOURCC!('a', 'v', 'i', 'h');
766 enum listtypeSTREAMHEADER = mmioFOURCC!('s', 't', 'r', 'l');
767 enum ckidSTREAMHEADER = mmioFOURCC!('s', 't', 'r', 'h');
768 enum ckidSTREAMFORMAT = mmioFOURCC!('s', 't', 'r', 'f');
769 enum ckidSTREAMHANDLERDATA = mmioFOURCC!('s', 't', 'r', 'd');
770 enum ckidSTREAMNAME = mmioFOURCC!('s', 't', 'r', 'n');
771 enum listtypeAVIMOVIE = mmioFOURCC!('m', 'o', 'v', 'i');
772 enum listtypeAVIRECORD = mmioFOURCC!('r', 'e', 'c', ' ');
773 enum ckidAVINEWINDEX = mmioFOURCC!('i', 'd', 'x', '1');
774 enum streamtypeVIDEO = mmioFOURCC!('v', 'i', 'd', 's');
775 enum streamtypeAUDIO = mmioFOURCC!('a', 'u', 'd', 's');
776 enum streamtypeMIDI = mmioFOURCC!('m', 'i', 'd', 's');
777 enum streamtypeTEXT = mmioFOURCC!('t', 'x', 't', 's');
778
779 enum cktypeDIBbits = aviTWOCC!('d', 'b');
780 enum cktypeDIBcompressed = aviTWOCC!('d', 'c');
781 enum cktypePALchange = aviTWOCC!('p', 'c');
782 enum cktypeWAVEbytes = aviTWOCC!('w', 'b');
783
784 enum ckidAVIPADDING = mmioFOURCC!('J', 'U', 'N', 'K');
785
FromHex(char n)786 DWORD FromHex(char n) {
787 return (n >= 'A') ? n + 10 - 'A' : n - '0';
788 }
789
StreamFromFOURCC(DWORD fcc)790 WORD StreamFromFOURCC(DWORD fcc) {
791 return cast(WORD)((FromHex(LOBYTE(LOWORD(fcc))) << 4) + (FromHex(HIBYTE(LOWORD(fcc)))));
792 }
793
TWOCCFromFOURCC(DWORD fcc)794 WORD TWOCCFromFOURCC(DWORD fcc) {
795 return HIWORD(fcc);
796 }
797
ToHex(DWORD n)798 BYTE ToHex(DWORD n) {
799 return cast(BYTE)((n > 9) ? n - 10 + 'A' : n + '0');
800 }
801
MAKEAVICKID(WORD tcc,WORD stream)802 DWORD MAKEAVICKID(WORD tcc, WORD stream) {
803 return MAKELONG(cast(WORD)((ToHex(stream & 0x0f) << 8) | (ToHex((stream & 0xf0) >> 4))), tcc);
804 }
805
806 enum {
807 AVIF_HASINDEX = 0x00000010,
808 AVIF_MUSTUSEINDEX = 0x00000020,
809 AVIF_ISINTERLEAVED = 0x00000100,
810 AVIF_WASCAPTUREFILE = 0x00010000,
811 AVIF_COPYRIGHTED = 0x00020000,
812 }
813
814 enum AVI_HEADERSIZE = 2048;
815
816 struct MainAVIHeader {
817 DWORD dwMicroSecPerFrame;
818 DWORD dwMaxBytesPerSec;
819 DWORD dwPaddingGranularity;
820 DWORD dwFlags;
821 DWORD dwTotalFrames;
822 DWORD dwInitialFrames;
823 DWORD dwStreams;
824 DWORD dwSuggestedBufferSize;
825 DWORD dwWidth;
826 DWORD dwHeight;
827 DWORD[4] dwReserved;
828 }
829
830 enum AVISF_DISABLED = 0x00000001;
831
832 enum AVISF_VIDEO_PALCHANGES = 0x00010000;
833
834 struct AVIStreamHeader {
835 FOURCC fccType;
836 FOURCC fccHandler;
837 DWORD dwFlags;
838 WORD wPriority;
839 WORD wLanguage;
840 DWORD dwInitialFrames;
841 DWORD dwScale;
842 DWORD dwRate;
843 DWORD dwStart;
844 DWORD dwLength;
845 DWORD dwSuggestedBufferSize;
846 DWORD dwQuality;
847 DWORD dwSampleSize;
848 RECT rcFrame;
849 }
850
851 enum {
852 AVIIF_FIRSTPART = 0x00000020L,
853 AVIIF_LASTPART = 0x00000040L,
854 AVIIF_MIDPART = (AVIIF_LASTPART|AVIIF_FIRSTPART),
855 AVIIF_NOTIME = 0x00000100L,
856 AVIIF_COMPUSE = 0x0FFF0000L,
857 }
858
859 struct AVIINDEXENTRY {
860 DWORD ckid;
861 DWORD dwFlags;
862 DWORD dwChunkOffset;
863 DWORD dwChunkLength;
864 }
865
866 struct AVIPALCHANGE {
867 BYTE bFirstEntry;
868 BYTE bNumEntries;
869 WORD wFlags;
870 PALETTEENTRY[1] _peNew;
871 PALETTEENTRY* peNew() return { return _peNew.ptr; }
872 }
873
874 enum AVIGETFRAMEF_BESTDISPLAYFMT = 1;
875
876 struct AVISTREAMINFOW {
877 DWORD fccType;
878 DWORD fccHandler;
879 DWORD dwFlags;
880 DWORD dwCaps;
881 WORD wPriority;
882 WORD wLanguage;
883 DWORD dwScale;
884 DWORD dwRate;
885 DWORD dwStart;
886 DWORD dwLength;
887 DWORD dwInitialFrames;
888 DWORD dwSuggestedBufferSize;
889 DWORD dwQuality;
890 DWORD dwSampleSize;
891 RECT rcFrame;
892 DWORD dwEditCount;
893 DWORD dwFormatChangeCount;
894 WCHAR[64] szName = 0;
895 }
896 alias AVISTREAMINFOW* LPAVISTREAMINFOW;
897
898 struct AVISTREAMINFOA {
899 DWORD fccType;
900 DWORD fccHandler;
901 DWORD dwFlags;
902 DWORD dwCaps;
903 WORD wPriority;
904 WORD wLanguage;
905 DWORD dwScale;
906 DWORD dwRate;
907 DWORD dwStart;
908 DWORD dwLength;
909 DWORD dwInitialFrames;
910 DWORD dwSuggestedBufferSize;
911 DWORD dwQuality;
912 DWORD dwSampleSize;
913 RECT rcFrame;
914 DWORD dwEditCount;
915 DWORD dwFormatChangeCount;
916 char[64] szName = 0;
917 }
918 alias AVISTREAMINFOA* LPAVISTREAMINFOA;
919
920 version (Unicode) {
921 alias AVISTREAMINFOW AVISTREAMINFO;
922 alias LPAVISTREAMINFOW LPAVISTREAMINFO;
923 } else { // Unicode
924 alias AVISTREAMINFOA AVISTREAMINFO;
925 alias LPAVISTREAMINFOA LPAVISTREAMINFO;
926 }
927
928 enum AVISTREAMINFO_DISABLED = 0x00000001;
929 enum AVISTREAMINFO_FORMATCHANGES = 0x00010000;
930
931 struct AVIFILEINFOW {
932 DWORD dwMaxBytesPerSec;
933 DWORD dwFlags;
934 DWORD dwCaps;
935 DWORD dwStreams;
936 DWORD dwSuggestedBufferSize;
937 DWORD dwWidth;
938 DWORD dwHeight;
939 DWORD dwScale;
940 DWORD dwRate;
941 DWORD dwLength;
942 DWORD dwEditCount;
943 WCHAR[64] szFileType = 0;
944 }
945 alias AVIFILEINFOW* LPAVIFILEINFOW;
946
947 struct AVIFILEINFOA {
948 DWORD dwMaxBytesPerSec;
949 DWORD dwFlags;
950 DWORD dwCaps;
951 DWORD dwStreams;
952 DWORD dwSuggestedBufferSize;
953 DWORD dwWidth;
954 DWORD dwHeight;
955 DWORD dwScale;
956 DWORD dwRate;
957 DWORD dwLength;
958 DWORD dwEditCount;
959 char[64] szFileType = 0;
960 }
961 alias AVIFILEINFOA* LPAVIFILEINFOA;
962
963 version (Unicode) {
964 alias AVIFILEINFOW AVIFILEINFO;
965 alias LPAVIFILEINFOW LPAVIFILEINFO;
966 } else { // Unicode
967 alias AVIFILEINFOA AVIFILEINFO;
968 alias LPAVIFILEINFOA LPAVIFILEINFO;
969 }
970
971 enum {
972 AVIFILEINFO_HASINDEX = 0x00000010,
973 AVIFILEINFO_MUSTUSEINDEX = 0x00000020,
974 AVIFILEINFO_ISINTERLEAVED = 0x00000100,
975 AVIFILEINFO_WASCAPTUREFILE = 0x00010000,
976 AVIFILEINFO_COPYRIGHTED = 0x00020000,
977 }
978
979 enum {
980 AVIFILECAPS_CANREAD = 0x00000001,
981 AVIFILECAPS_CANWRITE = 0x00000002,
982 AVIFILECAPS_ALLKEYFRAMES = 0x00000010,
983 AVIFILECAPS_NOCOMPRESSION = 0x00000020,
984 }
985
986 extern (Windows) {
987 alias BOOL function(int) AVISAVECALLBACK;
988 }
989
990 struct AVICOMPRESSOPTIONS {
991 DWORD fccType;
992 DWORD fccHandler;
993 DWORD dwKeyFrameEvery;
994 DWORD dwQuality;
995 DWORD dwBytesPerSecond;
996 DWORD dwFlags;
997 LPVOID lpFormat;
998 DWORD cbFormat;
999 LPVOID lpParms;
1000 DWORD cbParms;
1001 DWORD dwInterleaveEvery;
1002 }
1003 alias AVICOMPRESSOPTIONS* LPAVICOMPRESSOPTIONS;
1004
1005 enum {
1006 AVICOMPRESSF_INTERLEAVE = 0x00000001,
1007 AVICOMPRESSF_DATARATE = 0x00000002,
1008 AVICOMPRESSF_KEYFRAMES = 0x00000004,
1009 AVICOMPRESSF_VALID = 0x00000008,
1010 }
1011
1012 /+ TODO:
1013 DECLARE_INTERFACE_(IAVIStream, IUnknown)
1014 {
1015 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
1016 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1017 STDMETHOD_(ULONG,Release) (THIS) PURE;
1018
1019 STDMETHOD(Create) (THIS_ LPARAM lParam1, LPARAM lParam2) PURE ;
1020 STDMETHOD(Info) (THIS_ AVISTREAMINFOW FAR * psi, LONG lSize) PURE ;
1021 STDMETHOD_(LONG, FindSample)(THIS_ LONG lPos, LONG lFlags) PURE ;
1022 STDMETHOD(ReadFormat) (THIS_ LONG lPos,
1023 LPVOID lpFormat, LONG FAR *lpcbFormat) PURE ;
1024 STDMETHOD(SetFormat) (THIS_ LONG lPos,
1025 LPVOID lpFormat, LONG cbFormat) PURE ;
1026 STDMETHOD(Read) (THIS_ LONG lStart, LONG lSamples,
1027 LPVOID lpBuffer, LONG cbBuffer,
1028 LONG FAR * plBytes, LONG FAR * plSamples) PURE ;
1029 STDMETHOD(Write) (THIS_ LONG lStart, LONG lSamples,
1030 LPVOID lpBuffer, LONG cbBuffer,
1031 DWORD dwFlags,
1032 LONG FAR *plSampWritten,
1033 LONG FAR *plBytesWritten) PURE ;
1034 STDMETHOD(Delete) (THIS_ LONG lStart, LONG lSamples) PURE;
1035 STDMETHOD(ReadData) (THIS_ DWORD fcc, LPVOID lp, LONG FAR *lpcb) PURE ;
1036 STDMETHOD(WriteData) (THIS_ DWORD fcc, LPVOID lp, LONG cb) PURE ;
1037 #ifdef _WIN32
1038 STDMETHOD(SetInfo) (THIS_ AVISTREAMINFOW FAR * lpInfo,
1039 LONG cbInfo) PURE;
1040 #else
1041 STDMETHOD(Reserved1) (THIS) PURE;
1042 STDMETHOD(Reserved2) (THIS) PURE;
1043 STDMETHOD(Reserved3) (THIS) PURE;
1044 STDMETHOD(Reserved4) (THIS) PURE;
1045 STDMETHOD(Reserved5) (THIS) PURE;
1046 #endif
1047 };
1048
1049 alias TypeDef!(IAVIStream FAR*) PAVISTREAM;
1050
1051 #undef INTERFACE
1052 #define INTERFACE IAVIStreaming
1053
1054 DECLARE_INTERFACE_(IAVIStreaming, IUnknown)
1055 {
1056 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
1057 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1058 STDMETHOD_(ULONG,Release) (THIS) PURE;
1059
1060 STDMETHOD(Begin) (THIS_
1061 LONG lStart,
1062 LONG lEnd,
1063 LONG lRate) PURE;
1064 STDMETHOD(End) (THIS) PURE;
1065 };
1066
1067 alias TypeDef!(IAVIStreaming FAR*) PAVISTREAMING;
1068
1069
1070 #undef INTERFACE
1071 #define INTERFACE IAVIEditStream
1072
1073 DECLARE_INTERFACE_(IAVIEditStream, IUnknown)
1074 {
1075 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
1076 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1077 STDMETHOD_(ULONG,Release) (THIS) PURE;
1078
1079 STDMETHOD(Cut) (THIS_ LONG FAR *plStart,
1080 LONG FAR *plLength,
1081 PAVISTREAM FAR * ppResult) PURE;
1082 STDMETHOD(Copy) (THIS_ LONG FAR *plStart,
1083 LONG FAR *plLength,
1084 PAVISTREAM FAR * ppResult) PURE;
1085 STDMETHOD(Paste) (THIS_ LONG FAR *plPos,
1086 LONG FAR *plLength,
1087 PAVISTREAM pstream,
1088 LONG lStart,
1089 LONG lEnd) PURE;
1090 STDMETHOD(Clone) (THIS_ PAVISTREAM FAR *ppResult) PURE;
1091 STDMETHOD(SetInfo) (THIS_ AVISTREAMINFOW FAR * lpInfo,
1092 LONG cbInfo) PURE;
1093 };
1094
1095 alias TypeDef!(IAVIEditStream FAR*) PAVIEDITSTREAM;
1096
1097 #undef INTERFACE
1098 #define INTERFACE IAVIPersistFile
1099
1100 DECLARE_INTERFACE_(IAVIPersistFile, IPersistFile)
1101 {
1102 STDMETHOD(Reserved1)(THIS) PURE;
1103 };
1104
1105 alias TypeDef!(IAVIPersistFile FAR*) PAVIPERSISTFILE;
1106
1107 #undef INTERFACE
1108 #define INTERFACE IAVIFile
1109 #define PAVIFILE IAVIFile FAR*
1110
1111 DECLARE_INTERFACE_(IAVIFile, IUnknown)
1112 {
1113 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
1114 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1115 STDMETHOD_(ULONG,Release) (THIS) PURE;
1116
1117 STDMETHOD(Info) (THIS_
1118 AVIFILEINFOW FAR * pfi,
1119 LONG lSize) PURE;
1120 STDMETHOD(GetStream) (THIS_
1121 PAVISTREAM FAR * ppStream,
1122 DWORD fccType,
1123 LONG lParam) PURE;
1124 STDMETHOD(CreateStream) (THIS_
1125 PAVISTREAM FAR * ppStream,
1126 AVISTREAMINFOW FAR * psi) PURE;
1127 STDMETHOD(WriteData) (THIS_
1128 DWORD ckid,
1129 LPVOID lpData,
1130 LONG cbData) PURE;
1131 STDMETHOD(ReadData) (THIS_
1132 DWORD ckid,
1133 LPVOID lpData,
1134 LONG FAR *lpcbData) PURE;
1135 STDMETHOD(EndRecord) (THIS) PURE;
1136 STDMETHOD(DeleteStream) (THIS_
1137 DWORD fccType,
1138 LONG lParam) PURE;
1139 };
1140
1141 #undef PAVIFILE
1142 alias TypeDef!(IAVIFile FAR*) PAVIFILE;
1143
1144 #undef INTERFACE
1145 #define INTERFACE IGetFrame
1146 #define PGETFRAME IGetFrame FAR*
1147
1148 DECLARE_INTERFACE_(IGetFrame, IUnknown)
1149 {
1150 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;
1151 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1152 STDMETHOD_(ULONG,Release) (THIS) PURE;
1153
1154 STDMETHOD_(LPVOID,GetFrame) (THIS_ LONG lPos) PURE;
1155
1156 STDMETHOD(Begin) (THIS_ LONG lStart, LONG lEnd, LONG lRate) PURE;
1157 STDMETHOD(End) (THIS) PURE;
1158
1159 STDMETHOD(SetFormat) (THIS_ LPBITMAPINFOHEADER lpbi, LPVOID lpBits, int x, int y, int dx, int dy) PURE;
1160 };
1161
1162 #undef PGETFRAME
1163 alias TypeDef!(IGetFrame FAR*) PGETFRAME;
1164
1165 #define DEFINE_AVIGUID(name, l, w1, w2) DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)
1166
1167 DEFINE_AVIGUID(IID_IAVIFile, 0x00020020, 0, 0);
1168 DEFINE_AVIGUID(IID_IAVIStream, 0x00020021, 0, 0);
1169 DEFINE_AVIGUID(IID_IAVIStreaming, 0x00020022, 0, 0);
1170 DEFINE_AVIGUID(IID_IGetFrame, 0x00020023, 0, 0);
1171 DEFINE_AVIGUID(IID_IAVIEditStream, 0x00020024, 0, 0);
1172 DEFINE_AVIGUID(IID_IAVIPersistFile, 0x00020025, 0, 0);
1173 #ifndef UNICODE
1174 DEFINE_AVIGUID(CLSID_AVISimpleUnMarshal, 0x00020009, 0, 0);
1175 #endif
1176
1177 DEFINE_AVIGUID(CLSID_AVIFile, 0x00020000, 0, 0);
1178
1179 #define AVIFILEHANDLER_CANREAD 0x0001
1180 #define AVIFILEHANDLER_CANWRITE 0x0002
1181 #define AVIFILEHANDLER_CANACCEPTNONRGB 0x0004
1182
1183 STDAPI_(void) AVIFileInit(void);
1184 STDAPI_(void) AVIFileExit(void);
1185
1186 STDAPI_(ULONG) AVIFileAddRef (PAVIFILE pfile);
1187 STDAPI_(ULONG) AVIFileRelease (PAVIFILE pfile);
1188
1189 #ifdef _WIN32
1190 STDAPI AVIFileOpenA (PAVIFILE FAR * ppfile, LPCSTR szFile,
1191 UINT uMode, LPCLSID lpHandler);
1192 STDAPI AVIFileOpenW (PAVIFILE FAR * ppfile, LPCWSTR szFile,
1193 UINT uMode, LPCLSID lpHandler);
1194 #ifdef UNICODE
1195 #define AVIFileOpen AVIFileOpenW
1196 #else
1197 #define AVIFileOpen AVIFileOpenA
1198 #endif
1199 #else
1200 STDAPI AVIFileOpen (PAVIFILE FAR * ppfile, LPCSTR szFile,
1201 UINT uMode, LPCLSID lpHandler);
1202 #define AVIFileOpenW AVIFileOpen
1203 #endif
1204
1205 #ifdef _WIN32
1206 STDAPI AVIFileInfoW (PAVIFILE pfile, LPAVIFILEINFOW pfi, LONG lSize);
1207 STDAPI AVIFileInfoA (PAVIFILE pfile, LPAVIFILEINFOA pfi, LONG lSize);
1208 #ifdef UNICODE
1209 #define AVIFileInfo AVIFileInfoW
1210 #else
1211 #define AVIFileInfo AVIFileInfoA
1212 #endif
1213 #else
1214 STDAPI AVIFileInfo (PAVIFILE pfile, LPAVIFILEINFO pfi, LONG lSize);
1215 #define AVIFileInfoW AVIFileInfo
1216 #endif
1217
1218
1219 STDAPI AVIFileGetStream (PAVIFILE pfile, PAVISTREAM FAR * ppavi, DWORD fccType, LONG lParam);
1220
1221
1222 #ifdef _WIN32
1223 STDAPI AVIFileCreateStreamW (PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFOW FAR * psi);
1224 STDAPI AVIFileCreateStreamA (PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFOA FAR * psi);
1225 #ifdef UNICODE
1226 #define AVIFileCreateStream AVIFileCreateStreamW
1227 #else
1228 #define AVIFileCreateStream AVIFileCreateStreamA
1229 #endif
1230 #else
1231 STDAPI AVIFileCreateStream(PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFO FAR * psi);
1232 #define AVIFileCreateStreamW AVIFileCreateStream
1233 #endif
1234
1235 STDAPI AVIFileWriteData (PAVIFILE pfile,
1236 DWORD ckid,
1237 LPVOID lpData,
1238 LONG cbData);
1239 STDAPI AVIFileReadData (PAVIFILE pfile,
1240 DWORD ckid,
1241 LPVOID lpData,
1242 LONG FAR *lpcbData);
1243 STDAPI AVIFileEndRecord (PAVIFILE pfile);
1244
1245 STDAPI_(ULONG) AVIStreamAddRef (PAVISTREAM pavi);
1246 STDAPI_(ULONG) AVIStreamRelease (PAVISTREAM pavi);
1247
1248 STDAPI AVIStreamInfoW (PAVISTREAM pavi, LPAVISTREAMINFOW psi, LONG lSize);
1249 STDAPI AVIStreamInfoA (PAVISTREAM pavi, LPAVISTREAMINFOA psi, LONG lSize);
1250 #ifdef UNICODE
1251 #define AVIStreamInfo AVIStreamInfoW
1252 #else
1253 #define AVIStreamInfo AVIStreamInfoA
1254 #endif
1255
1256 STDAPI_(LONG) AVIStreamFindSample(PAVISTREAM pavi, LONG lPos, LONG lFlags);
1257 STDAPI AVIStreamReadFormat (PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG FAR *lpcbFormat);
1258 STDAPI AVIStreamSetFormat (PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG cbFormat);
1259 STDAPI AVIStreamReadData (PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG FAR *lpcb);
1260 STDAPI AVIStreamWriteData (PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG cb);
1261
1262 STDAPI AVIStreamRead (PAVISTREAM pavi,
1263 LONG lStart,
1264 LONG lSamples,
1265 LPVOID lpBuffer,
1266 LONG cbBuffer,
1267 LONG FAR * plBytes,
1268 LONG FAR * plSamples);
1269 #define AVISTREAMREAD_CONVENIENT (-1L)
1270
1271 STDAPI AVIStreamWrite (PAVISTREAM pavi,
1272 LONG lStart, LONG lSamples,
1273 LPVOID lpBuffer, LONG cbBuffer, DWORD dwFlags,
1274 LONG FAR *plSampWritten,
1275 LONG FAR *plBytesWritten);
1276
1277 STDAPI_(LONG) AVIStreamStart (PAVISTREAM pavi);
1278 STDAPI_(LONG) AVIStreamLength (PAVISTREAM pavi);
1279 STDAPI_(LONG) AVIStreamTimeToSample (PAVISTREAM pavi, LONG lTime);
1280 STDAPI_(LONG) AVIStreamSampleToTime (PAVISTREAM pavi, LONG lSample);
1281
1282
1283 STDAPI AVIStreamBeginStreaming(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate);
1284 STDAPI AVIStreamEndStreaming(PAVISTREAM pavi);
1285
1286 STDAPI_(PGETFRAME) AVIStreamGetFrameOpen(PAVISTREAM pavi,
1287 LPBITMAPINFOHEADER lpbiWanted);
1288 STDAPI_(LPVOID) AVIStreamGetFrame(PGETFRAME pg, LONG lPos);
1289 STDAPI AVIStreamGetFrameClose(PGETFRAME pg);
1290
1291 STDAPI AVIStreamOpenFromFileA(PAVISTREAM FAR *ppavi, LPCSTR szFile,
1292 DWORD fccType, LONG lParam,
1293 UINT mode, CLSID FAR *pclsidHandler);
1294 STDAPI AVIStreamOpenFromFileW(PAVISTREAM FAR *ppavi, LPCWSTR szFile,
1295 DWORD fccType, LONG lParam,
1296 UINT mode, CLSID FAR *pclsidHandler);
1297 #ifdef UNICODE
1298 #define AVIStreamOpenFromFile AVIStreamOpenFromFileW
1299 #else
1300 #define AVIStreamOpenFromFile AVIStreamOpenFromFileA
1301 #endif
1302
1303 STDAPI AVIStreamCreate(PAVISTREAM FAR *ppavi, LONG lParam1, LONG lParam2,
1304 CLSID FAR *pclsidHandler);
1305
1306
1307
1308 #define FIND_DIR 0x0000000FL
1309 #define FIND_NEXT 0x00000001L
1310 #define FIND_PREV 0x00000004L
1311 #define FIND_FROM_START 0x00000008L
1312
1313 #define FIND_TYPE 0x000000F0L
1314 #define FIND_KEY 0x00000010L
1315 #define FIND_ANY 0x00000020L
1316 #define FIND_FORMAT 0x00000040L
1317
1318 #define FIND_RET 0x0000F000L
1319 #define FIND_POS 0x00000000L
1320 #define FIND_LENGTH 0x00001000L
1321 #define FIND_OFFSET 0x00002000L
1322 #define FIND_SIZE 0x00003000L
1323 #define FIND_INDEX 0x00004000L
1324
1325 #define AVIStreamFindKeyFrame AVIStreamFindSample
1326 #define FindKeyFrame FindSample
1327
1328 #define AVIStreamClose AVIStreamRelease
1329 #define AVIFileClose AVIFileRelease
1330 #define AVIStreamInit AVIFileInit
1331 #define AVIStreamExit AVIFileExit
1332
1333 #define SEARCH_NEAREST FIND_PREV
1334 #define SEARCH_BACKWARD FIND_PREV
1335 #define SEARCH_FORWARD FIND_NEXT
1336 #define SEARCH_KEY FIND_KEY
1337 #define SEARCH_ANY FIND_ANY
1338
1339 #define AVIStreamSampleToSample(pavi1, pavi2, l) AVIStreamTimeToSample(pavi1,AVIStreamSampleToTime(pavi2, l))
1340
1341 #define AVIStreamNextSample(pavi, l) AVIStreamFindSample(pavi,l+1,FIND_NEXT|FIND_ANY)
1342
1343 #define AVIStreamPrevSample(pavi, l) AVIStreamFindSample(pavi,l-1,FIND_PREV|FIND_ANY)
1344
1345 #define AVIStreamNearestSample(pavi, l) AVIStreamFindSample(pavi,l,FIND_PREV|FIND_ANY)
1346
1347 #define AVIStreamNextKeyFrame(pavi,l) AVIStreamFindSample(pavi,l+1,FIND_NEXT|FIND_KEY)
1348
1349 #define AVIStreamPrevKeyFrame(pavi, l) AVIStreamFindSample(pavi,l-1,FIND_PREV|FIND_KEY)
1350
1351 #define AVIStreamNearestKeyFrame(pavi, l) AVIStreamFindSample(pavi,l,FIND_PREV|FIND_KEY)
1352
1353 #define AVIStreamIsKeyFrame(pavi, l) (AVIStreamNearestKeyFrame(pavi,l) == l)
1354
1355 #define AVIStreamPrevSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamPrevSample(pavi,AVIStreamTimeToSample(pavi,t)))
1356
1357 #define AVIStreamNextSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNextSample(pavi,AVIStreamTimeToSample(pavi,t)))
1358
1359 #define AVIStreamNearestSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNearestSample(pavi,AVIStreamTimeToSample(pavi,t)))
1360
1361 #define AVIStreamNextKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNextKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)))
1362
1363 #define AVIStreamPrevKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamPrevKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)))
1364
1365 #define AVIStreamNearestKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNearestKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)))
1366
1367 #define AVIStreamStartTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamStart(pavi))
1368
1369 #define AVIStreamLengthTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamLength(pavi))
1370
1371 #define AVIStreamEnd(pavi) (AVIStreamStart(pavi) + AVIStreamLength(pavi))
1372
1373 #define AVIStreamEndTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamEnd(pavi))
1374
1375 #define AVIStreamSampleSize(pavi, lPos, plSize) AVIStreamRead(pavi,lPos,1,NULL,0,plSize,NULL)
1376
1377 #define AVIStreamFormatSize(pavi, lPos, plSize) AVIStreamReadFormat(pavi,lPos,NULL,plSize)
1378
1379 #define AVIStreamDataSize(pavi, fcc, plSize) AVIStreamReadData(pavi,fcc,NULL,plSize)
1380
1381 #ifndef comptypeDIB
1382 #define comptypeDIB mmioFOURCC('D', 'I', 'B', ' ')
1383 #endif
1384
1385 STDAPI AVIMakeCompressedStream(
1386 PAVISTREAM FAR * ppsCompressed,
1387 PAVISTREAM ppsSource,
1388 AVICOMPRESSOPTIONS FAR * lpOptions,
1389 CLSID FAR *pclsidHandler);
1390
1391 EXTERN_C HRESULT CDECL AVISaveA (LPCSTR szFile,
1392 CLSID FAR *pclsidHandler,
1393 AVISAVECALLBACK lpfnCallback,
1394 int nStreams,
1395 PAVISTREAM pfile,
1396 LPAVICOMPRESSOPTIONS lpOptions,
1397 ...);
1398
1399 STDAPI AVISaveVA(LPCSTR szFile,
1400 CLSID FAR *pclsidHandler,
1401 AVISAVECALLBACK lpfnCallback,
1402 int nStreams,
1403 PAVISTREAM FAR * ppavi,
1404 LPAVICOMPRESSOPTIONS FAR *plpOptions);
1405 EXTERN_C HRESULT CDECL AVISaveW (LPCWSTR szFile,
1406 CLSID FAR *pclsidHandler,
1407 AVISAVECALLBACK lpfnCallback,
1408 int nStreams,
1409 PAVISTREAM pfile,
1410 LPAVICOMPRESSOPTIONS lpOptions,
1411 ...);
1412
1413 STDAPI AVISaveVW(LPCWSTR szFile,
1414 CLSID FAR *pclsidHandler,
1415 AVISAVECALLBACK lpfnCallback,
1416 int nStreams,
1417 PAVISTREAM FAR * ppavi,
1418 LPAVICOMPRESSOPTIONS FAR *plpOptions);
1419 #ifdef UNICODE
1420 #define AVISave AVISaveW
1421 #define AVISaveV AVISaveVW
1422 #else
1423 #define AVISave AVISaveA
1424 #define AVISaveV AVISaveVA
1425 #endif
1426
1427
1428
1429 STDAPI_(INT_PTR) AVISaveOptions(HWND hwnd,
1430 UINT uiFlags,
1431 int nStreams,
1432 PAVISTREAM FAR *ppavi,
1433 LPAVICOMPRESSOPTIONS FAR *plpOptions);
1434
1435 STDAPI AVISaveOptionsFree(int nStreams,
1436 LPAVICOMPRESSOPTIONS FAR *plpOptions);
1437
1438 STDAPI AVIBuildFilterW(LPWSTR lpszFilter, LONG cbFilter, BOOL fSaving);
1439 STDAPI AVIBuildFilterA(LPSTR lpszFilter, LONG cbFilter, BOOL fSaving);
1440 #ifdef UNICODE
1441 #define AVIBuildFilter AVIBuildFilterW
1442 #else
1443 #define AVIBuildFilter AVIBuildFilterA
1444 #endif
1445 STDAPI AVIMakeFileFromStreams(PAVIFILE FAR * ppfile,
1446 int nStreams,
1447 PAVISTREAM FAR * papStreams);
1448
1449 STDAPI AVIMakeStreamFromClipboard(UINT cfFormat, HANDLE hGlobal, PAVISTREAM FAR *ppstream);
1450
1451 STDAPI AVIPutFileOnClipboard(PAVIFILE pf);
1452
1453 STDAPI AVIGetFromClipboard(PAVIFILE FAR * lppf);
1454
1455 STDAPI AVIClearClipboard(void);
1456
1457 STDAPI CreateEditableStream(
1458 PAVISTREAM FAR * ppsEditable,
1459 PAVISTREAM psSource);
1460
1461 STDAPI EditStreamCut(PAVISTREAM pavi, LONG FAR *plStart, LONG FAR *plLength, PAVISTREAM FAR * ppResult);
1462
1463 STDAPI EditStreamCopy(PAVISTREAM pavi, LONG FAR *plStart, LONG FAR *plLength, PAVISTREAM FAR * ppResult);
1464
1465 STDAPI EditStreamPaste(PAVISTREAM pavi, LONG FAR *plPos, LONG FAR *plLength, PAVISTREAM pstream, LONG lStart, LONG lEnd);
1466
1467 STDAPI EditStreamClone(PAVISTREAM pavi, PAVISTREAM FAR *ppResult);
1468
1469
1470 STDAPI EditStreamSetNameA(PAVISTREAM pavi, LPCSTR lpszName);
1471 STDAPI EditStreamSetNameW(PAVISTREAM pavi, LPCWSTR lpszName);
1472 STDAPI EditStreamSetInfoW(PAVISTREAM pavi, LPAVISTREAMINFOW lpInfo, LONG cbInfo);
1473 STDAPI EditStreamSetInfoA(PAVISTREAM pavi, LPAVISTREAMINFOA lpInfo, LONG cbInfo);
1474 #ifdef UNICODE
1475 #define EditStreamSetInfo EditStreamSetInfoW
1476 #define EditStreamSetName EditStreamSetNameW
1477 #else
1478 #define EditStreamSetInfo EditStreamSetInfoA
1479 #define EditStreamSetName EditStreamSetNameA
1480 #endif
1481 +/
1482 enum AVIERR_OK = 0L;
1483
1484 SCODE MAKE_AVIERR(DWORD error) {
1485 return MAKE_SCODE(SEVERITY_ERROR, FACILITY_ITF, 0x4000 + error);
1486 }
1487
1488 enum AVIERR_UNSUPPORTED = MAKE_AVIERR(101);
1489 enum AVIERR_BADFORMAT = MAKE_AVIERR(102);
1490 enum AVIERR_MEMORY = MAKE_AVIERR(103);
1491 enum AVIERR_INTERNAL = MAKE_AVIERR(104);
1492 enum AVIERR_BADFLAGS = MAKE_AVIERR(105);
1493 enum AVIERR_BADPARAM = MAKE_AVIERR(106);
1494 enum AVIERR_BADSIZE = MAKE_AVIERR(107);
1495 enum AVIERR_BADHANDLE = MAKE_AVIERR(108);
1496 enum AVIERR_FILEREAD = MAKE_AVIERR(109);
1497 enum AVIERR_FILEWRITE = MAKE_AVIERR(110);
1498 enum AVIERR_FILEOPEN = MAKE_AVIERR(111);
1499 enum AVIERR_COMPRESSOR = MAKE_AVIERR(112);
1500 enum AVIERR_NOCOMPRESSOR = MAKE_AVIERR(113);
1501 enum AVIERR_READONLY = MAKE_AVIERR(114);
1502 enum AVIERR_NODATA = MAKE_AVIERR(115);
1503 enum AVIERR_BUFFERTOOSMALL = MAKE_AVIERR(116);
1504 enum AVIERR_CANTCOMPRESS = MAKE_AVIERR(117);
1505 enum AVIERR_USERABORT = MAKE_AVIERR(198);
1506 enum AVIERR_ERROR = MAKE_AVIERR(199);
1507
1508 const TCHAR[] MCIWND_WINDOW_CLASS = "MCIWndClass";
1509
1510 extern (Windows) {
1511 HWND MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCSTR szFile);
1512 HWND MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCWSTR szFile);
1513 }
1514
1515 version (Unicode) {
1516 alias MCIWndCreateW MCIWndCreate;
1517 } else { // Unicode
1518 alias MCIWndCreateA MCIWndCreate;
1519 }
1520
1521 extern(Windows) {
1522 BOOL MCIWndRegisterClass();
1523 }
1524
1525 enum {
1526 MCIWNDOPENF_NEW = 0x0001,
1527 MCIWNDF_NOAUTOSIZEWINDOW = 0x0001,
1528 MCIWNDF_NOPLAYBAR = 0x0002,
1529 MCIWNDF_NOAUTOSIZEMOVIE = 0x0004,
1530 MCIWNDF_NOMENU = 0x0008,
1531 MCIWNDF_SHOWNAME = 0x0010,
1532 MCIWNDF_SHOWPOS = 0x0020,
1533 MCIWNDF_SHOWMODE = 0x0040,
1534 MCIWNDF_SHOWALL = 0x0070,
1535 MCIWNDF_NOTIFYMODE = 0x0100,
1536 MCIWNDF_NOTIFYPOS = 0x0200,
1537 MCIWNDF_NOTIFYSIZE = 0x0400,
1538 MCIWNDF_NOTIFYERROR = 0x1000,
1539 MCIWNDF_NOTIFYALL = 0x1F00,
1540 MCIWNDF_NOTIFYANSI = 0x0080,
1541 MCIWNDF_NOTIFYMEDIAA = 0x0880,
1542 MCIWNDF_NOTIFYMEDIAW = 0x0800,
1543 }
1544
1545 version (Unicode) {
1546 alias MCIWNDF_NOTIFYMEDIAW MCIWNDF_NOTIFYMEDIA;
1547 } else { // Unicode
1548 alias MCIWNDF_NOTIFYMEDIAA MCIWNDF_NOTIFYMEDIA;
1549 }
1550
1551 enum {
1552 MCIWNDF_RECORD = 0x2000,
1553 MCIWNDF_NOERRORDLG = 0x4000,
1554 MCIWNDF_NOOPEN = 0x8000,
1555 }
1556
1557 // can macros
1558
1559 BOOL MCIWndCanPlay(HWND hwnd)
1560 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_PLAY, 0, 0); }
1561 BOOL MCIWndCanRecord(HWND hwnd)
1562 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_RECORD, 0, 0); }
1563 BOOL MCIWndCanSave(HWND hwnd)
1564 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_SAVE, 0, 0); }
1565 BOOL MCIWndCanWindow(HWND hwnd)
1566 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_WINDOW, 0, 0); }
1567 BOOL MCIWndCanEject(HWND hwnd)
1568 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_EJECT, 0, 0); }
1569 BOOL MCIWndCanConfig(HWND hwnd)
1570 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_CONFIG, 0, 0); }
1571 BOOL MCIWndPaletteKick(HWND hwnd)
1572 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_PALETTEKICK, 0, 0); }
1573 LONG MCIWndSave(HWND hwnd, LPVOID szFile)
1574 { return cast(LONG)SendMessage(hwnd, MCI_SAVE, 0, cast(LPARAM)szFile); }
1575 LONG MCIWndSaveDialog(HWND hwnd)
1576 { return MCIWndSave(hwnd, cast(LPVOID)-1); }
1577 LONG MCIWndNew(HWND hwnd, LPVOID lp)
1578 { return cast(LONG)SendMessage(hwnd, MCIWNDM_NEW, 0, cast(LPARAM)lp); }
1579 LONG MCIWndRecord(HWND hwnd)
1580 { return cast(LONG)SendMessage(hwnd, MCI_RECORD, 0, 0); }
1581 LONG MCIWndOpen(HWND hwnd, LPVOID sz, UINT f)
1582 { return cast(LONG)SendMessage(hwnd, MCIWNDM_OPEN, cast(WPARAM)f, cast(LPARAM)sz); }
1583 LONG MCIWndOpenDialog(HWND hwnd)
1584 { return MCIWndOpen(hwnd, cast(LPVOID)-1, 0); }
1585 LONG MCIWndClose(HWND hwnd)
1586 { return cast(LONG)SendMessage(hwnd, MCI_CLOSE, 0, 0); }
1587 LONG MCIWndPlay(HWND hwnd)
1588 { return cast(LONG)SendMessage(hwnd, MCI_PLAY, 0, 0); }
1589 LONG MCIWndStop(HWND hwnd)
1590 { return cast(LONG)SendMessage(hwnd, MCI_STOP, 0, 0); }
1591 LONG MCIWndPause(HWND hwnd)
1592 { return cast(LONG)SendMessage(hwnd, MCI_PAUSE, 0, 0); }
1593 LONG MCIWndResume(HWND hwnd)
1594 { return cast(LONG)SendMessage(hwnd, MCI_RESUME, 0, 0); }
1595 LONG MCIWndSeek(HWND hwnd, LONG lPos)
1596 { return cast(LONG)SendMessage(hwnd, MCI_SEEK, 0, cast(LPARAM)lPos); }
1597 LONG MCIWndHome(HWND hwnd)
1598 { return MCIWndSeek(hwnd, MCIWND_START); }
1599 LONG MCIWndEnd(HWND hwnd)
1600 { return MCIWndSeek(hwnd, MCIWND_END); }
1601 LONG MCIWndEject(HWND hwnd)
1602 { return cast(LONG)SendMessage(hwnd, MCIWNDM_EJECT, 0, 0); }
1603 LONG MCIWndGetSource(HWND hwnd, LPRECT prc)
1604 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GET_SOURCE, 0, cast(LPARAM)prc); }
1605 LONG MCIWndPutSource(HWND hwnd, LPRECT prc)
1606 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PUT_SOURCE, 0, cast(LPARAM)prc); }
1607 LONG MCIWndGetDest(HWND hwnd, LPRECT prc)
1608 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GET_DEST, 0, cast(LPARAM)prc); }
1609 LONG MCIWndPutDest(HWND hwnd, LPRECT prc)
1610 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PUT_DEST, 0, cast(LPARAM)prc); }
1611 LONG MCIWndPlayReverse(HWND hwnd)
1612 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYREVERSE, 0, 0); }
1613 LONG MCIWndPlayFrom(HWND hwnd, LONG lPos)
1614 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYFROM, 0, cast(LPARAM)lPos); }
1615 LONG MCIWndPlayTo(HWND hwnd, LONG lPos)
1616 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYTO, 0, cast(LPARAM)lPos); }
1617 LONG MCIWndPlayFromTo(HWND hwnd, LONG lStart, LONG lEnd)
1618 { MCIWndSeek(hwnd, lStart); return MCIWndPlayTo(hwnd, lEnd); }
1619 UINT MCIWndGetDeviceID(HWND hwnd)
1620 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETDEVICEID, 0, 0); }
1621 UINT MCIWndGetAlias(HWND hwnd)
1622 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETALIAS, 0, 0); }
1623 LONG MCIWndGetMode(HWND hwnd, LPTSTR lp, UINT len)
1624 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETMODE, cast(WPARAM)len, cast(LPARAM)lp); }
1625 LONG MCIWndGetPosition(HWND hwnd)
1626 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETPOSITION, 0, 0); }
1627 LONG MCIWndGetPositionString(HWND hwnd, LPTSTR lp, UINT len)
1628 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETPOSITION, cast(WPARAM)len, cast(LPARAM)lp); }
1629 LONG MCIWndGetStart(HWND hwnd)
1630 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETSTART, 0, 0); }
1631 LONG MCIWndGetLength(HWND hwnd)
1632 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETLENGTH, 0, 0); }
1633 LONG MCIWndGetEnd(HWND hwnd)
1634 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETEND, 0, 0); }
1635 LONG MCIWndStep(HWND hwnd, LONG n)
1636 { return cast(LONG)SendMessage(hwnd, MCI_STEP, 0, cast(LPARAM)n); }
1637 void MCIWndDestroy(HWND hwnd)
1638 { SendMessage(hwnd, WM_CLOSE, 0, 0); }
1639 void MCIWndSetZoom(HWND hwnd, UINT iZoom)
1640 { SendMessage(hwnd, MCIWNDM_SETZOOM, 0, cast(LPARAM)iZoom); }
1641 UINT MCIWndGetZoom(HWND hwnd)
1642 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETZOOM, 0, 0); }
1643 LONG MCIWndSetVolume(HWND hwnd, UINT iVol)
1644 { return cast(LONG)SendMessage(hwnd, MCIWNDM_SETVOLUME, 0, cast(LPARAM)iVol); }
1645 LONG MCIWndGetVolume(HWND hwnd)
1646 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETVOLUME, 0, 0); }
1647 LONG MCIWndSetSpeed(HWND hwnd, UINT iSpeed)
1648 { return cast(LONG)SendMessage(hwnd, MCIWNDM_SETSPEED, 0, cast(LPARAM)iSpeed); }
1649 LONG MCIWndGetSpeed(HWND hwnd)
1650 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETSPEED, 0, 0); }
1651 LONG MCIWndSetTimeFormat(HWND hwnd, LPTSTR lp)
1652 { return cast(LONG)SendMessage(hwnd, MCIWNDM_SETTIMEFORMAT, 0, cast(LPARAM)lp); }
1653 LONG MCIWndUseFrames(HWND hwnd)
1654 { return MCIWndSetTimeFormat(hwnd, (cast(TCHAR[])"frames").ptr); }
1655 LONG MCIWndUseTime(HWND hwnd)
1656 { return MCIWndSetTimeFormat(hwnd, (cast(TCHAR[])"ms").ptr); }
1657 LONG MCIWndGetTimeFormat(HWND hwnd, LPTSTR lp, UINT len)
1658 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETTIMEFORMAT, cast(WPARAM)len, cast(LPARAM)lp); }
1659 void MCIWndValidateMedia(HWND hwnd)
1660 { SendMessage(hwnd, MCIWNDM_VALIDATEMEDIA, 0, 0); }
1661 void MCIWndSetRepeat(HWND hwnd, BOOL f)
1662 { SendMessage(hwnd, MCIWNDM_SETREPEAT, 0, cast(LPARAM)f); }
1663 BOOL MCIWndGetRepeat(HWND hwnd)
1664 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_GETREPEAT, 0, 0); }
1665 void MCIWndSetActiveTimer(HWND hwnd, UINT active)
1666 { SendMessage(hwnd, MCIWNDM_SETACTIVETIMER, cast(WPARAM)active, 0); }
1667 void MCIWndSetInactiveTimer(HWND hwnd, UINT inactive)
1668 { SendMessage(hwnd, MCIWNDM_SETINACTIVETIMER, cast(WPARAM)inactive, 0); }
1669 void MCIWndSetTimers(HWND hwnd, UINT active, UINT inactive)
1670 { SendMessage(hwnd, MCIWNDM_SETTIMERS, cast(WPARAM)active, cast(LPARAM)inactive); }
1671 UINT MCIWndGetActiveTimer(HWND hwnd)
1672 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETACTIVETIMER, 0, 0); }
1673 UINT MCIWndGetInactiveTimer(HWND hwnd)
1674 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETINACTIVETIMER, 0, 0); }
1675 LONG MCIWndRealize(HWND hwnd, BOOL fBkgnd)
1676 { return cast(LONG) SendMessage(hwnd, MCIWNDM_REALIZE, cast(WPARAM)fBkgnd, 0); }
1677 LONG MCIWndSendString(HWND hwnd, LPTSTR sz)
1678 { return cast(LONG) SendMessage(hwnd, MCIWNDM_SENDSTRING, 0, cast(LPARAM)sz); }
1679 LONG MCIWndReturnString(HWND hwnd, LPVOID lp, UINT len)
1680 { return cast(LONG) SendMessage(hwnd, MCIWNDM_RETURNSTRING, cast(WPARAM)len, cast(LPARAM)lp); }
1681 LONG MCIWndGetError(HWND hwnd, LPVOID lp, UINT len)
1682 { return cast(LONG) SendMessage(hwnd, MCIWNDM_GETERROR, cast(WPARAM)len, cast(LPARAM)lp); }
1683 HPALETTE MCIWndGetPalette(HWND hwnd)
1684 { return cast(HPALETTE)SendMessage(hwnd, MCIWNDM_GETPALETTE, 0, 0); }
1685 LONG MCIWndSetPalette(HWND hwnd, HPALETTE hpal)
1686 { return cast(LONG) SendMessage(hwnd, MCIWNDM_SETPALETTE, cast(WPARAM)hpal, 0); }
1687 LONG MCIWndGetFileName(HWND hwnd, LPVOID lp, UINT len)
1688 { return cast(LONG) SendMessage(hwnd, MCIWNDM_GETFILENAME, cast(WPARAM)len, cast(LPARAM)lp); }
1689 LONG MCIWndGetDevice(HWND hwnd, LPVOID lp, UINT len)
1690 { return cast(LONG) SendMessage(hwnd, MCIWNDM_GETDEVICE, cast(WPARAM)len, cast(LPARAM)lp); }
1691 UINT MCIWndGetStyles(HWND hwnd)
1692 { return cast(UINT) SendMessage(hwnd, MCIWNDM_GETSTYLES, 0, 0); }
1693 LONG MCIWndChangeStyles(HWND hwnd, UINT mask, LONG value)
1694 { return cast(LONG) SendMessage(hwnd, MCIWNDM_CHANGESTYLES, cast(WPARAM)mask, cast(LPARAM)value); }
1695 LONG MCIWndOpenInterface(HWND hwnd, LPUNKNOWN pUnk)
1696 { return cast(LONG) SendMessage(hwnd, MCIWNDM_OPENINTERFACE, 0, cast(LPARAM)cast(void*)pUnk); }
1697 LONG MCIWndSetOwner(HWND hwnd, HWND hwndP)
1698 { return cast(LONG) SendMessage(hwnd, MCIWNDM_SETOWNER, cast(WPARAM)hwndP, 0); }
1699
1700 enum {
1701 MCIWNDM_GETDEVICEID = WM_USER + 100,
1702 MCIWNDM_SENDSTRINGA = WM_USER + 101,
1703 MCIWNDM_GETPOSITIONA = WM_USER + 102,
1704 MCIWNDM_GETSTART = WM_USER + 103,
1705 MCIWNDM_GETLENGTH = WM_USER + 104,
1706 MCIWNDM_GETEND = WM_USER + 105,
1707 MCIWNDM_GETMODEA = WM_USER + 106,
1708 MCIWNDM_EJECT = WM_USER + 107,
1709 MCIWNDM_SETZOOM = WM_USER + 108,
1710 MCIWNDM_GETZOOM = WM_USER + 109,
1711 MCIWNDM_SETVOLUME = WM_USER + 110,
1712 MCIWNDM_GETVOLUME = WM_USER + 111,
1713 MCIWNDM_SETSPEED = WM_USER + 112,
1714 MCIWNDM_GETSPEED = WM_USER + 113,
1715 MCIWNDM_SETREPEAT = WM_USER + 114,
1716 MCIWNDM_GETREPEAT = WM_USER + 115,
1717 MCIWNDM_REALIZE = WM_USER + 118,
1718 MCIWNDM_SETTIMEFORMATA = WM_USER + 119,
1719 MCIWNDM_GETTIMEFORMATA = WM_USER + 120,
1720 MCIWNDM_VALIDATEMEDIA = WM_USER + 121,
1721 MCIWNDM_PLAYFROM = WM_USER + 122,
1722 MCIWNDM_PLAYTO = WM_USER + 123,
1723 MCIWNDM_GETFILENAMEA = WM_USER + 124,
1724 MCIWNDM_GETDEVICEA = WM_USER + 125,
1725 MCIWNDM_GETPALETTE = WM_USER + 126,
1726 MCIWNDM_SETPALETTE = WM_USER + 127,
1727 MCIWNDM_GETERRORA = WM_USER + 128,
1728 MCIWNDM_SETTIMERS = WM_USER + 129,
1729 MCIWNDM_SETACTIVETIMER = WM_USER + 130,
1730 MCIWNDM_SETINACTIVETIMER = WM_USER + 131,
1731 MCIWNDM_GETACTIVETIMER = WM_USER + 132,
1732 MCIWNDM_GETINACTIVETIMER = WM_USER + 133,
1733 MCIWNDM_NEWA = WM_USER + 134,
1734 MCIWNDM_CHANGESTYLES = WM_USER + 135,
1735 MCIWNDM_GETSTYLES = WM_USER + 136,
1736 MCIWNDM_GETALIAS = WM_USER + 137,
1737 MCIWNDM_RETURNSTRINGA = WM_USER + 138,
1738 MCIWNDM_PLAYREVERSE = WM_USER + 139,
1739 MCIWNDM_GET_SOURCE = WM_USER + 140,
1740 MCIWNDM_PUT_SOURCE = WM_USER + 141,
1741 MCIWNDM_GET_DEST = WM_USER + 142,
1742 MCIWNDM_PUT_DEST = WM_USER + 143,
1743 MCIWNDM_CAN_PLAY = WM_USER + 144,
1744 MCIWNDM_CAN_WINDOW = WM_USER + 145,
1745 MCIWNDM_CAN_RECORD = WM_USER + 146,
1746 MCIWNDM_CAN_SAVE = WM_USER + 147,
1747 MCIWNDM_CAN_EJECT = WM_USER + 148,
1748 MCIWNDM_CAN_CONFIG = WM_USER + 149,
1749 MCIWNDM_PALETTEKICK = WM_USER + 150,
1750 MCIWNDM_OPENINTERFACE = WM_USER + 151,
1751 MCIWNDM_SETOWNER = WM_USER + 152,
1752 MCIWNDM_OPENA = WM_USER + 153,
1753 MCIWNDM_SENDSTRINGW = WM_USER + 201,
1754 MCIWNDM_GETPOSITIONW = WM_USER + 202,
1755 MCIWNDM_GETMODEW = WM_USER + 206,
1756 MCIWNDM_SETTIMEFORMATW = WM_USER + 219,
1757 MCIWNDM_GETTIMEFORMATW = WM_USER + 220,
1758 MCIWNDM_GETFILENAMEW = WM_USER + 224,
1759 MCIWNDM_GETDEVICEW = WM_USER + 225,
1760 MCIWNDM_GETERRORW = WM_USER + 228,
1761 MCIWNDM_NEWW = WM_USER + 234,
1762 MCIWNDM_RETURNSTRINGW = WM_USER + 238,
1763 MCIWNDM_OPENW = WM_USER + 252,
1764 }
1765
1766 version (Unicode) {
1767 alias MCIWNDM_SENDSTRINGW MCIWNDM_SENDSTRING;
1768 alias MCIWNDM_GETPOSITIONW MCIWNDM_GETPOSITION;
1769 alias MCIWNDM_GETMODEW MCIWNDM_GETMODE;
1770 alias MCIWNDM_SETTIMEFORMATW MCIWNDM_SETTIMEFORMAT;
1771 alias MCIWNDM_GETTIMEFORMATW MCIWNDM_GETTIMEFORMAT;
1772 alias MCIWNDM_GETFILENAMEW MCIWNDM_GETFILENAME;
1773 alias MCIWNDM_GETDEVICEW MCIWNDM_GETDEVICE;
1774 alias MCIWNDM_GETERRORW MCIWNDM_GETERROR;
1775 alias MCIWNDM_NEWW MCIWNDM_NEW;
1776 alias MCIWNDM_RETURNSTRINGW MCIWNDM_RETURNSTRING;
1777 alias MCIWNDM_OPENW MCIWNDM_OPEN;
1778 } else { // Unicode
1779 alias MCIWNDM_SENDSTRINGA MCIWNDM_SENDSTRING;
1780 alias MCIWNDM_GETPOSITIONA MCIWNDM_GETPOSITION;
1781 alias MCIWNDM_GETMODEA MCIWNDM_GETMODE;
1782 alias MCIWNDM_SETTIMEFORMATA MCIWNDM_SETTIMEFORMAT;
1783 alias MCIWNDM_GETTIMEFORMATA MCIWNDM_GETTIMEFORMAT;
1784 alias MCIWNDM_GETFILENAMEA MCIWNDM_GETFILENAME;
1785 alias MCIWNDM_GETDEVICEA MCIWNDM_GETDEVICE;
1786 alias MCIWNDM_GETERRORA MCIWNDM_GETERROR;
1787 alias MCIWNDM_NEWA MCIWNDM_NEW;
1788 alias MCIWNDM_RETURNSTRINGA MCIWNDM_RETURNSTRING;
1789 alias MCIWNDM_OPENA MCIWNDM_OPEN;
1790 }
1791
1792 enum {
1793 MCIWNDM_NOTIFYMODE = WM_USER + 200,
1794 MCIWNDM_NOTIFYPOS = WM_USER + 201,
1795 MCIWNDM_NOTIFYSIZE = WM_USER + 202,
1796 MCIWNDM_NOTIFYMEDIA = WM_USER + 203,
1797 MCIWNDM_NOTIFYERROR = WM_USER + 205,
1798 }
1799
1800 enum MCIWND_START = -1;
1801 enum MCIWND_END = -2;
1802
1803 enum {
1804 MCI_CLOSE = 0x0804,
1805 MCI_PLAY = 0x0806,
1806 MCI_SEEK = 0x0807,
1807 MCI_STOP = 0x0808,
1808 MCI_PAUSE = 0x0809,
1809 MCI_STEP = 0x080E,
1810 MCI_RECORD = 0x080F,
1811 MCI_SAVE = 0x0813,
1812 MCI_CUT = 0x0851,
1813 MCI_COPY = 0x0852,
1814 MCI_PASTE = 0x0853,
1815 MCI_RESUME = 0x0855,
1816 MCI_DELETE = 0x0856,
1817 }
1818
1819 enum {
1820 MCI_MODE_NOT_READY = 524,
1821 MCI_MODE_STOP,
1822 MCI_MODE_PLAY,
1823 MCI_MODE_RECORD,
1824 MCI_MODE_SEEK,
1825 MCI_MODE_PAUSE,
1826 MCI_MODE_OPEN,
1827 }
1828
1829 alias TypeDef!(HANDLE) HVIDEO;
1830 alias HVIDEO* LPHVIDEO;
1831
1832 // Error Return Values
1833
1834 enum {
1835 DV_ERR_OK = 0,
1836 DV_ERR_BASE = 1,
1837 DV_ERR_NONSPECIFIC = DV_ERR_BASE,
1838 DV_ERR_BADFORMAT = DV_ERR_BASE + 1,
1839 DV_ERR_STILLPLAYING = DV_ERR_BASE + 2,
1840 DV_ERR_UNPREPARED = DV_ERR_BASE + 3,
1841 DV_ERR_SYNC = DV_ERR_BASE + 4,
1842 DV_ERR_TOOMANYCHANNELS = DV_ERR_BASE + 5,
1843 DV_ERR_NOTDETECTED = DV_ERR_BASE + 6,
1844 DV_ERR_BADINSTALL = DV_ERR_BASE + 7,
1845 DV_ERR_CREATEPALETTE = DV_ERR_BASE + 8,
1846 DV_ERR_SIZEFIELD = DV_ERR_BASE + 9,
1847 DV_ERR_PARAM1 = DV_ERR_BASE + 10,
1848 DV_ERR_PARAM2 = DV_ERR_BASE + 11,
1849 DV_ERR_CONFIG1 = DV_ERR_BASE + 12,
1850 DV_ERR_CONFIG2 = DV_ERR_BASE + 13,
1851 DV_ERR_FLAGS = DV_ERR_BASE + 14,
1852 DV_ERR_13 = DV_ERR_BASE + 15,
1853 DV_ERR_NOTSUPPORTED = DV_ERR_BASE + 16,
1854 DV_ERR_NOMEM = DV_ERR_BASE + 17,
1855 DV_ERR_ALLOCATED = DV_ERR_BASE + 18,
1856 DV_ERR_BADDEVICEID = DV_ERR_BASE + 19,
1857 DV_ERR_INVALHANDLE = DV_ERR_BASE + 20,
1858 DV_ERR_BADERRNUM = DV_ERR_BASE + 21,
1859 DV_ERR_NO_BUFFERS = DV_ERR_BASE + 22,
1860 DV_ERR_MEM_CONFLICT = DV_ERR_BASE + 23,
1861 DV_ERR_IO_CONFLICT = DV_ERR_BASE + 24,
1862 DV_ERR_DMA_CONFLICT = DV_ERR_BASE + 25,
1863 DV_ERR_INT_CONFLICT = DV_ERR_BASE + 26,
1864 DV_ERR_PROTECT_ONLY = DV_ERR_BASE + 27,
1865 DV_ERR_LASTERROR = DV_ERR_BASE + 27,
1866 DV_ERR_USER_MSG = DV_ERR_BASE + 1000,
1867 }
1868
1869 // Callback Messages
1870
1871 enum {
1872 MM_DRVM_OPEN = 0x3D0,
1873 MM_DRVM_CLOSE,
1874 MM_DRVM_DATA,
1875 MM_DRVM_ERROR,
1876 }
1877
1878 enum {
1879 DV_VM_OPEN = MM_DRVM_OPEN,
1880 DV_VM_CLOSE = MM_DRVM_CLOSE,
1881 DV_VM_DATA = MM_DRVM_DATA,
1882 DV_VM_ERROR = MM_DRVM_ERROR,
1883 }
1884
1885 /**
1886 * Structures
1887 */
1888
1889 struct VIDEOHDR {
1890 LPBYTE lpData;
1891 DWORD dwBufferLength;
1892 DWORD dwBytesUsed;
1893 DWORD dwTimeCaptured;
1894 DWORD_PTR dwUser;
1895 DWORD dwFlags;
1896 DWORD_PTR[4]dwReserved;
1897 }
1898 alias VIDEOHDR* PVIDEOHDR, LPVIDEOHDR;
1899
1900 enum {
1901 VHDR_DONE = 0x00000001,
1902 VHDR_PREPARED = 0x00000002,
1903 VHDR_INQUEUE = 0x00000004,
1904 VHDR_KEYFRAME = 0x00000008,
1905 VHDR_VALID = 0x0000000F,
1906 }
1907
1908 struct CHANNEL_CAPS {
1909 DWORD dwFlags;
1910 DWORD dwSrcRectXMod;
1911 DWORD dwSrcRectYMod;
1912 DWORD dwSrcRectWidthMod;
1913 DWORD dwSrcRectHeightMod;
1914 DWORD dwDstRectXMod;
1915 DWORD dwDstRectYMod;
1916 DWORD dwDstRectWidthMod;
1917 DWORD dwDstRectHeightMod;
1918 }
1919 alias CHANNEL_CAPS* PCHANNEL_CAPS, LPCHANNEL_CAPS;
1920
1921 enum {
1922 VCAPS_OVERLAY = 0x00000001,
1923 VCAPS_SRC_CAN_CLIP = 0x00000002,
1924 VCAPS_DST_CAN_CLIP = 0x00000004,
1925 VCAPS_CAN_SCALE = 0x00000008,
1926 }
1927
1928 /**
1929 * API Flags
1930 */
1931
1932 enum {
1933 VIDEO_EXTERNALIN = 0x0001,
1934 VIDEO_EXTERNALOUT = 0x0002,
1935 VIDEO_IN = 0x0004,
1936 VIDEO_OUT = 0x0008,
1937 VIDEO_DLG_QUERY = 0x0010,
1938 }
1939
1940 enum {
1941 VIDEO_CONFIGURE_QUERYSIZE = 0x0001,
1942 VIDEO_CONFIGURE_CURRENT = 0x0010,
1943 VIDEO_CONFIGURE_NOMINAL = 0x0020,
1944 VIDEO_CONFIGURE_MIN = 0x0040,
1945 VIDEO_CONFIGURE_MAX = 0x0080,
1946 VIDEO_CONFIGURE_SET = 0x1000,
1947 VIDEO_CONFIGURE_GET = 0x2000,
1948 VIDEO_CONFIGURE_QUERY = 0x8000,
1949 }
1950
1951 /**
1952 * CONFIGURE MESSAGES
1953 */
1954
1955 enum {
1956 DVM_USER = 0x4000,
1957 DVM_CONFIGURE_START = 0x1000,
1958 DVM_CONFIGURE_END = 0x1FFF,
1959 DVM_PALETTE = DVM_CONFIGURE_START + 1,
1960 DVM_FORMAT = DVM_CONFIGURE_START + 2,
1961 DVM_PALETTERGB555 = DVM_CONFIGURE_START + 3,
1962 DVM_SRC_RECT = DVM_CONFIGURE_START + 4,
1963 DVM_DST_RECT = DVM_CONFIGURE_START + 5,
1964 }
1965
1966 /**
1967 * AVICap window class
1968 */
1969
1970 LRESULT AVICapSM(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
1971 if (IsWindow(hWnd)) {
1972 return SendMessage(hWnd, msg, wParam, lParam);
1973 }
1974 return 0;
1975 }
1976
1977 enum {
1978 WM_CAP_START = WM_USER,
1979 WM_CAP_UNICODE_START = WM_USER + 100,
1980
1981 WM_CAP_GET_CAPSTREAMPTR = WM_CAP_START + 1,
1982 WM_CAP_SET_CALLBACK_ERRORA = WM_CAP_START + 2,
1983 WM_CAP_SET_CALLBACK_STATUSA = WM_CAP_START + 3,
1984
1985 WM_CAP_SET_CALLBACK_ERRORW = WM_CAP_UNICODE_START + 2,
1986 WM_CAP_SET_CALLBACK_STATUSW = WM_CAP_UNICODE_START + 3,
1987 }
1988
1989 version (Unicode) {
1990 alias WM_CAP_SET_CALLBACK_ERRORW WM_CAP_SET_CALLBACK_ERROR;
1991 alias WM_CAP_SET_CALLBACK_STATUSW WM_CAP_SET_CALLBACK_STATUS;
1992 } else { // Unicode
1993 alias WM_CAP_SET_CALLBACK_ERRORA WM_CAP_SET_CALLBACK_ERROR;
1994 alias WM_CAP_SET_CALLBACK_STATUSA WM_CAP_SET_CALLBACK_STATUS;
1995 }
1996
1997 enum {
1998 WM_CAP_SET_CALLBACK_YIELD = WM_CAP_START + 4,
1999 WM_CAP_SET_CALLBACK_FRAME = WM_CAP_START + 5,
2000 WM_CAP_SET_CALLBACK_VIDEOSTREAM = WM_CAP_START + 6,
2001 WM_CAP_SET_CALLBACK_WAVESTREAM = WM_CAP_START + 7,
2002 WM_CAP_GET_USER_DATA = WM_CAP_START + 8,
2003 WM_CAP_SET_USER_DATA = WM_CAP_START + 9,
2004 WM_CAP_DRIVER_CONNECT = WM_CAP_START + 10,
2005 WM_CAP_DRIVER_DISCONNECT = WM_CAP_START + 11,
2006 WM_CAP_DRIVER_GET_NAMEA = WM_CAP_START + 12,
2007 WM_CAP_DRIVER_GET_VERSIONA = WM_CAP_START + 13,
2008
2009 WM_CAP_DRIVER_GET_NAMEW = WM_CAP_UNICODE_START + 12,
2010 WM_CAP_DRIVER_GET_VERSIONW = WM_CAP_UNICODE_START + 13,
2011 }
2012
2013 version (Unicode) {
2014 alias WM_CAP_DRIVER_GET_NAMEW WM_CAP_DRIVER_GET_NAME;
2015 alias WM_CAP_DRIVER_GET_VERSIONW WM_CAP_DRIVER_GET_VERSION;
2016 } else { // Unicode
2017 alias WM_CAP_DRIVER_GET_NAMEA WM_CAP_DRIVER_GET_NAME;
2018 alias WM_CAP_DRIVER_GET_VERSIONA WM_CAP_DRIVER_GET_VERSION;
2019 }
2020
2021 enum {
2022 WM_CAP_DRIVER_GET_CAPS = WM_CAP_START + 14,
2023 WM_CAP_FILE_SET_CAPTURE_FILEA = WM_CAP_START + 20,
2024 WM_CAP_FILE_GET_CAPTURE_FILEA = WM_CAP_START + 21,
2025 WM_CAP_FILE_SAVEASA = WM_CAP_START + 23,
2026 WM_CAP_FILE_SAVEDIBA = WM_CAP_START + 25,
2027
2028 WM_CAP_FILE_SET_CAPTURE_FILEW = WM_CAP_UNICODE_START + 20,
2029 WM_CAP_FILE_GET_CAPTURE_FILEW = WM_CAP_UNICODE_START + 21,
2030 WM_CAP_FILE_SAVEASW = WM_CAP_UNICODE_START + 23,
2031 WM_CAP_FILE_SAVEDIBW = WM_CAP_UNICODE_START + 25,
2032 }
2033
2034 version (Unicode) {
2035 alias WM_CAP_FILE_SET_CAPTURE_FILEW WM_CAP_FILE_SET_CAPTURE_FILE;
2036 alias WM_CAP_FILE_GET_CAPTURE_FILEW WM_CAP_FILE_GET_CAPTURE_FILE;
2037 alias WM_CAP_FILE_SAVEASW WM_CAP_FILE_SAVEAS;
2038 alias WM_CAP_FILE_SAVEDIBW WM_CAP_FILE_SAVEDIB;
2039 } else { // Unicode
2040 alias WM_CAP_FILE_SET_CAPTURE_FILEA WM_CAP_FILE_SET_CAPTURE_FILE;
2041 alias WM_CAP_FILE_GET_CAPTURE_FILEA WM_CAP_FILE_GET_CAPTURE_FILE;
2042 alias WM_CAP_FILE_SAVEASA WM_CAP_FILE_SAVEAS;
2043 alias WM_CAP_FILE_SAVEDIBA WM_CAP_FILE_SAVEDIB;
2044 }
2045
2046 enum {
2047 WM_CAP_FILE_ALLOCATE = WM_CAP_START + 22,
2048 WM_CAP_FILE_SET_INFOCHUNK = WM_CAP_START + 24,
2049 WM_CAP_EDIT_COPY = WM_CAP_START + 30,
2050 WM_CAP_SET_AUDIOFORMAT = WM_CAP_START + 35,
2051 WM_CAP_GET_AUDIOFORMAT = WM_CAP_START + 36,
2052 WM_CAP_DLG_VIDEOFORMAT = WM_CAP_START + 41,
2053 WM_CAP_DLG_VIDEOSOURCE = WM_CAP_START + 42,
2054 WM_CAP_DLG_VIDEODISPLAY = WM_CAP_START + 43,
2055 WM_CAP_GET_VIDEOFORMAT = WM_CAP_START + 44,
2056 WM_CAP_SET_VIDEOFORMAT = WM_CAP_START + 45,
2057 WM_CAP_DLG_VIDEOCOMPRESSION = WM_CAP_START + 46,
2058 WM_CAP_SET_PREVIEW = WM_CAP_START + 50,
2059 WM_CAP_SET_OVERLAY = WM_CAP_START + 51,
2060 WM_CAP_SET_PREVIEWRATE = WM_CAP_START + 52,
2061 WM_CAP_SET_SCALE = WM_CAP_START + 53,
2062 WM_CAP_GET_STATUS = WM_CAP_START + 54,
2063 WM_CAP_SET_SCROLL = WM_CAP_START + 55,
2064 WM_CAP_GRAB_FRAME = WM_CAP_START + 60,
2065 WM_CAP_GRAB_FRAME_NOSTOP = WM_CAP_START + 61,
2066 WM_CAP_SEQUENCE = WM_CAP_START + 62,
2067 WM_CAP_SEQUENCE_NOFILE = WM_CAP_START + 63,
2068 WM_CAP_SET_SEQUENCE_SETUP = WM_CAP_START + 64,
2069 WM_CAP_GET_SEQUENCE_SETUP = WM_CAP_START + 65,
2070 WM_CAP_SET_MCI_DEVICEA = WM_CAP_START + 66,
2071 WM_CAP_GET_MCI_DEVICEA = WM_CAP_START + 67,
2072
2073 WM_CAP_SET_MCI_DEVICEW = WM_CAP_UNICODE_START + 66,
2074 WM_CAP_GET_MCI_DEVICEW = WM_CAP_UNICODE_START + 67,
2075 }
2076
2077 version (Unicode) {
2078 alias WM_CAP_SET_MCI_DEVICEW WM_CAP_SET_MCI_DEVICE;
2079 alias WM_CAP_GET_MCI_DEVICEW WM_CAP_GET_MCI_DEVICE;
2080 } else { // Unicode
2081 alias WM_CAP_SET_MCI_DEVICEA WM_CAP_SET_MCI_DEVICE;
2082 alias WM_CAP_GET_MCI_DEVICEA WM_CAP_GET_MCI_DEVICE;
2083 }
2084
2085 enum {
2086 WM_CAP_STOP = WM_CAP_START + 68,
2087 WM_CAP_ABORT = WM_CAP_START + 69,
2088 WM_CAP_SINGLE_FRAME_OPEN = WM_CAP_START + 70,
2089 WM_CAP_SINGLE_FRAME_CLOSE = WM_CAP_START + 71,
2090 WM_CAP_SINGLE_FRAME = WM_CAP_START + 72,
2091 WM_CAP_PAL_OPENA = WM_CAP_START + 80,
2092 WM_CAP_PAL_SAVEA = WM_CAP_START + 81,
2093
2094 WM_CAP_PAL_OPENW = WM_CAP_UNICODE_START + 80,
2095 WM_CAP_PAL_SAVEW = WM_CAP_UNICODE_START + 81,
2096 }
2097
2098 version (Unicode) {
2099 alias WM_CAP_PAL_OPENW WM_CAP_PAL_OPEN;
2100 alias WM_CAP_PAL_SAVEW WM_CAP_PAL_SAVE;
2101 } else { // Unicode
2102 alias WM_CAP_PAL_OPENA WM_CAP_PAL_OPEN;
2103 alias WM_CAP_PAL_SAVEA WM_CAP_PAL_SAVE;
2104 }
2105
2106 enum {
2107 WM_CAP_PAL_PASTE = WM_CAP_START + 82,
2108 WM_CAP_PAL_AUTOCREATE = WM_CAP_START + 83,
2109 WM_CAP_PAL_MANUALCREATE = WM_CAP_START + 84,
2110 WM_CAP_SET_CALLBACK_CAPCONTROL = WM_CAP_START + 85,
2111 WM_CAP_UNICODE_END = WM_CAP_PAL_SAVEW,
2112 WM_CAP_END = WM_CAP_UNICODE_END,
2113 }
2114
2115 /**
2116 * message wrapper
2117 */
2118
2119 BOOL capSetCallbackOnError(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_ERROR, 0, cast(LPARAM)fpProc); }
2120 BOOL capSetCallbackOnStatus(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_STATUS, 0, cast(LPARAM)fpProc); }
2121 BOOL capSetCallbackOnYield(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_YIELD, 0, cast(LPARAM)fpProc); }
2122 BOOL capSetCallbackOnFrame(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_FRAME, 0, cast(LPARAM)fpProc); }
2123 BOOL capSetCallbackOnVideoStream(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, cast(LPARAM)fpProc); }
2124 BOOL capSetCallbackOnWaveStream(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_WAVESTREAM, 0, cast(LPARAM)fpProc); }
2125 BOOL capSetCallbackOnCapControl(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_CAPCONTROL, 0, cast(LPARAM)fpProc); }
2126
2127 BOOL capSetUserData(HWND hWnd, LPARAM lUser) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_USER_DATA, 0, lUser); }
2128 BOOL capGetUserData(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_USER_DATA, 0, 0); }
2129
2130 BOOL capDriverConnect(HWND hWnd, WPARAM i) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_CONNECT, i, 0); }
2131 BOOL capDriverDisconnect(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_DISCONNECT, 0, 0); }
2132 BOOL capDriverGetName(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_NAME, wSize, cast(LPARAM)szName); }
2133 BOOL capDriverGetVersion(HWND hWnd, LPTSTR szVer, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_VERSION, wSize, cast(LPARAM)szVer); }
2134 BOOL capDriverGetCaps(HWND hWnd, LPCAPDRIVERCAPS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_CAPS, wSize, cast(LPARAM)s); }
2135
2136 BOOL capFileSetCaptureFile(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SET_CAPTURE_FILE, 0, cast(LPARAM)szName); }
2137 BOOL capFileGetCaptureFile(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_GET_CAPTURE_FILE, wSize, cast(LPARAM)szName); }
2138 BOOL capFileAlloc(HWND hWnd, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_ALLOCATE, wSize, 0); }
2139 BOOL capFileSaveAs(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SAVEAS, 0, cast(LPARAM)szName); }
2140 BOOL capFileSetInfoChunk(HWND hWnd, LPCAPINFOCHUNK lpInfoChunk) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SET_INFOCHUNK, 0, cast(LPARAM)lpInfoChunk); }
2141 BOOL capFileSaveDIB(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SAVEDIB, 0, cast(LPARAM)szName); }
2142
2143 BOOL capEditCopy(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_EDIT_COPY, 0, 0); }
2144
2145 BOOL capSetAudioFormat(HWND hWnd, LPWAVEFORMATEX s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_AUDIOFORMAT, wSize, cast(LPARAM)s); }
2146 DWORD capGetAudioFormat(HWND hWnd, LPWAVEFORMATEX s, WPARAM wSize) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_AUDIOFORMAT, wSize, cast(LPARAM)s); }
2147 DWORD capGetAudioFormatSize(HWND hWnd) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_AUDIOFORMAT, 0, 0); }
2148
2149 BOOL capDlgVideoFormat(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOFORMAT, 0, 0); }
2150 BOOL capDlgVideoSource(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOSOURCE, 0, 0); }
2151 BOOL capDlgVideoDisplay(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEODISPLAY, 0, 0); }
2152 BOOL capDlgVideoCompression(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOCOMPRESSION, 0, 0); }
2153
2154 DWORD capGetVideoFormat(HWND hWnd, void* s, WPARAM wSize) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_VIDEOFORMAT, wSize, cast(LPARAM)s); }
2155 DWORD capGetVideoFormatSize(HWND hWnd) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_VIDEOFORMAT, 0, 0); }
2156 BOOL capSetVideoFormat(HWND hWnd, void* s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_VIDEOFORMAT, wSize, cast(LPARAM)s); }
2157
2158 BOOL capPreview(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_PREVIEW, cast(WPARAM)f, 0); }
2159 BOOL capPreviewRate(HWND hWnd, WPARAM wMS) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_PREVIEWRATE, wMS, 0); }
2160 BOOL capOverlay(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_OVERLAY, cast(WPARAM)f, 0); }
2161 BOOL capPreviewScale(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SCALE, cast(WPARAM)f, 0); }
2162 BOOL capGetStatus(HWND hWnd, LPCAPSTATUS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_STATUS, wSize, cast(LPARAM)s); }
2163 BOOL capSetScrollPos(HWND hWnd, LPPOINT lpP) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SCROLL, 0, cast(LPARAM)lpP); }
2164
2165 BOOL capGrabFrame(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GRAB_FRAME, 0, 0); }
2166 BOOL capGrabFrameNoStop(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GRAB_FRAME_NOSTOP, 0, 0); }
2167
2168 BOOL capCaptureSequence(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SEQUENCE, 0, 0); }
2169 BOOL capCaptureSequenceNoFile(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SEQUENCE_NOFILE, 0, 0); }
2170 BOOL capCaptureStop(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_STOP, 0, 0); }
2171 BOOL capCaptureAbort(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_ABORT, 0, 0); }
2172
2173 BOOL capCaptureSingleFrameOpen(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME_OPEN, 0, 0); }
2174 BOOL capCaptureSingleFrameClose(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME_CLOSE, 0, 0); }
2175 BOOL capCaptureSingleFrame(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME, 0, 0); }
2176
2177 BOOL capCaptureGetSetup(HWND hWnd, LPCAPTUREPARMS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_SEQUENCE_SETUP, wSize, cast(LPARAM)s); }
2178 BOOL capCaptureSetSetup(HWND hWnd, LPCAPTUREPARMS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SEQUENCE_SETUP, wSize, cast(LPARAM)s); }
2179
2180 BOOL capSetMCIDeviceName(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_MCI_DEVICE, 0, cast(LPARAM)szName); }
2181 BOOL capGetMCIDeviceName(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_MCI_DEVICE, wSize, cast(LPARAM)szName); }
2182
2183 BOOL capPaletteOpen(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_OPEN, 0, cast(LPARAM)szName); }
2184 BOOL capPaletteSave(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_SAVE, 0, cast(LPARAM)szName); }
2185 BOOL capPalettePaste(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_PASTE, 0, 0); }
2186 BOOL capPaletteAuto(HWND hWnd, WPARAM iFrames, LPARAM iColors) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_AUTOCREATE, iFrames, iColors); }
2187 BOOL capPaletteManual(HWND hWnd, WPARAM fGrab, LPARAM iColors) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_MANUALCREATE, fGrab, iColors); }
2188
2189 /**
2190 * structs
2191 */
2192
2193 struct CAPDRIVERCAPS {
2194 UINT wDeviceIndex;
2195 BOOL fHasOverlay;
2196 BOOL fHasDlgVideoSource;
2197 BOOL fHasDlgVideoFormat;
2198 BOOL fHasDlgVideoDisplay;
2199 BOOL fCaptureInitialized;
2200 BOOL fDriverSuppliesPalettes;
2201 HANDLE hVideoIn;
2202 HANDLE hVideoOut;
2203 HANDLE hVideoExtIn;
2204 HANDLE hVideoExtOut;
2205 }
2206 alias CAPDRIVERCAPS* PCAPDRIVERCAPS, LPCAPDRIVERCAPS;
2207
2208 struct CAPSTATUS {
2209 UINT uiImageWidth;
2210 UINT uiImageHeight;
2211 BOOL fLiveWindow;
2212 BOOL fOverlayWindow;
2213 BOOL fScale;
2214 POINT ptScroll;
2215 BOOL fUsingDefaultPalette;
2216 BOOL fAudioHardware;
2217 BOOL fCapFileExists;
2218 DWORD dwCurrentVideoFrame;
2219 DWORD dwCurrentVideoFramesDropped;
2220 DWORD dwCurrentWaveSamples;
2221 DWORD dwCurrentTimeElapsedMS;
2222 HPALETTE hPalCurrent;
2223 BOOL fCapturingNow;
2224 DWORD dwReturn;
2225 UINT wNumVideoAllocated;
2226 UINT wNumAudioAllocated;
2227 }
2228 alias CAPSTATUS* PCAPSTATUS, LPCAPSTATUS;
2229
2230 struct CAPTUREPARMS {
2231 DWORD dwRequestMicroSecPerFrame;
2232 BOOL fMakeUserHitOKToCapture;
2233 UINT wPercentDropForError;
2234 BOOL fYield;
2235 DWORD dwIndexSize;
2236 UINT wChunkGranularity;
2237 BOOL fUsingDOSMemory;
2238 UINT wNumVideoRequested;
2239 BOOL fCaptureAudio;
2240 UINT wNumAudioRequested;
2241 UINT vKeyAbort;
2242 BOOL fAbortLeftMouse;
2243 BOOL fAbortRightMouse;
2244 BOOL fLimitEnabled;
2245 UINT wTimeLimit;
2246 BOOL fMCIControl;
2247 BOOL fStepMCIDevice;
2248 DWORD dwMCIStartTime;
2249 DWORD dwMCIStopTime;
2250 BOOL fStepCaptureAt2x;
2251 UINT wStepCaptureAverageFrames;
2252 DWORD dwAudioBufferSize;
2253 BOOL fDisableWriteCache;
2254 UINT AVStreamMaster;
2255 }
2256 alias CAPTUREPARMS* PCAPTUREPARMS, LPCAPTUREPARMS;
2257
2258 enum AVSTREAMMASTER_AUDIO = 0;
2259 enum AVSTREAMMASTER_NONE = 1;
2260
2261 struct CAPINFOCHUNK {
2262 FOURCC fccInfoID;
2263 LPVOID lpData;
2264 LONG cbData;
2265 }
2266 alias CAPINFOCHUNK* PCAPINFOCHUNK, LPCAPINFOCHUNK;
2267
2268 // Callback Definitions
2269
2270 extern (Windows) {
2271 alias LRESULT function(HWND hWnd) CAPYIELDCALLBACK;
2272 alias LRESULT function(HWND hWnd, int nID, LPCWSTR lpsz) CAPSTATUSCALLBACKW;
2273 alias LRESULT function(HWND hWnd, int nID, LPCWSTR lpsz) CAPERRORCALLBACKW;
2274 alias LRESULT function(HWND hWnd, int nID, LPCSTR lpsz) CAPSTATUSCALLBACKA;
2275 alias LRESULT function(HWND hWnd, int nID, LPCSTR lpsz) CAPERRORCALLBACKA;
2276 }
2277
2278 version (Unicode) {
2279 alias CAPSTATUSCALLBACKW CAPSTATUSCALLBACK;
2280 alias CAPERRORCALLBACKW CAPERRORCALLBACK;
2281 } else { // Unicode
2282 alias CAPSTATUSCALLBACKA CAPSTATUSCALLBACK;
2283 alias CAPERRORCALLBACKA CAPERRORCALLBACK;
2284 }
2285
2286 extern (Windows) {
2287 alias LRESULT function(HWND hWnd, LPVIDEOHDR lpVHdr) CAPVIDEOCALLBACK;
2288 alias LRESULT function(HWND hWnd, LPWAVEHDR lpWHdr) CAPWAVECALLBACK;
2289 alias LRESULT function(HWND hWnd, int nState) CAPCONTROLCALLBACK;
2290 }
2291
2292 // CapControlCallback states
2293 enum CONTROLCALLBACK_PREROLL = 1;
2294 enum CONTROLCALLBACK_CAPTURING = 2;
2295
2296 extern (Windows) {
2297 HWND capCreateCaptureWindowA(LPCSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID);
2298 BOOL capGetDriverDescriptionA(UINT wDriverIndex, LPSTR lpszName, int cbName, LPSTR lpszVer, int cbVer);
2299 HWND capCreateCaptureWindowW(LPCWSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID);
2300 BOOL capGetDriverDescriptionW(UINT wDriverIndex, LPWSTR lpszName, int cbName, LPWSTR lpszVer, int cbVer);
2301 }
2302
2303 version (Unicode) {
2304 alias capCreateCaptureWindowW capCreateCaptureWindow;
2305 alias capGetDriverDescriptionW capGetDriverDescription;
2306 } else { // Unicode
2307 alias capCreateCaptureWindowA capCreateCaptureWindow;
2308 alias capGetDriverDescriptionA capGetDriverDescription;
2309 }
2310
2311 // New Information chunk IDs
2312 enum infotypeDIGITIZATION_TIME = mmioFOURCC!('I', 'D', 'I', 'T');
2313 enum infotypeSMPTE_TIME = mmioFOURCC!('I', 'S', 'M', 'P');
2314
2315 // status and error callbacks
2316 enum {
2317 IDS_CAP_BEGIN = 300,
2318 IDS_CAP_END = 301,
2319
2320 IDS_CAP_INFO = 401,
2321 IDS_CAP_OUTOFMEM = 402,
2322 IDS_CAP_FILEEXISTS = 403,
2323 IDS_CAP_ERRORPALOPEN = 404,
2324 IDS_CAP_ERRORPALSAVE = 405,
2325 IDS_CAP_ERRORDIBSAVE = 406,
2326 IDS_CAP_DEFAVIEXT = 407,
2327 IDS_CAP_DEFPALEXT = 408,
2328 IDS_CAP_CANTOPEN = 409,
2329 IDS_CAP_SEQ_MSGSTART = 410,
2330 IDS_CAP_SEQ_MSGSTOP = 411,
2331
2332 IDS_CAP_VIDEDITERR = 412,
2333 IDS_CAP_READONLYFILE = 413,
2334 IDS_CAP_WRITEERROR = 414,
2335 IDS_CAP_NODISKSPACE = 415,
2336 IDS_CAP_SETFILESIZE = 416,
2337 IDS_CAP_SAVEASPERCENT = 417,
2338
2339 IDS_CAP_DRIVER_ERROR = 418,
2340
2341 IDS_CAP_WAVE_OPEN_ERROR = 419,
2342 IDS_CAP_WAVE_ALLOC_ERROR = 420,
2343 IDS_CAP_WAVE_PREPARE_ERROR = 421,
2344 IDS_CAP_WAVE_ADD_ERROR = 422,
2345 IDS_CAP_WAVE_SIZE_ERROR = 423,
2346
2347 IDS_CAP_VIDEO_OPEN_ERROR = 424,
2348 IDS_CAP_VIDEO_ALLOC_ERROR = 425,
2349 IDS_CAP_VIDEO_PREPARE_ERROR = 426,
2350 IDS_CAP_VIDEO_ADD_ERROR = 427,
2351 IDS_CAP_VIDEO_SIZE_ERROR = 428,
2352
2353 IDS_CAP_FILE_OPEN_ERROR = 429,
2354 IDS_CAP_FILE_WRITE_ERROR = 430,
2355 IDS_CAP_RECORDING_ERROR = 431,
2356 IDS_CAP_RECORDING_ERROR2 = 432,
2357 IDS_CAP_AVI_INIT_ERROR = 433,
2358 IDS_CAP_NO_FRAME_CAP_ERROR = 434,
2359 IDS_CAP_NO_PALETTE_WARN = 435,
2360 IDS_CAP_MCI_CONTROL_ERROR = 436,
2361 IDS_CAP_MCI_CANT_STEP_ERROR = 437,
2362 IDS_CAP_NO_AUDIO_CAP_ERROR = 438,
2363 IDS_CAP_AVI_DRAWDIB_ERROR = 439,
2364 IDS_CAP_COMPRESSOR_ERROR = 440,
2365 IDS_CAP_AUDIO_DROP_ERROR = 441,
2366 IDS_CAP_AUDIO_DROP_COMPERROR = 442,
2367
2368 IDS_CAP_STAT_LIVE_MODE = 500,
2369 IDS_CAP_STAT_OVERLAY_MODE = 501,
2370 IDS_CAP_STAT_CAP_INIT = 502,
2371 IDS_CAP_STAT_CAP_FINI = 503,
2372 IDS_CAP_STAT_PALETTE_BUILD = 504,
2373 IDS_CAP_STAT_OPTPAL_BUILD = 505,
2374 IDS_CAP_STAT_I_FRAMES = 506,
2375 IDS_CAP_STAT_L_FRAMES = 507,
2376 IDS_CAP_STAT_CAP_L_FRAMES = 508,
2377 IDS_CAP_STAT_CAP_AUDIO = 509,
2378 IDS_CAP_STAT_VIDEOCURRENT = 510,
2379 IDS_CAP_STAT_VIDEOAUDIO = 511,
2380 IDS_CAP_STAT_VIDEOONLY = 512,
2381 IDS_CAP_STAT_FRAMESDROPPED = 513,
2382 }
2383
2384 /**
2385 * FilePreview dialog.
2386 */
2387
2388 extern (Windows) {
2389 BOOL GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn);
2390 BOOL GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn);
2391 BOOL GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn);
2392 BOOL GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn);
2393 }
2394
2395 version (Unicode) {
2396 alias GetOpenFileNamePreviewW GetOpenFileNamePreview;
2397 alias GetSaveFileNamePreviewW GetSaveFileNamePreview;
2398 } else { // Unicode
2399 alias GetOpenFileNamePreviewA GetOpenFileNamePreview;
2400 alias GetSaveFileNamePreviewA GetSaveFileNamePreview;
2401 }
2402