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

Last change on this file since 8001 was 7511, checked in by sandervl, 24 years ago

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