root/trunk/win32/vfw.d

Revision 372, 79.1 kB (checked in by CyberShadow, 5 months ago)

win32: Replace typedef with compatibility wrapper template

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