source: trunk/include/win/vfw.h@ 4620

Last change on this file since 4620 was 4608, checked in by sandervl, 25 years ago

header updates for comctl32
File size: 40.2 KB
Line 
1#ifndef __WINE_VFW_H
2#define __WINE_VFW_H
3
4#include "windef.h"
5#include "mmsystem.h"
6#include "wingdi.h"
7#include "unknwn.h"
8
9#ifndef __cplusplus
10#ifndef inline
11#define inline
12#endif
13#endif
14
15#define VFWAPI WINAPI
16#define VFWAPIV WINAPIV
17
18#ifdef __cplusplus
19extern "C" {
20#endif /* __cplusplus */
21
22typedef HANDLE HDRAWDIB;
23
24HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCSTR szFile);
25HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCWSTR szFile);
26#define MCIWndCreate WINELIB_NAME_AW(MCIWndCreate)
27DWORD VFWAPI VideoForWindowsVersion(void);
28LONG VFWAPI InitVFW(void);
29LONG VFWAPI TermVFW(void);
30
31#ifndef mmioFOURCC
32#define mmioFOURCC( ch0, ch1, ch2, ch3 ) \
33 ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \
34 ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
35#endif
36
37#ifndef aviTWOCC
38#define aviTWOCC(ch0, ch1) ((WORD)(BYTE)(ch0) | ((WORD)(BYTE)(ch1) << 8))
39#endif
40
41#define ICTYPE_VIDEO mmioFOURCC('v', 'i', 'd', 'c')
42#define ICTYPE_AUDIO mmioFOURCC('a', 'u', 'd', 'c')
43
44/*****************************************************************************
45 * Predeclare the interfaces
46 */
47typedef struct IAVIStream IAVIStream,*PAVISTREAM;
48typedef struct IAVIFile IAVIFile,*PAVIFILE;
49typedef struct IGetFrame IGetFrame,*PGETFRAME;
50
51/* Installable Compressor Manager */
52
53DECLARE_HANDLE(HIC);
54
55#ifdef __WINE__
56/* HIC struct (same layout as Win95 one) */
57typedef struct tagWINE_HIC {
58 DWORD magic; /* 00: 'Smag' */
59 HANDLE curthread; /* 04: */
60 DWORD type; /* 08: */
61 DWORD handler; /* 0C: */
62 HDRVR hdrv; /* 10: */
63 DWORD private; /* 14:(handled by SendDriverMessage)*/
64 FARPROC driverproc; /* 18:(handled by SendDriverMessage)*/
65 DWORD x1; /* 1c: name? */
66 WORD x2; /* 20: */
67 DWORD x3; /* 22: */
68 /* 26: */
69} WINE_HIC;
70#endif
71
72/* error return codes */
73#define ICERR_OK 0
74#define ICERR_DONTDRAW 1
75#define ICERR_NEWPALETTE 2
76#define ICERR_GOTOKEYFRAME 3
77#define ICERR_STOPDRAWING 4
78
79#define ICERR_UNSUPPORTED -1
80#define ICERR_BADFORMAT -2
81#define ICERR_MEMORY -3
82#define ICERR_INTERNAL -4
83#define ICERR_BADFLAGS -5
84#define ICERR_BADPARAM -6
85#define ICERR_BADSIZE -7
86#define ICERR_BADHANDLE -8
87#define ICERR_CANTUPDATE -9
88#define ICERR_ABORT -10
89#define ICERR_ERROR -100
90#define ICERR_BADBITDEPTH -200
91#define ICERR_BADIMAGESIZE -201
92
93#define ICERR_CUSTOM -400
94
95/* ICM Messages */
96#define ICM_USER (DRV_USER+0x0000)
97
98/* ICM driver message range */
99#define ICM_RESERVED_LOW (DRV_USER+0x1000)
100#define ICM_RESERVED_HIGH (DRV_USER+0x2000)
101#define ICM_RESERVED ICM_RESERVED_LOW
102
103#define ICM_GETSTATE (ICM_RESERVED+0)
104#define ICM_SETSTATE (ICM_RESERVED+1)
105#define ICM_GETINFO (ICM_RESERVED+2)
106
107#define ICM_CONFIGURE (ICM_RESERVED+10)
108#define ICM_ABOUT (ICM_RESERVED+11)
109/* */
110
111#define ICM_GETDEFAULTQUALITY (ICM_RESERVED+30)
112#define ICM_GETQUALITY (ICM_RESERVED+31)
113#define ICM_SETQUALITY (ICM_RESERVED+32)
114
115#define ICM_SET (ICM_RESERVED+40)
116#define ICM_GET (ICM_RESERVED+41)
117
118/* 2 constant FOURCC codes */
119#define ICM_FRAMERATE mmioFOURCC('F','r','m','R')
120#define ICM_KEYFRAMERATE mmioFOURCC('K','e','y','R')
121
122#define ICM_COMPRESS_GET_FORMAT (ICM_USER+4)
123#define ICM_COMPRESS_GET_SIZE (ICM_USER+5)
124#define ICM_COMPRESS_QUERY (ICM_USER+6)
125#define ICM_COMPRESS_BEGIN (ICM_USER+7)
126#define ICM_COMPRESS (ICM_USER+8)
127#define ICM_COMPRESS_END (ICM_USER+9)
128
129#define ICM_DECOMPRESS_GET_FORMAT (ICM_USER+10)
130#define ICM_DECOMPRESS_QUERY (ICM_USER+11)
131#define ICM_DECOMPRESS_BEGIN (ICM_USER+12)
132#define ICM_DECOMPRESS (ICM_USER+13)
133#define ICM_DECOMPRESS_END (ICM_USER+14)
134#define ICM_DECOMPRESS_SET_PALETTE (ICM_USER+29)
135#define ICM_DECOMPRESS_GET_PALETTE (ICM_USER+30)
136
137#define ICM_DRAW_QUERY (ICM_USER+31)
138#define ICM_DRAW_BEGIN (ICM_USER+15)
139#define ICM_DRAW_GET_PALETTE (ICM_USER+16)
140#define ICM_DRAW_START (ICM_USER+18)
141#define ICM_DRAW_STOP (ICM_USER+19)
142#define ICM_DRAW_END (ICM_USER+21)
143#define ICM_DRAW_GETTIME (ICM_USER+32)
144#define ICM_DRAW (ICM_USER+33)
145#define ICM_DRAW_WINDOW (ICM_USER+34)
146#define ICM_DRAW_SETTIME (ICM_USER+35)
147#define ICM_DRAW_REALIZE (ICM_USER+36)
148#define ICM_DRAW_FLUSH (ICM_USER+37)
149#define ICM_DRAW_RENDERBUFFER (ICM_USER+38)
150
151#define ICM_DRAW_START_PLAY (ICM_USER+39)
152#define ICM_DRAW_STOP_PLAY (ICM_USER+40)
153
154#define ICM_DRAW_SUGGESTFORMAT (ICM_USER+50)
155#define ICM_DRAW_CHANGEPALETTE (ICM_USER+51)
156
157#define ICM_GETBUFFERSWANTED (ICM_USER+41)
158
159#define ICM_GETDEFAULTKEYFRAMERATE (ICM_USER+42)
160
161#define ICM_DECOMPRESSEX_BEGIN (ICM_USER+60)
162#define ICM_DECOMPRESSEX_QUERY (ICM_USER+61)
163#define ICM_DECOMPRESSEX (ICM_USER+62)
164#define ICM_DECOMPRESSEX_END (ICM_USER+63)
165
166#define ICM_COMPRESS_FRAMES_INFO (ICM_USER+70)
167#define ICM_SET_STATUS_PROC (ICM_USER+72)
168
169/* structs */
170
171/* NOTE: Only the 16 bit structs are packed. Structs that are packed anyway
172 * have not been changed. If a structure is later extended, you may need to create
173 * two versions of it.
174 */
175
176typedef struct {
177 DWORD dwSize; /* 00: size */
178 DWORD fccType; /* 04: type 'vidc' usually */
179 DWORD fccHandler; /* 08: */
180 DWORD dwVersion; /* 0c: version of compman opening you */
181 DWORD dwFlags; /* 10: LOWORD is type specific */
182 LRESULT dwError; /* 14: */
183 LPVOID pV1Reserved; /* 18: */
184 LPVOID pV2Reserved; /* 1c: */
185 DWORD dnDevNode; /* 20: */
186 /* 24: */
187} ICOPEN,*LPICOPEN;
188
189#define ICCOMPRESS_KEYFRAME 0x00000001L
190
191typedef struct {
192 DWORD dwFlags;
193 LPBITMAPINFOHEADER lpbiOutput;
194 LPVOID lpOutput;
195 LPBITMAPINFOHEADER lpbiInput;
196 LPVOID lpInput;
197 LPDWORD lpckid;
198 LPDWORD lpdwFlags;
199 LONG lFrameNum;
200 DWORD dwFrameSize;
201 DWORD dwQuality;
202 LPBITMAPINFOHEADER lpbiPrev;
203 LPVOID lpPrev;
204} ICCOMPRESS;
205
206DWORD VFWAPIV ICCompress(
207 HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
208 LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
209 LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
210 LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
211);
212
213#define ICCompressGetFormat(hic, lpbiInput, lpbiOutput) \
214 ICSendMessage( \
215 hic,ICM_COMPRESS_GET_FORMAT,(DWORD)(LPVOID)(lpbiInput), \
216 (DWORD)(LPVOID)(lpbiOutput) \
217 )
218
219#define ICCompressGetFormatSize(hic,lpbi) ICCompressGetFormat(hic,lpbi,NULL)
220
221#define ICCompressBegin(hic, lpbiInput, lpbiOutput) \
222 ICSendMessage( \
223 hic, ICM_COMPRESS_BEGIN, (DWORD)(LPVOID)(lpbiInput), \
224 (DWORD)(LPVOID)(lpbiOutput) \
225 )
226
227#define ICCompressGetSize(hic, lpbiInput, lpbiOutput) \
228 ICSendMessage( \
229 hic, ICM_COMPRESS_GET_SIZE, (DWORD)(LPVOID)(lpbiInput), \
230 (DWORD)(LPVOID)(lpbiOutput) \
231 )
232
233#define ICCompressQuery(hic, lpbiInput, lpbiOutput) \
234 ICSendMessage( \
235 hic, ICM_COMPRESS_QUERY, (DWORD)(LPVOID)(lpbiInput), \
236 (DWORD)(LPVOID)(lpbiOutput) \
237 )
238
239#define ICCompressEnd(hic) ICSendMessage(hic, ICM_COMPRESS_END, 0, 0)
240
241/* ICCOMPRESSFRAMES.dwFlags */
242#define ICCOMPRESSFRAMES_PADDING 0x00000001
243typedef struct {
244 DWORD dwFlags;
245 LPBITMAPINFOHEADER lpbiOutput;
246 LPARAM lOutput;
247 LPBITMAPINFOHEADER lpbiInput;
248 LPARAM lInput;
249 LONG lStartFrame;
250 LONG lFrameCount;
251 LONG lQuality;
252 LONG lDataRate;
253 LONG lKeyRate;
254 DWORD dwRate;
255 DWORD dwScale;
256 DWORD dwOverheadPerFrame;
257 DWORD dwReserved2;
258#ifdef __WIN32OS2__
259 LONG (* CALLBACK GetData)(LPARAM lInput,LONG lFrame,LPVOID lpBits,LONG len);
260 LONG (* CALLBACK PutData)(LPARAM lOutput,LONG lFrame,LPVOID lpBits,LONG len);
261#else
262 LONG CALLBACK (*GetData)(LPARAM lInput,LONG lFrame,LPVOID lpBits,LONG len);
263 LONG CALLBACK (*PutData)(LPARAM lOutput,LONG lFrame,LPVOID lpBits,LONG len);
264#endif
265} ICCOMPRESSFRAMES;
266
267typedef struct {
268 DWORD dwFlags;
269 LPARAM lParam;
270 /* messages for Status callback */
271#define ICSTATUS_START 0
272#define ICSTATUS_STATUS 1
273#define ICSTATUS_END 2
274#define ICSTATUS_ERROR 3
275#define ICSTATUS_YIELD 4
276 /* FIXME: some X11 libs define Status as int... */
277 /* LONG CALLBACK (*zStatus)(LPARAM lParam, UINT message, LONG l); */
278#ifdef __WIN32OS2__
279 LONG (* CALLBACK zStatus)(LPARAM lParam, UINT message, LONG l);
280#else
281 LONG CALLBACK (*zStatus)(LPARAM lParam, UINT message, LONG l);
282#endif
283} ICSETSTATUSPROC;
284
285/* Values for wMode of ICOpen() */
286#define ICMODE_COMPRESS 1
287#define ICMODE_DECOMPRESS 2
288#define ICMODE_FASTDECOMPRESS 3
289#define ICMODE_QUERY 4
290#define ICMODE_FASTCOMPRESS 5
291#define ICMODE_DRAW 8
292
293/* quality flags */
294#define ICQUALITY_LOW 0
295#define ICQUALITY_HIGH 10000
296#define ICQUALITY_DEFAULT -1
297
298typedef struct {
299 DWORD dwSize; /* 00: */
300 DWORD fccType; /* 04:compressor type 'vidc' 'audc' */
301 DWORD fccHandler; /* 08:compressor sub-type 'rle ' 'jpeg' 'pcm '*/
302 DWORD dwFlags; /* 0c:flags LOWORD is type specific */
303 DWORD dwVersion; /* 10:version of the driver */
304 DWORD dwVersionICM; /* 14:version of the ICM used */
305 /*
306 * under Win32, the driver always returns UNICODE strings.
307 */
308 WCHAR szName[16]; /* 18:short name */
309 WCHAR szDescription[128]; /* 38:long name */
310 WCHAR szDriver[128]; /* 138:driver that contains compressor*/
311 /* 238: */
312} ICINFO;
313
314/* ICINFO.dwFlags */
315#define VIDCF_QUALITY 0x0001 /* supports quality */
316#define VIDCF_CRUNCH 0x0002 /* supports crunching to a frame size */
317#define VIDCF_TEMPORAL 0x0004 /* supports inter-frame compress */
318#define VIDCF_COMPRESSFRAMES 0x0008 /* wants the compress all frames message */
319#define VIDCF_DRAW 0x0010 /* supports drawing */
320#define VIDCF_FASTTEMPORALC 0x0020 /* does not need prev frame on compress */
321#define VIDCF_FASTTEMPORALD 0x0080 /* does not need prev frame on decompress */
322#define VIDCF_QUALITYTIME 0x0040 /* supports temporal quality */
323
324#define VIDCF_FASTTEMPORAL (VIDCF_FASTTEMPORALC|VIDCF_FASTTEMPORALD)
325
326
327/* function shortcuts */
328/* ICM_ABOUT */
329#define ICMF_ABOUT_QUERY 0x00000001
330
331#define ICQueryAbout(hic) \
332 (ICSendMessage(hic,ICM_ABOUT,(DWORD)-1,ICMF_ABOUT_QUERY)==ICERR_OK)
333
334#define ICAbout(hic, hwnd) ICSendMessage(hic,ICM_ABOUT,(DWORD)(UINT)(hwnd),0)
335
336/* ICM_CONFIGURE */
337#define ICMF_CONFIGURE_QUERY 0x00000001
338#define ICQueryConfigure(hic) \
339 (ICSendMessage(hic,ICM_CONFIGURE,(DWORD)-1,ICMF_CONFIGURE_QUERY)==ICERR_OK)
340
341#define ICConfigure(hic,hwnd) \
342 ICSendMessage(hic,ICM_CONFIGURE,(DWORD)(UINT)(hwnd),0)
343
344/* Decompression stuff */
345#define ICDECOMPRESS_HURRYUP 0x80000000 /* don't draw just buffer (hurry up!) */
346#define ICDECOMPRESS_UPDATE 0x40000000 /* don't draw just update screen */
347#define ICDECOMPRESS_PREROLL 0x20000000 /* this frame is before real start */
348#define ICDECOMPRESS_NULLFRAME 0x10000000 /* repeat last frame */
349#define ICDECOMPRESS_NOTKEYFRAME 0x08000000 /* this frame is not a key frame */
350
351typedef struct {
352 DWORD dwFlags; /* flags (from AVI index...) */
353 LPBITMAPINFOHEADER lpbiInput; /* BITMAPINFO of compressed data */
354 LPVOID lpInput; /* compressed data */
355 LPBITMAPINFOHEADER lpbiOutput; /* DIB to decompress to */
356 LPVOID lpOutput;
357 DWORD ckid; /* ckid from AVI file */
358} ICDECOMPRESS;
359
360typedef struct {
361 DWORD dwFlags;
362 LPBITMAPINFOHEADER lpbiSrc;
363 LPVOID lpSrc;
364 LPBITMAPINFOHEADER lpbiDst;
365 LPVOID lpDst;
366
367 /* changed for ICM_DECOMPRESSEX */
368 INT xDst; /* destination rectangle */
369 INT yDst;
370 INT dxDst;
371 INT dyDst;
372
373 INT xSrc; /* source rectangle */
374 INT ySrc;
375 INT dxSrc;
376 INT dySrc;
377} ICDECOMPRESSEX;
378
379DWORD VFWAPIV ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits);
380
381#define ICDecompressBegin(hic, lpbiInput, lpbiOutput) \
382 ICSendMessage( \
383 hic, ICM_DECOMPRESS_BEGIN, (DWORD)(LPVOID)(lpbiInput), \
384 (DWORD)(LPVOID)(lpbiOutput) \
385 )
386
387#define ICDecompressQuery(hic, lpbiInput, lpbiOutput) \
388 ICSendMessage( \
389 hic,ICM_DECOMPRESS_QUERY, (DWORD)(LPVOID)(lpbiInput), \
390 (DWORD) (LPVOID)(lpbiOutput) \
391 )
392
393#define ICDecompressGetFormat(hic, lpbiInput, lpbiOutput) \
394 ((LONG)ICSendMessage( \
395 hic,ICM_DECOMPRESS_GET_FORMAT, (DWORD)(LPVOID)(lpbiInput), \
396 (DWORD)(LPVOID)(lpbiOutput) \
397 ))
398
399#define ICDecompressGetFormatSize(hic, lpbi) \
400 ICDecompressGetFormat(hic, lpbi, NULL)
401
402#define ICDecompressGetPalette(hic, lpbiInput, lpbiOutput) \
403 ICSendMessage( \
404 hic, ICM_DECOMPRESS_GET_PALETTE, (DWORD)(LPVOID)(lpbiInput), \
405 (DWORD)(LPVOID)(lpbiOutput) \
406 )
407
408#define ICDecompressSetPalette(hic,lpbiPalette) \
409 ICSendMessage( \
410 hic,ICM_DECOMPRESS_SET_PALETTE, \
411 (DWORD)(LPVOID)(lpbiPalette),0 \
412 )
413
414#define ICDecompressEnd(hic) ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0)
415
416LRESULT VFWAPI ICSendMessage(HIC hic, UINT msg, DWORD dw1, DWORD dw2);
417
418inline static LRESULT VFWAPI ICDecompressEx(HIC hic, DWORD dwFlags,
419 LPBITMAPINFOHEADER lpbiSrc, LPVOID lpSrc,
420 int xSrc, int ySrc, int dxSrc, int dySrc,
421 LPBITMAPINFOHEADER lpbiDst, LPVOID lpDst,
422 int xDst, int yDst, int dxDst, int dyDst)
423{
424 ICDECOMPRESSEX ic;
425
426 ic.dwFlags = dwFlags;
427 ic.lpbiSrc = lpbiSrc;
428 ic.lpSrc = lpSrc;
429 ic.xSrc = xSrc;
430 ic.ySrc = ySrc;
431 ic.dxSrc = dxSrc;
432 ic.dySrc = dySrc;
433 ic.lpbiDst = lpbiDst;
434 ic.lpDst = lpDst;
435 ic.xDst = xDst;
436 ic.yDst = yDst;
437 ic.dxDst = dxDst;
438 ic.dyDst = dyDst;
439 return ICSendMessage(hic, ICM_DECOMPRESSEX, (DWORD)&ic, sizeof(ic));
440}
441
442inline static LRESULT VFWAPI ICDecompressExBegin(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_BEGIN, (DWORD)&ic, sizeof(ic));
469}
470inline static LRESULT VFWAPI ICDecompressExQuery(HIC hic, DWORD dwFlags,
471 LPBITMAPINFOHEADER lpbiSrc,
472 LPVOID lpSrc,
473 int xSrc, int ySrc, int dxSrc, int dySrc,
474 LPBITMAPINFOHEADER lpbiDst,
475 LPVOID lpDst,
476 int xDst,
477 int yDst,
478 int dxDst,
479 int dyDst)
480{
481 ICDECOMPRESSEX ic;
482
483 ic.dwFlags = dwFlags;
484 ic.lpbiSrc = lpbiSrc;
485 ic.lpSrc = lpSrc;
486 ic.xSrc = xSrc;
487 ic.ySrc = ySrc;
488 ic.dxSrc = dxSrc;
489 ic.dySrc = dySrc;
490 ic.lpbiDst = lpbiDst;
491 ic.lpDst = lpDst;
492 ic.xDst = xDst;
493 ic.yDst = yDst;
494 ic.dxDst = dxDst;
495 ic.dyDst = dyDst;
496 return ICSendMessage(hic, ICM_DECOMPRESSEX_QUERY, (DWORD)&ic, sizeof(ic));
497}
498
499#define ICDecompressExEnd(hic) \
500 ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0)
501
502#define ICDRAW_QUERY 0x00000001L /* test for support */
503#define ICDRAW_FULLSCREEN 0x00000002L /* draw to full screen */
504#define ICDRAW_HDC 0x00000004L /* draw to a HDC/HWND */
505#define ICDRAW_ANIMATE 0x00000008L /* expect palette animation */
506#define ICDRAW_CONTINUE 0x00000010L /* draw is a continuation of previous draw */
507#define ICDRAW_MEMORYDC 0x00000020L /* DC is offscreen, by the way */
508#define ICDRAW_UPDATING 0x00000040L /* We're updating, as opposed to playing */
509#define ICDRAW_RENDER 0x00000080L /* used to render data not draw it */
510#define ICDRAW_BUFFER 0x00000100L /* buffer data offscreen, we will need to update it */
511
512#define ICDecompressOpen(fccType, fccHandler, lpbiIn, lpbiOut) \
513 ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS)
514
515#define ICDrawOpen(fccType, fccHandler, lpbiIn) \
516 ICLocate(fccType, fccHandler, lpbiIn, NULL, ICMODE_DRAW)
517
518HANDLE VFWAPI ICImageCompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn,
519 LPVOID lpBits, LPBITMAPINFO lpbiOut, LONG lQuality,
520 LONG* plSize);
521
522HANDLE VFWAPI ICImageDecompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn,
523 LPVOID lpBits, LPBITMAPINFO lpbiOut);
524
525BOOL VFWAPI ICInfo(DWORD fccType, DWORD fccHandler, ICINFO * lpicinfo);
526BOOL VFWAPI ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags);
527BOOL VFWAPI ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags);
528LRESULT VFWAPI ICGetInfo(HIC hic,ICINFO *picinfo, DWORD cb);
529HIC VFWAPI ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode);
530HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler);
531
532LRESULT VFWAPI ICClose(HIC hic);
533HIC VFWAPI ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
534HIC VFWAPI ICGetDisplayFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, int BitDepth, int dx, int dy);
535
536/* Values for wFlags of ICInstall() */
537#define ICINSTALL_UNICODE 0x8000
538#define ICINSTALL_FUNCTION 0x0001
539#define ICINSTALL_DRIVER 0x0002
540#define ICINSTALL_HDRV 0x0004
541#define ICINSTALL_DRIVERW 0x8002
542
543#define ICGetState(hic, pv, cb) \
544 ICSendMessage(hic, ICM_GETSTATE, (DWORD)(LPVOID)(pv), (DWORD)(cb))
545#define ICSetState(hic, pv, cb) \
546 ICSendMessage(hic, ICM_SETSTATE, (DWORD)(LPVOID)(pv), (DWORD)(cb))
547#define ICGetStateSize(hic) \
548 ICGetState(hic, NULL, 0)
549
550inline static DWORD ICGetDefaultQuality(HIC hic)
551{
552 DWORD dwICValue;
553 ICSendMessage(hic, ICM_GETDEFAULTQUALITY, (DWORD)(LPVOID)&dwICValue, sizeof(DWORD));
554 return dwICValue;
555}
556
557inline static DWORD ICGetDefaultKeyFrameRate(HIC hic)
558{
559 DWORD dwICValue;
560 ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, (DWORD)(LPVOID)&dwICValue, sizeof(DWORD));
561 return dwICValue;
562}
563
564#define ICDrawWindow(hic, prc) \
565 ICSendMessage(hic, ICM_DRAW_WINDOW, (DWORD)(LPVOID)(prc), sizeof(RECT))
566
567/* As passed to ICM_DRAW_SUGGESTFORMAT */
568typedef struct {
569 DWORD dwFlags;
570 LPBITMAPINFOHEADER lpbiIn;
571 LPBITMAPINFOHEADER lpbiSuggest;
572 INT dxSrc;
573 INT dySrc;
574 INT dxDst;
575 INT dyDst;
576 HIC hicDecompressor;
577} ICDRAWSUGGEST;
578
579typedef struct {
580 DWORD dwFlags;
581 int iStart;
582 int iLen;
583 LPPALETTEENTRY lppe;
584} ICPALETTE;
585
586DWORD VFWAPIV ICDrawBegin(
587 HIC hic,
588 DWORD dwFlags,/* flags */
589 HPALETTE hpal, /* palette to draw with */
590 HWND hwnd, /* window to draw to */
591 HDC hdc, /* HDC to draw to */
592 INT xDst, /* destination rectangle */
593 INT yDst,
594 INT dxDst,
595 INT dyDst,
596 LPBITMAPINFOHEADER lpbi, /* format of frame to draw */
597 INT xSrc, /* source rectangle */
598 INT ySrc,
599 INT dxSrc,
600 INT dySrc,
601 DWORD dwRate, /* frames/second = (dwRate/dwScale) */
602 DWORD dwScale
603);
604
605/* as passed to ICM_DRAW_BEGIN */
606typedef struct {
607 DWORD dwFlags;
608 HPALETTE hpal;
609 HWND hwnd;
610 HDC hdc;
611 INT xDst;
612 INT yDst;
613 INT dxDst;
614 INT dyDst;
615 LPBITMAPINFOHEADER lpbi;
616 INT xSrc;
617 INT ySrc;
618 INT dxSrc;
619 INT dySrc;
620 DWORD dwRate;
621 DWORD dwScale;
622} ICDRAWBEGIN;
623
624#define ICDRAW_HURRYUP 0x80000000L /* don't draw just buffer (hurry up!) */
625#define ICDRAW_UPDATE 0x40000000L /* don't draw just update screen */
626#define ICDRAW_PREROLL 0x20000000L /* this frame is before real start */
627#define ICDRAW_NULLFRAME 0x10000000L /* repeat last frame */
628#define ICDRAW_NOTKEYFRAME 0x08000000L /* this frame is not a key frame */
629
630typedef struct {
631 DWORD dwFlags;
632 LPVOID lpFormat;
633 LPVOID lpData;
634 DWORD cbData;
635 LONG lTime;
636} ICDRAW;
637
638DWORD VFWAPIV ICDraw(HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,LONG lTime);
639
640inline static LRESULT VFWAPI ICDrawSuggestFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn,
641 LPBITMAPINFOHEADER lpbiOut,
642 int dxSrc, int dySrc,
643 int dxDst, int dyDst,
644 HIC hicDecomp)
645{
646 ICDRAWSUGGEST ic;
647
648 ic.lpbiIn = lpbiIn;
649 ic.lpbiSuggest = lpbiOut;
650 ic.dxSrc = dxSrc;
651 ic.dySrc = dySrc;
652 ic.dxDst = dxDst;
653 ic.dyDst = dyDst;
654 ic.hicDecompressor = hicDecomp;
655 return ICSendMessage(hic, ICM_DRAW_SUGGESTFORMAT, (DWORD)&ic, sizeof(ic));
656}
657
658#define ICDrawQuery(hic, lpbiInput) \
659 ICSendMessage(hic, ICM_DRAW_QUERY, (DWORD)(LPVOID)(lpbiInput), 0L)
660
661#define ICDrawChangePalette(hic, lpbiInput) \
662 ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, (DWORD)(LPVOID)(lpbiInput), 0L)
663
664#define ICGetBuffersWanted(hic, lpdwBuffers) \
665 ICSendMessage(hic, ICM_GETBUFFERSWANTED, (DWORD)(LPVOID)(lpdwBuffers), 0)
666
667#define ICDrawEnd(hic) \
668 ICSendMessage(hic, ICM_DRAW_END, 0, 0)
669
670#define ICDrawStart(hic) \
671 ICSendMessage(hic, ICM_DRAW_START, 0, 0)
672
673#define ICDrawStartPlay(hic, lFrom, lTo) \
674 ICSendMessage(hic, ICM_DRAW_START_PLAY, (DWORD)(lFrom), (DWORD)(lTo))
675
676#define ICDrawStop(hic) \
677 ICSendMessage(hic, ICM_DRAW_STOP, 0, 0)
678
679#define ICDrawStopPlay(hic) \
680 ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0)
681
682#define ICDrawGetTime(hic, lplTime) \
683 ICSendMessage(hic, ICM_DRAW_GETTIME, (DWORD)(LPVOID)(lplTime), 0)
684
685#define ICDrawSetTime(hic, lTime) \
686 ICSendMessage(hic, ICM_DRAW_SETTIME, (DWORD)lTime, 0)
687
688#define ICDrawRealize(hic, hdc, fBackground) \
689 ICSendMessage(hic, ICM_DRAW_REALIZE, (DWORD)(UINT)(HDC)(hdc), (DWORD)(BOOL)(fBackground))
690
691#define ICDrawFlush(hic) \
692 ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0)
693
694#define ICDrawRenderBuffer(hic) \
695 ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0)
696
697inline static LRESULT VFWAPI ICSetStatusProc(HIC hic, DWORD dwFlags, LRESULT lParam,
698#ifdef __WIN32OS2__
699 LONG (* CALLBACK fpfnStatus)(LPARAM, UINT, LONG))
700#else
701 LONG (CALLBACK *fpfnStatus)(LPARAM, UINT, LONG))
702#endif
703{
704 ICSETSTATUSPROC ic;
705
706 ic.dwFlags = dwFlags;
707 ic.lParam = lParam;
708 /* FIXME: see comment in ICSETSTATUSPROC definition */
709 ic.zStatus = fpfnStatus;
710
711 return ICSendMessage(hic, ICM_SET_STATUS_PROC, (DWORD)&ic, sizeof(ic));
712}
713
714typedef struct {
715 LONG cbSize;
716 DWORD dwFlags;
717 HIC hic;
718 DWORD fccType;
719 DWORD fccHandler;
720 LPBITMAPINFO lpbiIn;
721 LPBITMAPINFO lpbiOut;
722 LPVOID lpBitsOut;
723 LPVOID lpBitsPrev;
724 LONG lFrame;
725 LONG lKey;
726 LONG lDataRate;
727 LONG lQ;
728 LONG lKeyCount;
729 LPVOID lpState;
730 LONG cbState;
731} COMPVARS, *PCOMPVARS;
732
733#define ICMF_COMPVARS_VALID 0x00000001
734
735BOOL VFWAPI ICCompressorChoose(HWND hwnd, UINT uiFlags, LPVOID pvIn, LPVOID lpData,
736 PCOMPVARS pc, LPSTR lpszTitle);
737
738#define ICMF_CHOOSE_KEYFRAME 0x0001
739#define ICMF_CHOOSE_DATARATE 0x0002
740#define ICMF_CHOOSE_PREVIEW 0x0004
741#define ICMF_CHOOSE_ALLCOMPRESSORS 0x0008
742
743BOOL VFWAPI ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn);
744void VFWAPI ICSeqCompressFrameEnd(PCOMPVARS pc);
745
746LPVOID VFWAPI ICSeqCompressFrame(PCOMPVARS pc, UINT uiFlags, LPVOID lpBits,
747 BOOL *pfKey, LONG *plSize);
748void VFWAPI ICCompressorFree(PCOMPVARS pc);
749
750/********************* AVIFILE function declarations *************************/
751#define formtypeAVI mmioFOURCC('A', 'V', 'I', ' ')
752#define listtypeAVIHEADER mmioFOURCC('h', 'd', 'r', 'l')
753#define ckidAVIMAINHDR mmioFOURCC('a', 'v', 'i', 'h')
754#define listtypeSTREAMHEADER mmioFOURCC('s', 't', 'r', 'l')
755#define ckidSTREAMHEADER mmioFOURCC('s', 't', 'r', 'h')
756#define ckidSTREAMFORMAT mmioFOURCC('s', 't', 'r', 'f')
757#define ckidSTREAMHANDLERDATA mmioFOURCC('s', 't', 'r', 'd')
758#define ckidSTREAMNAME mmioFOURCC('s', 't', 'r', 'n')
759
760#define listtypeAVIMOVIE mmioFOURCC('m', 'o', 'v', 'i')
761#define listtypeAVIRECORD mmioFOURCC('r', 'e', 'c', ' ')
762
763#define ckidAVINEWINDEX mmioFOURCC('i', 'd', 'x', '1')
764
765#define streamtypeVIDEO mmioFOURCC('v', 'i', 'd', 's')
766#define streamtypeAUDIO mmioFOURCC('a', 'u', 'd', 's')
767#define streamtypeMIDI mmioFOURCC('m', 'i', 'd', 's')
768#define streamtypeTEXT mmioFOURCC('t', 'x', 't', 's')
769
770/* Basic chunk types */
771#define cktypeDIBbits aviTWOCC('d', 'b')
772#define cktypeDIBcompressed aviTWOCC('d', 'c')
773#define cktypePALchange aviTWOCC('p', 'c')
774#define cktypeWAVEbytes aviTWOCC('w', 'b')
775
776/* Chunk id to use for extra chunks for padding. */
777#define ckidAVIPADDING mmioFOURCC('J', 'U', 'N', 'K')
778
779/* AVIFileHdr.dwFlags */
780#define AVIF_HASINDEX 0x00000010 /* Index at end of file? */
781#define AVIF_MUSTUSEINDEX 0x00000020
782#define AVIF_ISINTERLEAVED 0x00000100
783#define AVIF_TRUSTCKTYPE 0x00000800 /* Use CKType to find key frames*/
784#define AVIF_WASCAPTUREFILE 0x00010000
785#define AVIF_COPYRIGHTED 0x00020000
786
787#define AVI_HEADERSIZE 2048
788
789typedef struct _MainAVIHeader
790{
791 DWORD dwMicroSecPerFrame;
792 DWORD dwMaxBytesPerSec;
793 DWORD dwPaddingGranularity;
794 DWORD dwFlags;
795 DWORD dwTotalFrames;
796 DWORD dwInitialFrames;
797 DWORD dwStreams;
798 DWORD dwSuggestedBufferSize;
799 DWORD dwWidth;
800 DWORD dwHeight;
801 DWORD dwReserved[4];
802} MainAVIHeader;
803
804/* AVIStreamHeader.dwFlags */
805#define AVISF_DISABLED 0x00000001
806#define AVISF_VIDEO_PALCHANGES 0x00010000
807
808typedef struct {
809 FOURCC fccType;
810 FOURCC fccHandler;
811 DWORD dwFlags; /* AVISF_* */
812 WORD wPriority;
813 WORD wLanguage;
814 DWORD dwInitialFrames;
815 DWORD dwScale;
816 DWORD dwRate; /* dwRate / dwScale == samples/second */
817 DWORD dwStart;
818 DWORD dwLength; /* In units above... */
819 DWORD dwSuggestedBufferSize;
820 DWORD dwQuality;
821 DWORD dwSampleSize;
822 struct { SHORT left, top, right, bottom; } rcFrame; /* word.word - word.word in file */
823} AVIStreamHeader;
824
825/* AVIINDEXENTRY.dwFlags */
826#define AVIIF_LIST 0x00000001 /* chunk is a 'LIST' */
827#define AVIIF_TWOCC 0x00000002
828#define AVIIF_KEYFRAME 0x00000010 /* this frame is a key frame. */
829
830#define AVIIF_NOTIME 0x00000100 /* this frame doesn't take any time */
831#define AVIIF_COMPUSE 0x0FFF0000
832
833typedef struct _AVIINDEXENTRY {
834 DWORD ckid;
835 DWORD dwFlags;
836 DWORD dwChunkOffset;
837 DWORD dwChunkLength;
838} AVIINDEXENTRY;
839
840typedef struct _AVIPALCHANGE {
841 BYTE bFirstEntry;
842 BYTE bNumEntries;
843 WORD wFlags; /* pad */
844 PALETTEENTRY peNew[1];
845} AVIPALCHANGE;
846
847#define AVIIF_KEYFRAME 0x00000010 /* this frame is a key frame. */
848
849#define AVIGETFRAMEF_BESTDISPLAYFMT 1
850
851typedef struct _AVISTREAMINFOA {
852 DWORD fccType;
853 DWORD fccHandler;
854 DWORD dwFlags; /* AVIIF_* */
855 DWORD dwCaps;
856 WORD wPriority;
857 WORD wLanguage;
858 DWORD dwScale;
859 DWORD dwRate; /* dwRate / dwScale == samples/second */
860 DWORD dwStart;
861 DWORD dwLength; /* In units above... */
862 DWORD dwInitialFrames;
863 DWORD dwSuggestedBufferSize;
864 DWORD dwQuality;
865 DWORD dwSampleSize;
866 RECT rcFrame;
867 DWORD dwEditCount;
868 DWORD dwFormatChangeCount;
869 CHAR szName[64];
870} AVISTREAMINFOA, * LPAVISTREAMINFOA, *PAVISTREAMINFOA;
871
872typedef struct _AVISTREAMINFOW {
873 DWORD fccType;
874 DWORD fccHandler;
875 DWORD dwFlags;
876 DWORD dwCaps;
877 WORD wPriority;
878 WORD wLanguage;
879 DWORD dwScale;
880 DWORD dwRate; /* dwRate / dwScale == samples/second */
881 DWORD dwStart;
882 DWORD dwLength; /* In units above... */
883 DWORD dwInitialFrames;
884 DWORD dwSuggestedBufferSize;
885 DWORD dwQuality;
886 DWORD dwSampleSize;
887 RECT rcFrame;
888 DWORD dwEditCount;
889 DWORD dwFormatChangeCount;
890 WCHAR szName[64];
891} AVISTREAMINFOW, * LPAVISTREAMINFOW, *PAVISTREAMINFOW;
892DECL_WINELIB_TYPE_AW(AVISTREAMINFO)
893DECL_WINELIB_TYPE_AW(LPAVISTREAMINFO)
894DECL_WINELIB_TYPE_AW(PAVISTREAMINFO)
895
896#define AVISTREAMINFO_DISABLED 0x00000001
897#define AVISTREAMINFO_FORMATCHANGES 0x00010000
898
899/* AVIFILEINFO.dwFlags */
900#define AVIFILEINFO_HASINDEX 0x00000010
901#define AVIFILEINFO_MUSTUSEINDEX 0x00000020
902#define AVIFILEINFO_ISINTERLEAVED 0x00000100
903#define AVIFILEINFO_WASCAPTUREFILE 0x00010000
904#define AVIFILEINFO_COPYRIGHTED 0x00020000
905
906/* AVIFILEINFO.dwCaps */
907#define AVIFILECAPS_CANREAD 0x00000001
908#define AVIFILECAPS_CANWRITE 0x00000002
909#define AVIFILECAPS_ALLKEYFRAMES 0x00000010
910#define AVIFILECAPS_NOCOMPRESSION 0x00000020
911
912typedef struct _AVIFILEINFOW {
913 DWORD dwMaxBytesPerSec;
914 DWORD dwFlags;
915 DWORD dwCaps;
916 DWORD dwStreams;
917 DWORD dwSuggestedBufferSize;
918 DWORD dwWidth;
919 DWORD dwHeight;
920 DWORD dwScale;
921 DWORD dwRate;
922 DWORD dwLength;
923 DWORD dwEditCount;
924 WCHAR szFileType[64];
925} AVIFILEINFOW, * LPAVIFILEINFOW, *PAVIFILEINFOW;
926typedef struct _AVIFILEINFOA {
927 DWORD dwMaxBytesPerSec;
928 DWORD dwFlags;
929 DWORD dwCaps;
930 DWORD dwStreams;
931 DWORD dwSuggestedBufferSize;
932 DWORD dwWidth;
933 DWORD dwHeight;
934 DWORD dwScale;
935 DWORD dwRate;
936 DWORD dwLength;
937 DWORD dwEditCount;
938 CHAR szFileType[64];
939} AVIFILEINFOA, * LPAVIFILEINFOA, *PAVIFILEINFOA;
940DECL_WINELIB_TYPE_AW(AVIFILEINFO)
941DECL_WINELIB_TYPE_AW(PAVIFILEINFO)
942DECL_WINELIB_TYPE_AW(LPAVIFILEINFO)
943
944/* AVICOMPRESSOPTIONS.dwFlags. determines presence of fields in below struct */
945#define AVICOMPRESSF_INTERLEAVE 0x00000001
946#define AVICOMPRESSF_DATARATE 0x00000002
947#define AVICOMPRESSF_KEYFRAMES 0x00000004
948#define AVICOMPRESSF_VALID 0x00000008
949
950typedef struct {
951 DWORD fccType; /* stream type, for consistency */
952 DWORD fccHandler; /* compressor */
953 DWORD dwKeyFrameEvery; /* keyframe rate */
954 DWORD dwQuality; /* compress quality 0-10,000 */
955 DWORD dwBytesPerSecond; /* bytes per second */
956 DWORD dwFlags; /* flags... see below */
957 LPVOID lpFormat; /* save format */
958 DWORD cbFormat;
959 LPVOID lpParms; /* compressor options */
960 DWORD cbParms;
961 DWORD dwInterleaveEvery; /* for non-video streams only */
962} AVICOMPRESSOPTIONS, *LPAVICOMPRESSOPTIONS,*PAVICOMPRESSOPTIONS;
963
964
965
966#define DEFINE_AVIGUID(name, l, w1, w2) \
967 DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)
968
969DEFINE_AVIGUID(IID_IAVIFile, 0x00020020, 0, 0);
970DEFINE_AVIGUID(IID_IAVIStream, 0x00020021, 0, 0);
971DEFINE_AVIGUID(IID_IAVIStreaming, 0x00020022, 0, 0);
972DEFINE_AVIGUID(IID_IGetFrame, 0x00020023, 0, 0);
973DEFINE_AVIGUID(IID_IAVIEditStream, 0x00020024, 0, 0);
974
975DEFINE_AVIGUID(CLSID_AVIFile, 0x00020000, 0, 0);
976
977/*****************************************************************************
978 * IAVIStream interface
979 */
980#define ICOM_INTERFACE IAVIStream
981#define IAVIStream_METHODS \
982 ICOM_METHOD2(HRESULT,Create, LPARAM,lParam1, LPARAM,lParam2) \
983 ICOM_METHOD2(HRESULT,Info, AVISTREAMINFOW*,psi, LONG,lSize) \
984 ICOM_METHOD2(LONG, FindSample, LONG,lPos, LONG,lFlags) \
985 ICOM_METHOD3(HRESULT,ReadFormat, LONG,lPos, LPVOID,lpFormat, LONG*,lpcbFormat) \
986 ICOM_METHOD3(HRESULT,SetFormat, LONG,lPos, LPVOID,lpFormat, LONG,cbFormat) \
987 ICOM_METHOD6(HRESULT,Read, LONG,lStart, LONG,lSamples, LPVOID,lpBuffer, LONG,cbBuffer, LONG*,plBytes, LONG*,plSamples) \
988 ICOM_METHOD7(HRESULT,Write, LONG,lStart, LONG,lSamples, LPVOID,lpBuffer, LONG,cbBuffer, DWORD,dwFlags, LONG*,plSampWritten, LONG*,plBytesWritten) \
989 ICOM_METHOD2(HRESULT,Delete, LONG,lStart, LONG,lSamples) \
990 ICOM_METHOD3(HRESULT,ReadData, DWORD,fcc, LPVOID,lpBuffer, LONG*,lpcbBuffer) \
991 ICOM_METHOD3(HRESULT,WriteData, DWORD,fcc, LPVOID,lpBuffer, LONG,cbBuffer) \
992 ICOM_METHOD2(HRESULT,SetInfo, AVISTREAMINFOW*,plInfo, LONG,cbInfo)
993#define IAVIStream_IMETHODS \
994 IUnknown_IMETHODS \
995 IAVIStream_METHODS
996ICOM_DEFINE(IAVIStream, IUnknown)
997#undef ICOM_INTERFACE
998
999/*** IUnknown methods ***/
1000#define IAVIStream_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
1001#define IAVIStream_AddRef(p) ICOM_CALL (AddRef,p)
1002#define IAVIStream_Release(p) ICOM_CALL (Release,p)
1003/*** IAVIStream methods ***/
1004#define IAVIStream_Create(p,a,b) ICOM_CALL2(Create,p,a,b)
1005#define IAVIStream_Info(p,a,b) ICOM_CALL2(Info,p,a,b)
1006#define IAVIStream_FindSample(p,a,b) ICOM_CALL2(FindSample,p,a,b)
1007#define IAVIStream_ReadFormat(p,a,b,c) ICOM_CALL3(ReadFormat,p,a,b,c)
1008#define IAVIStream_SetFormat(p,a,b,c) ICOM_CALL3(SetFormat,p,a,b,c)
1009#define IAVIStream_Read(p,a,b,c,d,e,f) ICOM_CALL6(Read,p,a,b,c,d,e,f)
1010#define IAVIStream_Write(p,a,b,c,d,e,f,g) ICOM_CALL7(Write,p,a,b,c,d,e,f,g)
1011#define IAVIStream_Delete(p,a,b) ICOM_CALL2(Delete,p,a,b)
1012#define IAVIStream_ReadData(p,a,b,c) ICOM_CALL3(ReadData,p,a,b,c)
1013#define IAVIStream_WriteData(p,a,b,c) ICOM_CALL3(WriteData,p,a,b,c)
1014#define IAVIStream_SetInfo(p,a,b) ICOM_CALL2(SetInfo,p,a,b)
1015
1016HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM*ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *lpOptions,CLSID*pclsidHandler);
1017
1018HRESULT WINAPI AVIStreamInfoA(PAVISTREAM iface,AVISTREAMINFOA *asi,LONG size);
1019HRESULT WINAPI AVIStreamInfoW(PAVISTREAM iface,AVISTREAMINFOW *asi,LONG size);
1020#define AVIStreamInfo WINELIB_NAME_AW(AVIStreamInfo)
1021LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pg,LONG pos);
1022HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pg);
1023PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pavi,LPBITMAPINFOHEADER lpbiWanted);
1024LONG WINAPI AVIStreamLength(PAVISTREAM iface);
1025HRESULT WINAPI AVIStreamRead(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread);
1026HRESULT WINAPI AVIStreamReadData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG *lpread);
1027HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG *formatsize);
1028ULONG WINAPI AVIStreamRelease(PAVISTREAM iface);
1029HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM iface,LONG pos,LPVOID format,LONG formatsize);
1030LONG WINAPI AVIStreamStart(PAVISTREAM iface);
1031HRESULT WINAPI AVIStreamWrite(PAVISTREAM iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
1032HRESULT WINAPI AVIStreamWriteData(PAVISTREAM iface,DWORD fcc,LPVOID lp,LONG size);
1033HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM *ppavi, LPCSTR szFile,
1034 DWORD fccType, LONG lParam,
1035 UINT mode, CLSID *pclsidHandler);
1036HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM *ppavi, LPCWSTR szFile,
1037 DWORD fccType, LONG lParam,
1038 UINT mode, CLSID *pclsidHandler);
1039#define AVIStreamOpenFromFile WINELIB_NAME_AW(AVIStreamOpenFromFile)
1040
1041#define AVIStreamFormatSize(pavi, lPos, plSize) \
1042 AVIStreamReadFormat(pavi, lPos, NULL, plSize)
1043
1044/*****************************************************************************
1045 * IAVIFile interface
1046 */
1047/* In Win32 this interface uses UNICODE only */
1048#define ICOM_INTERFACE IAVIFile
1049#define IAVIFile_METHODS \
1050 ICOM_METHOD2(HRESULT,Info, AVIFILEINFOW*,pfi, LONG,lSize) \
1051 ICOM_METHOD3(HRESULT,GetStream, PAVISTREAM*,ppStream, DWORD,fccType, LONG,lParam) \
1052 ICOM_METHOD2(HRESULT,CreateStream, PAVISTREAM*,ppStream, AVISTREAMINFOW*,psi) \
1053 ICOM_METHOD3(HRESULT,WriteData, DWORD,fcc, LPVOID,lpBuffer, LONG,cbBuffer) \
1054 ICOM_METHOD3(HRESULT,ReadData, DWORD,fcc, LPVOID,lpBuffer, LONG*,lpcbBuffer) \
1055 ICOM_METHOD (HRESULT,EndRecord) \
1056 ICOM_METHOD2(HRESULT,DeleteStream, DWORD,fccType, LONG,lParam)
1057#define IAVIFile_IMETHODS \
1058 IUnknown_IMETHODS \
1059 IAVIFile_METHODS
1060ICOM_DEFINE(IAVIFile,IUnknown)
1061#undef ICOM_INTERFACE
1062
1063/*** IUnknown methods ***/
1064#define IAVIFile_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
1065#define IAVIFile_AddRef(p) ICOM_CALL (AddRef,p)
1066#define IAVIFile_Release(p) ICOM_CALL (Release,p)
1067/*** IAVIFile methods ***/
1068#define IAVIFile_Info(p,a,b) ICOM_CALL2(Info,p,a,b)
1069#define IAVIFile_GetStream(p,a,b,c) ICOM_CALL3(GetStream,p,a,b,c)
1070#define IAVIFile_CreateStream(p,a,b) ICOM_CALL2(CreateStream,p,a,b)
1071#define IAVIFile_WriteData(p,a,b,c) ICOM_CALL3(WriteData,p,a,b,c)
1072#define IAVIFile_ReadData(p,a,b,c) ICOM_CALL3(ReadData,p,a,b,c)
1073#define IAVIFile_EndRecord(p) ICOM_CALL (EndRecord,p)
1074#define IAVIFile_DeleteStream(p,a,b) ICOM_CALL2(DeleteStream,p,a,b)
1075
1076HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile,PAVISTREAM* ppavi,AVISTREAMINFOA* psi);
1077HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile,PAVISTREAM* ppavi,AVISTREAMINFOW* psi);
1078#define AVIFileCreateStream WINELIB_NAME_AW(AVIFileCreateStream)
1079void WINAPI AVIFileExit(void);
1080HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile,PAVISTREAM* avis,DWORD fccType,LONG lParam);
1081HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile,PAVIFILEINFOA pfi,LONG lSize);
1082HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile,PAVIFILEINFOW pfi,LONG lSize);
1083#define AVIFileInfo WINELIB_NAME_AW(AVIFileInfo)
1084void WINAPI AVIFileInit(void);
1085HRESULT WINAPI AVIFileOpenA(PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler);
1086HRESULT WINAPI AVIFileOpenW(PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler);
1087#define AVIFileOpen WINELIB_NAME_AW(AVIFileOpen)
1088ULONG WINAPI AVIFileRelease(PAVIFILE iface);
1089
1090
1091/*****************************************************************************
1092 * IGetFrame interface
1093 */
1094#define ICOM_INTERFACE IGetFrame
1095#define IGetFrame_METHODS \
1096 ICOM_METHOD1(LPVOID, GetFrame, LONG,lPos) \
1097 ICOM_METHOD3(HRESULT,Begin, LONG,lStart, LONG,lEnd, LONG,lRate) \
1098 ICOM_METHOD (HRESULT,End) \
1099 ICOM_METHOD6(HRESULT,SetFormat, LPBITMAPINFOHEADER,lpbi, LPVOID,lpBits, INT,x, INT,y, INT,dx, INT,dy)
1100#define IGetFrame_IMETHODS \
1101 IUnknown_IMETHODS \
1102 IGetFrame_METHODS
1103ICOM_DEFINE(IGetFrame,IUnknown)
1104#undef ICOM_INTERFACE
1105
1106/*** IUnknown methods ***/
1107#define IGetFrame_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
1108#define IGetFrame_AddRef(p) ICOM_CALL (AddRef,p)
1109#define IGetFrame_Release(p) ICOM_CALL (Release,p)
1110/*** IGetFrame methods ***/
1111#define IGetFrame_GetFrame(p,a) ICOM_CALL1(GetFrame,p,a)
1112#define IGetFrame_Begin(p,a,b,c) ICOM_CALL3(Begin,p,a,b,c)
1113#define IGetFrame_End(p) ICOM_CALL (End,p)
1114#define IGetFrame_SetFormat(p,a,b,c,d,e,f) ICOM_CALL6(SetFormat,p,a,b,c,d,e,f)
1115
1116#define AVIERR_OK 0
1117#define MAKE_AVIERR(error) MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x4000+error)
1118
1119#define AVIERR_UNSUPPORTED MAKE_AVIERR(101)
1120#define AVIERR_BADFORMAT MAKE_AVIERR(102)
1121#define AVIERR_MEMORY MAKE_AVIERR(103)
1122#define AVIERR_INTERNAL MAKE_AVIERR(104)
1123#define AVIERR_BADFLAGS MAKE_AVIERR(105)
1124#define AVIERR_BADPARAM MAKE_AVIERR(106)
1125#define AVIERR_BADSIZE MAKE_AVIERR(107)
1126#define AVIERR_BADHANDLE MAKE_AVIERR(108)
1127#define AVIERR_FILEREAD MAKE_AVIERR(109)
1128#define AVIERR_FILEWRITE MAKE_AVIERR(110)
1129#define AVIERR_FILEOPEN MAKE_AVIERR(111)
1130#define AVIERR_COMPRESSOR MAKE_AVIERR(112)
1131#define AVIERR_NOCOMPRESSOR MAKE_AVIERR(113)
1132#define AVIERR_READONLY MAKE_AVIERR(114)
1133#define AVIERR_NODATA MAKE_AVIERR(115)
1134#define AVIERR_BUFFERTOOSMALL MAKE_AVIERR(116)
1135#define AVIERR_CANTCOMPRESS MAKE_AVIERR(117)
1136#define AVIERR_USERABORT MAKE_AVIERR(198)
1137#define AVIERR_ERROR MAKE_AVIERR(199)
1138
1139/********************************************
1140 * DrawDib declarations
1141 */
1142
1143HDRAWDIB VFWAPI DrawDibOpen( void );
1144UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground);
1145
1146BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd, HDC hdc, INT dxDst, INT dyDst,
1147 LPBITMAPINFOHEADER lpbi, INT dxSrc, INT dySrc, UINT wFlags);
1148
1149BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc, INT xDst, INT yDst, INT dxDst, INT dyDst,
1150 LPBITMAPINFOHEADER lpbi, LPVOID lpBits,
1151 INT xSrc, INT ySrc, INT dxSrc, INT dySrc, UINT wFlags);
1152
1153/* DrawDibDraw flags */
1154
1155#define DDF_UPDATE 0x0002
1156#define DDF_SAME_HDC 0x0004
1157#define DDF_SAME_DRAW 0x0008
1158#define DDF_DONTDRAW 0x0010
1159#define DDF_ANIMATE 0x0020
1160#define DDF_BUFFER 0x0040
1161#define DDF_JUSTDRAWIT 0x0080
1162#define DDF_FULLSCREEN 0x0100
1163#define DDF_BACKGROUNDPAL 0x0200
1164#define DDF_NOTKEYFRAME 0x0400
1165#define DDF_HURRYUP 0x0800
1166#define DDF_HALFTONE 0x1000
1167
1168#define DDF_PREROLL DDF_DONTDRAW
1169#define DDF_SAME_DIB DDF_SAME_DRAW
1170#define DDF_SAME_SIZE DDF_SAME_DRAW
1171
1172BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal);
1173HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd);
1174BOOL VFWAPI DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe);
1175LPVOID VFWAPI DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags);
1176
1177BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate);
1178BOOL VFWAPI DrawDibStop(HDRAWDIB hdd);
1179#define DrawDibUpdate(hdd, hdc, x, y) \
1180 DrawDibDraw(hdd, hdc, x, y, 0, 0, NULL, NULL, 0, 0, 0, 0, DDF_UPDATE)
1181
1182BOOL VFWAPI DrawDibEnd(HDRAWDIB hdd);
1183BOOL VFWAPI DrawDibClose(HDRAWDIB hdd);
1184
1185/* display profiling */
1186#define PD_CAN_DRAW_DIB 0x0001
1187#define PD_CAN_STRETCHDIB 0x0002
1188#define PD_STRETCHDIB_1_1_OK 0x0004
1189#define PD_STRETCHDIB_1_2_OK 0x0008
1190#define PD_STRETCHDIB_1_N_OK 0x0010
1191
1192DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi);
1193
1194#ifdef __cplusplus
1195}
1196#endif /* __cplusplus */
1197
1198#endif /* __WINE_VFW_H */
Note: See TracBrowser for help on using the repository browser.