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

Last change on this file since 7504 was 7502, checked in by phaller, 24 years ago

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