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