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