Context Navigation

source: trunk/src/msvfw32/msvfw32.cpp@ 2004

Visit:

Last change on this file since 2004 was 1607, checked in by sandervl, 26 years ago
Jens Weissner's update
File size: 19.9 KB

Line
1	/*
2	* Copyright 1998 Marcus Meissner
3	* Copyright 1999 Jens Wiessner
4	*/
5
6	#include <stdlib.h>
7	#include <string.h>
8	#include <odin.h>
9
10	#define ICOM_CINTERFACE 1
11	#define strcasecmp strcmp
12
13	#include <os2win.h>
14	#include "winerror.h"
15	#include "heap.h"
16	#include "resource.h"
17	#include "win.h"
18	#include "commdlg.h"
19	#include "spy.h"
20
21	#include "wine/obj_base.h"
22	#include "wingdi.h"
23	#include "vfw.h"
24	#include "driver.h"
25	// #include "msvfw32.h"
26
27	#include "debugtools.h"
28	#include <debugstr.h>
29	#include <heapstring.h>
30
31	DEFAULT_DEBUG_CHANNEL(msvideo)
32
33	/****************************************************************************
34	* VideoForWindowsVersion [MSVFW.2][MSVIDEO.2]
35	* Returns the version in major.minor form.
36	* In Windows95 this returns 0x040003b6 (4.950)
37	*/
38	DWORD WINAPI
39	VideoForWindowsVersion(void) {
40	return 0x040003B6; /* 4.950 */
41	}
42
43	/* system.ini: [drivers] */
44
45	/**************************************************************************
46	* ICInfo [MSVFW.33]
47	* Get information about an installable compressor. Return TRUE if there
48	* is one.
49	*/
50	BOOL WINAPI
51	ICInfo(
52	DWORD fccType, /* [in] type of compressor ('vidc') */
53	DWORD fccHandler, /* [in] <n>th compressor */
54	ICINFO lpicinfo / [out] information about compressor */
55	) {
56	char type[5],buf[2000];
57
58	memcpy(type,&fccType,4);type[4]=0;
59	TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
60	/* does OpenDriver/CloseDriver */
61	lpicinfo->dwSize = sizeof(ICINFO);
62	lpicinfo->fccType = fccType;
63	lpicinfo->dwFlags = 0;
64	if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,2000,"system.ini")) {
65	char *s = buf;
66	while (*s) {
67	if (!lstrncmpiA(type,s,4)) {
68	if(!fccHandler--) {
69	lpicinfo->fccHandler = mmioStringToFOURCCA(s+5,0);
70	return TRUE;
71	}
72	}
73	s=s+lstrlenA(s)+1; /* either next char or \0 */
74	}
75	}
76	return FALSE;
77	}
78
79	/**************************************************************************
80	* ICOpen [MSVFW.37]
81	* Opens an installable compressor. Return special handle.
82	*/
83	HIC WINAPI
84	ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
85	char type[5],handler[5],codecname[20];
86	ICOPEN icopen;
87	HDRVR hdrv;
88	WINE_HIC *whic;
89
90	memcpy(type,&fccType,4);type[4]=0;
91	memcpy(handler,&fccHandler,4);handler[4]=0;
92	TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
93	sprintf(codecname,"%s.%s",type,handler);
94
95	/* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
96	* same layout as ICOPEN
97	*/
98	icopen.fccType = fccType;
99	icopen.fccHandler = fccHandler;
100	icopen.dwSize = sizeof(ICOPEN);
101	icopen.dwFlags = wMode;
102	/* FIXME: do we need to fill out the rest too? */
103	hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
104	if (!hdrv) {
105	if (!strcasecmp(type,"vids")) {
106	sprintf(codecname,"vidc.%s",handler);
107	fccType = mmioFOURCC('v','i','d','c');
108	}
109	hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
110	if (!hdrv)
111	return 0;
112	}
113	whic = PWINE_HIC(HeapAlloc(GetProcessHeap(),0,sizeof(WINE_HIC)));
114	whic->hdrv = hdrv;
115	whic->driverproc= NULL;
116	whic->privatevfw= ICSendMessage((HIC)whic,DRV_OPEN,0,(LPARAM)&icopen);
117	return (HIC)whic;
118	}
119	HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode,
120	FARPROC lpfnHandler) {
121	char type[5],handler[5];
122	HIC hic;
123	WINE_HIC *whic;
124
125	memcpy(type,&fccType,4);type[4]=0;
126	memcpy(handler,&fccHandler,4);handler[4]=0;
127	dprintf(("(%s,%s,%d,%p), stub!\n",type,handler,wMode,lpfnHandler));
128	hic = ICOpen(fccType,fccHandler,wMode);
129	if (!hic)
130	return hic;
131	whic = (WINE_HIC*)hic;
132	whic->driverproc = lpfnHandler;
133	return hic;
134	}
135
136
137	LRESULT WINAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
138	LRESULT ret;
139
140	TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
141	ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
142	TRACE(" -> 0x%08lx\n",ret);
143	return ret;
144	}
145
146	HIC VFWAPI
147	ICLocate(
148	DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
149	LPBITMAPINFOHEADER lpbiOut, WORD wMode
150	) {
151	char type[5],handler[5];
152	HIC hic;
153	DWORD querymsg;
154
155	switch (wMode) {
156	case ICMODE_FASTCOMPRESS:
157	case ICMODE_COMPRESS:
158	querymsg = ICM_COMPRESS_QUERY;
159	break;
160	case ICMODE_DECOMPRESS:
161	case ICMODE_FASTDECOMPRESS:
162	querymsg = ICM_DECOMPRESS_QUERY;
163	break;
164	case ICMODE_DRAW:
165	querymsg = ICM_DRAW_QUERY;
166	break;
167	default:
168	dprintf(("Unknown mode (%d)\n",wMode));
169	return 0;
170	}
171
172	/* Easy case: handler/type match, we just fire a query and return */
173	hic = ICOpen(fccType,fccHandler,wMode);
174	if (hic) {
175	if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
176	return hic;
177	ICClose(hic);
178	}
179	type[4]='\0';memcpy(type,&fccType,4);
180	handler[4]='\0';memcpy(handler,&fccHandler,4);
181	if (fccType==streamtypeVIDEO) {
182	hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
183	if (hic)
184	return hic;
185	}
186	dprintf(("(%s,%s,%p,%p,0x%04x),unhandled!\n",type,handler,lpbiIn,lpbiOut,wMode));
187	return 0;
188	}
189
190	HIC VFWAPI ICGetDisplayFormat(
191	HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
192	INT depth,INT dx,INT dy
193	) {
194	HIC tmphic = hic;
195	LRESULT lres;
196
197	dprintf(("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy));
198	if (!tmphic) {
199	tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
200	if (!tmphic)
201	return tmphic;
202	}
203	if ((dy == lpbiIn->biHeight) \|\| (dx == lpbiIn->biWidth))
204	dy = dx = 0; /* no resize needed */
205	/* Can we decompress it ? */
206	lres = ICDecompressQuery(tmphic,lpbiIn,NULL);
207	if (lres)
208	goto errout; /* no, sorry */
209	ICDecompressGetFormat(hic,lpbiIn,lpbiOut);
210	lpbiOut=lpbiIn;
211	lpbiOut->biCompression = 0;
212	lpbiOut->biSize = sizeof(*lpbiOut);
213	if (!depth) {
214	HDC hdc;
215
216	hdc = GetDC(0);
217	depth = GetDeviceCaps(hdc,12)*GetDeviceCaps(hdc,14);
218	ReleaseDC(0,hdc);
219	if (depth==15) depth = 16;
220	if (depth<8) depth = 8;
221	/* more constraints and tests */
222	}
223	if (lpbiIn->biBitCount == 8)
224	depth = 8;
225
226	return hic;
227	errout:
228	if (hic!=tmphic)
229	ICClose(tmphic);
230	return 0;
231	}
232
233	DWORD VFWAPIV
234	ICCompress(
235	HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
236	LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
237	LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
238	LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
239	) {
240	ICCOMPRESS iccmp;
241
242	iccmp.dwFlags = dwFlags;
243
244	iccmp.lpbiOutput = lpbiOutput;
245	iccmp.lpOutput = lpData;
246	iccmp.lpbiInput = lpbiInput;
247	iccmp.lpInput = lpBits;
248
249	iccmp.lpckid = lpckid;
250	iccmp.lpdwFlags = lpdwFlags;
251	iccmp.lFrameNum = lFrameNum;
252	iccmp.dwFrameSize = dwFrameSize;
253	iccmp.dwQuality = dwQuality;
254	iccmp.lpbiPrev = lpbiPrev;
255	iccmp.lpPrev = lpPrev;
256	return ICSendMessage(hic,ICM_COMPRESS,(LPARAM)&iccmp,sizeof(iccmp));
257	}
258
259	DWORD VFWAPIV
260	ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits) {
261	ICDECOMPRESS icd;
262
263	icd.dwFlags = dwFlags;
264	icd.lpbiInput = lpbiFormat;
265	icd.lpInput = lpData;
266
267	icd.lpbiOutput = lpbi;
268	icd.lpOutput = lpBits;
269	icd.ckid = 0;
270	return ICSendMessage(hic,ICM_DECOMPRESS,(LPARAM)&icd,sizeof(icd));
271	}
272
273	LRESULT VFWAPI
274	ICSendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2) {
275	LRESULT ret;
276	WINE_HIC whic = (WINE_HIC)hic;
277
278	#define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx)\n",(DWORD)hic,lParam1,lParam2);break;
279
280	switch (msg) {
281	XX(ICM_ABOUT)
282	XX(ICM_GETINFO)
283	XX(ICM_COMPRESS_FRAMES_INFO)
284	XX(ICM_COMPRESS_GET_FORMAT)
285	XX(ICM_COMPRESS_GET_SIZE)
286	XX(ICM_COMPRESS_QUERY)
287	XX(ICM_COMPRESS_BEGIN)
288	XX(ICM_COMPRESS)
289	XX(ICM_COMPRESS_END)
290	XX(ICM_DECOMPRESS_GET_FORMAT)
291	XX(ICM_DECOMPRESS_QUERY)
292	XX(ICM_DECOMPRESS_BEGIN)
293	XX(ICM_DECOMPRESS)
294	XX(ICM_DECOMPRESS_END)
295	XX(ICM_DECOMPRESS_SET_PALETTE)
296	XX(ICM_DECOMPRESS_GET_PALETTE)
297	XX(ICM_DRAW_QUERY)
298	XX(ICM_DRAW_BEGIN)
299	XX(ICM_DRAW_GET_PALETTE)
300	XX(ICM_DRAW_START)
301	XX(ICM_DRAW_STOP)
302	XX(ICM_DRAW_END)
303	XX(ICM_DRAW_GETTIME)
304	XX(ICM_DRAW)
305	XX(ICM_DRAW_WINDOW)
306	XX(ICM_DRAW_SETTIME)
307	XX(ICM_DRAW_REALIZE)
308	XX(ICM_DRAW_FLUSH)
309	XX(ICM_DRAW_RENDERBUFFER)
310	XX(ICM_DRAW_START_PLAY)
311	XX(ICM_DRAW_STOP_PLAY)
312	XX(ICM_DRAW_SUGGESTFORMAT)
313	XX(ICM_DRAW_CHANGEPALETTE)
314	XX(ICM_GETBUFFERSWANTED)
315	XX(ICM_GETDEFAULTKEYFRAMERATE)
316	XX(ICM_DECOMPRESSEX_BEGIN)
317	XX(ICM_DECOMPRESSEX_QUERY)
318	XX(ICM_DECOMPRESSEX)
319	XX(ICM_DECOMPRESSEX_END)
320	XX(ICM_SET_STATUS_PROC)
321	default:
322	dprintf(("(0x%08lx,0x%08lx,0x%08lx,0x%08lx)\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2));
323	}
324	#if 0
325	if (whic->driverproc) {
326	dprintf(("(0x%08lx,0x%08lx,0x%08lx,0x%08lx), calling %p\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,whic->driverproc));
327	ret = whic->driverproc(whic->hdrv,1,msg,lParam1,lParam2);
328	} else
329	#endif
330	ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
331	TRACE(" -> 0x%08lx\n",ret);
332	return ret;
333	}
334
335	DWORD VFWAPIV ICDrawBegin(
336	HIC hic,
337	DWORD dwFlags,/* flags */
338	HPALETTE hpal, /* palette to draw with */
339	HWND hwnd, /* window to draw to */
340	HDC hdc, /* HDC to draw to */
341	INT xDst, /* destination rectangle */
342	INT yDst,
343	INT dxDst,
344	INT dyDst,
345	LPBITMAPINFOHEADER lpbi, /* format of frame to draw */
346	INT xSrc, /* source rectangle */
347	INT ySrc,
348	INT dxSrc,
349	INT dySrc,
350	DWORD dwRate, /* frames/second = (dwRate/dwScale) */
351	DWORD dwScale) {
352	ICDRAWBEGIN icdb;
353
354	icdb.dwFlags = dwFlags;
355	icdb.hpal = hpal;
356	icdb.hwnd = hwnd;
357	icdb.hdc = hdc;
358	icdb.xDst = xDst;
359	icdb.yDst = yDst;
360	icdb.dxDst = dxDst;
361	icdb.dyDst = dyDst;
362	icdb.lpbi = lpbi;
363	icdb.xSrc = xSrc;
364	icdb.ySrc = ySrc;
365	icdb.dxSrc = dxSrc;
366	icdb.dySrc = dySrc;
367	icdb.dwRate = dwRate;
368	icdb.dwScale = dwScale;
369	return ICSendMessage(hic,ICM_DRAW_BEGIN,(LPARAM)&icdb,sizeof(icdb));
370	}
371
372	DWORD VFWAPIV ICDraw(
373	HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,
374	LONG lTime
375	) {
376	ICDRAW icd;
377
378	icd.dwFlags = dwFlags;
379	icd.lpFormat = lpFormat;
380	icd.lpData = lpData;
381	icd.cbData = cbData;
382	icd.lTime = lTime;
383	return ICSendMessage(hic,ICM_DRAW,(LPARAM)&icd,sizeof(icd));
384	}
385
386	LRESULT WINAPI ICClose(HIC hic) {
387	WINE_HIC whic = (WINE_HIC)hic;
388	TRACE("(%d).\n",hic);
389	/* FIXME: correct? */
390	CloseDriver(whic->hdrv,0,0);
391	HeapFree(GetProcessHeap(),0,whic);
392	return 0;
393	}
394
395	HANDLE /* HDRAWDIB */ WINAPI
396	DrawDibOpen( void ) {
397	dprintf(("stub!\n"));
398	return 0xdead;
399	}
400
401	BOOL WINAPI
402	DrawDibClose( HANDLE /HDRAWDIB/ hDib ) {
403	dprintf(("stub!\n"));
404	return TRUE;
405	}
406
407	BOOL VFWAPI DrawDibBegin(HANDLE /HDRAWDIB/ hdd,
408	HDC hdc,
409	INT dxDst,
410	INT dyDst,
411	LPBITMAPINFOHEADER lpbi,
412	INT dxSrc,
413	INT dySrc,
414	UINT wFlags) {
415	dprintf(("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx), stub!\n",
416	hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
417	));
418	return TRUE;
419	}
420
421
422	BOOL VFWAPI
423	DrawDibSetPalette(HANDLE /HDRAWDIB/ hdd, HPALETTE hpal) {
424	dprintf(("(%d,%d),stub!\n",hdd,hpal));
425	return TRUE;
426	}
427
428	UINT VFWAPI DrawDibRealize(HANDLE /HDRAWDIB/ hdd, HDC hdc, BOOL fBackground) {
429	dprintf(("(0x%08lx,0x%08lx,%d),stub!\n",(DWORD)hdd,(DWORD)hdc,fBackground));
430	return 0;
431	}
432
433
434	HWND VFWAPIV MCIWndCreate (HWND hwndParent, HINSTANCE hInstance,
435	DWORD dwStyle,LPVOID szFile)
436	{ dprintf(("%x %x %lx %p\n",hwndParent, hInstance, dwStyle, szFile));
437	return 0;
438	}
439	HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
440	DWORD dwStyle,LPCSTR szFile)
441	{ dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile));
442	return 0;
443	}
444	HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
445	DWORD dwStyle,LPCWSTR szFile)
446	{ dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile)));
447	return 0;
448	}
449
450	/* Stubs not included in Wine-Code*/
451
452
453	/****************************************************************************
454	* DrawDibChangePalette [MSVFW.4]
455	*/
456
457	BOOL VFWAPI DrawDibChangePalette(HANDLE /HDRAWDIB/ hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
458	{
459	#ifdef DEBUG
460	dprintf(("MSVFW32: DrawDibChangePalette not implemented\n"));
461	#endif
462	return TRUE;
463	}
464
465
466	/****************************************************************************
467	* DrawDibDraw [MSVFW.6]
468	*/
469	BOOL VFWAPI DrawDibDraw(HANDLE /HDRAWDIB/ hdd,
470	HDC hdc,
471	int xDst,
472	int yDst,
473	int dxDst,
474	int dyDst,
475	LPBITMAPINFOHEADER lpbi,
476	LPVOID lpBits,
477	int xSrc,
478	int ySrc,
479	int dxSrc,
480	int dySrc,
481	UINT wFlags)
482	{
483	#ifdef DEBUG
484	dprintf(("MSVFW32: DrawDibDraw not implemented\n"));
485	#endif
486	return TRUE;
487	}
488
489
490	/****************************************************************************
491	* DrawDibEnd [MSVFW.7]
492	*/
493	BOOL VFWAPI DrawDibEnd(HANDLE /HDRAWDIB/ hdd)
494	{
495	#ifdef DEBUG
496	dprintf(("MSVFW32: DrawDibEnd not implemented\n"));
497	#endif
498	return TRUE;
499	}
500
501
502	/****************************************************************************
503	* DrawDibGetBuffer [MSVFW.8]
504	*/
505	LPVOID VFWAPI DrawDibGetBuffer(HANDLE /HDRAWDIB/ hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
506	{
507	#ifdef DEBUG
508	dprintf(("MSVFW32: DrawDibGetBuffer not implemented\n"));
509	#endif
510	return 0;
511	}
512
513
514	/****************************************************************************
515	* DrawDibGetPalette [MSVFW.9]
516	*/
517	HPALETTE VFWAPI DrawDibGetPalette(HANDLE /HDRAWDIB/ hdd)
518	{
519	#ifdef DEBUG
520	dprintf(("MSVFW32: DrawDibGetPalette not implemented\n"));
521	#endif
522	return TRUE;
523	}
524
525
526	/****************************************************************************
527	* DrawDibProfileDisplay [MSVFW.11]
528	*/
529	DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
530	{
531	#ifdef DEBUG
532	dprintf(("MSVFW32: DrawDibProfileDisplay not implemented\n"));
533	#endif
534	return TRUE;
535	}
536
537
538	/****************************************************************************
539	* DrawDibStart [MSVFW.14]
540	*/
541	BOOL VFWAPI DrawDibStart(HANDLE /HDRAWDIB/ hdd, DWORD rate)
542	{
543	#ifdef DEBUG
544	dprintf(("MSVFW32: DrawDibStart not implemented\n"));
545	#endif
546	return TRUE;
547	}
548
549
550	/****************************************************************************
551	* DrawDibStop [MSVFW.15]
552	*/
553	BOOL VFWAPI DrawDibStop(HANDLE /HDRAWDIB/ hdd)
554	{
555	#ifdef DEBUG
556	dprintf(("MSVFW32: DrawDibStop not implemented\n"));
557	#endif
558	return TRUE;
559	}
560
561
562	/****************************************************************************
563	* DrawDibTime [MSVFW.16]
564	*/
565	BOOL VFWAPI DrawDibTime(HANDLE /HDRAWDIB/ hdd, DWORD lpddtime)
566	{
567	#ifdef DEBUG
568	dprintf(("MSVFW32: DrawDibTime not implemented\n"));
569	#endif
570	return TRUE;
571	}
572
573
574	/****************************************************************************
575	* GetOpenFileNamePreview [MSVFW.17]
576	*/
577
578	/* NO */
579
580
581	/****************************************************************************
582	* GetOpenFileNamePreviewA [MSVFW.18]
583	*/
584	BOOL VFWAPI GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn)
585	{
586	#ifdef DEBUG
587	dprintf(("MSVFW32: GetOpenFileNamePreviewA not implemented\n"));
588	#endif
589	return TRUE;
590	}
591
592
593	/****************************************************************************
594	* GetOpenFileNamePreviewW [MSVFW.19]
595	*/
596	BOOL VFWAPI GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn)
597	{
598	#ifdef DEBUG
599	dprintf(("MSVFW32: GetOpenFileNamePreviewW not implemented\n"));
600	#endif
601	return TRUE;
602	}
603
604
605	/****************************************************************************
606	* GetSaveFileNamePreviewA [MSVFW.20]
607	*/
608	BOOL VFWAPI GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn)
609	{
610	#ifdef DEBUG
611	dprintf(("MSVFW32: GetSaveFileNamePreviewA not implemented\n"));
612	#endif
613	return TRUE;
614	}
615
616
617	/****************************************************************************
618	* GetSaveFileNamePreviewW [MSVFW.21]
619	*/
620	BOOL VFWAPI GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn)
621	{
622	#ifdef DEBUG
623	dprintf(("MSVFW32: GetSaveFileNamePreviewW not implemented\n"));
624	#endif
625	return TRUE;
626	}
627
628
629	/****************************************************************************
630	* ICCompressorChoose [MSVFW.24]
631	*/
632	BOOL VFWAPI ICCompressorChoose(
633	HWND hwnd, // parent window for dialog
634	UINT uiFlags, // flags
635	LPVOID pvIn, // input format (optional)
636	LPVOID lpData, // input data (optional)
637	PCOMPVARS pc, // data about the compressor/dlg
638	LPSTR lpszTitle) // dialog title (optional)
639	{
640	#ifdef DEBUG
641	dprintf(("MSVFW32: ICCompressorChoose not implemented\n"));
642	#endif
643	return TRUE;
644	}
645
646
647	/****************************************************************************
648	* ICCompressorFree [MSVFW.25]
649	*/
650	void VFWAPI ICCompressorFree(PCOMPVARS pc)
651	{
652	#ifdef DEBUG
653	dprintf(("MSVFW32: ICCompressorFree not implemented\n"));
654	#endif
655	return;
656	}
657
658
659	/****************************************************************************
660	* ICImageCompress [MSVFW.31]
661	*/
662	HANDLE VFWAPI ICImageCompress(
663	HIC hic, // compressor to use
664	UINT uiFlags, // flags (none yet)
665	LPBITMAPINFO lpbiIn, // format to compress from
666	LPVOID lpBits, // data to compress
667	LPBITMAPINFO lpbiOut, // compress to this (NULL ==> default)
668	LONG lQuality, // quality to use
669	LONG plSize) // compress to this size (0=whatever)
670	{
671	#ifdef DEBUG
672	dprintf(("MSVFW32: ICImageCompress not implemented\n"));
673	#endif
674	return 0;
675	}
676
677
678	/****************************************************************************
679	* ICImageDecompress [MSVFW.32]
680	*/
681	HANDLE VFWAPI ICImageDecompress(
682	HIC hic, // compressor to use
683	UINT uiFlags, // flags (none yet)
684	LPBITMAPINFO lpbiIn, // format to decompress from
685	LPVOID lpBits, // data to decompress
686	LPBITMAPINFO lpbiOut) // decompress to this (NULL ==> default)
687	{
688	#ifdef DEBUG
689	dprintf(("MSVFW32: ICImageDecompress not implemented\n"));
690	#endif
691	return 0;
692	}
693
694
695	/****************************************************************************
696	* ICInstall [MSVFW.34]
697	*/
698	BOOL VFWAPI ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags)
699	{
700	#ifdef DEBUG
701	dprintf(("MSVFW32: ICInstall not implemented\n"));
702	#endif
703	return TRUE;
704	}
705
706
707	/**************************************************************************
708	* ICRemove [MSVFW.39]
709	*/
710	BOOL VFWAPI ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags)
711	{
712	#ifdef DEBUG
713	dprintf(("MSVFW32: ICRemove not implemented\n"));
714	#endif
715	return TRUE;
716	}
717
718
719	/**************************************************************************
720	* ICSeqCompressFrame [MSVFW.41]
721	*/
722	LPVOID VFWAPI ICSeqCompressFrame(
723	PCOMPVARS pc, // set by ICCompressorChoose
724	UINT uiFlags, // flags
725	LPVOID lpBits, // input DIB bits
726	BOOL *pfKey, // did it end up being a key frame?
727	LONG *plSize) // size to compress to/of returned image
728	{
729	#ifdef DEBUG
730	dprintf(("MSVFW32: ICSeqCompressFrame not implemented\n"));
731	#endif
732	return 0;
733	}
734
735
736	/**************************************************************************
737	* ICSeqCompressFrameEnd [MSVFW.42]
738	*/
739	BOOL VFWAPI ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn)
740	{
741	#ifdef DEBUG
742	dprintf(("MSVFW32: ICSeqCompressFrameEnd not implemented\n"));
743	#endif
744	return TRUE;
745	}
746
747
748	/**************************************************************************
749	* ICSeqCompressFrameStart [MSVFW.43]
750	*/
751	void VFWAPI ICSeqCompressFrameEnd(PCOMPVARS pc)
752	{
753	#ifdef DEBUG
754	dprintf(("MSVFW32: ICSeqCompressFrameStart not implemented\n"));
755	#endif
756	return;
757	}
758
759
760	/**************************************************************************
761	* MCIWndRegisterClass [MSVFW.47]
762	*/
763	BOOL VFWAPIV MCIWndRegisterClass()
764	{
765	#ifdef DEBUG
766	dprintf(("MSVFW32: MCIWndRegisterClass not implemented\n"));
767	#endif
768	return TRUE;
769	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: