?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcp140: Implement _Stat and _Lstat.
[wine.git] / dlls / mmsystem.dll16 / mci16.c
blobb356a4431bac6f8ed4e9aaabed366598013f472a
1 /*
2 * MMSYSTEM functions
3 *
4 * Copyright 1993 Martin Ayotte
5 * 1998-2003,2009 Eric Pouech
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23 #include <string.h>
24 #include <stdio.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "mmsystem.h"
29 #include "winternl.h"
30 #include "wownt32.h"
31 #include "winnls.h"
32
33 #include "wine/winuser16.h"
34 #include "winemm16.h"
35 #include "digitalv.h"
36
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
40
41 /**************************************************************************
42 * MCI_MessageToString [internal]
43 */
44 static const char* MCI_MessageToString(UINT wMsg)
45 {
46 static char buffer[100];
47
48 #define CASE(s) case (s): return #s
49
50 switch (wMsg) {
51 CASE(DRV_LOAD);
52 CASE(DRV_ENABLE);
53 CASE(DRV_OPEN);
54 CASE(DRV_CLOSE);
55 CASE(DRV_DISABLE);
56 CASE(DRV_FREE);
57 CASE(DRV_CONFIGURE);
58 CASE(DRV_QUERYCONFIGURE);
59 CASE(DRV_INSTALL);
60 CASE(DRV_REMOVE);
61 CASE(DRV_EXITSESSION);
62 CASE(DRV_EXITAPPLICATION);
63 CASE(DRV_POWER);
64 CASE(MCI_BREAK);
65 CASE(MCI_CLOSE);
66 CASE(MCI_CLOSE_DRIVER);
67 CASE(MCI_COPY);
68 CASE(MCI_CUE);
69 CASE(MCI_CUT);
70 CASE(MCI_DELETE);
71 CASE(MCI_ESCAPE);
72 CASE(MCI_FREEZE);
73 CASE(MCI_PAUSE);
74 CASE(MCI_PLAY);
75 CASE(MCI_GETDEVCAPS);
76 CASE(MCI_INFO);
77 CASE(MCI_LOAD);
78 CASE(MCI_OPEN);
79 CASE(MCI_OPEN_DRIVER);
80 CASE(MCI_PASTE);
81 CASE(MCI_PUT);
82 CASE(MCI_REALIZE);
83 CASE(MCI_RECORD);
84 CASE(MCI_RESUME);
85 CASE(MCI_SAVE);
86 CASE(MCI_SEEK);
87 CASE(MCI_SET);
88 CASE(MCI_SOUND);
89 CASE(MCI_SPIN);
90 CASE(MCI_STATUS);
91 CASE(MCI_STEP);
92 CASE(MCI_STOP);
93 CASE(MCI_SYSINFO);
94 CASE(MCI_UNFREEZE);
95 CASE(MCI_UPDATE);
96 CASE(MCI_WHERE);
97 CASE(MCI_WINDOW);
98 /* constants for digital video */
99 CASE(MCI_CAPTURE);
100 CASE(MCI_MONITOR);
101 CASE(MCI_RESERVE);
102 CASE(MCI_SETAUDIO);
103 CASE(MCI_SIGNAL);
104 CASE(MCI_SETVIDEO);
105 CASE(MCI_QUALITY);
106 CASE(MCI_LIST);
107 CASE(MCI_UNDO);
108 CASE(MCI_CONFIGURE);
109 CASE(MCI_RESTORE);
110 #undef CASE
111 default:
112 sprintf(buffer, "MCI_<<%04X>>", wMsg);
113 return buffer;
114 }
115 }
116
117 static LPWSTR MCI_strdupAtoW( LPCSTR str )
118 {
119 LPWSTR ret;
120 INT len;
121
122 if (!str) return NULL;
123 len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
124 ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
125 if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
126 return ret;
127 }
128
129 /**************************************************************************
130 * MCI_MapMsg16To32W [internal]
131 */
132 static MMSYSTEM_MapType MCI_MapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
133 {
134 if (*lParam == 0)
135 return MMSYSTEM_MAP_OK;
136 /* FIXME: to add also (with seg/linear modifications to do):
137 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
138 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
139 */
140 switch (wMsg) {
141 /* case MCI_CAPTURE */
142 case MCI_CLOSE:
143 case MCI_CLOSE_DRIVER:
144 case MCI_CONFIGURE:
145 case MCI_COPY:
146 case MCI_CUE:
147 case MCI_CUT:
148 case MCI_DELETE:
149 case MCI_GETDEVCAPS:
150 /* case MCI_INDEX: */
151 /* case MCI_MARK: */
152 /* case MCI_MONITOR: */
153 case MCI_PASTE:
154 case MCI_PAUSE:
155 case MCI_PLAY:
156 case MCI_REALIZE:
157 case MCI_RECORD:
158 case MCI_RESUME:
159 case MCI_SEEK:
160 case MCI_SET:
161 /* case MCI_SETTIMECODE:*/
162 /* case MCI_SIGNAL:*/
163 case MCI_SPIN:
164 case MCI_STEP:
165 case MCI_STOP:
166 /* case MCI_UNDO: */
167 case MCI_UPDATE:
168 *lParam = (DWORD)MapSL(*lParam);
169 return MMSYSTEM_MAP_OK;
170 case MCI_WHERE:
171 case MCI_FREEZE:
172 case MCI_UNFREEZE:
173 case MCI_PUT:
174 {
175 LPMCI_DGV_RECT_PARMS mdrp32 = HeapAlloc(GetProcessHeap(), 0,
176 sizeof(LPMCI_DGV_RECT_PARMS16) + sizeof(MCI_DGV_RECT_PARMS));
177 LPMCI_DGV_RECT_PARMS16 mdrp16 = MapSL(*lParam);
178 if (mdrp32) {
179 *(LPMCI_DGV_RECT_PARMS16*)(mdrp32) = mdrp16;
180 mdrp32 = (LPMCI_DGV_RECT_PARMS)((char*)mdrp32 + sizeof(LPMCI_DGV_RECT_PARMS16));
181 mdrp32->dwCallback = mdrp16->dwCallback;
182 mdrp32->rc.left = mdrp16->rc.left;
183 mdrp32->rc.top = mdrp16->rc.top;
184 mdrp32->rc.right = mdrp16->rc.right;
185 mdrp32->rc.bottom = mdrp16->rc.bottom;
186 } else {
187 return MMSYSTEM_MAP_NOMEM;
188 }
189 *lParam = (DWORD)mdrp32;
190 }
191 return MMSYSTEM_MAP_OKMEM;
192 case MCI_STATUS:
193 {
194 if (dwFlags & (MCI_DGV_STATUS_REFERENCE | MCI_DGV_STATUS_DISKSPACE)) {
195 LPMCI_DGV_STATUS_PARMSW mdsp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
196 sizeof(LPMCI_DGV_STATUS_PARMS16) + sizeof(MCI_DGV_STATUS_PARMSW));
197 LPMCI_DGV_STATUS_PARMS16 mdsp16 = MapSL(*lParam);
198 if (mdsp32w) {
199 *(LPMCI_DGV_STATUS_PARMS16*)(mdsp32w) = mdsp16;
200 mdsp32w = (LPMCI_DGV_STATUS_PARMSW)((char*)mdsp32w + sizeof(LPMCI_DGV_STATUS_PARMS16));
201 mdsp32w->dwCallback = mdsp16->dwCallback;
202 mdsp32w->dwReturn = mdsp16->dwReturn;
203 mdsp32w->dwItem = mdsp16->dwItem;
204 mdsp32w->dwTrack = mdsp16->dwTrack;
205 if (dwFlags & MCI_DGV_STATUS_DISKSPACE)
206 mdsp32w->lpstrDrive = MCI_strdupAtoW(MapSL(mdsp16->lpstrDrive));
207 if (dwFlags & MCI_DGV_STATUS_REFERENCE)
208 mdsp32w->dwReference = mdsp16->dwReference;
209 *lParam = (DWORD)mdsp32w;
210 } else {
211 return MMSYSTEM_MAP_NOMEM;
212 }
213 } else {
214 *lParam = (DWORD)MapSL(*lParam);
215 return MMSYSTEM_MAP_OK;
216 }
217 }
218 return MMSYSTEM_MAP_OKMEM;
219 case MCI_WINDOW:
220 {
221 LPMCI_OVLY_WINDOW_PARMSW mowp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MCI_OVLY_WINDOW_PARMSW));
222 LPMCI_OVLY_WINDOW_PARMS16 mowp16 = MapSL(*lParam);
223 if (mowp32w) {
224 mowp32w->dwCallback = mowp16->dwCallback;
225 mowp32w->hWnd = HWND_32(mowp16->hWnd);
226 mowp32w->nCmdShow = mowp16->nCmdShow;
227 if (dwFlags & (MCI_DGV_WINDOW_TEXT | MCI_OVLY_WINDOW_TEXT))
228 mowp32w->lpstrText = MCI_strdupAtoW(MapSL(mowp16->lpstrText));
229 } else {
230 return MMSYSTEM_MAP_NOMEM;
231 }
232 *lParam = (DWORD)mowp32w;
233 }
234 return MMSYSTEM_MAP_OKMEM;
235 case MCI_BREAK:
236 {
237 LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
238 LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
239
240 if (mbp32) {
241 mbp32->dwCallback = mbp16->dwCallback;
242 mbp32->nVirtKey = mbp16->nVirtKey;
243 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
244 } else {
245 return MMSYSTEM_MAP_NOMEM;
246 }
247 *lParam = (DWORD)mbp32;
248 }
249 return MMSYSTEM_MAP_OKMEM;
250 case MCI_ESCAPE:
251 {
252 LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
253 LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
254
255 if (mvep32w) {
256 mvep32w->dwCallback = mvep16->dwCallback;
257 mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
258 } else {
259 return MMSYSTEM_MAP_NOMEM;
260 }
261 *lParam = (DWORD)mvep32w;
262 }
263 return MMSYSTEM_MAP_OKMEM;
264 case MCI_INFO:
265 {
266 LPMCI_DGV_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_DGV_INFO_PARMS16) + sizeof(MCI_DGV_INFO_PARMSW));
267 LPMCI_DGV_INFO_PARMS16 mip16 = MapSL(*lParam);
268
269 if (mip32w) {
270 *(LPMCI_DGV_INFO_PARMS16*)(mip32w) = mip16;
271 mip32w = (LPMCI_DGV_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_DGV_INFO_PARMS16));
272 mip32w->dwCallback = mip16->dwCallback;
273 mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
274 mip32w->dwRetSize = mip16->dwRetSize;
275 if (dwFlags & MCI_DGV_INFO_ITEM)
276 mip32w->dwItem = mip16->dwItem;
277 } else {
278 return MMSYSTEM_MAP_NOMEM;
279 }
280 *lParam = (DWORD)mip32w;
281 }
282 return MMSYSTEM_MAP_OKMEM;
283 case MCI_OPEN:
284 case MCI_OPEN_DRIVER:
285 {
286 LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_ANIM_OPEN_PARMSW));
287 LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
288
289 if (mop32w) {
290 *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
291 mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
292 mop32w->dwCallback = mop16->dwCallback;
293 mop32w->wDeviceID = mop16->wDeviceID;
294 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
295 mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
296 else
297 mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType;
298 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
299 mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
300 else
301 mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
302 if( ( dwFlags & MCI_OPEN_ALIAS))
303 mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
304 else
305 mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
306 /* copy extended information if any...
307 * FIXME: this may seg fault if initial structure does not contain them and
308 * the reads after msip16 fail under LDT limits...
309 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
310 * should not take care of extended parameters, and should be used by MCI_Open
311 * to fetch uDevType. When, this is known, the mapping for sending the
312 * MCI_OPEN_DRIVER shall be done depending on uDevType.
313 */
314 if (HIWORD(dwFlags))
315 memcpy(mop32w + 1, mop16 + 1, sizeof(MCI_ANIM_OPEN_PARMS16) - sizeof(MCI_OPEN_PARMS16));
316 } else {
317 return MMSYSTEM_MAP_NOMEM;
318 }
319 *lParam = (DWORD)mop32w;
320 }
321 return MMSYSTEM_MAP_OKMEM;
322 case MCI_SYSINFO:
323 {
324 MCI_SYSINFO_PARMSW *origmsip32w;
325 MCI_SYSINFO_PARMSW *msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_OPEN_PARMS16 *) + sizeof(MCI_SYSINFO_PARMSW));
326 MCI_SYSINFO_PARMS16 *msip16 = MapSL(*lParam);
327
328 if (!msip32w)
329 return MMSYSTEM_MAP_NOMEM;
330
331 origmsip32w = msip32w;
332 *(MCI_SYSINFO_PARMS16 **)msip32w = msip16;
333 msip32w = (MCI_SYSINFO_PARMSW *)((char *)msip32w + sizeof(MCI_OPEN_PARMS16 *));
334 msip32w->dwCallback = msip16->dwCallback;
335 msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, (dwFlags & MCI_SYSINFO_QUANTITY) ?
336 sizeof(DWORD) :
337 msip16->dwRetSize * sizeof(WCHAR));
338 if (!msip32w->lpstrReturn)
339 {
340 HeapFree(GetProcessHeap(), 0, origmsip32w);
341 return MMSYSTEM_MAP_NOMEM;
342 }
343 msip32w->dwRetSize = (dwFlags & MCI_SYSINFO_QUANTITY) ? sizeof(DWORD) : msip16->dwRetSize;
344 msip32w->dwNumber = msip16->dwNumber;
345 msip32w->wDeviceType = msip16->wDeviceType;
346
347 *lParam = (DWORD)msip32w;
348 }
349 return MMSYSTEM_MAP_OKMEM;
350 case MCI_SOUND:
351 {
352 LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
353 LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
354
355 if (mbp32) {
356 mbp32->dwCallback = mbp16->dwCallback;
357 mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
358 } else {
359 return MMSYSTEM_MAP_NOMEM;
360 }
361 *lParam = (DWORD)mbp32;
362 }
363 return MMSYSTEM_MAP_OKMEM;
364 case DRV_LOAD:
365 case DRV_ENABLE:
366 case DRV_OPEN:
367 case DRV_CLOSE:
368 case DRV_DISABLE:
369 case DRV_FREE:
370 case DRV_CONFIGURE:
371 case DRV_QUERYCONFIGURE:
372 case DRV_INSTALL:
373 case DRV_REMOVE:
374 case DRV_EXITSESSION:
375 case DRV_EXITAPPLICATION:
376 case DRV_POWER:
377 FIXME("This is a hack\n");
378 return MMSYSTEM_MAP_OK;
379 default:
380 FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
381 }
382 return MMSYSTEM_MAP_MSGERROR;
383 }
384
385 /**************************************************************************
386 * MCI_UnMapMsg16To32W [internal]
387 */
388 static void MCI_UnMapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR lParam, DWORD result)
389 {
390 switch (wMsg) {
391 case MCI_WHERE:
392 case MCI_FREEZE:
393 case MCI_UNFREEZE:
394 case MCI_PUT:
395 if (lParam) {
396 LPMCI_DGV_RECT_PARMS mdrp32 = (LPMCI_DGV_RECT_PARMS)lParam;
397 char *base = (char*)lParam - sizeof(LPMCI_DGV_RECT_PARMS16);
398 LPMCI_DGV_RECT_PARMS16 mdrp16 = *(LPMCI_DGV_RECT_PARMS16*)base;
399 mdrp16->rc.left = mdrp32->rc.left;
400 mdrp16->rc.top = mdrp32->rc.top;
401 mdrp16->rc.right = mdrp32->rc.right;
402 mdrp16->rc.bottom = mdrp32->rc.bottom;
403 HeapFree(GetProcessHeap(), 0, base);
404 }
405 break;
406 case MCI_STATUS:
407 if (lParam) {
408 LPMCI_DGV_STATUS_PARMSW mdsp32w = (LPMCI_DGV_STATUS_PARMSW)lParam;
409 char *base = (char*)lParam - sizeof(LPMCI_DGV_STATUS_PARMS16);
410 LPMCI_DGV_STATUS_PARMS16 mdsp16 = *(LPMCI_DGV_STATUS_PARMS16*)base;
411 mdsp16->dwReturn = mdsp32w->dwReturn;
412 HeapFree(GetProcessHeap(), 0, (LPVOID)mdsp32w->lpstrDrive);
413 HeapFree(GetProcessHeap(), 0, base);
414 }
415 break;
416 case MCI_WINDOW:
417 if (lParam) {
418 LPMCI_OVLY_WINDOW_PARMSW mowp32w = (LPMCI_OVLY_WINDOW_PARMSW)lParam;
419 HeapFree(GetProcessHeap(), 0, (LPVOID)mowp32w->lpstrText);
420 HeapFree(GetProcessHeap(), 0, mowp32w);
421 }
422 break;
423 case MCI_BREAK:
424 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
425 break;
426 case MCI_ESCAPE:
427 if (lParam) {
428 LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
429 HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
430 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
431 }
432 break;
433 case MCI_INFO:
434 if (lParam) {
435 LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
436 char *base = (char*)lParam - sizeof(LPMCI_INFO_PARMS16);
437 LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)base;
438
439 if (result == MMSYSERR_NOERROR)
440 WideCharToMultiByte(CP_ACP, 0,
441 mip32w->lpstrReturn, mip32w->dwRetSize,
442 MapSL(mip16->lpstrReturn), mip16->dwRetSize,
443 NULL, NULL);
444 mip16->dwRetSize = mip32w->dwRetSize; /* never update prior to NT? */
445 HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn);
446 HeapFree(GetProcessHeap(), 0, base);
447 }
448 break;
449 case MCI_SYSINFO:
450 if (lParam) {
451 MCI_SYSINFO_PARMSW *msip32w = (MCI_SYSINFO_PARMSW *)lParam;
452 char *base = (char*)lParam - sizeof(MCI_SYSINFO_PARMS16 *);
453 MCI_SYSINFO_PARMS16 *msip16 = *(MCI_SYSINFO_PARMS16 **)base;
454
455 if (dwFlags & MCI_SYSINFO_QUANTITY) {
456 DWORD *quantity = MapSL(msip16->lpstrReturn);
457
458 *quantity = *(DWORD *)msip32w->lpstrReturn;
459 }
460 else if (result == MMSYSERR_NOERROR) {
461 WideCharToMultiByte(CP_ACP, 0,
462 msip32w->lpstrReturn, msip32w->dwRetSize,
463 MapSL(msip16->lpstrReturn), msip16->dwRetSize,
464 NULL, NULL);
465 }
466
467 HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn);
468 HeapFree(GetProcessHeap(), 0, base);
469 }
470 break;
471 case MCI_SOUND:
472 if (lParam) {
473 LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
474 HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
475 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
476 }
477 break;
478 case MCI_OPEN:
479 case MCI_OPEN_DRIVER:
480 if (lParam) {
481 LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
482 char *base = (char*)lParam - sizeof(LPMCI_OPEN_PARMS16);
483 LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)base;
484
485 mop16->wDeviceID = mop32w->wDeviceID;
486 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
487 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
488 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
489 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
490 if( ( dwFlags & MCI_OPEN_ALIAS))
491 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
492 HeapFree(GetProcessHeap(), 0, base);
493 }
494 break;
495 default:
496 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
497 }
498 }
499
500 /* ###################################################
501 * # MCI #
502 * ###################################################
503 */
504
505 #include <pshpack1.h>
506 #define MCI_MAX_THUNKS 32
507
508 static struct mci_thunk
509 {
510 BYTE popl_eax; /* popl %eax (return address) */
511 BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
512 YIELDPROC16 yield16;
513 BYTE pushl_eax; /* pushl %eax */
514 BYTE jmp; /* ljmp MCI_Yield1632 */
515 DWORD callback;
516 MCIDEVICEID id;
517 } *MCI_Thunks;
518
519 #include <poppack.h>
520
521 static CRITICAL_SECTION mci_cs;
522 static CRITICAL_SECTION_DEBUG mci_critsect_debug =
523 {
524 0, 0, &mci_cs,
525 { &mci_critsect_debug.ProcessLocksList, &mci_critsect_debug.ProcessLocksList },
526 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mci_cs") }
527 };
528 static CRITICAL_SECTION mci_cs = { &mci_critsect_debug, -1, 0, 0, 0, 0 };
529
530 static UINT MCI_Yield1632(DWORD pfn16, MCIDEVICEID id, DWORD yield_data)
531 {
532 WORD args[8];
533
534 if (!pfn16)
535 {
536 MSG msg;
537 PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
538 return 0;
539 }
540
541 /* 16 bit func, call it */
542 TRACE("Function (16 bit) !\n");
543
544 args[2] = (MCIDEVICEID16)id;
545 args[1] = HIWORD(yield_data);
546 args[0] = LOWORD(yield_data);
547 return WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
548 }
549
550 /******************************************************************
551 * MCI_AddThunk
552 *
553 */
554 static struct mci_thunk* MCI_AddThunk(MCIDEVICEID id, YIELDPROC16 pfn16)
555 {
556 struct mci_thunk* thunk;
557
558 if (!MCI_Thunks)
559 {
560 MCI_Thunks = VirtualAlloc(NULL, MCI_MAX_THUNKS * sizeof(*MCI_Thunks), MEM_COMMIT,
561 PAGE_EXECUTE_READWRITE);
562 if (!MCI_Thunks) return NULL;
563 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
564 {
565 thunk->popl_eax = 0x58; /* popl %eax */
566 thunk->pushl_func = 0x68; /* pushl $pfn16 */
567 thunk->yield16 = 0;
568 thunk->pushl_eax = 0x50; /* pushl %eax */
569 thunk->jmp = 0xe9; /* jmp MCI_Yield1632 */
570 thunk->callback = (char *)MCI_Yield1632 - (char *)(&thunk->callback + 1);
571 thunk->id = 0;
572 }
573 }
574 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
575 {
576 if (thunk->yield16 == 0)
577 {
578 thunk->yield16 = pfn16;
579 thunk->id = id;
580 return thunk;
581 }
582 }
583 FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n");
584 return NULL;
585 }
586
587 /******************************************************************
588 * MCI_HasThunk
589 *
590 */
591 static struct mci_thunk* MCI_HasThunk(YIELDPROC pfn)
592 {
593 struct mci_thunk* thunk;
594
595 if (!MCI_Thunks) return NULL;
596 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
597 {
598 if ((YIELDPROC)thunk == pfn) return thunk;
599 }
600 return NULL;
601 }
602
603 /**************************************************************************
604 * mciSetYieldProc [MMSYSTEM.714]
605 */
606 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
607 {
608 struct mci_thunk* thunk;
609 BOOL ret;
610
611 TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
612
613 if (!(thunk = MCI_AddThunk(uDeviceID, fpYieldProc)))
614 return FALSE;
615 ret = mciSetYieldProc(uDeviceID, (YIELDPROC)thunk, dwYieldData);
616 if (!ret) thunk->yield16 = NULL;
617 return ret;
618 }
619
620 /**************************************************************************
621 * mciGetYieldProc [MMSYSTEM.716]
622 */
623 YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
624 {
625 YIELDPROC yield;
626 DWORD data;
627 struct mci_thunk* thunk;
628
629 TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
630
631 yield = mciGetYieldProc(uDeviceID, &data);
632 if (!yield || !(thunk = MCI_HasThunk(yield))) return NULL;
633
634 if (lpdwYieldData) *lpdwYieldData = data;
635 return thunk->yield16;
636 }
637
638 /**************************************************************************
639 * mciGetErrorString [MMSYSTEM.706]
640 */
641 BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
642 {
643 return mciGetErrorStringA(wError, lpstrBuffer, uLength);
644 }
645
646 /**************************************************************************
647 * mciDriverNotify [MMSYSTEM.711]
648 */
649 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
650 {
651 TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
652
653 return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID);
654 }
655
656 /**************************************************************************
657 * mciGetDriverData [MMSYSTEM.708]
658 */
659 DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
660 {
661 return mciGetDriverData(uDeviceID);
662 }
663
664 /**************************************************************************
665 * mciSetDriverData [MMSYSTEM.707]
666 */
667 BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
668 {
669 return mciSetDriverData(uDeviceID, data);
670 }
671
672 /**************************************************************************
673 * mciSendCommand [MMSYSTEM.701]
674 */
675 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD p2)
676 {
677 DWORD dwRet;
678 BOOL to32;
679 DWORD_PTR dwParam2 = p2;
680
681 TRACE("(%04X, %s, %08X, %08lX)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
682
683 switch (wMsg) {
684 case MCI_CLOSE:
685 case MCI_OPEN:
686 case MCI_SYSINFO:
687 case MCI_BREAK:
688 case MCI_SOUND:
689 to32 = TRUE;
690 break;
691 default:
692 /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be
693 * doing 16=>32W, then 32W=>16 conversions.
694 * We could directly call the 16bit driver if we had the information.
695 */
696 to32 = TRUE;
697 }
698 if (to32) {
699 MMSYSTEM_MapType res;
700
701 dwRet = MCIERR_INVALID_DEVICE_ID;
702
703 switch (res = MCI_MapMsg16To32W(wMsg, dwParam1, &dwParam2)) {
704 case MMSYSTEM_MAP_MSGERROR:
705 dwRet = MCIERR_DRIVER_INTERNAL;
706 break;
707 case MMSYSTEM_MAP_NOMEM:
708 TRACE("Problem mapping %s from 16 to 32\n", MCI_MessageToString(wMsg));
709 dwRet = MCIERR_OUT_OF_MEMORY;
710 break;
711 case MMSYSTEM_MAP_OK:
712 case MMSYSTEM_MAP_OKMEM:
713 dwRet = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
714 if (res == MMSYSTEM_MAP_OKMEM)
715 MCI_UnMapMsg16To32W(wMsg, dwParam1, dwParam2, dwRet);
716 break;
717 }
718 }
719 else
720 {
721 #if 0
722 if (wDevID == MCI_ALL_DEVICE_ID) {
723 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
724 dwRet = MCIERR_CANNOT_USE_ALL;
725 } else {
726 dwRet = SendDriverMessage(hdrv, wMsg, dwParam1, dwParam2);
727 }
728 #endif
729 }
730 if (wMsg == MCI_CLOSE && dwRet == 0 && MCI_Thunks)
731 {
732 /* free yield thunks, if any */
733 unsigned i;
734 for (i = 0; i < MCI_MAX_THUNKS; i++)
735 {
736 if (MCI_Thunks[i].id == wDevID)
737 MCI_Thunks[i].yield16 = NULL;
738 }
739 }
740 return dwRet;
741 }
742
743 /**************************************************************************
744 * mciGetDeviceID [MMSYSTEM.703]
745 */
746 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
747 {
748 TRACE("(\"%s\")\n", lpstrName);
749
750 return mciGetDeviceIDA(lpstrName);
751 }
752
753 /**************************************************************************
754 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
755 */
756 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
757 {
758 return mciGetDeviceIDFromElementIDA(dwElementID, lpstrType);
759 }
760
761 /**************************************************************************
762 * mciGetCreatorTask [MMSYSTEM.717]
763 */
764 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
765 {
766 return HTASK_16(mciGetCreatorTask(uDeviceID));
767 }
768
769 /**************************************************************************
770 * mciDriverYield [MMSYSTEM.710]
771 */
772 UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
773 {
774 return mciDriverYield(uDeviceID);
775 }
776
777 /**************************************************************************
778 * mciSendString [MMSYSTEM.702]
779 */
780 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
781 UINT16 uRetLen, HWND16 hwndCallback)
782 {
783 return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback));
784 }
785
786 /**************************************************************************
787 * mciLoadCommandResource [MMSYSTEM.705]
788 */
789 UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type)
790 {
791 TRACE("(%04x, %s, %x)!\n", hInst, resname, type);
792 return MCI_NO_COMMAND_TABLE;
793 }
794
795 /**************************************************************************
796 * mciFreeCommandResource [MMSYSTEM.713]
797 */
798 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
799 {
800 TRACE("(%04x)!\n", uTable);
801
802 return FALSE;
803 }
804
805 /**************************************************************************
806 * mciExecute [MMSYSTEM.712]
807 */
808 BOOL16 WINAPI mciExecute16(LPCSTR lpstrCommand)
809 {
810 return mciExecute(lpstrCommand);
811 }
Windows API implementation