2 * Copyright 1998 Marcus Meissner
3 * Copyright 2000 Bradley Baetz
4 * Copyright 2003 Michael Günnewig
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * FIXME: This all assumes 32 bit codecs
21 * Win95 appears to prefer 32 bit codecs, even from 16 bit code.
22 * There is the ICOpenFunction16 to worry about still, though.
31 #include "msvideo_private.h"
39 #include "wine/debug.h"
41 /* Drivers32 settings */
42 #define HKLM_DRIVERS32 "Software\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32"
44 WINE_DEFAULT_DEBUG_CHANNEL(msvideo
);
46 static inline const char *wine_dbgstr_fcc( DWORD fcc
)
48 return wine_dbg_sprintf("%c%c%c%c",
49 LOBYTE(LOWORD(fcc
)), HIBYTE(LOWORD(fcc
)),
50 LOBYTE(HIWORD(fcc
)), HIBYTE(HIWORD(fcc
)));
53 LRESULT (CALLBACK
*pFnCallTo16
)(HDRVR
, HIC
, UINT
, LPARAM
, LPARAM
) = NULL
;
55 static WINE_HIC
* MSVIDEO_FirstHic
/* = NULL */;
57 typedef struct _reg_driver reg_driver
;
67 static reg_driver
* reg_driver_list
= NULL
;
69 /* This one is a macro such that it works for both ASCII and Unicode */
70 #define fourcc_to_string(str, fcc) do { \
71 (str)[0] = LOBYTE(LOWORD(fcc)); \
72 (str)[1] = HIBYTE(LOWORD(fcc)); \
73 (str)[2] = LOBYTE(HIWORD(fcc)); \
74 (str)[3] = HIBYTE(HIWORD(fcc)); \
77 HMODULE MSVFW32_hModule
;
79 BOOL WINAPI
DllMain( HINSTANCE hinst
, DWORD reason
, LPVOID reserved
)
81 TRACE("%p,%lx,%p\n", hinst
, reason
, reserved
);
85 case DLL_PROCESS_ATTACH
:
86 DisableThreadLibraryCalls(hinst
);
87 MSVFW32_hModule
= (HMODULE
)hinst
;
93 static int compare_fourcc(DWORD fcc1
, DWORD fcc2
)
97 fourcc_to_string(fcc_str1
, fcc1
);
98 fourcc_to_string(fcc_str2
, fcc2
);
99 return strncasecmp(fcc_str1
, fcc_str2
, 4);
102 typedef BOOL (*enum_handler_t
)(const char*, int, void*);
104 static BOOL
enum_drivers(DWORD fccType
, enum_handler_t handler
, void* param
)
106 CHAR buf
[2048], fccTypeStr
[5], *s
;
107 DWORD i
, cnt
= 0, bufLen
, lRet
;
112 fourcc_to_string(fccTypeStr
, fccType
);
115 /* first, go through the registry entries */
116 lRet
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
, HKLM_DRIVERS32
, 0, KEY_QUERY_VALUE
, &hKey
);
117 if (lRet
== ERROR_SUCCESS
)
119 RegQueryInfoKeyA( hKey
, 0, 0, 0, &cnt
, 0, 0, 0, 0, 0, 0, 0);
120 for (i
= 0; i
< cnt
; i
++)
122 bufLen
= sizeof(buf
) / sizeof(buf
[0]);
123 lRet
= RegEnumKeyExA(hKey
, i
, buf
, &bufLen
, 0, 0, 0, &lastWrite
);
124 if (lRet
!= ERROR_SUCCESS
) continue;
125 if (strncasecmp(buf
, fccTypeStr
, 5) || buf
[9] != '=') continue;
126 if ((result
= handler(buf
, i
, param
))) break;
130 if (result
) return result
;
132 /* if that didn't work, go through the values in system.ini */
133 if (GetPrivateProfileSectionA("drivers32", buf
, sizeof(buf
), "system.ini"))
135 for (s
= buf
; *s
; cnt
++, s
+= strlen(s
) + 1)
137 if (strncasecmp(s
, fccTypeStr
, 5) || s
[9] != '=') continue;
138 if ((result
= handler(s
, cnt
, param
))) break;
145 /******************************************************************
150 WINE_HIC
* MSVIDEO_GetHicPtr(HIC hic
)
154 for (whic
= MSVIDEO_FirstHic
; whic
&& whic
->hic
!= hic
; whic
= whic
->next
);
158 /***********************************************************************
159 * VideoForWindowsVersion [MSVFW32.2]
160 * VideoForWindowsVersion [MSVIDEO.2]
161 * Returns the version in major.minor form.
162 * In Windows95 this returns 0x040003b6 (4.950)
164 DWORD WINAPI
VideoForWindowsVersion(void)
166 return 0x040003B6; /* 4.950 */
169 static BOOL
ICInfo_enum_handler(const char *drv
, int nr
, void *param
)
171 ICINFO
*lpicinfo
= (ICINFO
*)param
;
172 DWORD fccHandler
= mmioStringToFOURCCA(drv
+ 5, 0);
174 /* exact match of fccHandler or nth driver found */
175 if ((lpicinfo
->fccHandler
!= nr
) && (lpicinfo
->fccHandler
!= fccHandler
))
178 lpicinfo
->fccType
= mmioStringToFOURCCA(drv
, 0);
179 lpicinfo
->fccHandler
= fccHandler
;
180 lpicinfo
->dwFlags
= 0;
181 lpicinfo
->dwVersion
= 0;
182 lpicinfo
->dwVersionICM
= 0x104;
183 lpicinfo
->szName
[0] = 0;
184 lpicinfo
->szDescription
[0] = 0;
185 MultiByteToWideChar(CP_ACP
, 0, drv
+ 10, -1, lpicinfo
->szDriver
,
186 sizeof(lpicinfo
->szDriver
)/sizeof(WCHAR
));
191 /***********************************************************************
193 * Get information about an installable compressor. Return TRUE if there
197 * fccType [I] type of compressor (e.g. 'vidc')
198 * fccHandler [I] real fcc for handler or <n>th compressor
199 * lpicinfo [O] information about compressor
201 BOOL VFWAPI
ICInfo( DWORD fccType
, DWORD fccHandler
, ICINFO
*lpicinfo
)
203 TRACE("(%s,%s/%08lx,%p)\n",
204 wine_dbgstr_fcc(fccType
), wine_dbgstr_fcc(fccHandler
), fccHandler
, lpicinfo
);
206 lpicinfo
->fccHandler
= fccHandler
;
207 return enum_drivers(fccType
, ICInfo_enum_handler
, lpicinfo
);
210 static DWORD IC_HandleRef
= 1;
212 /***********************************************************************
213 * ICInstall [MSVFW32.@]
215 BOOL VFWAPI
ICInstall(DWORD fccType
, DWORD fccHandler
, LPARAM lParam
, LPSTR szDesc
, UINT wFlags
)
220 TRACE("(%s,%s,%p,%p,0x%08x)\n", wine_dbgstr_fcc(fccType
), wine_dbgstr_fcc(fccHandler
), (void*)lParam
, szDesc
, wFlags
);
222 /* Check if a driver is already registered */
223 for (driver
= reg_driver_list
; driver
; driver
= driver
->next
)
225 if (!compare_fourcc(fccType
, driver
->fccType
) &&
226 !compare_fourcc(fccHandler
, driver
->fccHandler
))
229 if (driver
) return FALSE
;
231 /* Register the driver */
232 driver
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(reg_driver
));
233 if (!driver
) goto oom
;
234 driver
->fccType
= fccType
;
235 driver
->fccHandler
= fccHandler
;
239 case ICINSTALL_FUNCTION
:
240 driver
->proc
= (DRIVERPROC
)lParam
;
243 case ICINSTALL_DRIVER
:
245 len
= MultiByteToWideChar(CP_ACP
, 0, (char*)lParam
, -1, NULL
, 0);
246 driver
->name
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
247 if (!driver
->name
) goto oom
;
248 MultiByteToWideChar(CP_ACP
, 0, (char*)lParam
, -1, driver
->name
, len
);
251 ERR("Invalid flags!\n");
252 HeapFree(GetProcessHeap(), 0, driver
);
256 /* Insert our driver in the list*/
257 driver
->next
= reg_driver_list
;
258 reg_driver_list
= driver
;
262 HeapFree(GetProcessHeap(), 0, driver
);
266 /***********************************************************************
267 * ICRemove [MSVFW32.@]
269 BOOL VFWAPI
ICRemove(DWORD fccType
, DWORD fccHandler
, UINT wFlags
)
271 reg_driver
** pdriver
;
273 TRACE("(%s,%s,0x%08x)\n", wine_dbgstr_fcc(fccType
), wine_dbgstr_fcc(fccHandler
), wFlags
);
275 /* Check if a driver is already registered */
276 for (pdriver
= ®_driver_list
; *pdriver
; pdriver
= &(*pdriver
)->next
)
278 if (!compare_fourcc(fccType
, (*pdriver
)->fccType
) &&
279 !compare_fourcc(fccHandler
, (*pdriver
)->fccHandler
))
285 /* Remove the driver from the list */
286 *pdriver
= (*pdriver
)->next
;
287 HeapFree(GetProcessHeap(), 0, (*pdriver
)->name
);
288 HeapFree(GetProcessHeap(), 0, *pdriver
);
294 /***********************************************************************
296 * Opens an installable compressor. Return special handle.
298 HIC VFWAPI
ICOpen(DWORD fccType
, DWORD fccHandler
, UINT wMode
)
305 static const WCHAR drv32W
[] = {'d','r','i','v','e','r','s','3','2','\0'};
308 TRACE("(%s,%s,0x%08x)\n", wine_dbgstr_fcc(fccType
), wine_dbgstr_fcc(fccHandler
), wMode
);
310 /* Check if there is a registered driver that matches */
311 driver
= reg_driver_list
;
313 if (!compare_fourcc(fccType
, driver
->fccType
) &&
314 !compare_fourcc(fccHandler
, driver
->fccHandler
))
317 driver
= driver
->next
;
319 if (driver
&& driver
->proc
)
320 /* The driver has been registered at runtime with its driverproc */
321 return MSVIDEO_OpenFunction(fccType
, fccHandler
, wMode
, (DRIVERPROC
)driver
->proc
, (DWORD
)NULL
);
323 /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
324 * same layout as ICOPEN
326 icopen
.dwSize
= sizeof(ICOPEN
);
327 icopen
.fccType
= fccType
;
328 icopen
.fccHandler
= fccHandler
;
329 icopen
.dwVersion
= 0x00001000; /* FIXME */
330 icopen
.dwFlags
= wMode
;
332 icopen
.pV1Reserved
= NULL
;
333 icopen
.pV2Reserved
= NULL
;
334 icopen
.dnDevNode
= 0; /* FIXME */
337 /* The driver is registered in the registry */
338 fourcc_to_string(codecname
, fccType
);
340 fourcc_to_string(codecname
+ 5, fccHandler
);
343 hdrv
= OpenDriver(codecname
, drv32W
, (LPARAM
)&icopen
);
346 if (fccType
== streamtypeVIDEO
)
353 fccType
= ICTYPE_VIDEO
;
354 hdrv
= OpenDriver(codecname
, drv32W
, (LPARAM
)&icopen
);
360 /* The driver has been registered at runtime with its name */
361 hdrv
= OpenDriver(driver
->name
, NULL
, (LPARAM
)&icopen
);
365 bIs16
= GetDriverFlags(hdrv
) & 0x10000000; /* undocumented flag: WINE_GDF_16BIT */
367 if (bIs16
&& !pFnCallTo16
)
369 FIXME("Got a 16 bit driver, but no 16 bit support in msvfw\n");
372 whic
= HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_HIC
));
375 CloseDriver(hdrv
, 0, 0);
379 /* FIXME: is the signature the real one ? */
380 whic
->driverproc
= bIs16
? (DRIVERPROC
)pFnCallTo16
: NULL
;
381 whic
->driverproc16
= 0;
382 whic
->type
= fccType
;
383 whic
->handler
= fccHandler
;
384 while (MSVIDEO_GetHicPtr(HIC_32(IC_HandleRef
)) != NULL
) IC_HandleRef
++;
385 whic
->hic
= HIC_32(IC_HandleRef
++);
386 whic
->next
= MSVIDEO_FirstHic
;
387 MSVIDEO_FirstHic
= whic
;
389 TRACE("=> %p\n", whic
->hic
);
393 /***********************************************************************
394 * MSVIDEO_OpenFunction
396 HIC
MSVIDEO_OpenFunction(DWORD fccType
, DWORD fccHandler
, UINT wMode
,
397 DRIVERPROC lpfnHandler
, DWORD lpfnHandler16
)
402 TRACE("(%s,%s,%d,%p,%08lx)\n",
403 wine_dbgstr_fcc(fccType
), wine_dbgstr_fcc(fccHandler
), wMode
, lpfnHandler
, lpfnHandler16
);
405 icopen
.dwSize
= sizeof(ICOPEN
);
406 icopen
.fccType
= fccType
;
407 icopen
.fccHandler
= fccHandler
;
408 icopen
.dwVersion
= 0x00001000; /* FIXME */
409 icopen
.dwFlags
= wMode
;
411 icopen
.pV1Reserved
= NULL
;
412 icopen
.pV2Reserved
= NULL
;
413 icopen
.dnDevNode
= 0; /* FIXME */
415 whic
= HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_HIC
));
418 whic
->driverproc
= lpfnHandler
;
419 whic
->driverproc16
= lpfnHandler16
;
420 while (MSVIDEO_GetHicPtr(HIC_32(IC_HandleRef
)) != NULL
) IC_HandleRef
++;
421 whic
->hic
= HIC_32(IC_HandleRef
++);
422 whic
->next
= MSVIDEO_FirstHic
;
423 MSVIDEO_FirstHic
= whic
;
425 /* Now try opening/loading the driver. Taken from DRIVER_AddToList */
426 /* What if the function is used more than once? */
428 if (MSVIDEO_SendMessage(whic
, DRV_LOAD
, 0L, 0L) != DRV_SUCCESS
)
430 WARN("DRV_LOAD failed for hic %p\n", whic
->hic
);
431 MSVIDEO_FirstHic
= whic
->next
;
432 HeapFree(GetProcessHeap(), 0, whic
);
435 /* return value is not checked */
436 MSVIDEO_SendMessage(whic
, DRV_ENABLE
, 0L, 0L);
438 whic
->driverId
= (DWORD
)MSVIDEO_SendMessage(whic
, DRV_OPEN
, 0, (DWORD
)&icopen
);
439 /* FIXME: What should we put here? */
442 if (whic
->driverId
== 0)
444 WARN("DRV_OPEN failed for hic %p\n", whic
->hic
);
445 MSVIDEO_FirstHic
= whic
->next
;
446 HeapFree(GetProcessHeap(), 0, whic
);
450 TRACE("=> %p\n", whic
->hic
);
454 /***********************************************************************
455 * ICOpenFunction [MSVFW32.@]
457 HIC VFWAPI
ICOpenFunction(DWORD fccType
, DWORD fccHandler
, UINT wMode
, FARPROC lpfnHandler
)
459 return MSVIDEO_OpenFunction(fccType
, fccHandler
, wMode
, (DRIVERPROC
)lpfnHandler
, 0);
462 /***********************************************************************
463 * ICGetInfo [MSVFW32.@]
465 LRESULT VFWAPI
ICGetInfo(HIC hic
, ICINFO
*picinfo
, DWORD cb
)
468 WINE_HIC
* whic
= MSVIDEO_GetHicPtr(hic
);
470 TRACE("(%p,%p,%ld)\n", hic
, picinfo
, cb
);
472 whic
= MSVIDEO_GetHicPtr(hic
);
473 if (!whic
) return ICERR_BADHANDLE
;
474 if (!picinfo
) return MMSYSERR_INVALPARAM
;
476 /* (WS) The field szDriver should be initialized because the driver
477 * is not obliged and often will not do it. Some applications, like
478 * VirtualDub, rely on this field and will occasionally crash if it
481 if (cb
>= sizeof(ICINFO
)) picinfo
->szDriver
[0] = '\0';
483 ret
= ICSendMessage(hic
, ICM_GETINFO
, (DWORD
)picinfo
, cb
);
485 /* (WS) When szDriver was not supplied by the driver itself, apparently
486 * Windows will set its value equal to the driver file name. This can
487 * be obtained from the registry as we do here.
489 if (cb
>= sizeof(ICINFO
) && picinfo
->szDriver
[0] == 0)
493 memset(&ii
, 0, sizeof(ii
));
494 ii
.dwSize
= sizeof(ii
);
495 ICInfo(picinfo
->fccType
, picinfo
->fccHandler
, &ii
);
496 lstrcpyW(picinfo
->szDriver
, ii
.szDriver
);
499 TRACE(" -> 0x%08lx\n", ret
);
506 LPBITMAPINFOHEADER lpbiIn
;
507 LPBITMAPINFOHEADER lpbiOut
;
513 static HIC
try_driver(driver_info_t
*info
)
517 if ((hic
= ICOpen(info
->fccType
, info
->fccHandler
, info
->wMode
)))
519 if (!ICSendMessage(hic
, info
->querymsg
, (DWORD
)info
->lpbiIn
, (DWORD
)info
->lpbiOut
))
526 static BOOL
ICLocate_enum_handler(const char *drv
, int nr
, void *param
)
528 driver_info_t
*info
= (driver_info_t
*)param
;
529 info
->fccHandler
= mmioStringToFOURCCA(drv
+ 5, 0);
530 info
->hic
= try_driver(info
);
531 return info
->hic
!= 0;
534 /***********************************************************************
535 * ICLocate [MSVFW32.@]
537 HIC VFWAPI
ICLocate(DWORD fccType
, DWORD fccHandler
, LPBITMAPINFOHEADER lpbiIn
,
538 LPBITMAPINFOHEADER lpbiOut
, WORD wMode
)
542 TRACE("(%s,%s,%p,%p,0x%04x)\n",
543 wine_dbgstr_fcc(fccType
), wine_dbgstr_fcc(fccHandler
), lpbiIn
, lpbiOut
, wMode
);
545 info
.fccType
= fccType
;
546 info
.fccHandler
= fccHandler
;
547 info
.lpbiIn
= lpbiIn
;
548 info
.lpbiOut
= lpbiOut
;
553 case ICMODE_FASTCOMPRESS
:
554 case ICMODE_COMPRESS
:
555 info
.querymsg
= ICM_COMPRESS_QUERY
;
557 case ICMODE_FASTDECOMPRESS
:
558 case ICMODE_DECOMPRESS
:
559 info
.querymsg
= ICM_DECOMPRESS_QUERY
;
562 info
.querymsg
= ICM_DRAW_QUERY
;
565 WARN("Unknown mode (%d)\n", wMode
);
569 /* Easy case: handler/type match, we just fire a query and return */
570 info
.hic
= try_driver(&info
);
571 /* If it didn't work, try each driver in turn. 32 bit codecs only. */
572 /* FIXME: Move this to an init routine? */
573 if (!info
.hic
) enum_drivers(fccType
, ICLocate_enum_handler
, &info
);
577 TRACE("=> %p\n", info
.hic
);
581 if (fccType
== streamtypeVIDEO
)
582 return ICLocate(ICTYPE_VIDEO
, fccHandler
, lpbiIn
, lpbiOut
, wMode
);
584 WARN("(%s,%s,%p,%p,0x%04x) not found!\n",
585 wine_dbgstr_fcc(fccType
), wine_dbgstr_fcc(fccHandler
), lpbiIn
, lpbiOut
, wMode
);
589 /***********************************************************************
590 * ICGetDisplayFormat [MSVFW32.@]
592 HIC VFWAPI
ICGetDisplayFormat(
593 HIC hic
,LPBITMAPINFOHEADER lpbiIn
,LPBITMAPINFOHEADER lpbiOut
,
594 INT depth
,INT dx
,INT dy
)
598 TRACE("(%p,%p,%p,%d,%d,%d)!\n",hic
,lpbiIn
,lpbiOut
,depth
,dx
,dy
);
601 tmphic
=ICLocate(ICTYPE_VIDEO
,0,lpbiIn
,NULL
,ICMODE_DECOMPRESS
);
605 if ((dy
== lpbiIn
->biHeight
) && (dx
== lpbiIn
->biWidth
))
606 dy
= dx
= 0; /* no resize needed */
608 /* Can we decompress it ? */
609 if (ICDecompressQuery(tmphic
,lpbiIn
,NULL
) != 0)
610 goto errout
; /* no, sorry */
612 ICDecompressGetFormat(tmphic
,lpbiIn
,lpbiOut
);
614 if (lpbiOut
->biCompression
!= 0) {
615 FIXME("Ooch, how come decompressor outputs compressed data (%ld)??\n",
616 lpbiOut
->biCompression
);
618 if (lpbiOut
->biSize
< sizeof(*lpbiOut
)) {
619 FIXME("Ooch, size of output BIH is too small (%ld)\n",
621 lpbiOut
->biSize
= sizeof(*lpbiOut
);
627 depth
= GetDeviceCaps(hdc
,BITSPIXEL
)*GetDeviceCaps(hdc
,PLANES
);
629 if (depth
==15) depth
= 16;
630 if (depth
<8) depth
= 8;
632 if (lpbiIn
->biBitCount
== 8)
635 TRACE("=> %p\n", tmphic
);
645 /***********************************************************************
646 * ICCompress [MSVFW32.@]
650 HIC hic
,DWORD dwFlags
,LPBITMAPINFOHEADER lpbiOutput
,LPVOID lpData
,
651 LPBITMAPINFOHEADER lpbiInput
,LPVOID lpBits
,LPDWORD lpckid
,
652 LPDWORD lpdwFlags
,LONG lFrameNum
,DWORD dwFrameSize
,DWORD dwQuality
,
653 LPBITMAPINFOHEADER lpbiPrev
,LPVOID lpPrev
)
657 TRACE("(%p,%ld,%p,%p,%p,%p,...)\n",hic
,dwFlags
,lpbiOutput
,lpData
,lpbiInput
,lpBits
);
659 iccmp
.dwFlags
= dwFlags
;
661 iccmp
.lpbiOutput
= lpbiOutput
;
662 iccmp
.lpOutput
= lpData
;
663 iccmp
.lpbiInput
= lpbiInput
;
664 iccmp
.lpInput
= lpBits
;
666 iccmp
.lpckid
= lpckid
;
667 iccmp
.lpdwFlags
= lpdwFlags
;
668 iccmp
.lFrameNum
= lFrameNum
;
669 iccmp
.dwFrameSize
= dwFrameSize
;
670 iccmp
.dwQuality
= dwQuality
;
671 iccmp
.lpbiPrev
= lpbiPrev
;
672 iccmp
.lpPrev
= lpPrev
;
673 return ICSendMessage(hic
,ICM_COMPRESS
,(DWORD
)&iccmp
,sizeof(iccmp
));
676 /***********************************************************************
677 * ICDecompress [MSVFW32.@]
679 DWORD VFWAPIV
ICDecompress(HIC hic
,DWORD dwFlags
,LPBITMAPINFOHEADER lpbiFormat
,
680 LPVOID lpData
,LPBITMAPINFOHEADER lpbi
,LPVOID lpBits
)
685 TRACE("(%p,%ld,%p,%p,%p,%p)\n",hic
,dwFlags
,lpbiFormat
,lpData
,lpbi
,lpBits
);
687 TRACE("lpBits[0] == %lx\n",((LPDWORD
)lpBits
)[0]);
689 icd
.dwFlags
= dwFlags
;
690 icd
.lpbiInput
= lpbiFormat
;
691 icd
.lpInput
= lpData
;
693 icd
.lpbiOutput
= lpbi
;
694 icd
.lpOutput
= lpBits
;
696 ret
= ICSendMessage(hic
,ICM_DECOMPRESS
,(DWORD
)&icd
,sizeof(ICDECOMPRESS
));
698 TRACE("lpBits[0] == %lx\n",((LPDWORD
)lpBits
)[0]);
700 TRACE("-> %ld\n",ret
);
706 /***********************************************************************
707 * ICCompressorChoose [MSVFW32.@]
709 BOOL VFWAPI
ICCompressorChoose(HWND hwnd
, UINT uiFlags
, LPVOID pvIn
,
710 LPVOID lpData
, PCOMPVARS pc
, LPSTR lpszTitle
)
712 FIXME("(%p,0x%X,%p,%p,%p,%s),stub!\n",hwnd
,uiFlags
,pvIn
,lpData
,pc
,lpszTitle
);
714 if (pc
== NULL
|| pc
->cbSize
!= sizeof(COMPVARS
))
717 if ((pc
->dwFlags
& ICMF_COMPVARS_VALID
) == 0) {
719 pc
->fccType
= pc
->fccHandler
= 0;
722 pc
->lpBitsOut
= pc
->lpBitsPrev
= pc
->lpState
= NULL
;
723 pc
->lQ
= ICQUALITY_DEFAULT
;
725 pc
->lDataRate
= 300; /* kB */
729 if (pc
->fccType
== 0)
730 pc
->fccType
= ICTYPE_VIDEO
;
738 /***********************************************************************
739 * ICCompressorFree [MSVFW32.@]
741 void VFWAPI
ICCompressorFree(PCOMPVARS pc
)
745 if (pc
!= NULL
&& pc
->cbSize
== sizeof(COMPVARS
)) {
746 if (pc
->hic
!= NULL
) {
750 if (pc
->lpbiOut
!= NULL
) {
751 GlobalFreePtr(pc
->lpbiOut
);
754 if (pc
->lpBitsOut
!= NULL
) {
755 GlobalFreePtr(pc
->lpBitsOut
);
756 pc
->lpBitsOut
= NULL
;
758 if (pc
->lpBitsPrev
!= NULL
) {
759 GlobalFreePtr(pc
->lpBitsPrev
);
760 pc
->lpBitsPrev
= NULL
;
762 if (pc
->lpState
!= NULL
) {
763 GlobalFreePtr(pc
->lpBitsPrev
);
771 /******************************************************************
772 * MSVIDEO_SendMessage
776 LRESULT
MSVIDEO_SendMessage(WINE_HIC
* whic
, UINT msg
, DWORD lParam1
, DWORD lParam2
)
780 #define XX(x) case x: TRACE("(%p,"#x",0x%08lx,0x%08lx)\n",whic,lParam1,lParam2); break;
795 XX(ICM_GETDEFAULTQUALITY
);
802 XX(ICM_COMPRESS_FRAMES_INFO
);
803 XX(ICM_COMPRESS_GET_FORMAT
);
804 XX(ICM_COMPRESS_GET_SIZE
);
805 XX(ICM_COMPRESS_QUERY
);
806 XX(ICM_COMPRESS_BEGIN
);
808 XX(ICM_COMPRESS_END
);
809 XX(ICM_DECOMPRESS_GET_FORMAT
);
810 XX(ICM_DECOMPRESS_QUERY
);
811 XX(ICM_DECOMPRESS_BEGIN
);
813 XX(ICM_DECOMPRESS_END
);
814 XX(ICM_DECOMPRESS_SET_PALETTE
);
815 XX(ICM_DECOMPRESS_GET_PALETTE
);
818 XX(ICM_DRAW_GET_PALETTE
);
822 XX(ICM_DRAW_GETTIME
);
825 XX(ICM_DRAW_SETTIME
);
826 XX(ICM_DRAW_REALIZE
);
828 XX(ICM_DRAW_RENDERBUFFER
);
829 XX(ICM_DRAW_START_PLAY
);
830 XX(ICM_DRAW_STOP_PLAY
);
831 XX(ICM_DRAW_SUGGESTFORMAT
);
832 XX(ICM_DRAW_CHANGEPALETTE
);
833 XX(ICM_GETBUFFERSWANTED
);
834 XX(ICM_GETDEFAULTKEYFRAMERATE
);
835 XX(ICM_DECOMPRESSEX_BEGIN
);
836 XX(ICM_DECOMPRESSEX_QUERY
);
837 XX(ICM_DECOMPRESSEX
);
838 XX(ICM_DECOMPRESSEX_END
);
839 XX(ICM_SET_STATUS_PROC
);
841 FIXME("(%p,0x%08lx,0x%08lx,0x%08lx) unknown message\n",whic
,(DWORD
)msg
,lParam1
,lParam2
);
846 if (whic
->driverproc
) {
847 /* dwDriverId parameter is the value returned by the DRV_OPEN */
848 ret
= whic
->driverproc(whic
->driverId
, whic
->hdrv
, msg
, lParam1
, lParam2
);
850 ret
= SendDriverMessage(whic
->hdrv
, msg
, lParam1
, lParam2
);
853 TRACE(" -> 0x%08lx\n", ret
);
857 /***********************************************************************
858 * ICSendMessage [MSVFW32.@]
860 LRESULT VFWAPI
ICSendMessage(HIC hic
, UINT msg
, DWORD lParam1
, DWORD lParam2
)
862 WINE_HIC
* whic
= MSVIDEO_GetHicPtr(hic
);
864 if (!whic
) return ICERR_BADHANDLE
;
865 return MSVIDEO_SendMessage(whic
, msg
, lParam1
, lParam2
);
868 /***********************************************************************
869 * ICDrawBegin [MSVFW32.@]
871 DWORD VFWAPIV
ICDrawBegin(
873 DWORD dwFlags
, /* [in] flags */
874 HPALETTE hpal
, /* [in] palette to draw with */
875 HWND hwnd
, /* [in] window to draw to */
876 HDC hdc
, /* [in] HDC to draw to */
877 INT xDst
, /* [in] destination rectangle */
879 INT dxDst
, /* [in] */
880 INT dyDst
, /* [in] */
881 LPBITMAPINFOHEADER lpbi
, /* [in] format of frame to draw */
882 INT xSrc
, /* [in] source rectangle */
884 INT dxSrc
, /* [in] */
885 INT dySrc
, /* [in] */
886 DWORD dwRate
, /* [in] frames/second = (dwRate/dwScale) */
887 DWORD dwScale
) /* [in] */
892 TRACE("(%p,%ld,%p,%p,%p,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
893 hic
, dwFlags
, hpal
, hwnd
, hdc
, xDst
, yDst
, dxDst
, dyDst
,
894 lpbi
, xSrc
, ySrc
, dxSrc
, dySrc
, dwRate
, dwScale
);
896 icdb
.dwFlags
= dwFlags
;
909 icdb
.dwRate
= dwRate
;
910 icdb
.dwScale
= dwScale
;
911 return ICSendMessage(hic
,ICM_DRAW_BEGIN
,(DWORD
)&icdb
,sizeof(icdb
));
914 /***********************************************************************
917 DWORD VFWAPIV
ICDraw(HIC hic
, DWORD dwFlags
, LPVOID lpFormat
, LPVOID lpData
, DWORD cbData
, LONG lTime
) {
920 TRACE("(%p,%ld,%p,%p,%ld,%ld)\n",hic
,dwFlags
,lpFormat
,lpData
,cbData
,lTime
);
922 icd
.dwFlags
= dwFlags
;
923 icd
.lpFormat
= lpFormat
;
928 return ICSendMessage(hic
,ICM_DRAW
,(DWORD
)&icd
,sizeof(icd
));
931 /***********************************************************************
932 * ICClose [MSVFW32.@]
934 LRESULT WINAPI
ICClose(HIC hic
)
936 WINE_HIC
* whic
= MSVIDEO_GetHicPtr(hic
);
941 if (!whic
) return ICERR_BADHANDLE
;
943 if (whic
->driverproc
)
945 MSVIDEO_SendMessage(whic
, DRV_CLOSE
, 0, 0);
946 MSVIDEO_SendMessage(whic
, DRV_DISABLE
, 0, 0);
947 MSVIDEO_SendMessage(whic
, DRV_FREE
, 0, 0);
951 CloseDriver(whic
->hdrv
, 0, 0);
954 /* remove whic from list */
955 for (p
= &MSVIDEO_FirstHic
; *p
!= NULL
; p
= &((*p
)->next
))
964 HeapFree(GetProcessHeap(), 0, whic
);
970 /***********************************************************************
971 * ICImageCompress [MSVFW32.@]
973 HANDLE VFWAPI
ICImageCompress(
974 HIC hic
, UINT uiFlags
,
975 LPBITMAPINFO lpbiIn
, LPVOID lpBits
,
976 LPBITMAPINFO lpbiOut
, LONG lQuality
,
979 FIXME("(%p,%08x,%p,%p,%p,%ld,%p)\n",
980 hic
, uiFlags
, lpbiIn
, lpBits
, lpbiOut
, lQuality
, plSize
);
985 /***********************************************************************
986 * ICImageDecompress [MSVFW32.@]
989 HANDLE VFWAPI
ICImageDecompress(
990 HIC hic
, UINT uiFlags
, LPBITMAPINFO lpbiIn
,
991 LPVOID lpBits
, LPBITMAPINFO lpbiOut
)
995 BOOL bReleaseIC
= FALSE
;
998 BOOL bSucceeded
= FALSE
;
999 BOOL bInDecompress
= FALSE
;
1002 TRACE("(%p,%08x,%p,%p,%p)\n",
1003 hic
, uiFlags
, lpbiIn
, lpBits
, lpbiOut
);
1007 hic
= ICDecompressOpen( ICTYPE_VIDEO
, 0, &lpbiIn
->bmiHeader
, (lpbiOut
!= NULL
) ? &lpbiOut
->bmiHeader
: NULL
);
1010 WARN("no handler\n" );
1017 FIXME( "unknown flag %08x\n", uiFlags
);
1020 if ( lpbiIn
== NULL
|| lpBits
== NULL
)
1022 WARN("invalid argument\n");
1026 if ( lpbiOut
!= NULL
)
1028 if ( lpbiOut
->bmiHeader
.biSize
!= sizeof(BITMAPINFOHEADER
) )
1030 cbHdr
= sizeof(BITMAPINFOHEADER
);
1031 if ( lpbiOut
->bmiHeader
.biCompression
== 3 )
1032 cbHdr
+= sizeof(DWORD
)*3;
1034 if ( lpbiOut
->bmiHeader
.biBitCount
<= 8 )
1036 if ( lpbiOut
->bmiHeader
.biClrUsed
== 0 )
1037 cbHdr
+= sizeof(RGBQUAD
) * (1<<lpbiOut
->bmiHeader
.biBitCount
);
1039 cbHdr
+= sizeof(RGBQUAD
) * lpbiOut
->bmiHeader
.biClrUsed
;
1044 TRACE( "get format\n" );
1046 cbHdr
= ICDecompressGetFormatSize(hic
,lpbiIn
);
1047 if ( cbHdr
< sizeof(BITMAPINFOHEADER
) )
1049 pHdr
= (BYTE
*)HeapAlloc(GetProcessHeap(),0,cbHdr
+sizeof(RGBQUAD
)*256);
1052 ZeroMemory( pHdr
, cbHdr
+sizeof(RGBQUAD
)*256 );
1053 if ( ICDecompressGetFormat( hic
, lpbiIn
, (BITMAPINFO
*)pHdr
) != ICERR_OK
)
1055 lpbiOut
= (BITMAPINFO
*)pHdr
;
1056 if ( lpbiOut
->bmiHeader
.biBitCount
<= 8 &&
1057 ICDecompressGetPalette( hic
, lpbiIn
, lpbiOut
) != ICERR_OK
&&
1058 lpbiIn
->bmiHeader
.biBitCount
== lpbiOut
->bmiHeader
.biBitCount
)
1060 if ( lpbiIn
->bmiHeader
.biClrUsed
== 0 )
1061 memcpy( lpbiOut
->bmiColors
, lpbiIn
->bmiColors
, sizeof(RGBQUAD
)*(1<<lpbiOut
->bmiHeader
.biBitCount
) );
1063 memcpy( lpbiOut
->bmiColors
, lpbiIn
->bmiColors
, sizeof(RGBQUAD
)*lpbiIn
->bmiHeader
.biClrUsed
);
1065 if ( lpbiOut
->bmiHeader
.biBitCount
<= 8 &&
1066 lpbiOut
->bmiHeader
.biClrUsed
== 0 )
1067 lpbiOut
->bmiHeader
.biClrUsed
= 1<<lpbiOut
->bmiHeader
.biBitCount
;
1069 lpbiOut
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1070 cbHdr
= sizeof(BITMAPINFOHEADER
) + sizeof(RGBQUAD
)*lpbiOut
->bmiHeader
.biClrUsed
;
1073 biSizeImage
= lpbiOut
->bmiHeader
.biSizeImage
;
1074 if ( biSizeImage
== 0 )
1075 biSizeImage
= ((((lpbiOut
->bmiHeader
.biWidth
* lpbiOut
->bmiHeader
.biBitCount
+ 7) >> 3) + 3) & (~3)) * abs(lpbiOut
->bmiHeader
.biHeight
);
1077 TRACE( "call ICDecompressBegin\n" );
1079 if ( ICDecompressBegin( hic
, lpbiIn
, lpbiOut
) != ICERR_OK
)
1081 bInDecompress
= TRUE
;
1083 TRACE( "cbHdr %ld, biSizeImage %ld\n", cbHdr
, biSizeImage
);
1085 hMem
= GlobalAlloc( GMEM_MOVEABLE
|GMEM_ZEROINIT
, cbHdr
+ biSizeImage
);
1088 WARN( "out of memory\n" );
1091 pMem
= (BYTE
*)GlobalLock( hMem
);
1094 memcpy( pMem
, lpbiOut
, cbHdr
);
1096 TRACE( "call ICDecompress\n" );
1097 if ( ICDecompress( hic
, 0, &lpbiIn
->bmiHeader
, lpBits
, &lpbiOut
->bmiHeader
, pMem
+cbHdr
) != ICERR_OK
)
1102 if ( bInDecompress
)
1103 ICDecompressEnd( hic
);
1106 HeapFree(GetProcessHeap(),0,pHdr
);
1108 GlobalUnlock( hMem
);
1109 if ( !bSucceeded
&& hMem
!= NULL
)
1111 GlobalFree(hMem
); hMem
= NULL
;
1114 return (HANDLE
)hMem
;
1117 static BOOL
GetFileNamePreview(LPVOID lpofn
,BOOL bSave
,BOOL bUnicode
)
1119 CHAR szFunctionName
[20];
1120 BOOL (*fnGetFileName
)(LPVOID
);
1124 FIXME("(%p,%d,%d), semi-stub!\n",lpofn
,bSave
,bUnicode
);
1126 lstrcpyA(szFunctionName
, (bSave
? "GetSaveFileName" : "GetOpenFileName"));
1127 lstrcatA(szFunctionName
, (bUnicode
? "W" : "A"));
1129 hComdlg32
= LoadLibraryA("COMDLG32.DLL");
1130 if (hComdlg32
== NULL
)
1133 fnGetFileName
= (LPVOID
)GetProcAddress(hComdlg32
, szFunctionName
);
1134 if (fnGetFileName
== NULL
)
1137 /* FIXME: need to add OFN_ENABLEHOOK and our own handler */
1138 ret
= fnGetFileName(lpofn
);
1140 FreeLibrary(hComdlg32
);
1144 /***********************************************************************
1145 * GetOpenFileNamePreviewA [MSVFW32.@]
1147 BOOL WINAPI
GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn
)
1149 FIXME("(%p), semi-stub!\n", lpofn
);
1151 return GetFileNamePreview(lpofn
, FALSE
, FALSE
);
1154 /***********************************************************************
1155 * GetOpenFileNamePreviewW [MSVFW32.@]
1157 BOOL WINAPI
GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn
)
1159 FIXME("(%p), semi-stub!\n", lpofn
);
1161 return GetFileNamePreview(lpofn
, FALSE
, TRUE
);
1164 /***********************************************************************
1165 * GetSaveFileNamePreviewA [MSVFW32.@]
1167 BOOL WINAPI
GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn
)
1169 FIXME("(%p), semi-stub!\n", lpofn
);
1171 return GetFileNamePreview(lpofn
, TRUE
, FALSE
);
1174 /***********************************************************************
1175 * GetSaveFileNamePreviewW [MSVFW32.@]
1177 BOOL WINAPI
GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn
)
1179 FIXME("(%p), semi-stub!\n", lpofn
);
1181 return GetFileNamePreview(lpofn
, TRUE
, TRUE
);