?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20030408.
[wine/gsoc-2012-control.git] / dlls / winmm / message16.c
blob08282dee0c6e4754b754cf583bb7ee9e969e774c
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * MMSYTEM MCI and low level mapping functions
5 *
6 * Copyright 1999 Eric Pouech
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include <string.h>
24 #include <stdio.h>
25 #include <assert.h>
26 #include "wine/winbase16.h"
27 #include "winreg.h"
28 #include "winver.h"
29 #include "wownt32.h"
30 #include "winemm.h"
31 #include "digitalv.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
35
36 /**************************************************************************
37 * MMDRV_Callback [internal]
38 */
39 static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
40 {
41 TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n",
42 mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2);
43
44 if (!mld->bFrom32 && (mld->dwFlags & DCB_TYPEMASK) == DCB_FUNCTION)
45 {
46 WORD args[8];
47 /* 16 bit func, call it */
48 TRACE("Function (16 bit) !\n");
49
50 args[7] = HDRVR_16(hDev);
51 args[6] = uMsg;
52 args[5] = HIWORD(mld->dwClientInstance);
53 args[4] = LOWORD(mld->dwClientInstance);
54 args[3] = HIWORD(dwParam1);
55 args[2] = LOWORD(dwParam1);
56 args[1] = HIWORD(dwParam2);
57 args[0] = LOWORD(dwParam2);
58 WOWCallback16Ex( mld->dwCallback, WCB16_PASCAL, sizeof(args), args, NULL );
59 } else {
60 DriverCallback(mld->dwCallback, mld->dwFlags, hDev, uMsg,
61 mld->dwClientInstance, dwParam1, dwParam2);
62 }
63 }
64
65 /* =================================
66 * A U X M A P P E R S
67 * ================================= */
68
69 /**************************************************************************
70 * MMDRV_Aux_Map16To32A [internal]
71 */
72 static WINMM_MapType MMDRV_Aux_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
73 {
74 return WINMM_MAP_MSGERROR;
75 }
76
77 /**************************************************************************
78 * MMDRV_Aux_UnMap16To32A [internal]
79 */
80 static WINMM_MapType MMDRV_Aux_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
81 {
82 return WINMM_MAP_MSGERROR;
83 }
84
85 /**************************************************************************
86 * MMDRV_Aux_Map32ATo16 [internal]
87 */
88 static WINMM_MapType MMDRV_Aux_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
89 {
90 return WINMM_MAP_MSGERROR;
91 }
92
93 /**************************************************************************
94 * MMDRV_Aux_UnMap32ATo16 [internal]
95 */
96 static WINMM_MapType MMDRV_Aux_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
97 {
98 #if 0
99 case AUXDM_GETDEVCAPS:
100 lpCaps->wMid = ac16.wMid;
101 lpCaps->wPid = ac16.wPid;
102 lpCaps->vDriverVersion = ac16.vDriverVersion;
103 strcpy(lpCaps->szPname, ac16.szPname);
104 lpCaps->wTechnology = ac16.wTechnology;
105 lpCaps->dwSupport = ac16.dwSupport;
106 #endif
107 return WINMM_MAP_MSGERROR;
108 }
109
110 /**************************************************************************
111 * MMDRV_Aux_Callback [internal]
112 */
113 static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
114 {
115 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
116
117 FIXME("NIY\n");
118 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
119 }
120
121 /* =================================
122 * M I X E R M A P P E R S
123 * ================================= */
124
125 /**************************************************************************
126 * xMMDRV_Mixer_Map16To32A [internal]
127 */
128 static WINMM_MapType MMDRV_Mixer_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
129 {
130 return WINMM_MAP_MSGERROR;
131 }
132
133 /**************************************************************************
134 * MMDRV_Mixer_UnMap16To32A [internal]
135 */
136 static WINMM_MapType MMDRV_Mixer_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
137 {
138 #if 0
139 MIXERCAPSA micA;
140 UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
141
142 if (ret == MMSYSERR_NOERROR) {
143 mixcaps->wMid = micA.wMid;
144 mixcaps->wPid = micA.wPid;
145 mixcaps->vDriverVersion = micA.vDriverVersion;
146 strcpy(mixcaps->szPname, micA.szPname);
147 mixcaps->fdwSupport = micA.fdwSupport;
148 mixcaps->cDestinations = micA.cDestinations;
149 }
150 return ret;
151 #endif
152 return WINMM_MAP_MSGERROR;
153 }
154
155 /**************************************************************************
156 * MMDRV_Mixer_Map32ATo16 [internal]
157 */
158 static WINMM_MapType MMDRV_Mixer_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
159 {
160 return WINMM_MAP_MSGERROR;
161 }
162
163 /**************************************************************************
164 * MMDRV_Mixer_UnMap32ATo16 [internal]
165 */
166 static WINMM_MapType MMDRV_Mixer_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
167 {
168 return WINMM_MAP_MSGERROR;
169 }
170
171 /**************************************************************************
172 * MMDRV_Mixer_Callback [internal]
173 */
174 static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
175 {
176 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
177
178 FIXME("NIY\n");
179 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
180 }
181
182 /* =================================
183 * M I D I I N M A P P E R S
184 * ================================= */
185
186 /**************************************************************************
187 * MMDRV_MidiIn_Map16To32A [internal]
188 */
189 static WINMM_MapType MMDRV_MidiIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
190 {
191 return WINMM_MAP_MSGERROR;
192 }
193
194 /**************************************************************************
195 * MMDRV_MidiIn_UnMap16To32A [internal]
196 */
197 static WINMM_MapType MMDRV_MidiIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
198 {
199 return WINMM_MAP_MSGERROR;
200 }
201
202 /**************************************************************************
203 * MMDRV_MidiIn_Map32ATo16 [internal]
204 */
205 static WINMM_MapType MMDRV_MidiIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
206 {
207 return WINMM_MAP_MSGERROR;
208 }
209
210 /**************************************************************************
211 * MMDRV_MidiIn_UnMap32ATo16 [internal]
212 */
213 static WINMM_MapType MMDRV_MidiIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
214 {
215 return WINMM_MAP_MSGERROR;
216 }
217
218 /**************************************************************************
219 * MMDRV_MidiIn_Callback [internal]
220 */
221 static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
222 {
223 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
224
225 switch (uMsg) {
226 case MIM_OPEN:
227 case MIM_CLOSE:
228 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
229
230 case MIM_DATA:
231 case MIM_MOREDATA:
232 case MIM_ERROR:
233 /* dwParam1 & dwParam2 are are data, nothing to do */
234 break;
235 case MIM_LONGDATA:
236 case MIM_LONGERROR:
237 /* dwParam1 points to a MidiHdr, work to be done !!! */
238 if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
239 /* initial map is: 32 => 16 */
240 LPMIDIHDR mh16 = MapSL(dwParam1);
241 LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
242
243 dwParam1 = (DWORD)mh32;
244 mh32->dwFlags = mh16->dwFlags;
245 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
246 if (mh32->reserved >= sizeof(MIDIHDR))
247 mh32->dwOffset = mh16->dwOffset;
248 } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
249 /* initial map is: 16 => 32 */
250 LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1);
251 SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
252 LPMIDIHDR mh16 = MapSL(segmh16);
253
254 dwParam1 = (DWORD)segmh16;
255 mh16->dwFlags = mh32->dwFlags;
256 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
257 if (mh16->reserved >= sizeof(MIDIHDR))
258 mh16->dwOffset = mh32->dwOffset;
259 }
260 /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
261 break;
262 /* case MOM_POSITIONCB: */
263 default:
264 ERR("Unknown msg %u\n", uMsg);
265 }
266
267 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
268 }
269
270 /* =================================
271 * M I D I O U T M A P P E R S
272 * ================================= */
273
274 /**************************************************************************
275 * MMDRV_MidiOut_Map16To32A [internal]
276 */
277 static WINMM_MapType MMDRV_MidiOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
278 {
279 WINMM_MapType ret = WINMM_MAP_MSGERROR;
280
281 switch (wMsg) {
282 case MODM_GETNUMDEVS:
283 case MODM_DATA:
284 case MODM_RESET:
285 case MODM_SETVOLUME:
286 ret = WINMM_MAP_OK;
287 break;
288
289 case MODM_OPEN:
290 case MODM_CLOSE:
291 case MODM_GETVOLUME:
292 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
293 break;
294
295 case MODM_GETDEVCAPS:
296 {
297 LPMIDIOUTCAPSA moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSA));
298 LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1);
299
300 if (moc32) {
301 *(LPMIDIOUTCAPS16*)moc32 = moc16;
302 moc32 = (LPMIDIOUTCAPSA)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16));
303 *lpParam1 = (DWORD)moc32;
304 *lpParam2 = sizeof(MIDIOUTCAPSA);
305
306 ret = WINMM_MAP_OKMEM;
307 } else {
308 ret = WINMM_MAP_NOMEM;
309 }
310 }
311 break;
312 case MODM_PREPARE:
313 {
314 LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
315 LPMIDIHDR mh16 = MapSL(*lpParam1);
316
317 if (mh32) {
318 *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1;
319 mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR));
320 mh32->lpData = MapSL((SEGPTR)mh16->lpData);
321 mh32->dwBufferLength = mh16->dwBufferLength;
322 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
323 mh32->dwUser = mh16->dwUser;
324 mh32->dwFlags = mh16->dwFlags;
325 /* FIXME: nothing on mh32->lpNext */
326 /* could link the mh32->lpNext at this level for memory house keeping */
327 mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? ((LPMIDIHDR)mh16)->dwOffset : 0;
328 mh16->lpNext = mh32; /* for reuse in unprepare and write */
329 /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
330 mh16->reserved = *lpParam2;
331 *lpParam1 = (DWORD)mh32;
332 *lpParam2 = sizeof(MIDIHDR);
333
334 ret = WINMM_MAP_OKMEM;
335 } else {
336 ret = WINMM_MAP_NOMEM;
337 }
338 }
339 break;
340 case MODM_UNPREPARE:
341 case MODM_LONGDATA:
342 {
343 LPMIDIHDR mh16 = MapSL(*lpParam1);
344 LPMIDIHDR mh32 = (LPMIDIHDR)mh16->lpNext;
345
346 *lpParam1 = (DWORD)mh32;
347 *lpParam2 = sizeof(MIDIHDR);
348 /* dwBufferLength can be reduced between prepare & write */
349 if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
350 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
351 mh32->dwBufferLength, mh16->dwBufferLength);
352 } else
353 mh32->dwBufferLength = mh16->dwBufferLength;
354 ret = WINMM_MAP_OKMEM;
355 }
356 break;
357
358 case MODM_CACHEPATCHES:
359 case MODM_CACHEDRUMPATCHES:
360 default:
361 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
362 break;
363 }
364 return ret;
365 }
366
367 /**************************************************************************
368 * MMDRV_MidiOut_UnMap16To32A [internal]
369 */
370 static WINMM_MapType MMDRV_MidiOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
371 {
372 WINMM_MapType ret = WINMM_MAP_MSGERROR;
373
374 switch (wMsg) {
375 case MODM_GETNUMDEVS:
376 case MODM_DATA:
377 case MODM_RESET:
378 case MODM_SETVOLUME:
379 ret = WINMM_MAP_OK;
380 break;
381
382 case MODM_OPEN:
383 case MODM_CLOSE:
384 case MODM_GETVOLUME:
385 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
386 break;
387
388 case MODM_GETDEVCAPS:
389 {
390 LPMIDIOUTCAPSA moc32 = (LPMIDIOUTCAPSA)(*lpParam1);
391 LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
392
393 moc16->wMid = moc32->wMid;
394 moc16->wPid = moc32->wPid;
395 moc16->vDriverVersion = moc32->vDriverVersion;
396 strcpy(moc16->szPname, moc32->szPname);
397 moc16->wTechnology = moc32->wTechnology;
398 moc16->wVoices = moc32->wVoices;
399 moc16->wNotes = moc32->wNotes;
400 moc16->wChannelMask = moc32->wChannelMask;
401 moc16->dwSupport = moc32->dwSupport;
402 HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
403 ret = WINMM_MAP_OK;
404 }
405 break;
406 case MODM_PREPARE:
407 case MODM_UNPREPARE:
408 case MODM_LONGDATA:
409 {
410 LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
411 LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
412
413 assert(mh16->lpNext == mh32);
414 mh16->dwBufferLength = mh32->dwBufferLength;
415 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
416 mh16->dwUser = mh32->dwUser;
417 mh16->dwFlags = mh32->dwFlags;
418 if (mh16->reserved >= sizeof(MIDIHDR))
419 mh16->dwOffset = mh32->dwOffset;
420
421 if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
422 HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
423 mh16->lpNext = 0;
424 }
425 ret = WINMM_MAP_OK;
426 }
427 break;
428
429 case MODM_CACHEPATCHES:
430 case MODM_CACHEDRUMPATCHES:
431 default:
432 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
433 break;
434 }
435 return ret;
436 }
437
438 /**************************************************************************
439 * MMDRV_MidiOut_Map32ATo16 [internal]
440 */
441 static WINMM_MapType MMDRV_MidiOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
442 {
443 WINMM_MapType ret = WINMM_MAP_MSGERROR;
444
445 switch (wMsg) {
446 case MODM_CLOSE:
447 case MODM_GETNUMDEVS:
448 case MODM_DATA:
449 case MODM_RESET:
450 case MODM_SETVOLUME:
451 ret = WINMM_MAP_OK;
452 break;
453 case MODM_GETDEVCAPS:
454 {
455 LPMIDIOUTCAPSA moc32 = (LPMIDIOUTCAPSA)*lpParam1;
456 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPSA)+sizeof(MIDIOUTCAPS16));
457
458 if (ptr) {
459 *(LPMIDIOUTCAPSA*)ptr = moc32;
460 ret = WINMM_MAP_OKMEM;
461 } else {
462 ret = WINMM_MAP_NOMEM;
463 }
464 *lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSA);
465 *lpParam2 = sizeof(MIDIOUTCAPS16);
466 }
467 break;
468 case MODM_PREPARE:
469 {
470 LPMIDIHDR mh32 = (LPMIDIHDR)*lpParam1;
471 LPMIDIHDR mh16;
472 LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
473 sizeof(LPMIDIHDR) + sizeof(MIDIHDR) + mh32->dwBufferLength);
474
475 if (ptr) {
476 *(LPMIDIHDR*)ptr = mh32;
477 mh16 = (LPMIDIHDR)((LPSTR)ptr + sizeof(LPMIDIHDR));
478 *lpParam1 = MapLS(mh16);
479 mh16->lpData = (LPSTR)*lpParam1 + sizeof(MIDIHDR);
480 /* data will be copied on WODM_WRITE */
481 mh16->dwBufferLength = mh32->dwBufferLength;
482 mh16->dwBytesRecorded = mh32->dwBytesRecorded;
483 mh16->dwUser = mh32->dwUser;
484 mh16->dwFlags = mh32->dwFlags;
485 /* FIXME: nothing on mh32->lpNext */
486 /* could link the mh32->lpNext at this level for memory house keeping */
487 mh16->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh32->dwOffset : 0;
488
489 mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */
490 mh32->reserved = *lpParam2;
491
492 TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n",
493 *lpParam1, (DWORD)mh16->lpData,
494 mh32->dwBufferLength, (DWORD)mh32->lpData);
495 *lpParam2 = sizeof(MIDIHDR);
496
497 ret = WINMM_MAP_OKMEM;
498 } else {
499 ret = WINMM_MAP_NOMEM;
500 }
501 }
502 break;
503 case MODM_UNPREPARE:
504 case MODM_LONGDATA:
505 {
506 LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
507 LPMIDIHDR mh16 = (LPMIDIHDR)mh32->lpNext;
508 LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
509
510 assert(*(LPMIDIHDR*)ptr == mh32);
511
512 if (wMsg == MODM_LONGDATA)
513 memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength);
514
515 *lpParam1 = MapLS(mh16);
516 *lpParam2 = sizeof(MIDIHDR);
517 TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n",
518 *lpParam1, (DWORD)mh16->lpData, mh32->dwBufferLength, (DWORD)mh32->lpData);
519
520 /* dwBufferLength can be reduced between prepare & write */
521 if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) {
522 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
523 mh16->dwBufferLength, mh32->dwBufferLength);
524 } else
525 mh16->dwBufferLength = mh32->dwBufferLength;
526 ret = WINMM_MAP_OKMEM;
527 }
528 break;
529 case MODM_OPEN:
530 {
531 LPMIDIOPENDESC mod32 = (LPMIDIOPENDESC)*lpParam1;
532 LPVOID ptr;
533 LPMIDIOPENDESC16 mod16;
534
535 /* allocated data are mapped as follows:
536 LPMIDIOPENDESC ptr to orig lParam1
537 DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
538 DWORD dwUser passed to driver
539 MIDIOPENDESC16 mod16: openDesc passed to driver
540 MIDIOPENSTRMID cIds
541 */
542 ptr = HeapAlloc( GetProcessHeap(), 0,
543 sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) +
544 mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0);
545
546 if (ptr) {
547 SEGPTR segptr = MapLS(ptr);
548 *(LPMIDIOPENDESC*)ptr = mod32;
549 *(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser;
550 mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD));
551
552 mod16->hMidi = HMIDI_16(mod32->hMidi);
553 mod16->dwCallback = mod32->dwCallback;
554 mod16->dwInstance = mod32->dwInstance;
555 mod16->dnDevNode = mod32->dnDevNode;
556 mod16->cIds = mod32->cIds;
557 memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID));
558
559 *lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD);
560 *lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD);
561
562 ret = WINMM_MAP_OKMEM;
563 } else {
564 ret = WINMM_MAP_NOMEM;
565 }
566 }
567 break;
568 case MODM_GETVOLUME:
569 case MODM_CACHEPATCHES:
570 case MODM_CACHEDRUMPATCHES:
571 default:
572 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
573 break;
574 }
575 return ret;
576 }
577
578 /**************************************************************************
579 * MMDRV_MidiOut_UnMap32ATo16 [internal]
580 */
581 static WINMM_MapType MMDRV_MidiOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
582 {
583 WINMM_MapType ret = WINMM_MAP_MSGERROR;
584
585 switch (wMsg) {
586 case MODM_CLOSE:
587 case MODM_GETNUMDEVS:
588 case MODM_DATA:
589 case MODM_RESET:
590 case MODM_SETVOLUME:
591 ret = WINMM_MAP_OK;
592 break;
593 case MODM_GETDEVCAPS:
594 {
595 LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1);
596 LPSTR ptr = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSA);
597 LPMIDIOUTCAPSA moc32 = *(LPMIDIOUTCAPSA*)ptr;
598
599 moc32->wMid = moc16->wMid;
600 moc32->wPid = moc16->wPid;
601 moc32->vDriverVersion = moc16->vDriverVersion;
602 strcpy(moc32->szPname, moc16->szPname);
603 moc32->wTechnology = moc16->wTechnology;
604 moc32->wVoices = moc16->wVoices;
605 moc32->wNotes = moc16->wNotes;
606 moc32->wChannelMask = moc16->wChannelMask;
607 moc32->dwSupport = moc16->dwSupport;
608 UnMapLS( *lpParam1 );
609 HeapFree( GetProcessHeap(), 0, ptr );
610 ret = WINMM_MAP_OK;
611 }
612 break;
613 case MODM_PREPARE:
614 case MODM_UNPREPARE:
615 case MODM_LONGDATA:
616 {
617 LPMIDIHDR mh16 = MapSL(*lpParam1);
618 LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
619 LPMIDIHDR mh32 = *(LPMIDIHDR*)ptr;
620
621 assert(mh32->lpNext == (LPMIDIHDR)mh16);
622 UnMapLS( *lpParam1 );
623 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
624 mh32->dwUser = mh16->dwUser;
625 mh32->dwFlags = mh16->dwFlags;
626
627 if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
628 HeapFree( GetProcessHeap(), 0, ptr );
629 mh32->lpNext = 0;
630 }
631 ret = WINMM_MAP_OK;
632 }
633 break;
634 case MODM_OPEN:
635 {
636 LPMIDIOPENDESC16 mod16 = MapSL(*lpParam1);
637 LPSTR ptr = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD);
638 UnMapLS( *lpParam1 );
639 **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD));
640
641 HeapFree( GetProcessHeap(), 0, ptr );
642 ret = WINMM_MAP_OK;
643 }
644 break;
645 case MODM_GETVOLUME:
646 case MODM_CACHEPATCHES:
647 case MODM_CACHEDRUMPATCHES:
648 default:
649 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
650 break;
651 }
652 return ret;
653 }
654
655 /**************************************************************************
656 * MMDRV_MidiOut_Callback [internal]
657 */
658 static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
659 {
660 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
661
662 switch (uMsg) {
663 case MOM_OPEN:
664 case MOM_CLOSE:
665 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
666 break;
667 case MOM_DONE:
668 if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
669 /* initial map is: 32 => 16 */
670 LPMIDIHDR mh16 = MapSL(dwParam1);
671 LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
672
673 dwParam1 = (DWORD)mh32;
674 mh32->dwFlags = mh16->dwFlags;
675 mh32->dwOffset = mh16->dwOffset;
676 if (mh32->reserved >= sizeof(MIDIHDR))
677 mh32->dwOffset = mh16->dwOffset;
678 } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
679 /* initial map is: 16 => 32 */
680 LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1);
681 SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
682 LPMIDIHDR mh16 = MapSL(segmh16);
683
684 dwParam1 = (DWORD)segmh16;
685 mh16->dwFlags = mh32->dwFlags;
686 if (mh16->reserved >= sizeof(MIDIHDR))
687 mh16->dwOffset = mh32->dwOffset;
688 }
689 /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
690 break;
691 /* case MOM_POSITIONCB: */
692 default:
693 ERR("Unknown msg %u\n", uMsg);
694 }
695
696 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
697 }
698
699 /* =================================
700 * W A V E I N M A P P E R S
701 * ================================= */
702
703 /**************************************************************************
704 * MMDRV_WaveIn_Map16To32A [internal]
705 */
706 static WINMM_MapType MMDRV_WaveIn_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
707 {
708 WINMM_MapType ret = WINMM_MAP_MSGERROR;
709
710 switch (wMsg) {
711 case WIDM_GETNUMDEVS:
712 case WIDM_RESET:
713 case WIDM_START:
714 case WIDM_STOP:
715 ret = WINMM_MAP_OK;
716 break;
717 case WIDM_OPEN:
718 case WIDM_CLOSE:
719 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
720 break;
721 case WIDM_GETDEVCAPS:
722 {
723 LPWAVEINCAPSA wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSA));
724 LPWAVEINCAPS16 wic16 = MapSL(*lpParam1);
725
726 if (wic32) {
727 *(LPWAVEINCAPS16*)wic32 = wic16;
728 wic32 = (LPWAVEINCAPSA)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
729 *lpParam1 = (DWORD)wic32;
730 *lpParam2 = sizeof(WAVEINCAPSA);
731
732 ret = WINMM_MAP_OKMEM;
733 } else {
734 ret = WINMM_MAP_NOMEM;
735 }
736 }
737 break;
738 case WIDM_GETPOS:
739 {
740 LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
741 LPMMTIME16 mmt16 = MapSL(*lpParam1);
742
743 if (mmt32) {
744 *(LPMMTIME16*)mmt32 = mmt16;
745 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
746
747 mmt32->wType = mmt16->wType;
748 *lpParam1 = (DWORD)mmt32;
749 *lpParam2 = sizeof(MMTIME);
750
751 ret = WINMM_MAP_OKMEM;
752 } else {
753 ret = WINMM_MAP_NOMEM;
754 }
755 }
756 break;
757 case WIDM_PREPARE:
758 {
759 LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
760 LPWAVEHDR wh16 = MapSL(*lpParam1);
761
762 if (wh32) {
763 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
764 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
765 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
766 wh32->dwBufferLength = wh16->dwBufferLength;
767 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
768 wh32->dwUser = wh16->dwUser;
769 wh32->dwFlags = wh16->dwFlags;
770 wh32->dwLoops = wh16->dwLoops;
771 /* FIXME: nothing on wh32->lpNext */
772 /* could link the wh32->lpNext at this level for memory house keeping */
773 wh16->lpNext = wh32; /* for reuse in unprepare and write */
774 *lpParam1 = (DWORD)wh32;
775 *lpParam2 = sizeof(WAVEHDR);
776
777 ret = WINMM_MAP_OKMEM;
778 } else {
779 ret = WINMM_MAP_NOMEM;
780 }
781 }
782 break;
783 case WIDM_ADDBUFFER:
784 case WIDM_UNPREPARE:
785 {
786 LPWAVEHDR wh16 = MapSL(*lpParam1);
787 LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext;
788
789 *lpParam1 = (DWORD)wh32;
790 *lpParam2 = sizeof(WAVEHDR);
791 /* dwBufferLength can be reduced between prepare & write */
792 if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
793 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
794 wh32->dwBufferLength, wh16->dwBufferLength);
795 } else
796 wh32->dwBufferLength = wh16->dwBufferLength;
797 ret = WINMM_MAP_OKMEM;
798 }
799 break;
800 case WIDM_MAPPER_STATUS:
801 /* just a single DWORD */
802 *lpParam2 = (DWORD)MapSL(*lpParam2);
803 ret = WINMM_MAP_OK;
804 break;
805 default:
806 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
807 break;
808 }
809 return ret;
810 }
811
812 /**************************************************************************
813 * MMDRV_WaveIn_UnMap16To32A [internal]
814 */
815 static WINMM_MapType MMDRV_WaveIn_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
816 {
817 WINMM_MapType ret = WINMM_MAP_MSGERROR;
818
819 switch (wMsg) {
820 case WIDM_GETNUMDEVS:
821 case WIDM_RESET:
822 case WIDM_START:
823 case WIDM_STOP:
824 case WIDM_MAPPER_STATUS:
825 ret = WINMM_MAP_OK;
826 break;
827 case WIDM_OPEN:
828 case WIDM_CLOSE:
829 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
830 break;
831 case WIDM_GETDEVCAPS:
832 {
833 LPWAVEINCAPSA wic32 = (LPWAVEINCAPSA)(*lpParam1);
834 LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
835
836 wic16->wMid = wic32->wMid;
837 wic16->wPid = wic32->wPid;
838 wic16->vDriverVersion = wic32->vDriverVersion;
839 strcpy(wic16->szPname, wic32->szPname);
840 wic16->dwFormats = wic32->dwFormats;
841 wic16->wChannels = wic32->wChannels;
842 HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
843 ret = WINMM_MAP_OK;
844 }
845 break;
846 case WIDM_GETPOS:
847 {
848 LPMMTIME mmt32 = (LPMMTIME)(*lpParam1);
849 LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
850
851 MMSYSTEM_MMTIME32to16(mmt16, mmt32);
852 HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
853 ret = WINMM_MAP_OK;
854 }
855 break;
856 case WIDM_ADDBUFFER:
857 case WIDM_PREPARE:
858 case WIDM_UNPREPARE:
859 {
860 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
861 LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
862
863 assert(wh16->lpNext == wh32);
864 wh16->dwBufferLength = wh32->dwBufferLength;
865 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
866 wh16->dwUser = wh32->dwUser;
867 wh16->dwFlags = wh32->dwFlags;
868 wh16->dwLoops = wh32->dwLoops;
869
870 if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
871 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
872 wh16->lpNext = 0;
873 }
874 ret = WINMM_MAP_OK;
875 }
876 break;
877 default:
878 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
879 break;
880 }
881 return ret;
882 }
883
884 /**************************************************************************
885 * MMDRV_WaveIn_Map32ATo16 [internal]
886 */
887 static WINMM_MapType MMDRV_WaveIn_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
888 {
889 WINMM_MapType ret = WINMM_MAP_MSGERROR;
890
891 switch (wMsg) {
892 case WIDM_CLOSE:
893 case WIDM_GETNUMDEVS:
894 case WIDM_RESET:
895 case WIDM_START:
896 case WIDM_STOP:
897 ret = WINMM_MAP_OK;
898 break;
899
900 case WIDM_OPEN:
901 {
902 LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1;
903 int sz = sizeof(WAVEFORMATEX);
904 LPVOID ptr;
905 LPWAVEOPENDESC16 wod16;
906
907 /* allocated data are mapped as follows:
908 LPWAVEOPENDESC ptr to orig lParam1
909 DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
910 DWORD dwUser passed to driver
911 WAVEOPENDESC16 wod16: openDesc passed to driver
912 WAVEFORMATEX openDesc->lpFormat passed to driver
913 xxx extra bytes to WAVEFORMATEX
914 */
915 if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
916 TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
917 sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
918 }
919
920 ptr = HeapAlloc( GetProcessHeap(), 0,
921 sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
922
923 if (ptr) {
924 SEGPTR seg_ptr = MapLS( ptr );
925 *(LPWAVEOPENDESC*)ptr = wod32;
926 *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
927 wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
928
929 wod16->hWave = HWAVE_16(wod32->hWave);
930 wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
931 memcpy(wod16 + 1, wod32->lpFormat, sz);
932
933 wod16->dwCallback = wod32->dwCallback;
934 wod16->dwInstance = wod32->dwInstance;
935 wod16->uMappedDeviceID = wod32->uMappedDeviceID;
936 wod16->dnDevNode = wod32->dnDevNode;
937
938 *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
939 *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
940
941 ret = WINMM_MAP_OKMEM;
942 } else {
943 ret = WINMM_MAP_NOMEM;
944 }
945 }
946 break;
947 case WIDM_PREPARE:
948 {
949 LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1;
950 LPWAVEHDR wh16;
951 LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
952 sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
953
954 if (ptr) {
955 SEGPTR seg_ptr = MapLS( ptr );
956 *(LPWAVEHDR*)ptr = wh32;
957 wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
958 wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
959 /* data will be copied on WODM_WRITE */
960 wh16->dwBufferLength = wh32->dwBufferLength;
961 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
962 wh16->dwUser = wh32->dwUser;
963 wh16->dwFlags = wh32->dwFlags;
964 wh16->dwLoops = wh32->dwLoops;
965 /* FIXME: nothing on wh32->lpNext */
966 /* could link the wh32->lpNext at this level for memory house keeping */
967 wh32->lpNext = wh16; /* for reuse in unprepare and write */
968 TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
969 seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
970 wh32->dwBufferLength, (DWORD)wh32->lpData);
971 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
972 *lpParam2 = sizeof(WAVEHDR);
973
974 ret = WINMM_MAP_OKMEM;
975 } else {
976 ret = WINMM_MAP_NOMEM;
977 }
978 }
979 break;
980 case WIDM_ADDBUFFER:
981 case WIDM_UNPREPARE:
982 {
983 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
984 LPWAVEHDR wh16 = wh32->lpNext;
985 LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
986 SEGPTR seg_ptr = MapLS( ptr );
987
988 assert(*(LPWAVEHDR*)ptr == wh32);
989
990 TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
991 seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
992 wh32->dwBufferLength, (DWORD)wh32->lpData);
993
994 if (wMsg == WIDM_ADDBUFFER)
995 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
996
997 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
998 *lpParam2 = sizeof(WAVEHDR);
999 /* dwBufferLength can be reduced between prepare & write */
1000 if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) {
1001 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1002 wh16->dwBufferLength, wh32->dwBufferLength);
1003 } else
1004 wh16->dwBufferLength = wh32->dwBufferLength;
1005 ret = WINMM_MAP_OKMEM;
1006 }
1007 break;
1008 case WIDM_GETDEVCAPS:
1009 {
1010 LPWAVEINCAPSA wic32 = (LPWAVEINCAPSA)*lpParam1;
1011 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSA) + sizeof(WAVEINCAPS16));
1012
1013 if (ptr) {
1014 *(LPWAVEINCAPSA*)ptr = wic32;
1015 ret = WINMM_MAP_OKMEM;
1016 } else {
1017 ret = WINMM_MAP_NOMEM;
1018 }
1019 *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSA);
1020 *lpParam2 = sizeof(WAVEINCAPS16);
1021 }
1022 break;
1023 case WIDM_GETPOS:
1024 {
1025 LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1026 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1027 LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1028
1029 if (ptr) {
1030 *(LPMMTIME*)ptr = mmt32;
1031 mmt16->wType = mmt32->wType;
1032 ret = WINMM_MAP_OKMEM;
1033 } else {
1034 ret = WINMM_MAP_NOMEM;
1035 }
1036 *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1037 *lpParam2 = sizeof(MMTIME16);
1038 }
1039 break;
1040 case DRVM_MAPPER_STATUS:
1041 {
1042 LPDWORD p32 = (LPDWORD)*lpParam2;
1043 *lpParam2 = MapLS(p32);
1044 ret = WINMM_MAP_OKMEM;
1045 }
1046 break;
1047 default:
1048 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1049 break;
1050 }
1051 return ret;
1052 }
1053
1054 /**************************************************************************
1055 * MMDRV_WaveIn_UnMap32ATo16 [internal]
1056 */
1057 static WINMM_MapType MMDRV_WaveIn_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1058 {
1059 WINMM_MapType ret = WINMM_MAP_MSGERROR;
1060
1061 switch (wMsg) {
1062 case WIDM_CLOSE:
1063 case WIDM_GETNUMDEVS:
1064 case WIDM_RESET:
1065 case WIDM_START:
1066 case WIDM_STOP:
1067 ret = WINMM_MAP_OK;
1068 break;
1069
1070 case WIDM_OPEN:
1071 {
1072 LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1);
1073 LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1074 LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr;
1075
1076 UnMapLS( *lpParam1 );
1077 wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1078 **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1079 HeapFree( GetProcessHeap(), 0, ptr );
1080 ret = WINMM_MAP_OK;
1081 }
1082 break;
1083
1084 case WIDM_ADDBUFFER:
1085 case WIDM_PREPARE:
1086 case WIDM_UNPREPARE:
1087 {
1088 LPWAVEHDR wh16 = MapSL(*lpParam1);
1089 LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1090 LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr;
1091
1092 assert(wh32->lpNext == wh16);
1093 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1094 wh32->dwUser = wh16->dwUser;
1095 wh32->dwFlags = wh16->dwFlags;
1096 wh32->dwLoops = wh16->dwLoops;
1097 UnMapLS( *lpParam1 );
1098
1099 if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1100 HeapFree( GetProcessHeap(), 0, ptr );
1101 wh32->lpNext = 0;
1102 }
1103 ret = WINMM_MAP_OK;
1104 }
1105 break;
1106 case WIDM_GETDEVCAPS:
1107 {
1108 LPWAVEINCAPS16 wic16 = MapSL(*lpParam1);
1109 LPSTR ptr = (LPSTR)wic16 - sizeof(LPWAVEINCAPSA);
1110 LPWAVEINCAPSA wic32 = *(LPWAVEINCAPSA*)ptr;
1111
1112 wic32->wMid = wic16->wMid;
1113 wic32->wPid = wic16->wPid;
1114 wic32->vDriverVersion = wic16->vDriverVersion;
1115 strcpy(wic32->szPname, wic16->szPname);
1116 wic32->dwFormats = wic16->dwFormats;
1117 wic32->wChannels = wic16->wChannels;
1118 UnMapLS( *lpParam1 );
1119 HeapFree( GetProcessHeap(), 0, ptr );
1120 ret = WINMM_MAP_OK;
1121 }
1122 break;
1123 case WIDM_GETPOS:
1124 {
1125 LPMMTIME16 mmt16 = MapSL(*lpParam1);
1126 LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME);
1127 LPMMTIME mmt32 = *(LPMMTIME*)ptr;
1128
1129 MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1130 UnMapLS( *lpParam1 );
1131 HeapFree( GetProcessHeap(), 0, ptr );
1132 ret = WINMM_MAP_OK;
1133 }
1134 break;
1135 case DRVM_MAPPER_STATUS:
1136 {
1137 UnMapLS( *lpParam2 );
1138 ret = WINMM_MAP_OK;
1139 }
1140 break;
1141 default:
1142 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1143 break;
1144 }
1145 return ret;
1146 }
1147
1148 /**************************************************************************
1149 * MMDRV_WaveIn_Callback [internal]
1150 */
1151 static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
1152 {
1153 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
1154
1155 switch (uMsg) {
1156 case WIM_OPEN:
1157 case WIM_CLOSE:
1158 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1159 break;
1160 case WIM_DATA:
1161 if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1162 /* initial map is: 32 => 16 */
1163 LPWAVEHDR wh16 = MapSL(dwParam1);
1164 LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1165
1166 dwParam1 = (DWORD)wh32;
1167 wh32->dwFlags = wh16->dwFlags;
1168 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1169 } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1170 /* initial map is: 16 => 32 */
1171 LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1);
1172 SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1173 LPWAVEHDR wh16 = MapSL(segwh16);
1174
1175 dwParam1 = (DWORD)segwh16;
1176 wh16->dwFlags = wh32->dwFlags;
1177 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1178 }
1179 /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1180 break;
1181 default:
1182 ERR("Unknown msg %u\n", uMsg);
1183 }
1184
1185 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1186 }
1187
1188 /* =================================
1189 * W A V E O U T M A P P E R S
1190 * ================================= */
1191
1192 /**************************************************************************
1193 * MMDRV_WaveOut_Map16To32A [internal]
1194 */
1195 static WINMM_MapType MMDRV_WaveOut_Map16To32A (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
1196 {
1197 WINMM_MapType ret = WINMM_MAP_MSGERROR;
1198
1199 switch (wMsg) {
1200 /* nothing to do */
1201 case WODM_BREAKLOOP:
1202 case WODM_CLOSE:
1203 case WODM_GETNUMDEVS:
1204 case WODM_PAUSE:
1205 case WODM_RESET:
1206 case WODM_RESTART:
1207 case WODM_SETPITCH:
1208 case WODM_SETPLAYBACKRATE:
1209 case WODM_SETVOLUME:
1210 ret = WINMM_MAP_OK;
1211 break;
1212
1213 case WODM_GETPITCH:
1214 case WODM_GETPLAYBACKRATE:
1215 case WODM_GETVOLUME:
1216 case WODM_OPEN:
1217 FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
1218 break;
1219
1220 case WODM_GETDEVCAPS:
1221 {
1222 LPWAVEOUTCAPSA woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSA));
1223 LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1);
1224
1225 if (woc32) {
1226 *(LPWAVEOUTCAPS16*)woc32 = woc16;
1227 woc32 = (LPWAVEOUTCAPSA)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
1228 *lpParam1 = (DWORD)woc32;
1229 *lpParam2 = sizeof(WAVEOUTCAPSA);
1230
1231 ret = WINMM_MAP_OKMEM;
1232 } else {
1233 ret = WINMM_MAP_NOMEM;
1234 }
1235 }
1236 break;
1237 case WODM_GETPOS:
1238 {
1239 LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
1240 LPMMTIME16 mmt16 = MapSL(*lpParam1);
1241
1242 if (mmt32) {
1243 *(LPMMTIME16*)mmt32 = mmt16;
1244 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
1245
1246 mmt32->wType = mmt16->wType;
1247 *lpParam1 = (DWORD)mmt32;
1248 *lpParam2 = sizeof(MMTIME);
1249
1250 ret = WINMM_MAP_OKMEM;
1251 } else {
1252 ret = WINMM_MAP_NOMEM;
1253 }
1254 }
1255 break;
1256 case WODM_PREPARE:
1257 {
1258 LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
1259 LPWAVEHDR wh16 = MapSL(*lpParam1);
1260
1261 if (wh32) {
1262 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
1263 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
1264 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
1265 wh32->dwBufferLength = wh16->dwBufferLength;
1266 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1267 wh32->dwUser = wh16->dwUser;
1268 wh32->dwFlags = wh16->dwFlags;
1269 wh32->dwLoops = wh16->dwLoops;
1270 /* FIXME: nothing on wh32->lpNext */
1271 /* could link the wh32->lpNext at this level for memory house keeping */
1272 wh16->lpNext = wh32; /* for reuse in unprepare and write */
1273 *lpParam1 = (DWORD)wh32;
1274 *lpParam2 = sizeof(WAVEHDR);
1275
1276 ret = WINMM_MAP_OKMEM;
1277 } else {
1278 ret = WINMM_MAP_NOMEM;
1279 }
1280 }
1281 break;
1282 case WODM_UNPREPARE:
1283 case WODM_WRITE:
1284 {
1285 LPWAVEHDR wh16 = MapSL(*lpParam1);
1286 LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext;
1287
1288 *lpParam1 = (DWORD)wh32;
1289 *lpParam2 = sizeof(WAVEHDR);
1290 /* dwBufferLength can be reduced between prepare & write */
1291 if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
1292 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1293 wh32->dwBufferLength, wh16->dwBufferLength);
1294 } else
1295 wh32->dwBufferLength = wh16->dwBufferLength;
1296 ret = WINMM_MAP_OKMEM;
1297 }
1298 break;
1299 case WODM_MAPPER_STATUS:
1300 *lpParam2 = (DWORD)MapSL(*lpParam2);
1301 ret = WINMM_MAP_OK;
1302 break;
1303 default:
1304 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1305 break;
1306 }
1307 return ret;
1308 }
1309
1310 /**************************************************************************
1311 * MMDRV_WaveOut_UnMap16To32A [internal]
1312 */
1313 static WINMM_MapType MMDRV_WaveOut_UnMap16To32A(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1314 {
1315 WINMM_MapType ret = WINMM_MAP_MSGERROR;
1316
1317 switch (wMsg) {
1318 /* nothing to do */
1319 case WODM_BREAKLOOP:
1320 case WODM_CLOSE:
1321 case WODM_GETNUMDEVS:
1322 case WODM_PAUSE:
1323 case WODM_RESET:
1324 case WODM_RESTART:
1325 case WODM_SETPITCH:
1326 case WODM_SETPLAYBACKRATE:
1327 case WODM_SETVOLUME:
1328 case WODM_MAPPER_STATUS:
1329 ret = WINMM_MAP_OK;
1330 break;
1331
1332 case WODM_GETPITCH:
1333 case WODM_GETPLAYBACKRATE:
1334 case WODM_GETVOLUME:
1335 case WODM_OPEN:
1336 FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
1337 break;
1338
1339 case WODM_GETDEVCAPS:
1340 {
1341 LPWAVEOUTCAPSA woc32 = (LPWAVEOUTCAPSA)(*lpParam1);
1342 LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1343
1344 woc16->wMid = woc32->wMid;
1345 woc16->wPid = woc32->wPid;
1346 woc16->vDriverVersion = woc32->vDriverVersion;
1347 strcpy(woc16->szPname, woc32->szPname);
1348 woc16->dwFormats = woc32->dwFormats;
1349 woc16->wChannels = woc32->wChannels;
1350 woc16->dwSupport = woc32->dwSupport;
1351 HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
1352 ret = WINMM_MAP_OK;
1353 }
1354 break;
1355 case WODM_GETPOS:
1356 {
1357 LPMMTIME mmt32 = (LPMMTIME)(*lpParam1);
1358 LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
1359
1360 MMSYSTEM_MMTIME32to16(mmt16, mmt32);
1361 HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
1362 ret = WINMM_MAP_OK;
1363 }
1364 break;
1365 case WODM_PREPARE:
1366 case WODM_UNPREPARE:
1367 case WODM_WRITE:
1368 {
1369 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
1370 LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
1371
1372 assert(wh16->lpNext == wh32);
1373 wh16->dwBufferLength = wh32->dwBufferLength;
1374 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1375 wh16->dwUser = wh32->dwUser;
1376 wh16->dwFlags = wh32->dwFlags;
1377 wh16->dwLoops = wh32->dwLoops;
1378
1379 if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1380 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
1381 wh16->lpNext = 0;
1382 }
1383 ret = WINMM_MAP_OK;
1384 }
1385 break;
1386 default:
1387 FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
1388 break;
1389 }
1390 return ret;
1391 }
1392
1393 /**************************************************************************
1394 * MMDRV_WaveOut_Map32ATo16 [internal]
1395 */
1396 static WINMM_MapType MMDRV_WaveOut_Map32ATo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2)
1397 {
1398 WINMM_MapType ret;
1399
1400 switch (wMsg) {
1401 /* nothing to do */
1402 case WODM_BREAKLOOP:
1403 case WODM_CLOSE:
1404 case WODM_GETNUMDEVS:
1405 case WODM_PAUSE:
1406 case WODM_RESET:
1407 case WODM_RESTART:
1408 case WODM_SETPITCH:
1409 case WODM_SETPLAYBACKRATE:
1410 case WODM_SETVOLUME:
1411 ret = WINMM_MAP_OK;
1412 break;
1413
1414 case WODM_GETDEVCAPS:
1415 {
1416 LPWAVEOUTCAPSA woc32 = (LPWAVEOUTCAPSA)*lpParam1;
1417 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0,
1418 sizeof(LPWAVEOUTCAPSA) + sizeof(WAVEOUTCAPS16));
1419
1420 if (ptr) {
1421 *(LPWAVEOUTCAPSA*)ptr = woc32;
1422 ret = WINMM_MAP_OKMEM;
1423 } else {
1424 ret = WINMM_MAP_NOMEM;
1425 }
1426 *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSA);
1427 *lpParam2 = sizeof(WAVEOUTCAPS16);
1428 }
1429 break;
1430 case WODM_GETPITCH:
1431 FIXME("NIY: no conversion yet\n");
1432 ret = WINMM_MAP_MSGERROR;
1433 break;
1434 case WODM_GETPLAYBACKRATE:
1435 FIXME("NIY: no conversion yet\n");
1436 ret = WINMM_MAP_MSGERROR;
1437 break;
1438 case WODM_GETPOS:
1439 {
1440 LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
1441 LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
1442 LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
1443
1444 if (ptr) {
1445 *(LPMMTIME*)ptr = mmt32;
1446 mmt16->wType = mmt32->wType;
1447 ret = WINMM_MAP_OKMEM;
1448 } else {
1449 ret = WINMM_MAP_NOMEM;
1450 }
1451 *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
1452 *lpParam2 = sizeof(MMTIME16);
1453 }
1454 break;
1455 case WODM_GETVOLUME:
1456 FIXME("NIY: no conversion yet\n");
1457 ret = WINMM_MAP_MSGERROR;
1458 break;
1459 case WODM_OPEN:
1460 {
1461 LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1;
1462 int sz = sizeof(WAVEFORMATEX);
1463 LPVOID ptr;
1464 LPWAVEOPENDESC16 wod16;
1465
1466 /* allocated data are mapped as follows:
1467 LPWAVEOPENDESC ptr to orig lParam1
1468 DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
1469 DWORD dwUser passed to driver
1470 WAVEOPENDESC16 wod16: openDesc passed to driver
1471 WAVEFORMATEX openDesc->lpFormat passed to driver
1472 xxx extra bytes to WAVEFORMATEX
1473 */
1474 if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
1475 TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
1476 sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
1477 }
1478
1479 ptr = HeapAlloc( GetProcessHeap(), 0,
1480 sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
1481
1482 if (ptr) {
1483 SEGPTR seg_ptr = MapLS( ptr );
1484 *(LPWAVEOPENDESC*)ptr = wod32;
1485 *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
1486 wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
1487
1488 wod16->hWave = HWAVE_16(wod32->hWave);
1489 wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
1490 memcpy(wod16 + 1, wod32->lpFormat, sz);
1491
1492 wod16->dwCallback = wod32->dwCallback;
1493 wod16->dwInstance = wod32->dwInstance;
1494 wod16->uMappedDeviceID = wod32->uMappedDeviceID;
1495 wod16->dnDevNode = wod32->dnDevNode;
1496
1497 *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
1498 *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
1499
1500 ret = WINMM_MAP_OKMEM;
1501 } else {
1502 ret = WINMM_MAP_NOMEM;
1503 }
1504 }
1505 break;
1506 case WODM_PREPARE:
1507 {
1508 LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1;
1509 LPWAVEHDR wh16;
1510 LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
1511 sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
1512
1513 if (ptr) {
1514 SEGPTR seg_ptr = MapLS( ptr );
1515 *(LPWAVEHDR*)ptr = wh32;
1516 wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
1517 wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
1518 /* data will be copied on WODM_WRITE */
1519 wh16->dwBufferLength = wh32->dwBufferLength;
1520 wh16->dwBytesRecorded = wh32->dwBytesRecorded;
1521 wh16->dwUser = wh32->dwUser;
1522 wh16->dwFlags = wh32->dwFlags;
1523 wh16->dwLoops = wh32->dwLoops;
1524 /* FIXME: nothing on wh32->lpNext */
1525 /* could link the wh32->lpNext at this level for memory house keeping */
1526 wh32->lpNext = wh16; /* for reuse in unprepare and write */
1527 TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
1528 seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
1529 wh32->dwBufferLength, (DWORD)wh32->lpData);
1530 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1531 *lpParam2 = sizeof(WAVEHDR);
1532
1533 ret = WINMM_MAP_OKMEM;
1534 } else {
1535 ret = WINMM_MAP_NOMEM;
1536 }
1537 }
1538 break;
1539 case WODM_UNPREPARE:
1540 case WODM_WRITE:
1541 {
1542 LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
1543 LPWAVEHDR wh16 = wh32->lpNext;
1544 LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1545 SEGPTR seg_ptr = MapLS( ptr );
1546
1547 assert(*(LPWAVEHDR*)ptr == wh32);
1548
1549 TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n",
1550 seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData,
1551 wh32->dwBufferLength, (DWORD)wh32->lpData);
1552
1553 if (wMsg == WODM_WRITE)
1554 memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
1555
1556 *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
1557 *lpParam2 = sizeof(WAVEHDR);
1558 /* dwBufferLength can be reduced between prepare & write */
1559 if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) {
1560 ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n",
1561 wh16->dwBufferLength, wh32->dwBufferLength);
1562 } else
1563 wh16->dwBufferLength = wh32->dwBufferLength;
1564 ret = WINMM_MAP_OKMEM;
1565 }
1566 break;
1567 case DRVM_MAPPER_STATUS:
1568 {
1569 LPDWORD p32 = (LPDWORD)*lpParam2;
1570 *lpParam2 = MapLS(p32);
1571 ret = WINMM_MAP_OKMEM;
1572 }
1573 break;
1574 default:
1575 FIXME("NIY: no conversion yet\n");
1576 ret = WINMM_MAP_MSGERROR;
1577 break;
1578 }
1579 return ret;
1580 }
1581
1582 /**************************************************************************
1583 * MMDRV_WaveOut_UnMap32ATo16 [internal]
1584 */
1585 static WINMM_MapType MMDRV_WaveOut_UnMap32ATo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret)
1586 {
1587 WINMM_MapType ret;
1588
1589 switch (wMsg) {
1590 /* nothing to do */
1591 case WODM_BREAKLOOP:
1592 case WODM_CLOSE:
1593 case WODM_GETNUMDEVS:
1594 case WODM_PAUSE:
1595 case WODM_RESET:
1596 case WODM_RESTART:
1597 case WODM_SETPITCH:
1598 case WODM_SETPLAYBACKRATE:
1599 case WODM_SETVOLUME:
1600 ret = WINMM_MAP_OK;
1601 break;
1602
1603 case WODM_GETDEVCAPS:
1604 {
1605 LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1);
1606 LPSTR ptr = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSA);
1607 LPWAVEOUTCAPSA woc32 = *(LPWAVEOUTCAPSA*)ptr;
1608
1609 woc32->wMid = woc16->wMid;
1610 woc32->wPid = woc16->wPid;
1611 woc32->vDriverVersion = woc16->vDriverVersion;
1612 strcpy(woc32->szPname, woc16->szPname);
1613 woc32->dwFormats = woc16->dwFormats;
1614 woc32->wChannels = woc16->wChannels;
1615 woc32->dwSupport = woc16->dwSupport;
1616 UnMapLS( *lpParam1 );
1617 HeapFree( GetProcessHeap(), 0, ptr );
1618 ret = WINMM_MAP_OK;
1619 }
1620 break;
1621 case WODM_GETPITCH:
1622 FIXME("NIY: no conversion yet\n");
1623 ret = WINMM_MAP_MSGERROR;
1624 break;
1625 case WODM_GETPLAYBACKRATE:
1626 FIXME("NIY: no conversion yet\n");
1627 ret = WINMM_MAP_MSGERROR;
1628 break;
1629 case WODM_GETPOS:
1630 {
1631 LPMMTIME16 mmt16 = MapSL(*lpParam1);
1632 LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME);
1633 LPMMTIME mmt32 = *(LPMMTIME*)ptr;
1634
1635 MMSYSTEM_MMTIME16to32(mmt32, mmt16);
1636 UnMapLS( *lpParam1 );
1637 HeapFree( GetProcessHeap(), 0, ptr );
1638 ret = WINMM_MAP_OK;
1639 }
1640 break;
1641 case WODM_OPEN:
1642 {
1643 LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1);
1644 LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
1645 LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr;
1646
1647 wod32->uMappedDeviceID = wod16->uMappedDeviceID;
1648 **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
1649 UnMapLS( *lpParam1 );
1650 HeapFree( GetProcessHeap(), 0, ptr );
1651 ret = WINMM_MAP_OK;
1652 }
1653 break;
1654 case WODM_PREPARE:
1655 case WODM_UNPREPARE:
1656 case WODM_WRITE:
1657 {
1658 LPWAVEHDR wh16 = MapSL(*lpParam1);
1659 LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
1660 LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr;
1661
1662 assert(wh32->lpNext == wh16);
1663 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
1664 wh32->dwUser = wh16->dwUser;
1665 wh32->dwFlags = wh16->dwFlags;
1666 wh32->dwLoops = wh16->dwLoops;
1667
1668 UnMapLS( *lpParam1 );
1669 if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
1670 HeapFree( GetProcessHeap(), 0, ptr );
1671 wh32->lpNext = 0;
1672 }
1673 ret = WINMM_MAP_OK;
1674 }
1675 break;
1676 case WODM_GETVOLUME:
1677 FIXME("NIY: no conversion yet\n");
1678 ret = WINMM_MAP_MSGERROR;
1679 break;
1680 case DRVM_MAPPER_STATUS:
1681 {
1682 UnMapLS( *lpParam2 );
1683 ret = WINMM_MAP_OK;
1684 }
1685 break;
1686 default:
1687 FIXME("NIY: no conversion yet\n");
1688 ret = WINMM_MAP_MSGERROR;
1689 break;
1690 }
1691 return ret;
1692 }
1693
1694 /**************************************************************************
1695 * MMDRV_WaveOut_Callback [internal]
1696 */
1697 static void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
1698 {
1699 LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
1700
1701 switch (uMsg) {
1702 case WOM_OPEN:
1703 case WOM_CLOSE:
1704 /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
1705 break;
1706 case WOM_DONE:
1707 if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
1708 /* initial map is: 32 => 16 */
1709 LPWAVEHDR wh16 = MapSL(dwParam1);
1710 LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
1711
1712 dwParam1 = (DWORD)wh32;
1713 wh32->dwFlags = wh16->dwFlags;
1714 } else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
1715 /* initial map is: 16 => 32 */
1716 LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1);
1717 SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
1718 LPWAVEHDR wh16 = MapSL(segwh16);
1719
1720 dwParam1 = (DWORD)segwh16;
1721 wh16->dwFlags = wh32->dwFlags;
1722 }
1723 /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
1724 break;
1725 default:
1726 ERR("Unknown msg %u\n", uMsg);
1727 }
1728
1729 MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
1730 }
1731
1732 /* =================================
1733 * M A P P E R S H A N D L I N G
1734 * ================================= */
1735
1736 static LRESULT MMDRV_CallMMDrvFunc16(FARPROC16 fp16, WORD dev, WORD msg, LONG instance,
1737 LONG lp1, LONG lp2)
1738 {
1739 WORD args[8];
1740 DWORD ret;
1741
1742 args[7] = dev;
1743 args[6] = msg;
1744 args[5] = HIWORD(instance);
1745 args[4] = LOWORD(instance);
1746 args[3] = HIWORD(lp1);
1747 args[2] = LOWORD(lp1);
1748 args[1] = HIWORD(lp2);
1749 args[0] = LOWORD(lp2);
1750 WOWCallback16Ex( (DWORD)fp16, WCB16_PASCAL, sizeof(args), args, &ret );
1751 return LOWORD(ret);
1752 }
1753
1754 /**************************************************************************
1755 * MMDRV_GetDescription16 [internal]
1756 */
1757 static BOOL MMDRV_GetDescription16(const char* fname, char* buf, int buflen)
1758 {
1759 OFSTRUCT ofs;
1760 HFILE hFile;
1761 WORD w;
1762 DWORD dw;
1763 BOOL ret = FALSE;
1764
1765 if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) {
1766 ERR("Can't open file %s (builtin driver ?)\n", fname);
1767 return FALSE;
1768 }
1769
1770 #define E(_x) do {TRACE _x;goto theEnd;} while(0)
1771
1772 if (_lread(hFile, &w, 2) != 2) E(("Can't read sig\n"));
1773 if (w != ('Z' * 256 + 'M')) E(("Bad sig %04x\n", w));
1774 if (_llseek(hFile, 0x3C, SEEK_SET) < 0) E(("Can't seek to ext header offset\n"));
1775 if (_lread(hFile, &dw, 4) != 4) E(("Can't read ext header offset\n"));
1776 if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %lu\n", dw+0x2C));
1777 if (_lread(hFile, &dw, 4) != 4) E(("Can't read nr table offset\n"));
1778 if (_llseek(hFile, dw, SEEK_SET) < 0) E(("Can't seek to nr table %lu\n", dw));
1779 if (_lread(hFile, buf, 1) != 1) E(("Can't read descr length\n"));
1780 buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1);
1781 if (_lread(hFile, buf, buflen) != buflen) E(("Can't read descr (%d)\n", buflen));
1782 buf[buflen] = '\0';
1783 ret = TRUE;
1784 TRACE("Got '%s' [%d]\n", buf, buflen);
1785 theEnd:
1786 _lclose(hFile);
1787 return ret;
1788 }
1789
1790 /******************************************************************
1791 * MMDRV_LoadMMDrvFunc16
1792 *
1793 */
1794 unsigned MMDRV_LoadMMDrvFunc16(LPCSTR drvName, LPWINE_DRIVER d,
1795 LPWINE_MM_DRIVER lpDrv)
1796 {
1797 WINEMM_msgFunc16 func;
1798 unsigned count = 0;
1799 char buffer[128];
1800 /*
1801 * DESCRIPTION 'wave,aux,mixer:Creative Labs Sound Blaster 16 Driver'
1802 * The beginning of the module description indicates the driver supports
1803 * waveform, auxiliary, and mixer devices. Use one of the following
1804 * device-type names, followed by a colon (:) to indicate the type of
1805 * device your driver supports. If the driver supports more than one
1806 * type of device, separate each device-type name with a comma (,).
1807 *
1808 * wave for waveform audio devices
1809 * wavemapper for wave mappers
1810 * midi for MIDI audio devices
1811 * midimapper for midi mappers
1812 * aux for auxiliary audio devices
1813 * mixer for mixer devices
1814 */
1815
1816 if (d->d.d16.hDriver16) {
1817 HMODULE16 hMod16 = GetDriverModuleHandle16(d->d.d16.hDriver16);
1818
1819 #define AA(_h,_w,_x,_y,_z) \
1820 func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \
1821 if (func != NULL) \
1822 { lpDrv->parts[_w].u.fnMessage##_y = func; count++; \
1823 TRACE("Got %d bit func '%s'\n", _y, #_x); }
1824
1825 #define A(_x,_y) AA(hMod16,_x,_y,16,GetProcAddress16)
1826 A(MMDRV_AUX, auxMessage);
1827 A(MMDRV_MIXER, mxdMessage);
1828 A(MMDRV_MIDIIN, midMessage);
1829 A(MMDRV_MIDIOUT,modMessage);
1830 A(MMDRV_WAVEIN, widMessage);
1831 A(MMDRV_WAVEOUT,wodMessage);
1832 #undef A
1833 #undef AA
1834 }
1835 if (TRACE_ON(winmm)) {
1836 if (MMDRV_GetDescription16(drvName, buffer, sizeof(buffer)))
1837 TRACE("%s => %s\n", drvName, buffer);
1838 else
1839 TRACE("%s => No description\n", drvName);
1840 }
1841
1842 return count;
1843 }
1844
1845 /* =================================
1846 * M C I
1847 * ================================= */
1848
1849 /**************************************************************************
1850 * MCI_MapMsg16To32A [internal]
1851 */
1852 static WINMM_MapType MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
1853 {
1854 if (*lParam == 0)
1855 return WINMM_MAP_OK;
1856 /* FIXME: to add also (with seg/linear modifications to do):
1857 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1858 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1859 */
1860 switch (wMsg) {
1861 /* case MCI_CAPTURE */
1862 case MCI_CLOSE:
1863 case MCI_CLOSE_DRIVER:
1864 case MCI_CONFIGURE:
1865 case MCI_COPY:
1866 case MCI_CUE:
1867 case MCI_CUT:
1868 case MCI_DELETE:
1869 case MCI_FREEZE:
1870 case MCI_GETDEVCAPS:
1871 /* case MCI_INDEX: */
1872 /* case MCI_MARK: */
1873 /* case MCI_MONITOR: */
1874 case MCI_PASTE:
1875 case MCI_PAUSE:
1876 case MCI_PLAY:
1877 case MCI_PUT:
1878 case MCI_REALIZE:
1879 case MCI_RECORD:
1880 case MCI_RESUME:
1881 case MCI_SEEK:
1882 case MCI_SET:
1883 /* case MCI_SETTIMECODE:*/
1884 /* case MCI_SIGNAL:*/
1885 case MCI_SPIN:
1886 case MCI_STATUS: /* FIXME: is wrong for digital video */
1887 case MCI_STEP:
1888 case MCI_STOP:
1889 /* case MCI_UNDO: */
1890 case MCI_UNFREEZE:
1891 case MCI_UPDATE:
1892 case MCI_WHERE:
1893 *lParam = (DWORD)MapSL(*lParam);
1894 return WINMM_MAP_OK;
1895 case MCI_WINDOW:
1896 /* in fact, I would also need the dwFlags... to see
1897 * which members of lParam are effectively used
1898 */
1899 *lParam = (DWORD)MapSL(*lParam);
1900 FIXME("Current mapping may be wrong\n");
1901 break;
1902 case MCI_BREAK:
1903 {
1904 LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
1905 LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
1906
1907 if (mbp32) {
1908 mbp32->dwCallback = mbp16->dwCallback;
1909 mbp32->nVirtKey = mbp16->nVirtKey;
1910 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
1911 } else {
1912 return WINMM_MAP_NOMEM;
1913 }
1914 *lParam = (DWORD)mbp32;
1915 }
1916 return WINMM_MAP_OKMEM;
1917 case MCI_ESCAPE:
1918 {
1919 LPMCI_VD_ESCAPE_PARMSA mvep32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA));
1920 LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
1921
1922 if (mvep32a) {
1923 mvep32a->dwCallback = mvep16->dwCallback;
1924 mvep32a->lpstrCommand = MapSL(mvep16->lpstrCommand);
1925 } else {
1926 return WINMM_MAP_NOMEM;
1927 }
1928 *lParam = (DWORD)mvep32a;
1929 }
1930 return WINMM_MAP_OKMEM;
1931 case MCI_INFO:
1932 {
1933 LPMCI_INFO_PARMSA mip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA));
1934 LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
1935
1936 /* FIXME this is wrong if device is of type
1937 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
1938 */
1939 if (mip32a) {
1940 mip32a->dwCallback = mip16->dwCallback;
1941 mip32a->lpstrReturn = MapSL(mip16->lpstrReturn);
1942 mip32a->dwRetSize = mip16->dwRetSize;
1943 } else {
1944 return WINMM_MAP_NOMEM;
1945 }
1946 *lParam = (DWORD)mip32a;
1947 }
1948 return WINMM_MAP_OKMEM;
1949 case MCI_OPEN:
1950 case MCI_OPEN_DRIVER:
1951 {
1952 LPMCI_OPEN_PARMSA mop32a = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD));
1953 LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
1954
1955 if (mop32a) {
1956 *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
1957 mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
1958 mop32a->dwCallback = mop16->dwCallback;
1959 mop32a->wDeviceID = mop16->wDeviceID;
1960 mop32a->lpstrDeviceType = MapSL(mop16->lpstrDeviceType);
1961 mop32a->lpstrElementName = MapSL(mop16->lpstrElementName);
1962 mop32a->lpstrAlias = MapSL(mop16->lpstrAlias);
1963 /* copy extended information if any...
1964 * FIXME: this may seg fault if initial structure does not contain them and
1965 * the reads after msip16 fail under LDT limits...
1966 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1967 * should not take care of extended parameters, and should be used by MCI_Open
1968 * to fetch uDevType. When, this is known, the mapping for sending the
1969 * MCI_OPEN_DRIVER shall be done depending on uDevType.
1970 */
1971 memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD));
1972 } else {
1973 return WINMM_MAP_NOMEM;
1974 }
1975 *lParam = (DWORD)mop32a;
1976 }
1977 return WINMM_MAP_OKMEM;
1978 case MCI_SYSINFO:
1979 {
1980 LPMCI_SYSINFO_PARMSA msip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA));
1981 LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam);
1982
1983 if (msip32a) {
1984 msip32a->dwCallback = msip16->dwCallback;
1985 msip32a->lpstrReturn = MapSL(msip16->lpstrReturn);
1986 msip32a->dwRetSize = msip16->dwRetSize;
1987 msip32a->dwNumber = msip16->dwNumber;
1988 msip32a->wDeviceType = msip16->wDeviceType;
1989 } else {
1990 return WINMM_MAP_NOMEM;
1991 }
1992 *lParam = (DWORD)msip32a;
1993 }
1994 return WINMM_MAP_OKMEM;
1995 case DRV_LOAD:
1996 case DRV_ENABLE:
1997 case DRV_OPEN:
1998 case DRV_CLOSE:
1999 case DRV_DISABLE:
2000 case DRV_FREE:
2001 case DRV_CONFIGURE:
2002 case DRV_QUERYCONFIGURE:
2003 case DRV_INSTALL:
2004 case DRV_REMOVE:
2005 case DRV_EXITSESSION:
2006 case DRV_EXITAPPLICATION:
2007 case DRV_POWER:
2008 FIXME("This is a hack\n");
2009 return WINMM_MAP_OK;
2010
2011 default:
2012 WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2013 }
2014 return WINMM_MAP_MSGERROR;
2015 }
2016
2017 /**************************************************************************
2018 * MCI_UnMapMsg16To32A [internal]
2019 */
2020 static WINMM_MapType MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
2021 {
2022 switch (wMsg) {
2023 /* case MCI_CAPTURE */
2024 case MCI_CLOSE:
2025 case MCI_CLOSE_DRIVER:
2026 case MCI_CONFIGURE:
2027 case MCI_COPY:
2028 case MCI_CUE:
2029 case MCI_CUT:
2030 case MCI_DELETE:
2031 case MCI_FREEZE:
2032 case MCI_GETDEVCAPS:
2033 /* case MCI_INDEX: */
2034 /* case MCI_MARK: */
2035 /* case MCI_MONITOR: */
2036 case MCI_PASTE:
2037 case MCI_PAUSE:
2038 case MCI_PLAY:
2039 case MCI_PUT:
2040 case MCI_REALIZE:
2041 case MCI_RECORD:
2042 case MCI_RESUME:
2043 case MCI_SEEK:
2044 case MCI_SET:
2045 /* case MCI_SETTIMECODE:*/
2046 /* case MCI_SIGNAL:*/
2047 case MCI_SPIN:
2048 case MCI_STATUS:
2049 case MCI_STEP:
2050 case MCI_STOP:
2051 /* case MCI_UNDO: */
2052 case MCI_UNFREEZE:
2053 case MCI_UPDATE:
2054 case MCI_WHERE:
2055 return WINMM_MAP_OK;
2056
2057 case MCI_WINDOW:
2058 /* FIXME ?? see Map function */
2059 return WINMM_MAP_OK;
2060
2061 case MCI_BREAK:
2062 case MCI_ESCAPE:
2063 case MCI_INFO:
2064 case MCI_SYSINFO:
2065 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
2066 return WINMM_MAP_OK;
2067 case MCI_OPEN:
2068 case MCI_OPEN_DRIVER:
2069 if (lParam) {
2070 LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)lParam;
2071 LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16));
2072
2073 mop16->wDeviceID = mop32a->wDeviceID;
2074 if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
2075 FIXME("bad free line=%d\n", __LINE__);
2076 }
2077 return WINMM_MAP_OK;
2078 case DRV_LOAD:
2079 case DRV_ENABLE:
2080 case DRV_OPEN:
2081 case DRV_CLOSE:
2082 case DRV_DISABLE:
2083 case DRV_FREE:
2084 case DRV_CONFIGURE:
2085 case DRV_QUERYCONFIGURE:
2086 case DRV_INSTALL:
2087 case DRV_REMOVE:
2088 case DRV_EXITSESSION:
2089 case DRV_EXITAPPLICATION:
2090 case DRV_POWER:
2091 FIXME("This is a hack\n");
2092 return WINMM_MAP_OK;
2093 default:
2094 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2095 }
2096 return WINMM_MAP_MSGERROR;
2097 }
2098
2099 /*
2100 * 0000 stop
2101 * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
2102 * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
2103 * 0100
2104 * 0101
2105 * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
2106 * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
2107 * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
2108 */
2109
2110 /**************************************************************************
2111 * MCI_MsgMapper32To16_Create [internal]
2112 *
2113 * Helper for MCI_MapMsg32ATo16.
2114 * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
2115 * segmented pointer.
2116 * map contains a list of action to be performed for the mapping (see list
2117 * above)
2118 * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
2119 */
2120 static WINMM_MapType MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
2121 {
2122 void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
2123 LPBYTE p16, p32;
2124
2125 if (!lp) {
2126 return WINMM_MAP_NOMEM;
2127 }
2128 p32 = (LPBYTE)(*ptr);
2129 if (keep) {
2130 *(void**)lp = *ptr;
2131 p16 = (LPBYTE)lp + sizeof(void**);
2132 *ptr = (char*)MapLS(lp) + sizeof(void**);
2133 } else {
2134 p16 = lp;
2135 *ptr = (void*)MapLS(lp);
2136 }
2137
2138 if (map == 0) {
2139 memcpy(p16, p32, size16);
2140 } else {
2141 unsigned nibble;
2142 unsigned sz;
2143
2144 while (map & 0xF) {
2145 nibble = map & 0xF;
2146 if (nibble & 0x8) {
2147 sz = (nibble & 7) + 1;
2148 memcpy(p16, p32, sz);
2149 p16 += sz;
2150 p32 += sz;
2151 size16 -= sz; /* DEBUG only */
2152 } else {
2153 switch (nibble) {
2154 case 0x1:
2155 *(LPINT16)p16 = *(LPINT)p32;
2156 p16 += sizeof(INT16);
2157 p32 += sizeof(INT);
2158 size16 -= sizeof(INT16);
2159 break;
2160 case 0x2:
2161 *(LPUINT16)p16 = *(LPUINT)p32;
2162 p16 += sizeof(UINT16);
2163 p32 += sizeof(UINT);
2164 size16 -= sizeof(UINT16);
2165 break;
2166 case 0x6:
2167 *(LPDWORD)p16 = 0;
2168 p16 += sizeof(DWORD);
2169 p32 += sizeof(DWORD);
2170 size16 -= sizeof(DWORD);
2171 break;
2172 case 0x7:
2173 *(SEGPTR *)p16 = MapLS( *(LPSTR *)p32 );
2174 p16 += sizeof(SEGPTR);
2175 p32 += sizeof(LPSTR);
2176 size16 -= sizeof(SEGPTR);
2177 break;
2178 default:
2179 FIXME("Unknown nibble for mapping (%x)\n", nibble);
2180 }
2181 }
2182 map >>= 4;
2183 }
2184 if (size16 != 0) /* DEBUG only */
2185 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2186 }
2187 return WINMM_MAP_OKMEM;
2188 }
2189
2190 /**************************************************************************
2191 * MCI_MsgMapper32To16_Destroy [internal]
2192 *
2193 * Helper for MCI_UnMapMsg32ATo16.
2194 */
2195 static WINMM_MapType MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
2196 {
2197 if (ptr) {
2198 void* msg16 = MapSL((SEGPTR)ptr);
2199 void* alloc;
2200 LPBYTE p32, p16;
2201 unsigned nibble;
2202
2203 UnMapLS( (SEGPTR)ptr );
2204 if (kept) {
2205 alloc = (char*)msg16 - sizeof(void**);
2206 p32 = *(void**)alloc;
2207 p16 = msg16;
2208
2209 if (map == 0) {
2210 memcpy(p32, p16, size16);
2211 } else {
2212 while (map & 0xF) {
2213 nibble = map & 0xF;
2214 if (nibble & 0x8) {
2215 memcpy(p32, p16, (nibble & 7) + 1);
2216 p16 += (nibble & 7) + 1;
2217 p32 += (nibble & 7) + 1;
2218 size16 -= (nibble & 7) + 1;
2219 } else {
2220 switch (nibble) {
2221 case 0x1:
2222 *(LPINT)p32 = *(LPINT16)p16;
2223 p16 += sizeof(INT16);
2224 p32 += sizeof(INT);
2225 size16 -= sizeof(INT16);
2226 break;
2227 case 0x2:
2228 *(LPUINT)p32 = *(LPUINT16)p16;
2229 p16 += sizeof(UINT16);
2230 p32 += sizeof(UINT);
2231 size16 -= sizeof(UINT16);
2232 break;
2233 case 0x6:
2234 p16 += sizeof(UINT);
2235 p32 += sizeof(UINT);
2236 size16 -= sizeof(UINT);
2237 break;
2238 case 0x7:
2239 UnMapLS( *(SEGPTR *)p16 );
2240 p16 += sizeof(SEGPTR);
2241 p32 += sizeof(char*);
2242 size16 -= sizeof(SEGPTR);
2243 break;
2244 default:
2245 FIXME("Unknown nibble for mapping (%x)\n", nibble);
2246 }
2247 }
2248 map >>= 4;
2249 }
2250 if (size16 != 0) /* DEBUG only */
2251 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
2252 }
2253 } else {
2254 alloc = msg16;
2255 }
2256
2257 HeapFree( GetProcessHeap(), 0, alloc );
2258 }
2259 return WINMM_MAP_OK;
2260 }
2261
2262 /**************************************************************************
2263 * MCI_MapMsg32ATo16 [internal]
2264 *
2265 * Map a 32-A bit MCI message to a 16 bit MCI message.
2266 */
2267 static WINMM_MapType MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
2268 {
2269 int size;
2270 BOOLEAN keep = FALSE;
2271 DWORD map = 0;
2272
2273 if (*lParam == 0)
2274 return WINMM_MAP_OK;
2275
2276 /* FIXME: to add also (with seg/linear modifications to do):
2277 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
2278 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
2279 */
2280 switch (wMsg) {
2281 case MCI_BREAK:
2282 size = sizeof(MCI_BREAK_PARMS);
2283 break;
2284 /* case MCI_CAPTURE */
2285 case MCI_CLOSE:
2286 case MCI_CLOSE_DRIVER:
2287 case MCI_CONFIGURE:
2288 size = sizeof(MCI_GENERIC_PARMS);
2289 break;
2290 /* case MCI_COPY: */
2291 case MCI_CUE:
2292 switch (uDevType) {
2293 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
2294 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2295 default: size = sizeof(MCI_GENERIC_PARMS); break;
2296 }
2297 break;
2298 /* case MCI_CUT:*/
2299 case MCI_DELETE:
2300 switch (uDevType) {
2301 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break;
2302 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
2303 default: size = sizeof(MCI_GENERIC_PARMS); break;
2304 }
2305 break;
2306 /* case MCI_ESCAPE: */
2307 case MCI_FREEZE:
2308 switch (uDevType) {
2309 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break;
2310 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
2311 default: size = sizeof(MCI_GENERIC_PARMS); break;
2312 }
2313 break;
2314 case MCI_GETDEVCAPS:
2315 keep = TRUE;
2316 size = sizeof(MCI_GETDEVCAPS_PARMS);
2317 break;
2318 /* case MCI_INDEX: */
2319 case MCI_INFO:
2320 {
2321 LPMCI_INFO_PARMSA mip32a = (LPMCI_INFO_PARMSA)(*lParam);
2322 LPMCI_INFO_PARMS16 mip16;
2323
2324 switch (uDevType) {
2325 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
2326 default: size = sizeof(MCI_INFO_PARMS16); break;
2327 }
2328 mip16 = HeapAlloc( GetProcessHeap(), 0, size);
2329 if (mip16)
2330 {
2331 mip16->dwCallback = mip32a->dwCallback;
2332 mip16->lpstrReturn = MapLS( mip32a->lpstrReturn );
2333 mip16->dwRetSize = mip32a->dwRetSize;
2334 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
2335 ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
2336 }
2337 } else {
2338 return WINMM_MAP_NOMEM;
2339 }
2340 *lParam = MapLS(mip16);
2341 }
2342 return WINMM_MAP_OKMEM;
2343 /* case MCI_MARK: */
2344 /* case MCI_MONITOR: */
2345 case MCI_OPEN:
2346 case MCI_OPEN_DRIVER:
2347 {
2348 LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
2349 char* ptr = HeapAlloc( GetProcessHeap(), 0,
2350 sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
2351 LPMCI_OPEN_PARMS16 mop16;
2352
2353
2354 if (ptr) {
2355 *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
2356 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
2357 mop16->dwCallback = mop32a->dwCallback;
2358 mop16->wDeviceID = mop32a->wDeviceID;
2359 if (dwFlags & MCI_OPEN_TYPE) {
2360 if (dwFlags & MCI_OPEN_TYPE_ID) {
2361 /* dword "transparent" value */
2362 mop16->lpstrDeviceType = (SEGPTR)mop32a->lpstrDeviceType;
2363 } else {
2364 /* string */
2365 mop16->lpstrDeviceType = MapLS( mop32a->lpstrDeviceType );
2366 }
2367 } else {
2368 /* nuthin' */
2369 mop16->lpstrDeviceType = 0;
2370 }
2371 if (dwFlags & MCI_OPEN_ELEMENT) {
2372 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
2373 mop16->lpstrElementName = (SEGPTR)mop32a->lpstrElementName;
2374 } else {
2375 mop16->lpstrElementName = MapLS( mop32a->lpstrElementName );
2376 }
2377 } else {
2378 mop16->lpstrElementName = 0;
2379 }
2380 if (dwFlags & MCI_OPEN_ALIAS) {
2381 mop16->lpstrAlias = MapLS( mop32a->lpstrAlias );
2382 } else {
2383 mop16->lpstrAlias = 0;
2384 }
2385 /* copy extended information if any...
2386 * FIXME: this may seg fault if initial structure does not contain them and
2387 * the reads after msip16 fail under LDT limits...
2388 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2389 * should not take care of extended parameters, and should be used by MCI_Open
2390 * to fetch uDevType. When, this is known, the mapping for sending the
2391 * MCI_OPEN_DRIVER shall be done depending on uDevType.
2392 */
2393 memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
2394 } else {
2395 return WINMM_MAP_NOMEM;
2396 }
2397 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA);
2398 }
2399 return WINMM_MAP_OKMEM;
2400 /* case MCI_PASTE:*/
2401 case MCI_PAUSE:
2402 size = sizeof(MCI_GENERIC_PARMS);
2403 break;
2404 case MCI_PLAY:
2405 size = sizeof(MCI_PLAY_PARMS);
2406 break;
2407 case MCI_PUT:
2408 switch (uDevType) {
2409 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
2410 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
2411 default: size = sizeof(MCI_GENERIC_PARMS); break;
2412 }
2413 break;
2414 case MCI_REALIZE:
2415 size = sizeof(MCI_GENERIC_PARMS);
2416 break;
2417 case MCI_RECORD:
2418 switch (uDevType) {
2419 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break;
2420 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2421 default: size = sizeof(MCI_RECORD_PARMS); break;
2422 }
2423 break;
2424 case MCI_RESUME:
2425 size = sizeof(MCI_GENERIC_PARMS);
2426 break;
2427 case MCI_SEEK:
2428 switch (uDevType) {
2429 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2430 default: size = sizeof(MCI_SEEK_PARMS); break;
2431 }
2432 break;
2433 case MCI_SET:
2434 switch (uDevType) {
2435 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
2436 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2437 case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
2438 /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
2439 * so not doing anything should work...
2440 */
2441 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break;
2442 default: size = sizeof(MCI_SET_PARMS); break;
2443 }
2444 break;
2445 case MCI_SETAUDIO:
2446 switch (uDevType) {
2447 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break;
2448 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2449 default: size = sizeof(MCI_GENERIC_PARMS); break;
2450 }
2451 break;
2452 /* case MCI_SETTIMECODE:*/
2453 /* case MCI_SIGNAL:*/
2454 case MCI_SPIN:
2455 size = sizeof(MCI_SET_PARMS);
2456 break;
2457 case MCI_STATUS:
2458 keep = TRUE;
2459 switch (uDevType) {
2460 /* FIXME:
2461 * don't know if buffer for value is the one passed through lpstrDevice
2462 * or is provided by MCI driver.
2463 * Assuming solution 2: provided by MCI driver, so zeroing on entry
2464 */
2465 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break;
2466 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2467 default: size = sizeof(MCI_STATUS_PARMS); break;
2468 }
2469 break;
2470 case MCI_STEP:
2471 switch (uDevType) {
2472 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
2473 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2474 case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
2475 default: size = sizeof(MCI_GENERIC_PARMS); break;
2476 }
2477 break;
2478 case MCI_STOP:
2479 size = sizeof(MCI_SET_PARMS);
2480 break;
2481 case MCI_SYSINFO:
2482 {
2483 LPMCI_SYSINFO_PARMSA msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
2484 LPMCI_SYSINFO_PARMS16 msip16;
2485 char* ptr = HeapAlloc( GetProcessHeap(), 0,
2486 sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16) );
2487
2488 if (ptr) {
2489 *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
2490 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
2491
2492 msip16->dwCallback = msip32a->dwCallback;
2493 msip16->lpstrReturn = MapLS( msip32a->lpstrReturn );
2494 msip16->dwRetSize = msip32a->dwRetSize;
2495 msip16->dwNumber = msip32a->dwNumber;
2496 msip16->wDeviceType = msip32a->wDeviceType;
2497 } else {
2498 return WINMM_MAP_NOMEM;
2499 }
2500 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
2501 }
2502 return WINMM_MAP_OKMEM;
2503 /* case MCI_UNDO: */
2504 case MCI_UNFREEZE:
2505 switch (uDevType) {
2506 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
2507 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break;
2508 default: size = sizeof(MCI_GENERIC_PARMS); break;
2509 }
2510 break;
2511 case MCI_UPDATE:
2512 switch (uDevType) {
2513 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break;
2514 default: size = sizeof(MCI_GENERIC_PARMS); break;
2515 }
2516 break;
2517 case MCI_WHERE:
2518 switch (uDevType) {
2519 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
2520 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
2521 default: size = sizeof(MCI_GENERIC_PARMS); break;
2522 }
2523 break;
2524 case MCI_WINDOW:
2525 switch (uDevType) {
2526 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break;
2527 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break;
2528 default: size = sizeof(MCI_GENERIC_PARMS); break;
2529 }
2530 break;
2531 case DRV_OPEN:
2532 {
2533 LPMCI_OPEN_DRIVER_PARMSA modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam);
2534 LPMCI_OPEN_DRIVER_PARMS16 modp16;
2535 char *ptr = HeapAlloc( GetProcessHeap(), 0,
2536 sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
2537
2538 if (ptr) {
2539 *(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a;
2540 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2541 modp16->wDeviceID = modp32a->wDeviceID;
2542 modp16->lpstrParams = MapLS( modp32a->lpstrParams );
2543 /* other fields are gonna be filled by the driver, don't copy them */
2544 } else {
2545 return WINMM_MAP_NOMEM;
2546 }
2547 *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA);
2548 }
2549 return WINMM_MAP_OKMEM;
2550 case DRV_LOAD:
2551 case DRV_ENABLE:
2552 case DRV_CLOSE:
2553 case DRV_DISABLE:
2554 case DRV_FREE:
2555 case DRV_CONFIGURE:
2556 case DRV_QUERYCONFIGURE:
2557 case DRV_INSTALL:
2558 case DRV_REMOVE:
2559 case DRV_EXITSESSION:
2560 case DRV_EXITAPPLICATION:
2561 case DRV_POWER:
2562 return WINMM_MAP_OK;
2563
2564 default:
2565 WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
2566 return WINMM_MAP_MSGERROR;
2567 }
2568 return MCI_MsgMapper32To16_Create((void**)lParam, size, map, keep);
2569 }
2570
2571 /**************************************************************************
2572 * MCI_UnMapMsg32ATo16 [internal]
2573 */
2574 static WINMM_MapType MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
2575 {
2576 int size = 0;
2577 BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
2578 DWORD map = 0;
2579
2580 switch (wMsg) {
2581 case MCI_BREAK:
2582 break;
2583 /* case MCI_CAPTURE */
2584 case MCI_CLOSE:
2585 case MCI_CLOSE_DRIVER:
2586 case MCI_CONFIGURE:
2587 break;
2588 /* case MCI_COPY: */
2589 case MCI_CUE:
2590 break;
2591 /* case MCI_CUT: */
2592 case MCI_DELETE:
2593 break;
2594 /* case MCI_ESCAPE: */
2595 case MCI_FREEZE:
2596 break;
2597 case MCI_GETDEVCAPS:
2598 kept = TRUE;
2599 size = sizeof(MCI_GETDEVCAPS_PARMS);
2600 break;
2601 /* case MCI_INDEX: */
2602 case MCI_INFO:
2603 {
2604 LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam);
2605 UnMapLS( lParam );
2606 UnMapLS( mip16->lpstrReturn );
2607 HeapFree( GetProcessHeap(), 0, mip16 );
2608 }
2609 return WINMM_MAP_OK;
2610 /* case MCI_MARK: */
2611 /* case MCI_MONITOR: */
2612 case MCI_OPEN:
2613 case MCI_OPEN_DRIVER:
2614 if (lParam) {
2615 LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam);
2616 LPMCI_OPEN_PARMSA mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
2617 UnMapLS( lParam );
2618 mop32a->wDeviceID = mop16->wDeviceID;
2619 if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
2620 UnMapLS( mop16->lpstrDeviceType );
2621 if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
2622 UnMapLS( mop16->lpstrElementName );
2623 if (dwFlags & MCI_OPEN_ALIAS)
2624 UnMapLS( mop16->lpstrAlias );
2625 HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) );
2626 }
2627 return WINMM_MAP_OK;
2628 /* case MCI_PASTE:*/
2629 case MCI_PAUSE:
2630 break;
2631 case MCI_PLAY:
2632 break;
2633 case MCI_PUT:
2634 break;
2635 case MCI_REALIZE:
2636 break;
2637 case MCI_RECORD:
2638 break;
2639 case MCI_RESUME:
2640 break;
2641 case MCI_SEEK:
2642 break;
2643 case MCI_SET:
2644 break;
2645 case MCI_SETAUDIO:
2646 switch (uDevType) {
2647 case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break;
2648 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2649 }
2650 break;
2651 /* case MCI_SETTIMECODE:*/
2652 /* case MCI_SIGNAL:*/
2653 case MCI_SPIN:
2654 break;
2655 case MCI_STATUS:
2656 kept = TRUE;
2657 switch (uDevType) {
2658 case MCI_DEVTYPE_DIGITAL_VIDEO:
2659 if (lParam) {
2660 LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
2661 LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
2662
2663 UnMapLS( lParam );
2664 if (mdsp16) {
2665 mdsp32a->dwReturn = mdsp16->dwReturn;
2666 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
2667 TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
2668 TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
2669 UnMapLS( mdsp16->lpstrDrive );
2670 }
2671 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
2672 } else {
2673 return WINMM_MAP_NOMEM;
2674 }
2675 }
2676 return WINMM_MAP_OKMEM;
2677 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
2678 default: size = sizeof(MCI_STATUS_PARMS); break;
2679 }
2680 break;
2681 case MCI_STEP:
2682 break;
2683 case MCI_STOP:
2684 break;
2685 case MCI_SYSINFO:
2686 if (lParam) {
2687 LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
2688 LPMCI_SYSINFO_PARMSA msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
2689
2690 UnMapLS( lParam );
2691 if (msip16) {
2692 msip16->dwCallback = msip32a->dwCallback;
2693 UnMapLS( msip16->lpstrReturn );
2694 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) );
2695 } else {
2696 return WINMM_MAP_NOMEM;
2697 }
2698 }
2699 return WINMM_MAP_OKMEM;
2700 /* case MCI_UNDO: */
2701 case MCI_UNFREEZE:
2702 break;
2703 case MCI_UPDATE:
2704 break;
2705 case MCI_WHERE:
2706 switch (uDevType) {
2707 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
2708 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
2709 default: break;
2710 }
2711 break;
2712 case MCI_WINDOW:
2713 switch (uDevType) {
2714 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break;
2715 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break;
2716 default: break;
2717 }
2718 /* FIXME: see map function */
2719 break;
2720
2721 case DRV_OPEN:
2722 if (lParam) {
2723 LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
2724 LPMCI_OPEN_DRIVER_PARMSA modp32a = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2725
2726 UnMapLS( lParam );
2727 modp32a->wCustomCommandTable = modp16->wCustomCommandTable;
2728 modp32a->wType = modp16->wType;
2729 UnMapLS( modp16->lpstrParams );
2730 HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) );
2731 }
2732 return WINMM_MAP_OK;
2733 case DRV_LOAD:
2734 case DRV_ENABLE:
2735 case DRV_CLOSE:
2736 case DRV_DISABLE:
2737 case DRV_FREE:
2738 case DRV_CONFIGURE:
2739 case DRV_QUERYCONFIGURE:
2740 case DRV_INSTALL:
2741 case DRV_REMOVE:
2742 case DRV_EXITSESSION:
2743 case DRV_EXITAPPLICATION:
2744 case DRV_POWER:
2745 FIXME("This is a hack\n");
2746 return WINMM_MAP_OK;
2747 default:
2748 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2749 return WINMM_MAP_MSGERROR;
2750 }
2751 return MCI_MsgMapper32To16_Destroy((void*)lParam, size, map, kept);
2752 }
2753
2754 void MMDRV_Init16(void)
2755 {
2756 #define A(_x,_y) MMDRV_InstallMap(_x, \
2757 MMDRV_##_y##_Map16To32A, MMDRV_##_y##_UnMap16To32A, \
2758 MMDRV_##_y##_Map32ATo16, MMDRV_##_y##_UnMap32ATo16, \
2759 MMDRV_##_y##_Callback)
2760 A(MMDRV_AUX, Aux);
2761 A(MMDRV_MIXER, Mixer);
2762 A(MMDRV_MIDIIN, MidiIn);
2763 A(MMDRV_MIDIOUT, MidiOut);
2764 A(MMDRV_WAVEIN, WaveIn);
2765 A(MMDRV_WAVEOUT, WaveOut);
2766 #undef A
2767
2768 pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16;
2769 pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16;
2770
2771 pFnMciMapMsg16To32A = MCI_MapMsg16To32A;
2772 pFnMciUnMapMsg16To32A = MCI_UnMapMsg16To32A;
2773 pFnMciMapMsg32ATo16 = MCI_MapMsg32ATo16;
2774 pFnMciUnMapMsg32ATo16 = MCI_UnMapMsg32ATo16;
2775 }
GSOC 2012 project to enhance the control panel