VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/include/vfw.h@ 30705

Last change on this file since 30705 was 25949, checked in by vboxsync, 15 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette