krnl386.exe: Fix size calculation in GetSystemDirectory16.
[wine] / dlls / mmsystem.dll16 / message16.c
1 /*
2  * MMSYSTEM MCI and low level mapping functions
3  *
4  * Copyright 1999 Eric Pouech
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <string.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <assert.h>
25 #include "wine/winbase16.h"
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "wownt32.h"
30 #include "winemm16.h"
31 #include "digitalv.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
35
36 /* =================================
37  *       A U X    M A P P E R S
38  * ================================= */
39
40 /* =================================
41  *     M I X E R  M A P P E R S
42  * ================================= */
43
44 /**************************************************************************
45  *                              MMSYSTDRV_Mixer_Map16To32W              [internal]
46  */
47 static  MMSYSTEM_MapType        MMSYSTDRV_Mixer_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
48 {
49     return MMSYSTEM_MAP_MSGERROR;
50 }
51
52 /**************************************************************************
53  *                              MMSYSTDRV_Mixer_UnMap16To32W    [internal]
54  */
55 static  MMSYSTEM_MapType        MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
56 {
57 #if 0
58     MIXERCAPSA  micA;
59     UINT        ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
60
61     if (ret == MMSYSERR_NOERROR) {
62         mixcaps->wMid           = micA.wMid;
63         mixcaps->wPid           = micA.wPid;
64         mixcaps->vDriverVersion = micA.vDriverVersion;
65         strcpy(mixcaps->szPname, micA.szPname);
66         mixcaps->fdwSupport     = micA.fdwSupport;
67         mixcaps->cDestinations  = micA.cDestinations;
68     }
69     return ret;
70 #endif
71     return MMSYSTEM_MAP_MSGERROR;
72 }
73
74 /**************************************************************************
75  *                              MMSYSTDRV_Mixer_MapCB
76  */
77 static  void                    MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
78 {
79     FIXME("NIY\n");
80 }
81
82 /* =================================
83  *   M I D I  I N    M A P P E R S
84  * ================================= */
85
86 /**************************************************************************
87  *                              MMSYSTDRV_MidiIn_Map16To32W             [internal]
88  */
89 static  MMSYSTEM_MapType        MMSYSTDRV_MidiIn_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
90 {
91     return MMSYSTEM_MAP_MSGERROR;
92 }
93
94 /**************************************************************************
95  *                              MMSYSTDRV_MidiIn_UnMap16To32W   [internal]
96  */
97 static  MMSYSTEM_MapType        MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
98 {
99     return MMSYSTEM_MAP_MSGERROR;
100 }
101
102 /**************************************************************************
103  *                              MMSYSTDRV_MidiIn_MapCB          [internal]
104  */
105 static  void                    MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
106 {
107     switch (uMsg) {
108     case MIM_OPEN:
109     case MIM_CLOSE:
110         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
111
112     case MIM_DATA:
113     case MIM_MOREDATA:
114     case MIM_ERROR:
115         /* dwParam1 & dwParam2 are data, nothing to do */
116         break;
117     case MIM_LONGDATA:
118     case MIM_LONGERROR:
119         {
120             LPMIDIHDR           mh32 = (LPMIDIHDR)(*dwParam1);
121             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
122             LPMIDIHDR           mh16 = MapSL(segmh16);
123
124             *dwParam1 = (DWORD)segmh16;
125             mh16->dwFlags = mh32->dwFlags;
126             mh16->dwBytesRecorded = mh32->dwBytesRecorded;
127             if (mh16->reserved >= sizeof(MIDIHDR))
128                 mh16->dwOffset = mh32->dwOffset;
129         }
130         break;
131     default:
132         ERR("Unknown msg %u\n", uMsg);
133     }
134 }
135
136 /* =================================
137  *   M I D I  O U T  M A P P E R S
138  * ================================= */
139
140 /**************************************************************************
141  *                              MMSYSTDRV_MidiOut_Map16To32W    [internal]
142  */
143 static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
144 {
145     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
146
147     switch (wMsg) {
148     case MODM_GETNUMDEVS:
149     case MODM_DATA:
150     case MODM_RESET:
151     case MODM_SETVOLUME:
152         ret = MMSYSTEM_MAP_OK;
153         break;
154
155     case MODM_OPEN:
156     case MODM_CLOSE:
157     case MODM_GETVOLUME:
158         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
159         break;
160
161     case MODM_GETDEVCAPS:
162         {
163             LPMIDIOUTCAPSW      moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW));
164             LPMIDIOUTCAPS16     moc16 = MapSL(*lpParam1);
165
166             if (moc32) {
167                 *(LPMIDIOUTCAPS16*)moc32 = moc16;
168                 moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16));
169                 *lpParam1 = (DWORD)moc32;
170                 *lpParam2 = sizeof(MIDIOUTCAPSW);
171
172                 ret = MMSYSTEM_MAP_OKMEM;
173             } else {
174                 ret = MMSYSTEM_MAP_NOMEM;
175             }
176         }
177         break;
178     case MODM_PREPARE:
179         {
180             LPMIDIHDR           mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
181             LPMIDIHDR           mh16 = MapSL(*lpParam1);
182
183             if (mh32) {
184                 *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1;
185                 mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR));
186                 mh32->lpData = MapSL((SEGPTR)mh16->lpData);
187                 mh32->dwBufferLength = mh16->dwBufferLength;
188                 mh32->dwBytesRecorded = mh16->dwBytesRecorded;
189                 mh32->dwUser = mh16->dwUser;
190                 mh32->dwFlags = mh16->dwFlags;
191                 /* FIXME: nothing on mh32->lpNext */
192                 /* could link the mh32->lpNext at this level for memory house keeping */
193                 mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh16->dwOffset : 0;
194                 mh16->lpNext = mh32; /* for reuse in unprepare and write */
195                 /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
196                 mh16->reserved = *lpParam2;
197                 *lpParam1 = (DWORD)mh32;
198                 *lpParam2 = sizeof(MIDIHDR);
199
200                 ret = MMSYSTEM_MAP_OKMEM;
201             } else {
202                 ret = MMSYSTEM_MAP_NOMEM;
203             }
204         }
205         break;
206     case MODM_UNPREPARE:
207     case MODM_LONGDATA:
208         {
209             LPMIDIHDR           mh16 = MapSL(*lpParam1);
210             LPMIDIHDR           mh32 = mh16->lpNext;
211
212             *lpParam1 = (DWORD)mh32;
213             *lpParam2 = sizeof(MIDIHDR);
214             /* dwBufferLength can be reduced between prepare & write */
215             if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
216                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
217                     mh32->dwBufferLength, mh16->dwBufferLength);
218             } else
219                 mh32->dwBufferLength = mh16->dwBufferLength;
220             ret = MMSYSTEM_MAP_OKMEM;
221         }
222         break;
223
224     case MODM_CACHEPATCHES:
225     case MODM_CACHEDRUMPATCHES:
226     default:
227         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
228         break;
229     }
230     return ret;
231 }
232
233 /**************************************************************************
234  *                              MMSYSTDRV_MidiOut_UnMap16To32W  [internal]
235  */
236 static  MMSYSTEM_MapType        MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
237 {
238     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
239
240     switch (wMsg) {
241     case MODM_GETNUMDEVS:
242     case MODM_DATA:
243     case MODM_RESET:
244     case MODM_SETVOLUME:
245         ret = MMSYSTEM_MAP_OK;
246         break;
247
248     case MODM_OPEN:
249     case MODM_CLOSE:
250     case MODM_GETVOLUME:
251         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
252         break;
253
254     case MODM_GETDEVCAPS:
255         {
256             LPMIDIOUTCAPSW              moc32 = (LPMIDIOUTCAPSW)(*lpParam1);
257             LPMIDIOUTCAPS16             moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
258
259             moc16->wMid                 = moc32->wMid;
260             moc16->wPid                 = moc32->wPid;
261             moc16->vDriverVersion       = moc32->vDriverVersion;
262             WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
263                                  sizeof(moc16->szPname), NULL, NULL );
264             moc16->wTechnology          = moc32->wTechnology;
265             moc16->wVoices              = moc32->wVoices;
266             moc16->wNotes               = moc32->wNotes;
267             moc16->wChannelMask         = moc32->wChannelMask;
268             moc16->dwSupport            = moc32->dwSupport;
269             HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
270             ret = MMSYSTEM_MAP_OK;
271         }
272         break;
273     case MODM_PREPARE:
274     case MODM_UNPREPARE:
275     case MODM_LONGDATA:
276         {
277             LPMIDIHDR           mh32 = (LPMIDIHDR)(*lpParam1);
278             LPMIDIHDR           mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
279
280             assert(mh16->lpNext == mh32);
281             mh16->dwBufferLength = mh32->dwBufferLength;
282             mh16->dwBytesRecorded = mh32->dwBytesRecorded;
283             mh16->dwUser = mh32->dwUser;
284             mh16->dwFlags = mh32->dwFlags;
285             if (mh16->reserved >= sizeof(MIDIHDR))
286                 mh16->dwOffset = mh32->dwOffset;
287
288             if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
289                 HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
290                 mh16->lpNext = 0;
291             }
292             ret = MMSYSTEM_MAP_OK;
293         }
294         break;
295
296     case MODM_CACHEPATCHES:
297     case MODM_CACHEDRUMPATCHES:
298     default:
299         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
300         break;
301     }
302     return ret;
303 }
304
305 /******************************************************************
306  *                                      MMSYSTDRV_MidiOut_MapCB
307  */
308 static  void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
309 {
310     switch (uMsg) {
311     case MOM_OPEN:
312     case MOM_CLOSE:
313         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
314         break;
315     case MOM_DONE:
316         {
317             /* initial map is: 16 => 32 */
318             LPMIDIHDR           mh32 = (LPMIDIHDR)(*dwParam1);
319             SEGPTR              segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
320             LPMIDIHDR           mh16 = MapSL(segmh16);
321
322             *dwParam1 = (DWORD)segmh16;
323             mh16->dwFlags = mh32->dwFlags;
324             if (mh16->reserved >= sizeof(MIDIHDR))
325                 mh16->dwOffset = mh32->dwOffset;
326         }
327         break;
328     case MOM_POSITIONCB:
329         FIXME("NIY\n");
330         /* FIXME: would require to recreate a 16bit MIDIHDR here */
331         *dwParam1 = *dwParam2 = 0;
332         break;
333     default:
334         ERR("Unknown msg %u\n", uMsg);
335     }
336 }
337
338 /* =================================
339  *   W A V E  I N    M A P P E R S
340  * ================================= */
341
342 /**************************************************************************
343  *                              MMSYSTDRV_WaveIn_Map16To32W             [internal]
344  */
345 static  MMSYSTEM_MapType        MMSYSTDRV_WaveIn_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
346 {
347     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
348
349     switch (wMsg) {
350     case WIDM_GETNUMDEVS:
351     case WIDM_RESET:
352     case WIDM_START:
353     case WIDM_STOP:
354         ret = MMSYSTEM_MAP_OK;
355         break;
356     case WIDM_OPEN:
357     case WIDM_CLOSE:
358         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
359         break;
360     case WIDM_GETDEVCAPS:
361         {
362             LPWAVEINCAPSW       wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW));
363             LPWAVEINCAPS16      wic16 = MapSL(*lpParam1);
364
365             if (wic32) {
366                 *(LPWAVEINCAPS16*)wic32 = wic16;
367                 wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
368                 *lpParam1 = (DWORD)wic32;
369                 *lpParam2 = sizeof(WAVEINCAPSW);
370
371                 ret = MMSYSTEM_MAP_OKMEM;
372             } else {
373                 ret = MMSYSTEM_MAP_NOMEM;
374             }
375         }
376         break;
377     case WIDM_GETPOS:
378         {
379             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
380             LPMMTIME16          mmt16 = MapSL(*lpParam1);
381
382             if (mmt32) {
383                 *(LPMMTIME16*)mmt32 = mmt16;
384                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
385
386                 mmt32->wType = mmt16->wType;
387                 *lpParam1 = (DWORD)mmt32;
388                 *lpParam2 = sizeof(MMTIME);
389
390                 ret = MMSYSTEM_MAP_OKMEM;
391             } else {
392                 ret = MMSYSTEM_MAP_NOMEM;
393             }
394         }
395         break;
396     case WIDM_PREPARE:
397         {
398             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
399             LPWAVEHDR           wh16 = MapSL(*lpParam1);
400
401             if (wh32) {
402                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
403                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
404                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
405                 wh32->dwBufferLength = wh16->dwBufferLength;
406                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
407                 wh32->dwUser = wh16->dwUser;
408                 wh32->dwFlags = wh16->dwFlags;
409                 wh32->dwLoops = wh16->dwLoops;
410                 /* FIXME: nothing on wh32->lpNext */
411                 /* could link the wh32->lpNext at this level for memory house keeping */
412                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
413                 *lpParam1 = (DWORD)wh32;
414                 *lpParam2 = sizeof(WAVEHDR);
415
416                 ret = MMSYSTEM_MAP_OKMEM;
417             } else {
418                 ret = MMSYSTEM_MAP_NOMEM;
419             }
420         }
421         break;
422     case WIDM_ADDBUFFER:
423     case WIDM_UNPREPARE:
424         {
425             LPWAVEHDR           wh16 = MapSL(*lpParam1);
426             LPWAVEHDR           wh32 = wh16->lpNext;
427
428             *lpParam1 = (DWORD)wh32;
429             *lpParam2 = sizeof(WAVEHDR);
430             /* dwBufferLength can be reduced between prepare & write */
431             if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
432                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
433                     wh32->dwBufferLength, wh16->dwBufferLength);
434             } else
435                 wh32->dwBufferLength = wh16->dwBufferLength;
436             ret = MMSYSTEM_MAP_OKMEM;
437         }
438         break;
439     case WIDM_MAPPER_STATUS:
440         /* just a single DWORD */
441         *lpParam2 = (DWORD)MapSL(*lpParam2);
442         ret = MMSYSTEM_MAP_OK;
443         break;
444     default:
445         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
446         break;
447     }
448     return ret;
449 }
450
451 /**************************************************************************
452  *                              MMSYSTDRV_WaveIn_UnMap16To32W   [internal]
453  */
454 static  MMSYSTEM_MapType        MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
455 {
456     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
457
458     switch (wMsg) {
459     case WIDM_GETNUMDEVS:
460     case WIDM_RESET:
461     case WIDM_START:
462     case WIDM_STOP:
463     case WIDM_MAPPER_STATUS:
464         ret = MMSYSTEM_MAP_OK;
465         break;
466     case WIDM_OPEN:
467     case WIDM_CLOSE:
468         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
469         break;
470     case WIDM_GETDEVCAPS:
471         {
472             LPWAVEINCAPSW               wic32 = (LPWAVEINCAPSW)(*lpParam1);
473             LPWAVEINCAPS16              wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
474
475             wic16->wMid = wic32->wMid;
476             wic16->wPid = wic32->wPid;
477             wic16->vDriverVersion = wic32->vDriverVersion;
478             WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
479                                  sizeof(wic16->szPname), NULL, NULL );
480             wic16->dwFormats = wic32->dwFormats;
481             wic16->wChannels = wic32->wChannels;
482             HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
483             ret = MMSYSTEM_MAP_OK;
484         }
485         break;
486     case WIDM_GETPOS:
487         {
488             LPMMTIME            mmt32 = (LPMMTIME)(*lpParam1);
489             LPMMTIME16          mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
490
491             MMSYSTEM_MMTIME32to16(mmt16, mmt32);
492             HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
493             ret = MMSYSTEM_MAP_OK;
494         }
495         break;
496     case WIDM_ADDBUFFER:
497     case WIDM_PREPARE:
498     case WIDM_UNPREPARE:
499         {
500             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
501             LPWAVEHDR           wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
502
503             assert(wh16->lpNext == wh32);
504             wh16->dwBufferLength = wh32->dwBufferLength;
505             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
506             wh16->dwUser = wh32->dwUser;
507             wh16->dwFlags = wh32->dwFlags;
508             wh16->dwLoops = wh32->dwLoops;
509
510             if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
511                 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
512                 wh16->lpNext = 0;
513             }
514             ret = MMSYSTEM_MAP_OK;
515         }
516         break;
517     default:
518         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
519         break;
520     }
521     return ret;
522 }
523
524 /**************************************************************************
525  *                              MMSYSTDRV_WaveIn_MapCB          [internal]
526  */
527 static  void    MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
528 {
529     switch (uMsg) {
530     case WIM_OPEN:
531     case WIM_CLOSE:
532         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
533         break;
534     case WIM_DATA:
535         {
536             /* initial map is: 16 => 32 */
537             LPWAVEHDR           wh32 = (LPWAVEHDR)(*dwParam1);
538             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
539             LPWAVEHDR           wh16 = MapSL(segwh16);
540
541             *dwParam1 = (DWORD)segwh16;
542             wh16->dwFlags = wh32->dwFlags;
543             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
544         }
545         break;
546     default:
547         ERR("Unknown msg %u\n", uMsg);
548     }
549 }
550
551 /* =================================
552  *   W A V E  O U T  M A P P E R S
553  * ================================= */
554
555 /**************************************************************************
556  *                              MMSYSTDRV_WaveOut_Map16To32W    [internal]
557  */
558 static  MMSYSTEM_MapType        MMSYSTDRV_WaveOut_Map16To32W  (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
559 {
560     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
561
562     switch (wMsg) {
563     /* nothing to do */
564     case WODM_BREAKLOOP:
565     case WODM_CLOSE:
566     case WODM_GETNUMDEVS:
567     case WODM_PAUSE:
568     case WODM_RESET:
569     case WODM_RESTART:
570     case WODM_SETPITCH:
571     case WODM_SETPLAYBACKRATE:
572     case WODM_SETVOLUME:
573         ret = MMSYSTEM_MAP_OK;
574         break;
575
576     case WODM_GETPITCH:
577     case WODM_GETPLAYBACKRATE:
578     case WODM_GETVOLUME:
579     case WODM_OPEN:
580         FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
581         break;
582
583     case WODM_GETDEVCAPS:
584         {
585             LPWAVEOUTCAPSW              woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW));
586             LPWAVEOUTCAPS16             woc16 = MapSL(*lpParam1);
587
588             if (woc32) {
589                 *(LPWAVEOUTCAPS16*)woc32 = woc16;
590                 woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
591                 *lpParam1 = (DWORD)woc32;
592                 *lpParam2 = sizeof(WAVEOUTCAPSW);
593
594                 ret = MMSYSTEM_MAP_OKMEM;
595             } else {
596                 ret = MMSYSTEM_MAP_NOMEM;
597             }
598         }
599         break;
600     case WODM_GETPOS:
601         {
602             LPMMTIME            mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
603             LPMMTIME16          mmt16 = MapSL(*lpParam1);
604
605             if (mmt32) {
606                 *(LPMMTIME16*)mmt32 = mmt16;
607                 mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
608
609                 mmt32->wType = mmt16->wType;
610                 *lpParam1 = (DWORD)mmt32;
611                 *lpParam2 = sizeof(MMTIME);
612
613                 ret = MMSYSTEM_MAP_OKMEM;
614             } else {
615                 ret = MMSYSTEM_MAP_NOMEM;
616             }
617         }
618         break;
619     case WODM_PREPARE:
620         {
621             LPWAVEHDR           wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
622             LPWAVEHDR           wh16 = MapSL(*lpParam1);
623
624             if (wh32) {
625                 *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
626                 wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
627                 wh32->lpData = MapSL((SEGPTR)wh16->lpData);
628                 wh32->dwBufferLength = wh16->dwBufferLength;
629                 wh32->dwBytesRecorded = wh16->dwBytesRecorded;
630                 wh32->dwUser = wh16->dwUser;
631                 wh32->dwFlags = wh16->dwFlags;
632                 wh32->dwLoops = wh16->dwLoops;
633                 /* FIXME: nothing on wh32->lpNext */
634                 /* could link the wh32->lpNext at this level for memory house keeping */
635                 wh16->lpNext = wh32; /* for reuse in unprepare and write */
636                 *lpParam1 = (DWORD)wh32;
637                 *lpParam2 = sizeof(WAVEHDR);
638
639                 ret = MMSYSTEM_MAP_OKMEM;
640             } else {
641                 ret = MMSYSTEM_MAP_NOMEM;
642             }
643         }
644         break;
645     case WODM_UNPREPARE:
646     case WODM_WRITE:
647         {
648             LPWAVEHDR           wh16 = MapSL(*lpParam1);
649             LPWAVEHDR           wh32 = wh16->lpNext;
650
651             *lpParam1 = (DWORD)wh32;
652             *lpParam2 = sizeof(WAVEHDR);
653             /* dwBufferLength can be reduced between prepare & write */
654             if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
655                 ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
656                     wh32->dwBufferLength, wh16->dwBufferLength);
657             } else
658                 wh32->dwBufferLength = wh16->dwBufferLength;
659             ret = MMSYSTEM_MAP_OKMEM;
660         }
661         break;
662     case WODM_MAPPER_STATUS:
663         *lpParam2 = (DWORD)MapSL(*lpParam2);
664         ret = MMSYSTEM_MAP_OK;
665         break;
666     default:
667         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
668         break;
669     }
670     return ret;
671 }
672
673 /**************************************************************************
674  *                              MMSYSTDRV_WaveOut_UnMap16To32W  [internal]
675  */
676 static  MMSYSTEM_MapType        MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
677 {
678     MMSYSTEM_MapType    ret = MMSYSTEM_MAP_MSGERROR;
679
680     switch (wMsg) {
681     /* nothing to do */
682     case WODM_BREAKLOOP:
683     case WODM_CLOSE:
684     case WODM_GETNUMDEVS:
685     case WODM_PAUSE:
686     case WODM_RESET:
687     case WODM_RESTART:
688     case WODM_SETPITCH:
689     case WODM_SETPLAYBACKRATE:
690     case WODM_SETVOLUME:
691     case WODM_MAPPER_STATUS:
692         ret = MMSYSTEM_MAP_OK;
693         break;
694
695     case WODM_GETPITCH:
696     case WODM_GETPLAYBACKRATE:
697     case WODM_GETVOLUME:
698     case WODM_OPEN:
699         FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
700         break;
701
702     case WODM_GETDEVCAPS:
703         {
704             LPWAVEOUTCAPSW              woc32 = (LPWAVEOUTCAPSW)(*lpParam1);
705             LPWAVEOUTCAPS16             woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
706
707             woc16->wMid = woc32->wMid;
708             woc16->wPid = woc32->wPid;
709             woc16->vDriverVersion = woc32->vDriverVersion;
710             WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
711                                  sizeof(woc16->szPname), NULL, NULL );
712             woc16->dwFormats = woc32->dwFormats;
713             woc16->wChannels = woc32->wChannels;
714             woc16->dwSupport = woc32->dwSupport;
715             HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
716             ret = MMSYSTEM_MAP_OK;
717         }
718         break;
719     case WODM_GETPOS:
720         {
721             LPMMTIME            mmt32 = (LPMMTIME)(*lpParam1);
722             LPMMTIME16          mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
723
724             MMSYSTEM_MMTIME32to16(mmt16, mmt32);
725             HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
726             ret = MMSYSTEM_MAP_OK;
727         }
728         break;
729     case WODM_PREPARE:
730     case WODM_UNPREPARE:
731     case WODM_WRITE:
732         {
733             LPWAVEHDR           wh32 = (LPWAVEHDR)(*lpParam1);
734             LPWAVEHDR           wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
735
736             assert(wh16->lpNext == wh32);
737             wh16->dwBufferLength = wh32->dwBufferLength;
738             wh16->dwBytesRecorded = wh32->dwBytesRecorded;
739             wh16->dwUser = wh32->dwUser;
740             wh16->dwFlags = wh32->dwFlags;
741             wh16->dwLoops = wh32->dwLoops;
742
743             if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
744                 HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
745                 wh16->lpNext = 0;
746             }
747             ret = MMSYSTEM_MAP_OK;
748         }
749         break;
750     default:
751         FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
752         break;
753     }
754     return ret;
755 }
756
757 /**************************************************************************
758  *                              MMDRV_WaveOut_Callback          [internal]
759  */
760 static  void    MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
761 {
762     switch (uMsg) {
763     case WOM_OPEN:
764     case WOM_CLOSE:
765         /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
766         break;
767     case WOM_DONE:
768         {
769             /* initial map is: 16 => 32 */
770             LPWAVEHDR           wh32 = (LPWAVEHDR)(*dwParam1);
771             SEGPTR              segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
772             LPWAVEHDR           wh16 = MapSL(segwh16);
773
774             *dwParam1 = (DWORD)segwh16;
775             wh16->dwFlags = wh32->dwFlags;
776         }
777         break;
778     default:
779         ERR("Unknown msg %u\n", uMsg);
780     }
781 }
782
783 /* ###################################################
784  * #                DRIVER THUNKING                  #
785  * ###################################################
786  */
787 typedef MMSYSTEM_MapType        (*MMSYSTDRV_MAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2);
788 typedef MMSYSTEM_MapType        (*MMSYSTDRV_UNMAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret);
789 typedef void                    (*MMSYSTDRV_MAPCB)(DWORD wMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2);
790
791 #include <pshpack1.h>
792 #define MMSYSTDRV_MAX_THUNKS      32
793
794 static struct mmsystdrv_thunk
795 {
796     BYTE                        popl_eax;       /* popl  %eax (return address) */
797     BYTE                        pushl_this;     /* pushl this (this very thunk) */
798     struct mmsystdrv_thunk*     this;
799     BYTE                        pushl_eax;      /* pushl %eax */
800     BYTE                        jmp;            /* ljmp MMDRV_Callback3216 */
801     DWORD                       callback3216;
802     DWORD                       callback;       /* callback value (function, window, event...) */
803     DWORD                       flags;          /* flags to control callback value (CALLBACK_???) */
804     void*                       hMmdrv;         /* Handle to 32bit mmdrv object */
805     enum MMSYSTEM_DriverType    kind;
806 } *MMSYSTDRV_Thunks;
807
808 #include <poppack.h>
809
810 static struct MMSYSTDRV_Type
811 {
812     MMSYSTDRV_MAPMSG    mapmsg16to32W;
813     MMSYSTDRV_UNMAPMSG  unmapmsg16to32W;
814     MMSYSTDRV_MAPCB     mapcb;
815 } MMSYSTEM_DriversType[MMSYSTDRV_MAX] =
816 {
817     {MMSYSTDRV_Mixer_Map16To32W,   MMSYSTDRV_Mixer_UnMap16To32W,   MMSYSTDRV_Mixer_MapCB},
818     {MMSYSTDRV_MidiIn_Map16To32W,  MMSYSTDRV_MidiIn_UnMap16To32W,  MMSYSTDRV_MidiIn_MapCB},
819     {MMSYSTDRV_MidiOut_Map16To32W, MMSYSTDRV_MidiOut_UnMap16To32W, MMSYSTDRV_MidiOut_MapCB},
820     {MMSYSTDRV_WaveIn_Map16To32W,  MMSYSTDRV_WaveIn_UnMap16To32W,  MMSYSTDRV_WaveIn_MapCB},
821     {MMSYSTDRV_WaveOut_Map16To32W, MMSYSTDRV_WaveOut_UnMap16To32W, MMSYSTDRV_WaveOut_MapCB},
822 };
823
824 /******************************************************************
825  *              MMSYSTDRV_Callback3216
826  *
827  */
828 static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, HDRVR hDev,
829                                                DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
830                                                DWORD_PTR dwParam2)
831 {
832     WORD args[8];
833
834     assert(thunk->kind < MMSYSTDRV_MAX);
835     assert(MMSYSTEM_DriversType[thunk->kind].mapcb);
836
837     MMSYSTEM_DriversType[thunk->kind].mapcb(wMsg, &dwUser, &dwParam1, &dwParam2);
838
839     switch (thunk->flags & CALLBACK_TYPEMASK) {
840     case CALLBACK_NULL:
841         TRACE("Null !\n");
842         break;
843     case CALLBACK_WINDOW:
844         TRACE("Window(%04X) handle=%p!\n", thunk->callback, hDev);
845         PostMessageA((HWND)thunk->callback, wMsg, (WPARAM)hDev, dwParam1);
846         break;
847     case CALLBACK_TASK: /* aka CALLBACK_THREAD */
848         TRACE("Task(%04x) !\n", thunk->callback);
849         PostThreadMessageA(thunk->callback, wMsg, (WPARAM)hDev, dwParam1);
850         break;
851     case CALLBACK_FUNCTION:
852         /* 16 bit func, call it */
853         TRACE("Function (16 bit) %x!\n", thunk->callback);
854
855         args[7] = HDRVR_16(hDev);
856         args[6] = wMsg;
857         args[5] = HIWORD(dwUser);
858         args[4] = LOWORD(dwUser);
859         args[3] = HIWORD(dwParam1);
860         args[2] = LOWORD(dwParam1);
861         args[1] = HIWORD(dwParam2);
862         args[0] = LOWORD(dwParam2);
863         return WOWCallback16Ex(thunk->callback, WCB16_PASCAL, sizeof(args), args, NULL);
864     case CALLBACK_EVENT:
865         TRACE("Event(%08x) !\n", thunk->callback);
866         SetEvent((HANDLE)thunk->callback);
867         break;
868     default:
869         WARN("Unknown callback type %lx\n", thunk->flags & CALLBACK_TYPEMASK);
870         return FALSE;
871     }
872     TRACE("Done\n");
873     return TRUE;
874 }
875
876 /******************************************************************
877  *              MMSYSTDRV_AddThunk
878  *
879  */
880 struct mmsystdrv_thunk*       MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, enum MMSYSTEM_DriverType kind)
881 {
882     struct mmsystdrv_thunk* thunk;
883
884     EnterCriticalSection(&mmdrv_cs);
885     if (!MMSYSTDRV_Thunks)
886     {
887         MMSYSTDRV_Thunks = VirtualAlloc(NULL, MMSYSTDRV_MAX_THUNKS * sizeof(*MMSYSTDRV_Thunks),
888                                         MEM_COMMIT, PAGE_EXECUTE_READWRITE);
889         if (!MMSYSTDRV_Thunks)
890         {
891             LeaveCriticalSection(&mmdrv_cs);
892             return NULL;
893         }
894         for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
895         {
896             thunk->popl_eax     = 0x58;   /* popl  %eax */
897             thunk->pushl_this   = 0x68;   /* pushl this */
898             thunk->this         = thunk;
899             thunk->pushl_eax    = 0x50;   /* pushl %eax */
900             thunk->jmp          = 0xe9;   /* jmp MMDRV_Callback3216 */
901             thunk->callback3216 = (char *)MMSYSTDRV_Callback3216 - (char *)(&thunk->callback3216 + 1);
902             thunk->callback     = 0;
903             thunk->flags        = CALLBACK_NULL;
904             thunk->hMmdrv       = NULL;
905             thunk->kind         = MMSYSTDRV_MAX;
906         }
907     }
908     for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
909     {
910         if (thunk->callback == 0 && thunk->hMmdrv == NULL)
911         {
912             thunk->callback = callback;
913             thunk->flags = flags;
914             thunk->hMmdrv = NULL;
915             thunk->kind = kind;
916             LeaveCriticalSection(&mmdrv_cs);
917             return thunk;
918         }
919     }
920     LeaveCriticalSection(&mmdrv_cs);
921     FIXME("Out of mmdrv-thunks. Bump MMDRV_MAX_THUNKS\n");
922     return NULL;
923 }
924
925 /******************************************************************
926  *              MMSYSTDRV_FindHandle
927  *
928  * Must be called with lock set
929  */
930 static void*    MMSYSTDRV_FindHandle(void* h)
931 {
932     struct mmsystdrv_thunk* thunk;
933
934     for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
935     {
936         if (thunk->hMmdrv == h)
937         {
938             if (thunk->kind >= MMSYSTDRV_MAX) FIXME("Kind isn't properly initialized %x\n", thunk->kind);
939             return thunk;
940         }
941     }
942     return NULL;
943 }
944
945 /******************************************************************
946  *              MMSYSTDRV_SetHandle
947  *
948  */
949 void    MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h)
950 {
951     if (MMSYSTDRV_FindHandle(h)) FIXME("Already has a thunk for this handle %p!!!\n", h);
952     thunk->hMmdrv = h;
953 }
954
955 /******************************************************************
956  *              MMSYSTDRV_DeleteThunk
957  */
958 void    MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk)
959 {
960     thunk->callback = 0;
961     thunk->flags = CALLBACK_NULL;
962     thunk->hMmdrv = NULL;
963     thunk->kind = MMSYSTDRV_MAX;
964 }
965
966 /******************************************************************
967  *              MMSYSTDRV_CloseHandle
968  */
969 void    MMSYSTDRV_CloseHandle(void* h)
970 {
971     struct mmsystdrv_thunk* thunk;
972
973     EnterCriticalSection(&mmdrv_cs);
974     if ((thunk = MMSYSTDRV_FindHandle(h)))
975     {
976         MMSYSTDRV_DeleteThunk(thunk);
977     }
978     LeaveCriticalSection(&mmdrv_cs);
979 }
980
981 /******************************************************************
982  *              MMSYSTDRV_Message
983  */
984 DWORD   MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2)
985 {
986     struct mmsystdrv_thunk*     thunk = MMSYSTDRV_FindHandle(h);
987     struct MMSYSTDRV_Type*      drvtype;
988     MMSYSTEM_MapType            map;
989     DWORD                       ret;
990
991     if (!thunk) return MMSYSERR_INVALHANDLE;
992     drvtype = &MMSYSTEM_DriversType[thunk->kind];
993
994     map = drvtype->mapmsg16to32W(msg, &param1, &param2);
995     switch (map) {
996     case MMSYSTEM_MAP_NOMEM:
997         ret = MMSYSERR_NOMEM;
998         break;
999     case MMSYSTEM_MAP_MSGERROR:
1000         FIXME("NIY: no conversion yet 16->32 kind=%u msg=%u\n", thunk->kind, msg);
1001         ret = MMSYSERR_ERROR;
1002         break;
1003     case MMSYSTEM_MAP_OK:
1004     case MMSYSTEM_MAP_OKMEM:
1005         TRACE("Calling message(msg=%u p1=0x%08lx p2=0x%08lx)\n",
1006               msg, param1, param2);
1007         switch (thunk->kind)
1008         {
1009         case MMSYSTDRV_MIXER:   ret = mixerMessage  (h, msg, param1, param2); break;
1010         case MMSYSTDRV_MIDIIN:
1011             switch (msg)
1012             {
1013             case MIDM_ADDBUFFER: ret = midiInAddBuffer(h, (LPMIDIHDR)param1, param2); break;
1014             case MIDM_PREPARE:   ret = midiInPrepareHeader(h, (LPMIDIHDR)param1, param2); break;
1015             case MIDM_UNPREPARE: ret = midiInUnprepareHeader(h, (LPMIDIHDR)param1, param2); break;
1016             default:             ret = midiInMessage(h, msg, param1, param2); break;
1017             }
1018             break;
1019         case MMSYSTDRV_MIDIOUT:
1020             switch (msg)
1021             {
1022             case MODM_PREPARE:   ret = midiOutPrepareHeader(h, (LPMIDIHDR)param1, param2); break;
1023             case MODM_UNPREPARE: ret = midiOutUnprepareHeader(h, (LPMIDIHDR)param1, param2); break;
1024             case MODM_LONGDATA:  ret = midiOutLongMsg(h, (LPMIDIHDR)param1, param2); break;
1025             default:             ret = midiOutMessage(h, msg, param1, param2); break;
1026             }
1027             break;
1028         case MMSYSTDRV_WAVEIN:
1029             switch (msg)
1030             {
1031             case WIDM_ADDBUFFER: ret = waveInAddBuffer(h, (LPWAVEHDR)param1, param2); break;
1032             case WIDM_PREPARE:   ret = waveInPrepareHeader(h, (LPWAVEHDR)param1, param2); break;
1033             case WIDM_UNPREPARE: ret = waveInUnprepareHeader(h, (LPWAVEHDR)param1, param2); break;
1034             default:             ret = waveInMessage(h, msg, param1, param2); break;
1035             }
1036             break;
1037         case MMSYSTDRV_WAVEOUT:
1038             switch (msg)
1039             {
1040             case WODM_PREPARE:   ret = waveOutPrepareHeader(h, (LPWAVEHDR)param1, param2); break;
1041             case WODM_UNPREPARE: ret = waveOutUnprepareHeader(h, (LPWAVEHDR)param1, param2); break;
1042             case WODM_WRITE:     ret = waveOutWrite(h, (LPWAVEHDR)param1, param2); break;
1043             default:             ret = waveOutMessage(h, msg, param1, param2); break;
1044             }
1045             break;
1046         default: ret = MMSYSERR_INVALHANDLE; break; /* should never be reached */
1047         }
1048         if (map == MMSYSTEM_MAP_OKMEM)
1049             drvtype->unmapmsg16to32W(msg, &param1, &param2, ret);
1050         break;
1051     default:
1052         FIXME("NIY\n");
1053         ret = MMSYSERR_NOTSUPPORTED;
1054         break;
1055     }
1056     return ret;
1057 }