source: trunk/src/msvfw32/msvideo_main.c@ 7178

Last change on this file since 7178 was 6712, checked in by sandervl, 24 years ago

restored old version
File size: 33.6 KB
Line 
1/*
2 * Copyright 1998 Marcus Meissner
3 * Copyright 2000 Bradley Baetz
4 *
5 * FIXME: This all assumes 32 bit codecs
6 * Win95 appears to prefer 32 bit codecs, even from 16 bit code.
7 * There is the ICOpenFunction16 to worry about still, though.
8 */
9
10#include <stdio.h>
11#include <string.h>
12
13#include "winbase.h"
14#include "windef.h"
15#include "winnls.h"
16#include "wingdi.h"
17#include "winuser.h"
18#include "winver.h"
19#include "vfw.h"
20#include "vfw16.h"
21#include "wine/winbase16.h"
22#include "debugtools.h"
23#include "heap.h"
24#include "stackframe.h"
25
26DEFAULT_DEBUG_CHANNEL(msvideo);
27
28#ifdef __WIN32OS2__
29#include <heapstring.h>
30
31#define GlobalAlloc16 GlobalAlloc
32#define GlobalLock16 GlobalLock
33#define GlobalUnlock16 GlobalUnlock
34#define GlobalFree16 GlobalFree
35#undef SEGPTR_NEW
36#define SEGPTR_NEW(a) malloc(sizeof(a))
37#define SEGPTR_FREE(a) free(a)
38#define SEGPTR_GET(a) a
39
40#undef FIXME
41#undef TRACE
42#ifdef DEBUG
43#define TRACE WriteLog("MSVFW32: %s", __FUNCTION__); WriteLog
44#define FIXME WriteLog("FIXME MSVFW32: %s", __FUNCTION__); WriteLog
45#else
46#define TRACE 1 ? (void)0 : (void)((int (*)(char *, ...)) NULL)
47#define FIXME 1 ? (void)0 : (void)((int (*)(char *, ...)) NULL)
48#endif
49
50#endif
51
52/* ### start build ### */
53extern LONG CALLBACK MSVIDEO_CallTo16_long_lwwll(FARPROC16,LONG,WORD,WORD,LONG,LONG);
54/* ### stop build ### */
55
56LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2);
57void MSVIDEO_UnmapMsg16To32(UINT msg, LPVOID lpv, LPDWORD lParam1, LPDWORD lParam2);
58LRESULT MSVIDEO_SendMessage(HIC hic, UINT msg, DWORD lParam1, DWORD lParam2, BOOL bFrom32);
59
60/***********************************************************************
61 * VideoForWindowsVersion [MSVFW32.2]
62 * VideoForWindowsVersion [MSVIDEO.2]
63 * Returns the version in major.minor form.
64 * In Windows95 this returns 0x040003b6 (4.950)
65 */
66DWORD WINAPI VideoForWindowsVersion(void) {
67 return 0x040003B6; /* 4.950 */
68}
69
70/***********************************************************************
71 * VideoCapDriverDescAndVer [MSVIDEO.22]
72 */
73DWORD WINAPI VideoCapDriverDescAndVer(
74 WORD nr,LPSTR buf1,WORD buf1len,LPSTR buf2,WORD buf2len
75) {
76 DWORD verhandle;
77 WORD xnr = nr;
78 DWORD infosize;
79 UINT subblocklen;
80 char *s,buf[2000],fn[260];
81 LPBYTE infobuf;
82 LPVOID subblock;
83
84 TRACE("(%d,%p,%d,%p,%d)\n",nr,buf1,buf1len,buf2,buf2len);
85 if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,sizeof(buf),"system.ini")) {
86 s = buf;
87 while (*s) {
88 if (!strncasecmp(s,"vid",3)) {
89 if (!xnr)
90 break;
91 xnr--;
92 }
93 s=s+strlen(s)+1; /* either next char or \0 */
94 }
95 } else
96 return 20; /* hmm, out of entries even if we don't have any */
97 if (xnr) {
98 FIXME("No more VID* entries found\n");
99 return 20;
100 }
101 GetPrivateProfileStringA("drivers32",s,NULL,fn,sizeof(fn),"system.ini");
102 infosize = GetFileVersionInfoSizeA(fn,&verhandle);
103 if (!infosize) {
104 TRACE("%s has no fileversioninfo.\n",fn);
105 return 18;
106 }
107 infobuf = HeapAlloc(GetProcessHeap(),0,infosize);
108 if (GetFileVersionInfoA(fn,verhandle,infosize,infobuf)) {
109 char vbuf[200];
110 /* Yes, two space behind : */
111 /* FIXME: test for buflen */
112 sprintf(vbuf,"Version: %d.%d.%d.%d\n",
113 ((WORD*)infobuf)[0x0f],
114 ((WORD*)infobuf)[0x0e],
115 ((WORD*)infobuf)[0x11],
116 ((WORD*)infobuf)[0x10]
117 );
118 TRACE("version of %s is %s\n",fn,vbuf);
119 strncpy(buf2,vbuf,buf2len);
120 } else {
121 TRACE("GetFileVersionInfoA failed for %s.\n",fn);
122 strncpy(buf2,fn,buf2len); /* msvideo.dll appears to copy fn*/
123 }
124 /* FIXME: language problem? */
125 if (VerQueryValueA( infobuf,
126 "\\StringFileInfo\\040904E4\\FileDescription",
127 &subblock,
128 &subblocklen
129 )) {
130 TRACE("VQA returned %s\n",(LPCSTR)subblock);
131 strncpy(buf1,subblock,buf1len);
132 } else {
133 TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n");
134 strncpy(buf1,fn,buf1len); /* msvideo.dll appears to copy fn*/
135 }
136 HeapFree(GetProcessHeap(),0,infobuf);
137 return 0;
138}
139
140/* system.ini: [drivers] */
141
142/***********************************************************************
143 * ICInfo [MSVFW32.@]
144 * Get information about an installable compressor. Return TRUE if there
145 * is one.
146 */
147BOOL VFWAPI ICInfo(
148 DWORD fccType, /* [in] type of compressor ('vidc') */
149 DWORD fccHandler, /* [in] <n>th compressor */
150 ICINFO *lpicinfo) /* [out] information about compressor */
151{
152 char type[5],buf[2000];
153
154 memcpy(type,&fccType,4);type[4]=0;
155 TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
156 /* does OpenDriver/CloseDriver */
157 lpicinfo->dwSize = sizeof(ICINFO);
158 lpicinfo->fccType = fccType;
159 lpicinfo->dwFlags = 0;
160 if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,2000,"system.ini")) {
161 char *s = buf;
162 while (*s) {
163 if (!strncasecmp(type,s,4)) {
164 if(!fccHandler--) {
165 lpicinfo->fccHandler = mmioStringToFOURCCA(s+5,0);
166 return TRUE;
167 }
168 }
169 s=s+strlen(s)+1; /* either next char or \0 */
170 }
171 }
172 return FALSE;
173}
174#ifndef __WIN32OS2__
175/***********************************************************************
176 * ICInfo [MSVIDEO.200]
177 */
178BOOL16 VFWAPI ICInfo16(
179 DWORD fccType, /* [in] */
180 DWORD fccHandler, /* [in] */
181 ICINFO16 *lpicinfo) /* [in/out] NOTE: SEGPTR */
182{
183 BOOL16 ret;
184 LPVOID lpv;
185 DWORD lParam = (DWORD)lpicinfo;
186 DWORD size = ((ICINFO*)(MapSL((SEGPTR)lpicinfo)))->dwSize;
187
188 /* Use the mapping functions to map the ICINFO structure */
189 lpv = MSVIDEO_MapMsg16To32(ICM_GETINFO,&lParam,&size);
190
191 ret = ICInfo(fccType,fccHandler,(ICINFO*)lParam);
192
193 MSVIDEO_UnmapMsg16To32(ICM_GETINFO,lpv,&lParam,&size);
194
195 return ret;
196}
197#endif
198/***********************************************************************
199 * ICOpen [MSVFW32.@]
200 * Opens an installable compressor. Return special handle.
201 */
202HIC VFWAPI ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
203 char type[5],handler[5],codecname[20];
204 ICOPEN icopen;
205 HDRVR hdrv;
206 HIC16 hic;
207 WINE_HIC *whic;
208
209 memcpy(type,&fccType,4);type[4]=0;
210 memcpy(handler,&fccHandler,4);handler[4]=0;
211 TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
212
213 sprintf(codecname,"%s.%s",type,handler);
214
215 /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
216 * same layout as ICOPEN
217 */
218 icopen.fccType = fccType;
219 icopen.fccHandler = fccHandler;
220 icopen.dwSize = sizeof(ICOPEN);
221 icopen.dwFlags = wMode;
222 /* FIXME: do we need to fill out the rest too? */
223 hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
224 if (!hdrv) {
225 if (!strcasecmp(type,"vids")) {
226 sprintf(codecname,"vidc.%s",handler);
227 fccType = mmioFOURCC('v','i','d','c');
228 }
229 hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
230 if (!hdrv)
231 return 0;
232 }
233 /* The handle should be a valid 16-bit handle as well */
234 hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
235 whic = (WINE_HIC*)GlobalLock16(hic);
236 whic->hdrv = hdrv;
237 whic->driverproc= NULL;
238#ifdef __WIN32OS2__
239 whic->privatevfw = 0;
240#else
241 whic->private = 0;
242#endif
243 GlobalUnlock16(hic);
244 TRACE("=> 0x%08lx\n",(DWORD)hic);
245 return hic;
246}
247
248HIC MSVIDEO_OpenFunc(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler, BOOL bFrom32) {
249 char type[5],handler[5],codecname[20];
250 HIC16 hic;
251 ICOPEN* icopen = SEGPTR_NEW(ICOPEN);
252 WINE_HIC *whic;
253
254 memcpy(type,&fccType,4);type[4]=0;
255 memcpy(handler,&fccHandler,4);handler[4]=0;
256 TRACE("(%s,%s,%d,%p,%d)\n",type,handler,wMode,lpfnHandler,bFrom32?32:16);
257
258 icopen->fccType = fccType;
259 icopen->fccHandler = fccHandler;
260 icopen->dwSize = sizeof(ICOPEN);
261 icopen->dwFlags = wMode;
262
263 sprintf(codecname,"%s.%s",type,handler);
264
265 hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
266 if (!hic)
267 return 0;
268 whic = GlobalLock16(hic);
269 whic->driverproc = lpfnHandler;
270
271#ifdef __WIN32OS2__
272 whic->privatevfw = bFrom32;
273#else
274 whic->private = bFrom32;
275#endif
276
277 /* Now try opening/loading the driver. Taken from DRIVER_AddToList */
278 /* What if the function is used more than once? */
279
280 if (MSVIDEO_SendMessage(hic,DRV_LOAD,0L,0L,bFrom32) != DRV_SUCCESS) {
281 WARN("DRV_LOAD failed for hic 0x%08lx\n",(DWORD)hic);
282 GlobalFree16(hic);
283 return 0;
284 }
285 /* return value is not checked */
286 MSVIDEO_SendMessage(hic,DRV_ENABLE,0L,0L,bFrom32);
287
288 whic->hdrv = MSVIDEO_SendMessage(hic,DRV_OPEN,0,(LPARAM)(SEGPTR_GET(icopen)),FALSE);
289 if (whic->hdrv == 0) {
290 WARN("DRV_OPEN failed for hic 0x%08lx\n",(DWORD)hic);
291 GlobalFree16(hic);
292 return 0;
293 }
294
295 GlobalUnlock16(hic);
296 TRACE("=> 0x%08lx\n",(DWORD)hic);
297 return hic;
298}
299
300/***********************************************************************
301 * ICOpenFunction [MSVFW32.@]
302 */
303HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler) {
304 return MSVIDEO_OpenFunc(fccType,fccHandler,wMode,lpfnHandler,TRUE);
305}
306
307#ifndef __WIN32OS2__
308/***********************************************************************
309 * ICOpen [MSVIDEO.203]
310 */
311HIC16 VFWAPI ICOpen16(DWORD fccType, DWORD fccHandler, UINT16 wMode) {
312 return (HIC16)ICOpen(fccType, fccHandler, wMode);
313}
314
315/***********************************************************************
316 * ICOpenFunction [MSVIDEO.206]
317 */
318HIC16 VFWAPI ICOpenFunction16(DWORD fccType, DWORD fccHandler, UINT16 wMode, FARPROC16 lpfnHandler)
319{
320 return MSVIDEO_OpenFunc(fccType, fccHandler, wMode, (FARPROC)lpfnHandler,FALSE);
321}
322#endif
323
324/***********************************************************************
325 * ICGetInfo [MSVFW32.@]
326 */
327LRESULT VFWAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
328 LRESULT ret;
329
330 TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
331 ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
332 TRACE(" -> 0x%08lx\n",ret);
333 return ret;
334}
335
336#ifndef __WIN32OS2__
337/***********************************************************************
338 * ICGetInfo [MSVIDEO.212]
339 */
340LRESULT VFWAPI ICGetInfo16(HIC16 hic, ICINFO16 *picinfo,DWORD cb) {
341 LRESULT ret;
342
343 TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
344 ret = ICSendMessage16(hic,ICM_GETINFO,(DWORD)picinfo,cb);
345 TRACE(" -> 0x%08lx\n",ret);
346 return ret;
347}
348#endif
349
350/***********************************************************************
351 * ICLocate [MSVFW32.@]
352 */
353HIC VFWAPI ICLocate(
354 DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
355 LPBITMAPINFOHEADER lpbiOut, WORD wMode)
356{
357 char type[5],handler[5];
358 HIC hic;
359 DWORD querymsg;
360 LPSTR pszBuffer;
361
362 type[4]=0;memcpy(type,&fccType,4);
363 handler[4]=0;memcpy(handler,&fccHandler,4);
364
365 TRACE("(%s,%s,%p,%p,0x%04x)\n", type, handler, lpbiIn, lpbiOut, wMode);
366
367 switch (wMode) {
368 case ICMODE_FASTCOMPRESS:
369 case ICMODE_COMPRESS:
370 querymsg = ICM_COMPRESS_QUERY;
371 break;
372 case ICMODE_FASTDECOMPRESS:
373 case ICMODE_DECOMPRESS:
374 querymsg = ICM_DECOMPRESS_QUERY;
375 break;
376 case ICMODE_DRAW:
377 querymsg = ICM_DRAW_QUERY;
378 break;
379 default:
380 WARN("Unknown mode (%d)\n",wMode);
381 return 0;
382 }
383
384 /* Easy case: handler/type match, we just fire a query and return */
385 hic = ICOpen(fccType,fccHandler,wMode);
386 if (hic) {
387 if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
388 return hic;
389 ICClose(hic);
390 }
391
392 type[4]='.';memcpy(type,&fccType,4);
393 handler[4]='.';memcpy(handler,&fccHandler,4);
394
395 /* Now try each driver in turn. 32 bit codecs only. */
396 /* FIXME: Move this to an init routine? */
397
398 pszBuffer = (LPSTR)HeapAlloc(GetProcessHeap(),0,1024);
399 if (GetPrivateProfileSectionA("drivers32",pszBuffer,1024,"system.ini")) {
400 char* s = pszBuffer;
401 while (*s) {
402 if (!strncasecmp(type,s,5)) {
403 char *s2 = s;
404 while (*s2 != '\0' && *s2 != '.') s2++;
405 if (*s2++) {
406 HIC h;
407
408 h = ICOpen(fccType,*(DWORD*)s2,wMode);
409 if (h) {
410 if (!ICSendMessage(h,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
411 return h;
412 ICClose(h);
413 }
414 }
415 }
416 s += strlen(s) + 1;
417 }
418 }
419 HeapFree(GetProcessHeap(),0,pszBuffer);
420
421 if (fccType==streamtypeVIDEO) {
422 hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
423 if (hic)
424 return hic;
425 }
426
427 type[4] = handler[4] = '\0';
428 WARN("(%.4s,%.4s,%p,%p,0x%04x) not found!\n",type,handler,lpbiIn,lpbiOut,wMode);
429 return 0;
430}
431
432#ifndef __WIN32OS2__
433/***********************************************************************
434 * ICLocate [MSVIDEO.213]
435 */
436HIC16 VFWAPI ICLocate16(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
437 LPBITMAPINFOHEADER lpbiOut, WORD wFlags) {
438 return (HIC16)ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags);
439}
440#endif
441
442/***********************************************************************
443 * ICGetDisplayFormat [MSVFW32.@]
444 */
445HIC VFWAPI ICGetDisplayFormat(
446 HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
447 INT depth,INT dx,INT dy)
448{
449 HIC tmphic = hic;
450
451 FIXME("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy);
452 if (!tmphic) {
453 tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
454 if (!tmphic)
455 return tmphic;
456 }
457 if ((dy == lpbiIn->biHeight) && (dx == lpbiIn->biWidth))
458 dy = dx = 0; /* no resize needed */
459
460 /* Can we decompress it ? */
461 if (ICDecompressQuery(tmphic,lpbiIn,NULL) != 0)
462 goto errout; /* no, sorry */
463
464 ICDecompressGetFormat(tmphic,lpbiIn,lpbiOut);
465
466 if (lpbiOut->biCompression != 0) {
467 FIXME("Ooch, how come decompressor outputs compressed data (%ld)??\n",
468 lpbiOut->biCompression);
469 }
470 if (lpbiOut->biSize < sizeof(*lpbiOut)) {
471 FIXME("Ooch, size of output BIH is too small (%ld)\n",
472 lpbiOut->biSize);
473 lpbiOut->biSize = sizeof(*lpbiOut);
474 }
475 if (!depth) {
476 HDC hdc;
477
478 hdc = GetDC(0);
479 depth = GetDeviceCaps(hdc,BITSPIXEL)*GetDeviceCaps(hdc,PLANES);
480 ReleaseDC(0,hdc);
481 if (depth==15) depth = 16;
482 if (depth<8) depth = 8;
483 }
484 if (lpbiIn->biBitCount == 8)
485 depth = 8;
486
487 TRACE("=> 0x%08lx\n",(DWORD)tmphic);
488 return tmphic;
489errout:
490 if (hic!=tmphic)
491 ICClose(tmphic);
492
493 TRACE("=> 0\n");
494 return 0;
495}
496
497#ifndef __WIN32OS2__
498/***********************************************************************
499 * ICGetDisplayFormat [MSVIDEO.239]
500 */
501HIC16 VFWAPI ICGetDisplayFormat16(HIC16 hic, LPBITMAPINFOHEADER lpbiIn,
502 LPBITMAPINFOHEADER lpbiOut, INT16 depth, INT16 dx, INT16 dy) {
503 return (HIC16)ICGetDisplayFormat(hic,lpbiIn,lpbiOut,depth,dx,dy);
504}
505#endif
506
507/***********************************************************************
508 * ICCompress [MSVFW32.@]
509 */
510DWORD VFWAPIV
511ICCompress(
512 HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
513 LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
514 LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
515 LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev)
516{
517 ICCOMPRESS iccmp;
518
519 TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
520
521 iccmp.dwFlags = dwFlags;
522
523 iccmp.lpbiOutput = lpbiOutput;
524 iccmp.lpOutput = lpData;
525 iccmp.lpbiInput = lpbiInput;
526 iccmp.lpInput = lpBits;
527
528 iccmp.lpckid = lpckid;
529 iccmp.lpdwFlags = lpdwFlags;
530 iccmp.lFrameNum = lFrameNum;
531 iccmp.dwFrameSize = dwFrameSize;
532 iccmp.dwQuality = dwQuality;
533 iccmp.lpbiPrev = lpbiPrev;
534 iccmp.lpPrev = lpPrev;
535 return ICSendMessage(hic,ICM_COMPRESS,(DWORD)&iccmp,sizeof(iccmp));
536}
537
538#ifndef __WIN32OS2__
539/***********************************************************************
540 * _ICCompress [MSVIDEO.224]
541 */
542DWORD VFWAPIV ICCompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData,
543 LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid,
544 LPDWORD lpdwFlags, LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality,
545 LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev) {
546
547 DWORD ret;
548 ICCOMPRESS *iccmp = SEGPTR_NEW(ICCOMPRESS);
549
550 TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
551
552 iccmp->dwFlags = dwFlags;
553
554 iccmp->lpbiOutput = lpbiOutput;
555 iccmp->lpOutput = lpData;
556 iccmp->lpbiInput = lpbiInput;
557 iccmp->lpInput = lpBits;
558
559 iccmp->lpckid = lpckid;
560 iccmp->lpdwFlags = lpdwFlags;
561 iccmp->lFrameNum = lFrameNum;
562 iccmp->dwFrameSize = dwFrameSize;
563 iccmp->dwQuality = dwQuality;
564 iccmp->lpbiPrev = lpbiPrev;
565 iccmp->lpPrev = lpPrev;
566 ret = ICSendMessage16(hic,ICM_COMPRESS,(DWORD)SEGPTR_GET(iccmp),sizeof(ICCOMPRESS));
567 SEGPTR_FREE(iccmp);
568 return ret;
569}
570#endif
571
572/***********************************************************************
573 * ICDecompress [MSVFW32.@]
574 */
575DWORD VFWAPIV ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,
576 LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits)
577{
578 ICDECOMPRESS icd;
579 DWORD ret;
580
581 TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
582
583 TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
584
585 icd.dwFlags = dwFlags;
586 icd.lpbiInput = lpbiFormat;
587 icd.lpInput = lpData;
588
589 icd.lpbiOutput = lpbi;
590 icd.lpOutput = lpBits;
591 icd.ckid = 0;
592 ret = ICSendMessage(hic,ICM_DECOMPRESS,(DWORD)&icd,sizeof(ICDECOMPRESS));
593
594 TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
595
596 TRACE("-> %ld\n",ret);
597
598 return ret;
599}
600
601#ifndef __WIN32OS2__
602/***********************************************************************
603 * _ICDecompress [MSVIDEO.230]
604 */
605DWORD VFWAPIV ICDecompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat,
606 LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits) {
607
608 ICDECOMPRESS *icd = SEGPTR_NEW(ICDECOMPRESS);
609 DWORD ret;
610
611 TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
612
613 icd->dwFlags = dwFlags;
614 icd->lpbiInput = lpbiFormat;
615 icd->lpInput = lpData;
616 icd->lpbiOutput = lpbi;
617 icd->lpOutput = lpBits;
618 icd->ckid = 0;
619
620 ret = ICSendMessage16(hic,ICM_DECOMPRESS,(DWORD)SEGPTR_GET(icd),sizeof(ICDECOMPRESS));
621
622 SEGPTR_FREE(icd);
623 return ret;
624}
625
626#define COPY(x,y) (x->y = x##16->y);
627#define COPYPTR(x,y) (x->y = MapSL((SEGPTR)x##16->y));
628
629LPVOID MSVIDEO_MapICDEX16To32(LPDWORD lParam) {
630 LPVOID ret;
631
632 ICDECOMPRESSEX *icdx = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESSEX));
633 ICDECOMPRESSEX16 *icdx16 = MapSL(*lParam);
634 ret = icdx16;
635
636 COPY(icdx,dwFlags);
637 COPYPTR(icdx,lpbiSrc);
638 COPYPTR(icdx,lpSrc);
639 COPYPTR(icdx,lpbiDst);
640 COPYPTR(icdx,lpDst);
641 COPY(icdx,xDst);
642 COPY(icdx,yDst);
643 COPY(icdx,dxDst);
644 COPY(icdx,dyDst);
645 COPY(icdx,xSrc);
646 COPY(icdx,ySrc);
647 COPY(icdx,dxSrc);
648 COPY(icdx,dySrc);
649
650 *lParam = (DWORD)(icdx);
651 return ret;
652}
653
654LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2) {
655 LPVOID ret = 0;
656
657 TRACE("Mapping %d\n",msg);
658
659 switch (msg) {
660 case DRV_LOAD:
661 case DRV_ENABLE:
662 case DRV_CLOSE:
663 case DRV_DISABLE:
664 case DRV_FREE:
665 case ICM_ABOUT:
666 case ICM_CONFIGURE:
667 case ICM_COMPRESS_END:
668 case ICM_DECOMPRESS_END:
669 case ICM_DECOMPRESSEX_END:
670 case ICM_SETQUALITY:
671 case ICM_DRAW_START_PLAY:
672 case ICM_DRAW_STOP_PLAY:
673 case ICM_DRAW_REALIZE:
674 case ICM_DRAW_RENDERBUFFER:
675 case ICM_DRAW_END:
676 break;
677 case DRV_OPEN:
678 case ICM_GETDEFAULTQUALITY:
679 case ICM_GETQUALITY:
680 case ICM_SETSTATE:
681 case ICM_DRAW_WINDOW:
682 case ICM_GETBUFFERSWANTED:
683 *lParam1 = (DWORD)MapSL(*lParam1);
684 break;
685 case ICM_GETINFO:
686 {
687 ICINFO *ici = HeapAlloc(GetProcessHeap(),0,sizeof(ICINFO));
688 ICINFO16 *ici16;
689
690 ici16 = MapSL(*lParam1);
691 ret = ici16;
692
693 ici->dwSize = sizeof(ICINFO);
694 COPY(ici,fccType);
695 COPY(ici,fccHandler);
696 COPY(ici,dwFlags);
697 COPY(ici,dwVersion);
698 COPY(ici,dwVersionICM);
699 MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 );
700 MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 );
701 MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 );
702 *lParam1 = (DWORD)(ici);
703 *lParam2 = sizeof(ICINFO);
704 }
705 break;
706 case ICM_COMPRESS:
707 {
708 ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(),0,sizeof(ICCOMPRESS));
709 ICCOMPRESS *icc16;
710
711 icc16 = MapSL(*lParam1);
712 ret = icc16;
713
714 COPY(icc,dwFlags);
715 COPYPTR(icc,lpbiOutput);
716 COPYPTR(icc,lpOutput);
717 COPYPTR(icc,lpbiInput);
718 COPYPTR(icc,lpInput);
719 COPYPTR(icc,lpckid);
720 COPYPTR(icc,lpdwFlags);
721 COPY(icc,lFrameNum);
722 COPY(icc,dwFrameSize);
723 COPY(icc,dwQuality);
724 COPYPTR(icc,lpbiPrev);
725 COPYPTR(icc,lpPrev);
726
727 *lParam1 = (DWORD)(icc);
728 *lParam2 = sizeof(ICCOMPRESS);
729 }
730 break;
731 case ICM_DECOMPRESS:
732 {
733 ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESS));
734 ICDECOMPRESS *icd16; /* Same structure except for the pointers */
735
736 icd16 = MapSL(*lParam1);
737 ret = icd16;
738
739 COPY(icd,dwFlags);
740 COPYPTR(icd,lpbiInput);
741 COPYPTR(icd,lpInput);
742 COPYPTR(icd,lpbiOutput);
743 COPYPTR(icd,lpOutput);
744 COPY(icd,ckid);
745
746 *lParam1 = (DWORD)(icd);
747 *lParam2 = sizeof(ICDECOMPRESS);
748 }
749 break;
750 case ICM_COMPRESS_BEGIN:
751 case ICM_COMPRESS_GET_FORMAT:
752 case ICM_COMPRESS_GET_SIZE:
753 case ICM_COMPRESS_QUERY:
754 case ICM_DECOMPRESS_GET_FORMAT:
755 case ICM_DECOMPRESS_QUERY:
756 case ICM_DECOMPRESS_BEGIN:
757 case ICM_DECOMPRESS_SET_PALETTE:
758 case ICM_DECOMPRESS_GET_PALETTE:
759 *lParam1 = (DWORD)MapSL(*lParam1);
760 *lParam2 = (DWORD)MapSL(*lParam2);
761 break;
762 case ICM_DECOMPRESSEX_QUERY:
763 if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
764 WARN("*lParam2 has unknown value %p\n",(ICDECOMPRESSEX16*)*lParam2);
765 /* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
766 * This is because of ICMessage(). Special case it?
767 {
768 LPVOID* addr = HeapAlloc(GetProcessHeap(),0,2*sizeof(LPVOID));
769 addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
770 if (*lParam2)
771 addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
772 else
773 addr[1] = 0;
774
775 ret = addr;
776 }
777 break;*/
778 case ICM_DECOMPRESSEX_BEGIN:
779 case ICM_DECOMPRESSEX:
780 ret = MSVIDEO_MapICDEX16To32(lParam1);
781 *lParam2 = sizeof(ICDECOMPRESSEX);
782 break;
783 case ICM_DRAW_BEGIN:
784 {
785 ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWBEGIN));
786 ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
787 ret = icdb16;
788
789 COPY(icdb,dwFlags);
790 COPY(icdb,hpal);
791 COPY(icdb,hwnd);
792 COPY(icdb,hdc);
793 COPY(icdb,xDst);
794 COPY(icdb,yDst);
795 COPY(icdb,dxDst);
796 COPY(icdb,dyDst);
797 COPYPTR(icdb,lpbi);
798 COPY(icdb,xSrc);
799 COPY(icdb,ySrc);
800 COPY(icdb,dxSrc);
801 COPY(icdb,dySrc);
802 COPY(icdb,dwRate);
803 COPY(icdb,dwScale);
804
805 *lParam1 = (DWORD)(icdb);
806 *lParam2 = sizeof(ICDRAWBEGIN);
807 }
808 break;
809 case ICM_DRAW_SUGGESTFORMAT:
810 {
811 ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWSUGGEST));
812 ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
813
814 ret = icds16;
815
816 COPY(icds,dwFlags);
817 COPYPTR(icds,lpbiIn);
818 COPYPTR(icds,lpbiSuggest);
819 COPY(icds,dxSrc);
820 COPY(icds,dySrc);
821 COPY(icds,dxDst);
822 COPY(icds,dyDst);
823 COPY(icds,hicDecompressor);
824
825 *lParam1 = (DWORD)(icds);
826 *lParam2 = sizeof(ICDRAWSUGGEST);
827 }
828 break;
829 case ICM_DRAW:
830 {
831 ICDRAW *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAW));
832 ICDRAW *icd16 = MapSL(*lParam1);
833 ret = icd16;
834
835 COPY(icd,dwFlags);
836 COPYPTR(icd,lpFormat);
837 COPYPTR(icd,lpData);
838 COPY(icd,cbData);
839 COPY(icd,lTime);
840
841 *lParam1 = (DWORD)(icd);
842 *lParam2 = sizeof(ICDRAW);
843 }
844 break;
845 case ICM_DRAW_START:
846 case ICM_DRAW_STOP:
847 break;
848 default:
849 FIXME("%d is not yet handled. Expect a crash.\n",msg);
850 }
851 return ret;
852}
853
854#undef COPY
855#undef COPYPTR
856
857void MSVIDEO_UnmapMsg16To32(UINT msg, LPVOID data16, LPDWORD lParam1, LPDWORD lParam2) {
858 TRACE("Unmapping %d\n",msg);
859
860#define UNCOPY(x,y) (x##16->y = x->y);
861
862 switch (msg) {
863 case ICM_GETINFO:
864 {
865 ICINFO *ici = (ICINFO*)(*lParam1);
866 ICINFO16 *ici16 = (ICINFO16*)data16;
867
868 UNCOPY(ici,fccType);
869 UNCOPY(ici,fccHandler);
870 UNCOPY(ici,dwFlags);
871 UNCOPY(ici,dwVersion);
872 UNCOPY(ici,dwVersionICM);
873 WideCharToMultiByte( CP_ACP, 0, ici->szName, -1, ici16->szName,
874 sizeof(ici16->szName), NULL, NULL );
875 ici16->szName[sizeof(ici16->szName)-1] = 0;
876 WideCharToMultiByte( CP_ACP, 0, ici->szDescription, -1, ici16->szDescription,
877 sizeof(ici16->szDescription), NULL, NULL );
878 ici16->szDescription[sizeof(ici16->szDescription)-1] = 0;
879 /* This just gives garbage for some reason - BB
880 lstrcpynWtoA(ici16->szDriver,ici->szDriver,128);*/
881
882 HeapFree(GetProcessHeap(),0,ici);
883 }
884 break;
885 case ICM_DECOMPRESS_QUERY:
886 /*{
887 LPVOID* x = data16;
888 HeapFree(GetProcessHeap(),0,x[0]);
889 if (x[1])
890 HeapFree(GetProcessHeap(),0,x[1]);
891 }
892 break;*/
893 case ICM_COMPRESS:
894 case ICM_DECOMPRESS:
895 case ICM_DECOMPRESSEX_QUERY:
896 case ICM_DECOMPRESSEX_BEGIN:
897 case ICM_DECOMPRESSEX:
898 case ICM_DRAW_BEGIN:
899 case ICM_DRAW_SUGGESTFORMAT:
900 case ICM_DRAW:
901 HeapFree(GetProcessHeap(),0,data16);
902 break;
903 default:
904 ERR("Unmapping unmapped msg %d\n",msg);
905 }
906#undef UNCOPY
907}
908#endif
909
910LRESULT MSVIDEO_SendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2, BOOL bFrom32) {
911 LRESULT ret;
912 WINE_HIC *whic = GlobalLock16(hic);
913 LPVOID data16 = 0;
914 BOOL bDrv32;
915
916#define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx,%d)\n",(DWORD)hic,lParam1,lParam2,bFrom32?32:16);break;
917
918 switch (msg) {
919 /* DRV_* */
920 XX(DRV_LOAD);
921 XX(DRV_ENABLE);
922 XX(DRV_OPEN);
923 XX(DRV_CLOSE);
924 XX(DRV_DISABLE);
925 XX(DRV_FREE);
926 /* ICM_RESERVED+X */
927 XX(ICM_ABOUT);
928 XX(ICM_CONFIGURE);
929 XX(ICM_GET);
930 XX(ICM_GETINFO);
931 XX(ICM_GETDEFAULTQUALITY);
932 XX(ICM_GETQUALITY);
933 XX(ICM_GETSTATE);
934 XX(ICM_SETQUALITY);
935 XX(ICM_SET);
936 XX(ICM_SETSTATE);
937 /* ICM_USER+X */
938 XX(ICM_COMPRESS_FRAMES_INFO);
939 XX(ICM_COMPRESS_GET_FORMAT);
940 XX(ICM_COMPRESS_GET_SIZE);
941 XX(ICM_COMPRESS_QUERY);
942 XX(ICM_COMPRESS_BEGIN);
943 XX(ICM_COMPRESS);
944 XX(ICM_COMPRESS_END);
945 XX(ICM_DECOMPRESS_GET_FORMAT);
946 XX(ICM_DECOMPRESS_QUERY);
947 XX(ICM_DECOMPRESS_BEGIN);
948 XX(ICM_DECOMPRESS);
949 XX(ICM_DECOMPRESS_END);
950 XX(ICM_DECOMPRESS_SET_PALETTE);
951 XX(ICM_DECOMPRESS_GET_PALETTE);
952 XX(ICM_DRAW_QUERY);
953 XX(ICM_DRAW_BEGIN);
954 XX(ICM_DRAW_GET_PALETTE);
955 XX(ICM_DRAW_START);
956 XX(ICM_DRAW_STOP);
957 XX(ICM_DRAW_END);
958 XX(ICM_DRAW_GETTIME);
959 XX(ICM_DRAW);
960 XX(ICM_DRAW_WINDOW);
961 XX(ICM_DRAW_SETTIME);
962 XX(ICM_DRAW_REALIZE);
963 XX(ICM_DRAW_FLUSH);
964 XX(ICM_DRAW_RENDERBUFFER);
965 XX(ICM_DRAW_START_PLAY);
966 XX(ICM_DRAW_STOP_PLAY);
967 XX(ICM_DRAW_SUGGESTFORMAT);
968 XX(ICM_DRAW_CHANGEPALETTE);
969 XX(ICM_GETBUFFERSWANTED);
970 XX(ICM_GETDEFAULTKEYFRAMERATE);
971 XX(ICM_DECOMPRESSEX_BEGIN);
972 XX(ICM_DECOMPRESSEX_QUERY);
973 XX(ICM_DECOMPRESSEX);
974 XX(ICM_DECOMPRESSEX_END);
975 XX(ICM_SET_STATUS_PROC);
976 default:
977 FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,%i) unknown message\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,bFrom32?32:16);
978 }
979
980#undef XX
981
982 if (!whic) return ICERR_BADHANDLE;
983
984 if (whic->driverproc) { /* IC is a function */
985#ifdef __WIN32OS2__
986 bDrv32 = whic->privatevfw;
987#else
988 bDrv32 = whic->private;
989#endif
990 } else {
991 bDrv32 = ((GetDriverFlags(whic->hdrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) == WINE_GDF_EXIST);
992 }
993
994#ifndef __WIN32OS2__
995 if (!bFrom32) {
996 if (bDrv32)
997 data16 = MSVIDEO_MapMsg16To32(msg,&lParam1,&lParam2);
998 } else {
999 if (!bDrv32) {
1000 ERR("Can't do 32->16 mappings\n");
1001 ret = -1;
1002 goto out;
1003 }
1004 }
1005#endif
1006
1007 if (whic->driverproc) {
1008#ifdef __WIN32OS2__
1009 ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
1010#else
1011 if (bDrv32) {
1012 ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
1013 } else {
1014 ret = MSVIDEO_CallTo16_long_lwwll((FARPROC16)whic->driverproc,whic->hdrv,hic,msg,lParam1,lParam2);
1015 }
1016#endif
1017 } else {
1018 ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
1019 }
1020
1021#ifndef __WIN32OS2__
1022 if (data16)
1023 MSVIDEO_UnmapMsg16To32(msg,data16,&lParam1,&lParam2);
1024#endif
1025
1026 out:
1027 GlobalUnlock16(hic);
1028
1029 TRACE(" -> 0x%08lx\n",ret);
1030 return ret;
1031}
1032
1033/***********************************************************************
1034 * ICSendMessage [MSVFW32.@]
1035 */
1036LRESULT VFWAPI ICSendMessage(HIC hic, UINT msg, DWORD lParam1, DWORD lParam2) {
1037 return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,TRUE);
1038}
1039#ifndef __WIN32OS2__
1040/***********************************************************************
1041 * ICSendMessage [MSVIDEO.205]
1042 */
1043LRESULT VFWAPI ICSendMessage16(HIC16 hic, UINT16 msg, DWORD lParam1, DWORD lParam2) {
1044 return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,FALSE);
1045}
1046
1047/***********************************************************************
1048 * _ICMessage [MSVIDEO.207]
1049 */
1050LRESULT VFWAPIV ICMessage16(void) {
1051 HIC16 hic;
1052 UINT16 msg;
1053 UINT16 cb;
1054 LPWORD lpData;
1055 LRESULT ret;
1056 UINT16 i;
1057
1058 VA_LIST16 valist;
1059
1060 VA_START16(valist);
1061 hic = VA_ARG16(valist, HIC16);
1062 msg = VA_ARG16(valist, UINT16);
1063 cb = VA_ARG16(valist, UINT16);
1064
1065 lpData = SEGPTR_ALLOC(cb);
1066
1067 TRACE("0x%08lx, %u, %u, ...)\n",(DWORD)hic,msg,cb);
1068
1069 for(i=0;i<cb/sizeof(WORD);i++) {
1070 lpData[i] = VA_ARG16(valist, WORD);
1071 }
1072
1073 VA_END16(valist);
1074 ret = ICSendMessage16(hic, msg, (DWORD)(SEGPTR_GET(lpData)), (DWORD)cb);
1075
1076 SEGPTR_FREE(lpData);
1077 return ret;
1078}
1079#endif
1080/***********************************************************************
1081 * ICDrawBegin [MSVFW32.@]
1082 */
1083DWORD VFWAPIV ICDrawBegin(
1084 HIC hic, /* [in] */
1085 DWORD dwFlags, /* [in] flags */
1086 HPALETTE hpal, /* [in] palette to draw with */
1087 HWND hwnd, /* [in] window to draw to */
1088 HDC hdc, /* [in] HDC to draw to */
1089 INT xDst, /* [in] destination rectangle */
1090 INT yDst, /* [in] */
1091 INT dxDst, /* [in] */
1092 INT dyDst, /* [in] */
1093 LPBITMAPINFOHEADER lpbi, /* [in] format of frame to draw */
1094 INT xSrc, /* [in] source rectangle */
1095 INT ySrc, /* [in] */
1096 INT dxSrc, /* [in] */
1097 INT dySrc, /* [in] */
1098 DWORD dwRate, /* [in] frames/second = (dwRate/dwScale) */
1099 DWORD dwScale) /* [in] */
1100{
1101
1102 ICDRAWBEGIN icdb;
1103
1104 TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
1105 (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
1106 lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
1107
1108 icdb.dwFlags = dwFlags;
1109 icdb.hpal = hpal;
1110 icdb.hwnd = hwnd;
1111 icdb.hdc = hdc;
1112 icdb.xDst = xDst;
1113 icdb.yDst = yDst;
1114 icdb.dxDst = dxDst;
1115 icdb.dyDst = dyDst;
1116 icdb.lpbi = lpbi;
1117 icdb.xSrc = xSrc;
1118 icdb.ySrc = ySrc;
1119 icdb.dxSrc = dxSrc;
1120 icdb.dySrc = dySrc;
1121 icdb.dwRate = dwRate;
1122 icdb.dwScale = dwScale;
1123 return ICSendMessage(hic,ICM_DRAW_BEGIN,(DWORD)&icdb,sizeof(icdb));
1124}
1125
1126#ifndef __WIN32OS2__
1127/***********************************************************************
1128 * _ICDrawBegin [MSVIDEO.232]
1129 */
1130DWORD VFWAPIV ICDrawBegin16(
1131 HIC16 hic, /* [in] */
1132 DWORD dwFlags, /* [in] flags */
1133 HPALETTE16 hpal, /* [in] palette to draw with */
1134 HWND16 hwnd, /* [in] window to draw to */
1135 HDC16 hdc, /* [in] HDC to draw to */
1136 INT16 xDst, /* [in] destination rectangle */
1137 INT16 yDst, /* [in] */
1138 INT16 dxDst, /* [in] */
1139 INT16 dyDst, /* [in] */
1140 LPBITMAPINFOHEADER lpbi, /* [in] format of frame to draw NOTE: SEGPTR */
1141 INT16 xSrc, /* [in] source rectangle */
1142 INT16 ySrc, /* [in] */
1143 INT16 dxSrc, /* [in] */
1144 INT16 dySrc, /* [in] */
1145 DWORD dwRate, /* [in] frames/second = (dwRate/dwScale) */
1146 DWORD dwScale) /* [in] */
1147{
1148 DWORD ret;
1149 ICDRAWBEGIN16* icdb = SEGPTR_NEW(ICDRAWBEGIN16); /* SEGPTR for mapper to deal with */
1150
1151 TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
1152 (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
1153 lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
1154
1155 icdb->dwFlags = dwFlags;
1156 icdb->hpal = hpal;
1157 icdb->hwnd = hwnd;
1158 icdb->hdc = hdc;
1159 icdb->xDst = xDst;
1160 icdb->yDst = yDst;
1161 icdb->dxDst = dxDst;
1162 icdb->dyDst = dyDst;
1163 icdb->lpbi = lpbi; /* Keep this as SEGPTR for the mapping code to deal with */
1164 icdb->xSrc = xSrc;
1165 icdb->ySrc = ySrc;
1166 icdb->dxSrc = dxSrc;
1167 icdb->dySrc = dySrc;
1168 icdb->dwRate = dwRate;
1169 icdb->dwScale = dwScale;
1170
1171 ret = (DWORD)ICSendMessage16(hic,ICM_DRAW_BEGIN,(DWORD)SEGPTR_GET(icdb),sizeof(ICDRAWBEGIN16));
1172 SEGPTR_FREE(icdb);
1173 return ret;
1174}
1175#endif
1176
1177/***********************************************************************
1178 * ICDraw [MSVFW32.@]
1179 */
1180DWORD VFWAPIV ICDraw(HIC hic, DWORD dwFlags, LPVOID lpFormat, LPVOID lpData, DWORD cbData, LONG lTime) {
1181 ICDRAW icd;
1182
1183 TRACE("(0x%09lx,%ld,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
1184
1185 icd.dwFlags = dwFlags;
1186 icd.lpFormat = lpFormat;
1187 icd.lpData = lpData;
1188 icd.cbData = cbData;
1189 icd.lTime = lTime;
1190
1191 return ICSendMessage(hic,ICM_DRAW,(DWORD)&icd,sizeof(icd));
1192}
1193
1194#ifndef __WIN32OS2__
1195/***********************************************************************
1196 * _ICDraw [MSVIDEO.234]
1197 */
1198DWORD VFWAPIV ICDraw16(
1199 HIC16 hic,
1200 DWORD dwFlags,
1201 LPVOID lpFormat, /* [???] NOTE: SEGPTR */
1202 LPVOID lpData, /* [???] NOTE: SEGPTR */
1203 DWORD cbData,
1204 LONG lTime)
1205{
1206 ICDRAW* icd = SEGPTR_NEW(ICDRAW); /* SEGPTR for mapper to deal with */
1207
1208 TRACE("(0x%08lx,0x%08lx,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
1209 icd->dwFlags = dwFlags;
1210 icd->lpFormat = lpFormat;
1211 icd->lpData = lpData;
1212 icd->cbData = cbData;
1213 icd->lTime = lTime;
1214
1215 return ICSendMessage16(hic,ICM_DRAW,(DWORD)SEGPTR_GET(icd),sizeof(ICDRAW));
1216}
1217#endif
1218
1219/***********************************************************************
1220 * ICClose [MSVFW32.@]
1221 */
1222LRESULT WINAPI ICClose(HIC hic) {
1223 WINE_HIC *whic = GlobalLock16(hic);
1224 TRACE("(0x%08lx)\n",(DWORD)hic);
1225 if (whic->driverproc) {
1226 ICSendMessage(hic,DRV_CLOSE,0,0);
1227 ICSendMessage(hic,DRV_DISABLE,0,0);
1228 ICSendMessage(hic,DRV_FREE,0,0);
1229 } else {
1230 CloseDriver(whic->hdrv,0,0);
1231 }
1232
1233 GlobalUnlock16(hic);
1234 GlobalFree16(hic);
1235 return 0;
1236}
1237
1238#ifndef __WIN32OS2__
1239/***********************************************************************
1240 * ICClose [MSVIDEO.204]
1241 */
1242LRESULT WINAPI ICClose16(HIC16 hic) {
1243 return ICClose(hic);
1244}
1245#endif
1246
1247/***********************************************************************
1248 * MCIWndCreate [MSVFW32.@]
1249 * MCIWndCreateA [MSVFW32.@]
1250 */
1251HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
1252 DWORD dwStyle,LPCSTR szFile)
1253{
1254 FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
1255 return 0;
1256}
1257
1258/***********************************************************************
1259 * MCIWndCreateW [MSVFW32.@]
1260 */
1261HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
1262 DWORD dwStyle,LPCWSTR szFile)
1263{
1264 FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));
1265 return 0;
1266}
Note: See TracBrowser for help on using the repository browser.