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

Last change on this file since 6648 was 6648, checked in by bird, 24 years ago

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