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