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