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

Last change on this file since 5614 was 5614, checked in by hugh, 24 years ago

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