ntoskrnl.exe: Add a stub implementation of KeInitializeTimer.
[wine] / dlls / msvfw32 / msvideo16.c
CommitLineData
a1412f68
MS
1/*
2 * msvideo 16-bit functions
3 *
4 * Copyright 1998 Marcus Meissner
5 * Copyright 2000 Bradley Baetz
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
360a3f91 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
a1412f68
MS
20 */
21
fd2004e5 22#include <stdarg.h>
7656b145
EP
23#include <stdio.h>
24#include <string.h>
25
fd2004e5
DT
26#include "windef.h"
27#include "winbase.h"
7656b145 28#include "winver.h"
617839d5 29#include "winnls.h"
ed78e4f3 30#include "winreg.h"
fd2004e5 31#include "winuser.h"
a1412f68 32#include "vfw16.h"
fd2004e5 33#include "msvideo_private.h"
a1412f68
MS
34#include "wine/debug.h"
35
36WINE_DEFAULT_DEBUG_CHANNEL(msvideo);
37
ed78e4f3
DP
38/* Drivers32 settings */
39#define HKLM_DRIVERS32 "Software\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32"
7656b145 40
a1412f68
MS
41/***********************************************************************
42 * DrawDibOpen [MSVIDEO.102]
43 */
44HDRAWDIB16 VFWAPI DrawDibOpen16(void)
45{
46 return HDRAWDIB_16(DrawDibOpen());
47}
48
49/***********************************************************************
50 * DrawDibClose [MSVIDEO.103]
51 */
52BOOL16 VFWAPI DrawDibClose16(HDRAWDIB16 hdd)
53{
54 return DrawDibClose(HDRAWDIB_32(hdd));
55}
56
57/************************************************************************
58 * DrawDibBegin [MSVIDEO.104]
59 */
60BOOL16 VFWAPI DrawDibBegin16(HDRAWDIB16 hdd, HDC16 hdc, INT16 dxDst,
61 INT16 dyDst, LPBITMAPINFOHEADER lpbi, INT16 dxSrc,
62 INT16 dySrc, UINT16 wFlags)
63{
64 return DrawDibBegin(HDRAWDIB_32(hdd), HDC_32(hdc), dxDst, dyDst, lpbi,
65 dxSrc, dySrc, wFlags);
66}
67
68/***********************************************************************
69 * DrawDibEnd [MSVIDEO.105]
70 */
71BOOL16 VFWAPI DrawDibEnd16(HDRAWDIB16 hdd)
72{
73 return DrawDibEnd(HDRAWDIB_32(hdd));
74}
75
76/**********************************************************************
77 * DrawDibDraw [MSVIDEO.106]
78 */
79BOOL16 VFWAPI DrawDibDraw16(HDRAWDIB16 hdd, HDC16 hdc, INT16 xDst, INT16 yDst,
80 INT16 dxDst, INT16 dyDst, LPBITMAPINFOHEADER lpbi,
81 LPVOID lpBits, INT16 xSrc, INT16 ySrc, INT16 dxSrc,
82 INT16 dySrc, UINT16 wFlags)
83{
84 return DrawDibDraw(HDRAWDIB_32(hdd), HDC_32(hdc), xDst, yDst, dxDst,
85 dyDst, lpbi, lpBits, xSrc, ySrc, dxSrc, dySrc, wFlags);
86}
87
88/***********************************************************************
89 * DrawDibGetPalette [MSVIDEO.108]
90 */
91HPALETTE16 VFWAPI DrawDibGetPalette16(HDRAWDIB16 hdd)
92{
93 return HPALETTE_16(DrawDibGetPalette(HDRAWDIB_32(hdd)));
94}
95
96/***********************************************************************
97 * DrawDibSetPalette [MSVIDEO.110]
98 */
99BOOL16 VFWAPI DrawDibSetPalette16(HDRAWDIB16 hdd, HPALETTE16 hpal)
100{
101 return DrawDibSetPalette(HDRAWDIB_32(hdd), HPALETTE_32(hpal));
102}
103
104/***********************************************************************
105 * DrawDibRealize [MSVIDEO.112]
106 */
107UINT16 VFWAPI DrawDibRealize16(HDRAWDIB16 hdd, HDC16 hdc,
108 BOOL16 fBackground)
109{
7c598742 110 return (UINT16)DrawDibRealize(HDRAWDIB_32(hdd), HDC_32(hdc), fBackground);
a1412f68
MS
111}
112
113/*************************************************************************
114 * DrawDibStart [MSVIDEO.118]
115 */
116BOOL16 VFWAPI DrawDibStart16(HDRAWDIB16 hdd, DWORD rate)
117{
118 return DrawDibStart(HDRAWDIB_32(hdd), rate);
119}
120
121/*************************************************************************
122 * DrawDibStop [MSVIDEO.119]
123 */
80e023bd 124BOOL16 VFWAPI DrawDibStop16(HDRAWDIB16 hdd)
a1412f68
MS
125{
126 return DrawDibStop(HDRAWDIB_32(hdd));
127}
128
129/***********************************************************************
130 * ICOpen [MSVIDEO.203]
131 */
132HIC16 VFWAPI ICOpen16(DWORD fccType, DWORD fccHandler, UINT16 wMode)
133{
134 return HIC_16(ICOpen(fccType, fccHandler, wMode));
135}
136
137/***********************************************************************
138 * ICClose [MSVIDEO.204]
139 */
140LRESULT WINAPI ICClose16(HIC16 hic)
141{
142 return ICClose(HIC_32(hic));
143}
144
145/***********************************************************************
146 * _ICMessage [MSVIDEO.207]
147 */
617839d5 148LRESULT VFWAPIV ICMessage16( HIC16 hic, UINT16 msg, UINT16 cb, VA_LIST16 valist )
a1412f68 149{
a1412f68
MS
150 LPWORD lpData;
151 SEGPTR segData;
152 LRESULT ret;
153 UINT16 i;
154
a1412f68
MS
155 lpData = HeapAlloc(GetProcessHeap(), 0, cb);
156
c840d396 157 TRACE("0x%08x, %u, %u, ...)\n", (DWORD) hic, msg, cb);
a1412f68 158
7656b145
EP
159 for (i = 0; i < cb / sizeof(WORD); i++)
160 {
a1412f68
MS
161 lpData[i] = VA_ARG16(valist, WORD);
162 }
163
a1412f68
MS
164 segData = MapLS(lpData);
165 ret = ICSendMessage16(hic, msg, segData, (DWORD) cb);
166 UnMapLS(segData);
167 HeapFree(GetProcessHeap(), 0, lpData);
168 return ret;
169}
170
171/***********************************************************************
172 * ICGetInfo [MSVIDEO.212]
173 */
174LRESULT VFWAPI ICGetInfo16(HIC16 hic, ICINFO16 * picinfo, DWORD cb)
175{
176 LRESULT ret;
177
c840d396 178 TRACE("(0x%08x,%p,%d)\n", (DWORD) hic, picinfo, cb);
a1412f68
MS
179 ret = ICSendMessage16(hic, ICM_GETINFO, (DWORD) picinfo, cb);
180 TRACE(" -> 0x%08lx\n", ret);
181 return ret;
182}
183
184/***********************************************************************
185 * ICLocate [MSVIDEO.213]
186 */
187HIC16 VFWAPI ICLocate16(DWORD fccType, DWORD fccHandler,
188 LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut,
189 WORD wFlags)
190{
191 return HIC_16(ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags));
192}
193
194/***********************************************************************
195 * _ICCompress [MSVIDEO.224]
196 */
197DWORD VFWAPIV ICCompress16(HIC16 hic, DWORD dwFlags,
198 LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData,
199 LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits,
200 LPDWORD lpckid, LPDWORD lpdwFlags,
201 LONG lFrameNum, DWORD dwFrameSize,
202 DWORD dwQuality, LPBITMAPINFOHEADER lpbiPrev,
203 LPVOID lpPrev)
204{
a1412f68
MS
205 DWORD ret;
206 ICCOMPRESS iccmp;
207 SEGPTR seg_iccmp;
7656b145 208
c840d396 209 TRACE("(0x%08x,%d,%p,%p,%p,%p,...)\n", (DWORD) hic, dwFlags,
a1412f68
MS
210 lpbiOutput, lpData, lpbiInput, lpBits);
211
212 iccmp.dwFlags = dwFlags;
213
214 iccmp.lpbiOutput = lpbiOutput;
215 iccmp.lpOutput = lpData;
216 iccmp.lpbiInput = lpbiInput;
217 iccmp.lpInput = lpBits;
218
219 iccmp.lpckid = lpckid;
220 iccmp.lpdwFlags = lpdwFlags;
221 iccmp.lFrameNum = lFrameNum;
222 iccmp.dwFrameSize = dwFrameSize;
223 iccmp.dwQuality = dwQuality;
224 iccmp.lpbiPrev = lpbiPrev;
225 iccmp.lpPrev = lpPrev;
226 seg_iccmp = MapLS(&iccmp);
227 ret = ICSendMessage16(hic, ICM_COMPRESS, seg_iccmp, sizeof(ICCOMPRESS));
228 UnMapLS(seg_iccmp);
229 return ret;
230}
231
232/***********************************************************************
233 * _ICDecompress [MSVIDEO.230]
234 */
235DWORD VFWAPIV ICDecompress16(HIC16 hic, DWORD dwFlags,
236 LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData,
237 LPBITMAPINFOHEADER lpbi, LPVOID lpBits)
238{
239 ICDECOMPRESS icd;
240 SEGPTR segptr;
241 DWORD ret;
242
c840d396 243 TRACE("(0x%08x,%d,%p,%p,%p,%p)\n", (DWORD) hic, dwFlags, lpbiFormat,
a1412f68
MS
244 lpData, lpbi, lpBits);
245
246 icd.dwFlags = dwFlags;
247 icd.lpbiInput = lpbiFormat;
248 icd.lpInput = lpData;
249 icd.lpbiOutput = lpbi;
250 icd.lpOutput = lpBits;
251 icd.ckid = 0;
252 segptr = MapLS(&icd);
253 ret = ICSendMessage16(hic, ICM_DECOMPRESS, segptr, sizeof(ICDECOMPRESS));
254 UnMapLS(segptr);
255 return ret;
256}
257
258/***********************************************************************
259 * _ICDrawBegin [MSVIDEO.232]
260 */
261DWORD VFWAPIV ICDrawBegin16(HIC16 hic, /* [in] */
262 DWORD dwFlags, /* [in] flags */
263 HPALETTE16 hpal, /* [in] palette to draw with */
264 HWND16 hwnd, /* [in] window to draw to */
265 HDC16 hdc, /* [in] HDC to draw to */
266 INT16 xDst, /* [in] destination rectangle */
267 INT16 yDst, /* [in] */
268 INT16 dxDst, /* [in] */
269 INT16 dyDst, /* [in] */
270 LPBITMAPINFOHEADER lpbi, /* [in] format of frame to draw NOTE: SEGPTR */
271 INT16 xSrc, /* [in] source rectangle */
272 INT16 ySrc, /* [in] */
273 INT16 dxSrc, /* [in] */
274 INT16 dySrc, /* [in] */
275 DWORD dwRate, /* [in] frames/second = (dwRate/dwScale) */
276 DWORD dwScale) /* [in] */
277{
278 DWORD ret;
279 ICDRAWBEGIN16 icdb;
280 SEGPTR seg_icdb;
281
c840d396 282 TRACE ("(0x%08x,%d,0x%08x,0x%08x,0x%08x,%u,%u,%u,%u,%p,%u,%u,%u,%u,%d,%d)\n",
a1412f68
MS
283 (DWORD) hic, dwFlags, (DWORD) hpal, (DWORD) hwnd, (DWORD) hdc,
284 xDst, yDst, dxDst, dyDst, lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate,
285 dwScale);
286
287 icdb.dwFlags = dwFlags;
288 icdb.hpal = hpal;
289 icdb.hwnd = hwnd;
290 icdb.hdc = hdc;
291 icdb.xDst = xDst;
292 icdb.yDst = yDst;
293 icdb.dxDst = dxDst;
294 icdb.dyDst = dyDst;
295 icdb.lpbi = lpbi; /* Keep this as SEGPTR for the mapping code to deal with */
296 icdb.xSrc = xSrc;
297 icdb.ySrc = ySrc;
298 icdb.dxSrc = dxSrc;
299 icdb.dySrc = dySrc;
300 icdb.dwRate = dwRate;
301 icdb.dwScale = dwScale;
302 seg_icdb = MapLS(&icdb);
303 ret = (DWORD) ICSendMessage16(hic, ICM_DRAW_BEGIN, seg_icdb,
304 sizeof(ICDRAWBEGIN16));
305 UnMapLS(seg_icdb);
306 return ret;
307}
308
309/***********************************************************************
310 * _ICDraw [MSVIDEO.234]
311 */
312DWORD VFWAPIV ICDraw16(HIC16 hic, DWORD dwFlags,
313 LPVOID lpFormat, /* [???] NOTE: SEGPTR */
314 LPVOID lpData, /* [???] NOTE: SEGPTR */
315 DWORD cbData, LONG lTime)
316{
317 DWORD ret;
318 ICDRAW icd;
319 SEGPTR seg_icd;
320
c840d396 321 TRACE("(0x%08x,0x%08x,%p,%p,%d,%d)\n", (DWORD) hic, dwFlags,
a1412f68
MS
322 lpFormat, lpData, cbData, lTime);
323 icd.dwFlags = dwFlags;
324 icd.lpFormat = lpFormat;
325 icd.lpData = lpData;
326 icd.cbData = cbData;
327 icd.lTime = lTime;
328 seg_icd = MapLS(&icd);
329 ret = ICSendMessage16(hic, ICM_DRAW, seg_icd, sizeof(ICDRAW));
330 UnMapLS(seg_icd);
331 return ret;
332}
333
334/***********************************************************************
335 * ICGetDisplayFormat [MSVIDEO.239]
336 */
337HIC16 VFWAPI ICGetDisplayFormat16(HIC16 hic, LPBITMAPINFOHEADER lpbiIn,
338 LPBITMAPINFOHEADER lpbiOut, INT16 depth,
339 INT16 dx, INT16 dy)
340{
341 return HIC_16(ICGetDisplayFormat(HIC_32(hic), lpbiIn, lpbiOut, depth,
342 dx, dy));
343}
7656b145
EP
344
345#define COPY(x,y) (x->y = x##16->y);
346#define COPYPTR(x,y) (x->y = MapSL((SEGPTR)x##16->y));
347
348/******************************************************************
349 * MSVIDEO_MapICDEX16To32
350 *
351 *
352 */
353static LPVOID MSVIDEO_MapICDEX16To32(LPDWORD lParam)
354{
355 LPVOID ret;
356
357 ICDECOMPRESSEX *icdx = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDECOMPRESSEX));
358 ICDECOMPRESSEX16 *icdx16 = MapSL(*lParam);
359 ret = icdx16;
360
361 COPY(icdx, dwFlags);
362 COPYPTR(icdx, lpbiSrc);
363 COPYPTR(icdx, lpSrc);
364 COPYPTR(icdx, lpbiDst);
365 COPYPTR(icdx, lpDst);
366 COPY(icdx, xDst);
367 COPY(icdx, yDst);
368 COPY(icdx, dxDst);
369 COPY(icdx, dyDst);
370 COPY(icdx, xSrc);
371 COPY(icdx, ySrc);
372 COPY(icdx, dxSrc);
373 COPY(icdx, dySrc);
374
375 *lParam = (DWORD)(icdx);
376 return ret;
377}
378
379/******************************************************************
380 * MSVIDEO_MapMsg16To32
381 *
382 *
383 */
384static LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2)
385{
386 LPVOID ret = 0;
387
388 TRACE("Mapping %d\n", msg);
389
390 switch (msg)
391 {
392 case DRV_LOAD:
393 case DRV_ENABLE:
394 case DRV_CLOSE:
395 case DRV_DISABLE:
396 case DRV_FREE:
397 case ICM_ABOUT:
398 case ICM_CONFIGURE:
399 case ICM_COMPRESS_END:
400 case ICM_DECOMPRESS_END:
401 case ICM_DECOMPRESSEX_END:
402 case ICM_SETQUALITY:
403 case ICM_DRAW_START_PLAY:
404 case ICM_DRAW_STOP_PLAY:
405 case ICM_DRAW_REALIZE:
406 case ICM_DRAW_RENDERBUFFER:
407 case ICM_DRAW_END:
408 break;
409 case DRV_OPEN:
410 case ICM_GETDEFAULTQUALITY:
411 case ICM_GETQUALITY:
412 case ICM_SETSTATE:
413 case ICM_DRAW_WINDOW:
414 case ICM_GETBUFFERSWANTED:
415 *lParam1 = (DWORD)MapSL(*lParam1);
416 break;
417 case ICM_GETINFO:
418 {
419 ICINFO *ici = HeapAlloc(GetProcessHeap(), 0, sizeof(ICINFO));
420 ICINFO16 *ici16;
421
422 ici16 = MapSL(*lParam1);
423 ret = ici16;
424
425 ici->dwSize = sizeof(ICINFO);
426 COPY(ici, fccType);
427 COPY(ici, fccHandler);
428 COPY(ici, dwFlags);
429 COPY(ici, dwVersion);
430 COPY(ici, dwVersionICM);
431 MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 );
432 MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 );
433 MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 );
434 *lParam1 = (DWORD)(ici);
435 *lParam2 = sizeof(ICINFO);
436 }
437 break;
438 case ICM_COMPRESS:
439 {
440 ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(), 0, sizeof(ICCOMPRESS));
441 ICCOMPRESS *icc16;
442
443 icc16 = MapSL(*lParam1);
444 ret = icc16;
445
446 COPY(icc, dwFlags);
447 COPYPTR(icc, lpbiOutput);
448 COPYPTR(icc, lpOutput);
449 COPYPTR(icc, lpbiInput);
450 COPYPTR(icc, lpInput);
451 COPYPTR(icc, lpckid);
452 COPYPTR(icc, lpdwFlags);
453 COPY(icc, lFrameNum);
454 COPY(icc, dwFrameSize);
455 COPY(icc, dwQuality);
456 COPYPTR(icc, lpbiPrev);
457 COPYPTR(icc, lpPrev);
458
459 *lParam1 = (DWORD)(icc);
460 *lParam2 = sizeof(ICCOMPRESS);
461 }
462 break;
463 case ICM_DECOMPRESS:
464 {
465 ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDECOMPRESS));
466 ICDECOMPRESS *icd16; /* Same structure except for the pointers */
467
468 icd16 = MapSL(*lParam1);
469 ret = icd16;
470
471 COPY(icd, dwFlags);
472 COPYPTR(icd, lpbiInput);
473 COPYPTR(icd, lpInput);
474 COPYPTR(icd, lpbiOutput);
475 COPYPTR(icd, lpOutput);
476 COPY(icd, ckid);
477
478 *lParam1 = (DWORD)(icd);
479 *lParam2 = sizeof(ICDECOMPRESS);
480 }
481 break;
482 case ICM_COMPRESS_BEGIN:
483 case ICM_COMPRESS_GET_FORMAT:
484 case ICM_COMPRESS_GET_SIZE:
485 case ICM_COMPRESS_QUERY:
486 case ICM_DECOMPRESS_GET_FORMAT:
487 case ICM_DECOMPRESS_QUERY:
488 case ICM_DECOMPRESS_BEGIN:
489 case ICM_DECOMPRESS_SET_PALETTE:
490 case ICM_DECOMPRESS_GET_PALETTE:
491 *lParam1 = (DWORD)MapSL(*lParam1);
492 *lParam2 = (DWORD)MapSL(*lParam2);
493 break;
494 case ICM_DECOMPRESSEX_QUERY:
495 if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
496 WARN("*lParam2 has unknown value %p\n", (ICDECOMPRESSEX16*)*lParam2);
497 /* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
498 * This is because of ICMessage(). Special case it?
499 {
500 LPVOID* addr = HeapAlloc(GetProcessHeap(), 0, 2*sizeof(LPVOID));
501 addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
502 if (*lParam2)
503 addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
504 else
505 addr[1] = 0;
506
507 ret = addr;
508 }
509 break;*/
510 case ICM_DECOMPRESSEX_BEGIN:
511 case ICM_DECOMPRESSEX:
512 ret = MSVIDEO_MapICDEX16To32(lParam1);
513 *lParam2 = sizeof(ICDECOMPRESSEX);
514 break;
515 case ICM_DRAW_BEGIN:
516 {
517 ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWBEGIN));
518 ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
519 ret = icdb16;
520
521 COPY(icdb, dwFlags);
522 icdb->hpal = HPALETTE_32(icdb16->hpal);
523 icdb->hwnd = HWND_32(icdb16->hwnd);
524 icdb->hdc = HDC_32(icdb16->hdc);
525 COPY(icdb, xDst);
526 COPY(icdb, yDst);
527 COPY(icdb, dxDst);
528 COPY(icdb, dyDst);
529 COPYPTR(icdb, lpbi);
530 COPY(icdb, xSrc);
531 COPY(icdb, ySrc);
532 COPY(icdb, dxSrc);
533 COPY(icdb, dySrc);
534 COPY(icdb, dwRate);
535 COPY(icdb, dwScale);
536
537 *lParam1 = (DWORD)(icdb);
538 *lParam2 = sizeof(ICDRAWBEGIN);
539 }
540 break;
541 case ICM_DRAW_SUGGESTFORMAT:
542 {
543 ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWSUGGEST));
544 ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
545
546 ret = icds16;
547
548 COPY(icds, dwFlags);
549 COPYPTR(icds, lpbiIn);
550 COPYPTR(icds, lpbiSuggest);
551 COPY(icds, dxSrc);
552 COPY(icds, dySrc);
553 COPY(icds, dxDst);
554 COPY(icds, dyDst);
555 icds->hicDecompressor = HIC_32(icds16->hicDecompressor);
556
557 *lParam1 = (DWORD)(icds);
558 *lParam2 = sizeof(ICDRAWSUGGEST);
559 }
560 break;
561 case ICM_DRAW:
562 {
563 ICDRAW *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAW));
564 ICDRAW *icd16 = MapSL(*lParam1);
565 ret = icd16;
566
567 COPY(icd, dwFlags);
568 COPYPTR(icd, lpFormat);
569 COPYPTR(icd, lpData);
570 COPY(icd, cbData);
571 COPY(icd, lTime);
572
573 *lParam1 = (DWORD)(icd);
574 *lParam2 = sizeof(ICDRAW);
575 }
576 break;
577 case ICM_DRAW_START:
578 case ICM_DRAW_STOP:
579 break;
580 default:
581 FIXME("%d is not yet handled. Expect a crash.\n", msg);
582 }
583 return ret;
584}
585
586#undef COPY
587#undef COPYPTR
588
589/******************************************************************
590 * MSVIDEO_UnmapMsg16To32
591 *
592 *
593 */
594static void MSVIDEO_UnmapMsg16To32(UINT msg, LPVOID data16, LPDWORD lParam1, LPDWORD lParam2)
595{
596 TRACE("Unmapping %d\n", msg);
597
598#define UNCOPY(x, y) (x##16->y = x->y);
599
600 switch (msg)
601 {
602 case ICM_GETINFO:
603 {
604 ICINFO *ici = (ICINFO*)(*lParam1);
605 ICINFO16 *ici16 = (ICINFO16*)data16;
606
607 UNCOPY(ici, fccType);
608 UNCOPY(ici, fccHandler);
609 UNCOPY(ici, dwFlags);
610 UNCOPY(ici, dwVersion);
611 UNCOPY(ici, dwVersionICM);
612 WideCharToMultiByte( CP_ACP, 0, ici->szName, -1, ici16->szName,
613 sizeof(ici16->szName), NULL, NULL );
614 ici16->szName[sizeof(ici16->szName)-1] = 0;
615 WideCharToMultiByte( CP_ACP, 0, ici->szDescription, -1, ici16->szDescription,
616 sizeof(ici16->szDescription), NULL, NULL );
617 ici16->szDescription[sizeof(ici16->szDescription)-1] = 0;
618 /* This just gives garbage for some reason - BB
619 lstrcpynWtoA(ici16->szDriver, ici->szDriver, 128);*/
620
621 HeapFree(GetProcessHeap(), 0, ici);
622 }
623 break;
624 case ICM_DECOMPRESS_QUERY:
625 /*{
626 LPVOID* x = data16;
627 HeapFree(GetProcessHeap(), 0, x[0]);
628 if (x[1])
629 HeapFree(GetProcessHeap(), 0, x[1]);
630 }
631 break;*/
632 case ICM_COMPRESS:
633 case ICM_DECOMPRESS:
634 case ICM_DECOMPRESSEX_QUERY:
635 case ICM_DECOMPRESSEX_BEGIN:
636 case ICM_DECOMPRESSEX:
637 case ICM_DRAW_BEGIN:
638 case ICM_DRAW_SUGGESTFORMAT:
639 case ICM_DRAW:
640 HeapFree(GetProcessHeap(), 0, data16);
641 break;
642 default:
643 ERR("Unmapping unmapped msg %d\n", msg);
644 }
645#undef UNCOPY
646}
647
648/***********************************************************************
649 * ICInfo [MSVIDEO.200]
650 */
651BOOL16 VFWAPI ICInfo16(DWORD fccType, DWORD fccHandler, ICINFO16 *lpicinfo)
652{
653 BOOL16 ret;
654 LPVOID lpv;
655 DWORD lParam = (DWORD)lpicinfo;
656 DWORD size = ((ICINFO*)(MapSL((SEGPTR)lpicinfo)))->dwSize;
657
658 /* Use the mapping functions to map the ICINFO structure */
659 lpv = MSVIDEO_MapMsg16To32(ICM_GETINFO, &lParam, &size);
660
661 ret = ICInfo(fccType, fccHandler, (ICINFO*)lParam);
662
663 MSVIDEO_UnmapMsg16To32(ICM_GETINFO, lpv, &lParam, &size);
664
665 return ret;
666}
667
668/******************************************************************
669 * IC_Callback3216
670 *
671 *
672 */
673static LRESULT CALLBACK IC_Callback3216(HIC hic, HDRVR hdrv, UINT msg, DWORD lp1, DWORD lp2)
674{
675 WINE_HIC* whic;
7e92c9af 676 WORD args[8];
7656b145 677
7c598742 678 whic = MSVIDEO_GetHicPtr(hic);
7656b145
EP
679 if (whic)
680 {
792d7eb2 681 DWORD ret = 0;
7656b145
EP
682 switch (msg)
683 {
684 case DRV_OPEN:
685 lp2 = (DWORD)MapLS((void*)lp2);
686 break;
687 }
7e92c9af
AJ
688 args[7] = HIWORD(hic);
689 args[6] = LOWORD(hic);
690 args[5] = HDRVR_16(whic->hdrv);
691 args[4] = msg;
692 args[3] = HIWORD(lp1);
693 args[2] = LOWORD(lp1);
694 args[1] = HIWORD(lp2);
695 args[0] = LOWORD(lp2);
696 WOWCallback16Ex( (DWORD)whic->driverproc16, WCB16_PASCAL, sizeof(args), args, &ret );
7656b145 697
7656b145
EP
698 switch (msg)
699 {
700 case DRV_OPEN:
701 UnMapLS(lp2);
702 break;
703 }
792d7eb2 704 return ret;
7656b145 705 }
792d7eb2 706 else return ICERR_BADHANDLE;
7656b145
EP
707}
708
709/***********************************************************************
710 * ICOpenFunction [MSVIDEO.206]
711 */
712HIC16 VFWAPI ICOpenFunction16(DWORD fccType, DWORD fccHandler, UINT16 wMode, FARPROC16 lpfnHandler)
713{
714 HIC hic32;
715
716 hic32 = MSVIDEO_OpenFunction(fccType, fccHandler, wMode,
7c598742 717 (DRIVERPROC)IC_Callback3216, (DWORD)lpfnHandler);
7656b145
EP
718 return HIC_16(hic32);
719}
720
721/***********************************************************************
722 * ICSendMessage [MSVIDEO.205]
723 */
724LRESULT VFWAPI ICSendMessage16(HIC16 hic, UINT16 msg, DWORD lParam1, DWORD lParam2)
725{
7c598742 726 LRESULT ret = ICERR_BADHANDLE;
7656b145
EP
727 WINE_HIC* whic;
728
7c598742 729 whic = MSVIDEO_GetHicPtr(HIC_32(hic));
7656b145
EP
730 if (whic)
731 {
732 /* we've got a 16 bit driver proc... call it directly */
733 if (whic->driverproc16)
734 {
7e92c9af 735 WORD args[8];
792d7eb2 736 DWORD result;
7e92c9af
AJ
737
738 /* FIXME: original code was passing hdrv first and hic second */
739 /* but this doesn't match what IC_Callback3216 does */
740 args[7] = HIWORD(hic);
741 args[6] = LOWORD(hic);
742 args[5] = HDRVR_16(whic->hdrv);
743 args[4] = msg;
744 args[3] = HIWORD(lParam1);
745 args[2] = LOWORD(lParam1);
746 args[1] = HIWORD(lParam2);
747 args[0] = LOWORD(lParam2);
792d7eb2
MM
748 WOWCallback16Ex( (DWORD)whic->driverproc16, WCB16_PASCAL, sizeof(args), args, &result );
749 ret = result;
7656b145
EP
750 }
751 else
752 {
753 /* map the message for a 32 bit infrastructure, and pass it along */
754 void* data16 = MSVIDEO_MapMsg16To32(msg, &lParam1, &lParam2);
755
766ea910 756 ret = MSVIDEO_SendMessage(whic, msg, lParam1, lParam2);
7656b145
EP
757 if (data16)
758 MSVIDEO_UnmapMsg16To32(msg, data16, &lParam1, &lParam2);
759 }
7656b145
EP
760 }
761 return ret;
762}
763
764/***********************************************************************
765 * VideoCapDriverDescAndVer [MSVIDEO.22]
766 */
767DWORD WINAPI VideoCapDriverDescAndVer16(WORD nr, LPSTR buf1, WORD buf1len,
768 LPSTR buf2, WORD buf2len)
769{
b8e73ace 770 static const char version_info_spec[] = "\\StringFileInfo\\040904E4\\FileDescription";
7656b145 771 DWORD verhandle;
7656b145
EP
772 DWORD infosize;
773 UINT subblocklen;
ed78e4f3 774 char *s, buf[2048], fn[260];
7656b145
EP
775 LPBYTE infobuf;
776 LPVOID subblock;
ed78e4f3
DP
777 DWORD i, cnt = 0, lRet;
778 DWORD bufLen, fnLen;
779 FILETIME lastWrite;
780 HKEY hKey;
781 BOOL found = FALSE;
7656b145
EP
782
783 TRACE("(%d,%p,%d,%p,%d)\n", nr, buf1, buf1len, buf2, buf2len);
ed78e4f3
DP
784 lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_DRIVERS32, 0, KEY_QUERY_VALUE, &hKey);
785 if (lRet == ERROR_SUCCESS)
7656b145 786 {
ed78e4f3
DP
787 RegQueryInfoKeyA( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
788 for (i = 0; i < cnt; i++)
789 {
790 bufLen = sizeof(buf) / sizeof(buf[0]);
791 lRet = RegEnumKeyExA(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite);
792 if (lRet != ERROR_SUCCESS) continue;
793 if (strncasecmp(buf, "vid", 3)) continue;
794 if (nr--) continue;
795 fnLen = sizeof(fn);
d7b9a23a 796 lRet = RegQueryValueExA(hKey, buf, 0, 0, (LPBYTE)fn, &fnLen);
ed78e4f3
DP
797 if (lRet == ERROR_SUCCESS) found = TRUE;
798 break;
799 }
800 RegCloseKey( hKey );
801 }
802
803 /* search system.ini if not found in the registry */
804 if (!found && GetPrivateProfileStringA("drivers32", NULL, NULL, buf, sizeof(buf), "system.ini"))
805 {
806 for (s = buf; *s; s += strlen(s) + 1)
807 {
808 if (strncasecmp(s, "vid", 3)) continue;
809 if (nr--) continue;
810 if (GetPrivateProfileStringA("drivers32", s, NULL, fn, sizeof(fn), "system.ini"))
811 found = TRUE;
812 break;
813 }
7656b145 814 }
ed78e4f3
DP
815
816 if (nr || !found)
7656b145 817 {
ed78e4f3 818 TRACE("No more VID* entries found nr=%d\n", nr);
7656b145
EP
819 return 20;
820 }
7656b145
EP
821 infosize = GetFileVersionInfoSizeA(fn, &verhandle);
822 if (!infosize)
823 {
824 TRACE("%s has no fileversioninfo.\n", fn);
825 return 18;
826 }
827 infobuf = HeapAlloc(GetProcessHeap(), 0, infosize);
828 if (GetFileVersionInfoA(fn, verhandle, infosize, infobuf))
829 {
7656b145
EP
830 /* Yes, two space behind : */
831 /* FIXME: test for buflen */
e732fc02 832 snprintf(buf2, buf2len, "Version: %d.%d.%d.%d\n",
7656b145
EP
833 ((WORD*)infobuf)[0x0f],
834 ((WORD*)infobuf)[0x0e],
835 ((WORD*)infobuf)[0x11],
836 ((WORD*)infobuf)[0x10]
837 );
e732fc02 838 TRACE("version of %s is %s\n", fn, buf2);
7656b145
EP
839 }
840 else
841 {
842 TRACE("GetFileVersionInfoA failed for %s.\n", fn);
6e3bcb5a 843 lstrcpynA(buf2, fn, buf2len); /* msvideo.dll appears to copy fn*/
7656b145
EP
844 }
845 /* FIXME: language problem? */
846 if (VerQueryValueA( infobuf,
a92e7b1a 847 version_info_spec,
7656b145
EP
848 &subblock,
849 &subblocklen
850 ))
851 {
6e3bcb5a
PBL
852 UINT copylen = min(subblocklen,buf1len-1);
853 memcpy(buf1, subblock, copylen);
854 buf1[copylen] = '\0';
7656b145 855 TRACE("VQA returned %s\n", (LPCSTR)subblock);
7656b145
EP
856 }
857 else
858 {
859 TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n");
6e3bcb5a 860 lstrcpynA(buf1, fn, buf1len); /* msvideo.dll appears to copy fn*/
7656b145
EP
861 }
862 HeapFree(GetProcessHeap(), 0, infobuf);
863 return 0;
864}
865
866/******************************************************************
867 * IC_CallTo16
868 *
869 *
870 */
871static LRESULT CALLBACK IC_CallTo16(HDRVR hdrv, HIC hic, UINT msg, LPARAM lp1, LPARAM lp2)
872{
873#if 0
7c598742 874 WINE_HIC* whic = IC_GetPtr(hic);
7656b145
EP
875 LRESULT ret = 0;
876
877
878 if (whic->driverproc)
879 {
880 ret = whic->driverproc(hic, whic->hdrv, msg, lParam1, lParam2);
881 }
882 else
883 {
884 ret = SendDriverMessage(whic->hdrv, msg, lParam1, lParam2);
885 }
886#else
887 FIXME("No 32=>16 conversion yet\n");
888#endif
889 return 0;
890}
891
892/**************************************************************************
0ddd30b0 893 * DllEntryPoint (MSVIDEO.3)
7656b145
EP
894 *
895 * MSVIDEO DLL entry point
896 *
897 */
898BOOL WINAPI VIDEO_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
899 WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
900{
901 switch (fdwReason)
902 {
903 case DLL_PROCESS_ATTACH:
904 /* hook in our 16 bit management functions */
905 pFnCallTo16 = IC_CallTo16;
906 break;
907 case DLL_PROCESS_DETACH:
908 /* remove our 16 bit management functions */
909 pFnCallTo16 = NULL;
910 break;
911 case DLL_THREAD_ATTACH:
912 case DLL_THREAD_DETACH:
913 break;
914 }
915 return TRUE;
916}