?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Add IAuthenticateEx interface definition.
[wine.git] / dlls / mmsystem.dll16 / mci16.c
blobd7a356d527b4a82fbb428cf1ae73f6a1064aef66
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_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE, MCI_SETTUNER
138 */
139 switch (wMsg) {
140 /* case MCI_CAPTURE */
141 case MCI_CLOSE:
142 case MCI_CLOSE_DRIVER:
143 case MCI_CONFIGURE:
144 case MCI_COPY:
145 case MCI_CUE:
146 case MCI_CUT:
147 case MCI_DELETE:
148 case MCI_GETDEVCAPS:
149 /* case MCI_INDEX: */
150 case MCI_LIST:
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_SETAUDIO:
162 case MCI_SETVIDEO:
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 if (dwFlags & MCI_DGV_STATUS_REFERENCE)
210 mdsp32w->dwReference = mdsp16->dwReference;
211 *lParam = (DWORD)mdsp32w;
212 } else {
213 return MMSYSTEM_MAP_NOMEM;
214 }
215 } else {
216 *lParam = (DWORD)MapSL(*lParam);
217 return MMSYSTEM_MAP_OK;
218 }
219 }
220 return MMSYSTEM_MAP_OKMEM;
221 case MCI_WINDOW:
222 {
223 LPMCI_OVLY_WINDOW_PARMSW mowp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MCI_OVLY_WINDOW_PARMSW));
224 LPMCI_OVLY_WINDOW_PARMS16 mowp16 = MapSL(*lParam);
225 if (mowp32w) {
226 mowp32w->dwCallback = mowp16->dwCallback;
227 mowp32w->hWnd = HWND_32(mowp16->hWnd);
228 mowp32w->nCmdShow = mowp16->nCmdShow;
229 if (dwFlags & (MCI_DGV_WINDOW_TEXT | MCI_OVLY_WINDOW_TEXT))
230 mowp32w->lpstrText = MCI_strdupAtoW(MapSL(mowp16->lpstrText));
231 } else {
232 return MMSYSTEM_MAP_NOMEM;
233 }
234 *lParam = (DWORD)mowp32w;
235 }
236 return MMSYSTEM_MAP_OKMEM;
237 case MCI_BREAK:
238 {
239 LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
240 LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
241
242 if (mbp32) {
243 mbp32->dwCallback = mbp16->dwCallback;
244 mbp32->nVirtKey = mbp16->nVirtKey;
245 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
246 } else {
247 return MMSYSTEM_MAP_NOMEM;
248 }
249 *lParam = (DWORD)mbp32;
250 }
251 return MMSYSTEM_MAP_OKMEM;
252 case MCI_ESCAPE:
253 {
254 LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
255 LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
256
257 if (mvep32w) {
258 mvep32w->dwCallback = mvep16->dwCallback;
259 mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
260 } else {
261 return MMSYSTEM_MAP_NOMEM;
262 }
263 *lParam = (DWORD)mvep32w;
264 }
265 return MMSYSTEM_MAP_OKMEM;
266 case MCI_INFO:
267 {
268 LPMCI_DGV_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_DGV_INFO_PARMS16) + sizeof(MCI_DGV_INFO_PARMSW));
269 LPMCI_DGV_INFO_PARMS16 mip16 = MapSL(*lParam);
270
271 if (mip32w) {
272 *(LPMCI_DGV_INFO_PARMS16*)(mip32w) = mip16;
273 mip32w = (LPMCI_DGV_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_DGV_INFO_PARMS16));
274 mip32w->dwCallback = mip16->dwCallback;
275 mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
276 mip32w->dwRetSize = mip16->dwRetSize;
277 if (dwFlags & MCI_DGV_INFO_ITEM)
278 mip32w->dwItem = mip16->dwItem;
279 } else {
280 return MMSYSTEM_MAP_NOMEM;
281 }
282 *lParam = (DWORD)mip32w;
283 }
284 return MMSYSTEM_MAP_OKMEM;
285 case MCI_OPEN:
286 case MCI_OPEN_DRIVER:
287 {
288 LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_ANIM_OPEN_PARMSW));
289 LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
290
291 if (mop32w) {
292 *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
293 mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
294 mop32w->dwCallback = mop16->dwCallback;
295 mop32w->wDeviceID = mop16->wDeviceID;
296 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
297 mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
298 else
299 mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType;
300 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
301 mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
302 else
303 mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
304 if( ( dwFlags & MCI_OPEN_ALIAS))
305 mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
306 else
307 mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
308 /* copy extended information if any...
309 * FIXME: this may seg fault if initial structure does not contain them and
310 * the reads after msip16 fail under LDT limits...
311 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
312 * should not take care of extended parameters, and should be used by MCI_Open
313 * to fetch uDevType. When, this is known, the mapping for sending the
314 * MCI_OPEN_DRIVER shall be done depending on uDevType.
315 */
316 if (HIWORD(dwFlags))
317 memcpy(mop32w + 1, mop16 + 1, sizeof(MCI_ANIM_OPEN_PARMS16) - sizeof(MCI_OPEN_PARMS16));
318 } else {
319 return MMSYSTEM_MAP_NOMEM;
320 }
321 *lParam = (DWORD)mop32w;
322 }
323 return MMSYSTEM_MAP_OKMEM;
324 case MCI_SYSINFO:
325 {
326 MCI_SYSINFO_PARMSW *origmsip32w;
327 MCI_SYSINFO_PARMSW *msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_OPEN_PARMS16 *) + sizeof(MCI_SYSINFO_PARMSW));
328 MCI_SYSINFO_PARMS16 *msip16 = MapSL(*lParam);
329
330 if (!msip32w)
331 return MMSYSTEM_MAP_NOMEM;
332
333 origmsip32w = msip32w;
334 *(MCI_SYSINFO_PARMS16 **)msip32w = msip16;
335 msip32w = (MCI_SYSINFO_PARMSW *)((char *)msip32w + sizeof(MCI_OPEN_PARMS16 *));
336 msip32w->dwCallback = msip16->dwCallback;
337 msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, (dwFlags & MCI_SYSINFO_QUANTITY) ?
338 sizeof(DWORD) :
339 msip16->dwRetSize * sizeof(WCHAR));
340 if (!msip32w->lpstrReturn)
341 {
342 HeapFree(GetProcessHeap(), 0, origmsip32w);
343 return MMSYSTEM_MAP_NOMEM;
344 }
345 msip32w->dwRetSize = (dwFlags & MCI_SYSINFO_QUANTITY) ? sizeof(DWORD) : msip16->dwRetSize;
346 msip32w->dwNumber = msip16->dwNumber;
347 msip32w->wDeviceType = msip16->wDeviceType;
348
349 *lParam = (DWORD)msip32w;
350 }
351 return MMSYSTEM_MAP_OKMEM;
352 case MCI_SOUND:
353 {
354 LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
355 LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
356
357 if (mbp32) {
358 mbp32->dwCallback = mbp16->dwCallback;
359 mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
360 } else {
361 return MMSYSTEM_MAP_NOMEM;
362 }
363 *lParam = (DWORD)mbp32;
364 }
365 return MMSYSTEM_MAP_OKMEM;
366 case DRV_LOAD:
367 case DRV_ENABLE:
368 case DRV_OPEN:
369 case DRV_CLOSE:
370 case DRV_DISABLE:
371 case DRV_FREE:
372 case DRV_CONFIGURE:
373 case DRV_QUERYCONFIGURE:
374 case DRV_INSTALL:
375 case DRV_REMOVE:
376 case DRV_EXITSESSION:
377 case DRV_EXITAPPLICATION:
378 case DRV_POWER:
379 FIXME("This is a hack\n");
380 return MMSYSTEM_MAP_OK;
381 default:
382 FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
383 }
384 return MMSYSTEM_MAP_MSGERROR;
385 }
386
387 /**************************************************************************
388 * MCI_UnMapMsg16To32W [internal]
389 */
390 static void MCI_UnMapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR lParam, DWORD result)
391 {
392 switch (wMsg) {
393 case MCI_WHERE:
394 case MCI_FREEZE:
395 case MCI_UNFREEZE:
396 case MCI_PUT:
397 if (lParam) {
398 LPMCI_DGV_RECT_PARMS mdrp32 = (LPMCI_DGV_RECT_PARMS)lParam;
399 char *base = (char*)lParam - sizeof(LPMCI_DGV_RECT_PARMS16);
400 LPMCI_DGV_RECT_PARMS16 mdrp16 = *(LPMCI_DGV_RECT_PARMS16*)base;
401 mdrp16->rc.left = mdrp32->rc.left;
402 mdrp16->rc.top = mdrp32->rc.top;
403 mdrp16->rc.right = mdrp32->rc.right;
404 mdrp16->rc.bottom = mdrp32->rc.bottom;
405 HeapFree(GetProcessHeap(), 0, base);
406 }
407 break;
408 case MCI_STATUS:
409 if (lParam) {
410 LPMCI_DGV_STATUS_PARMSW mdsp32w = (LPMCI_DGV_STATUS_PARMSW)lParam;
411 char *base = (char*)lParam - sizeof(LPMCI_DGV_STATUS_PARMS16);
412 LPMCI_DGV_STATUS_PARMS16 mdsp16 = *(LPMCI_DGV_STATUS_PARMS16*)base;
413 mdsp16->dwReturn = mdsp32w->dwReturn;
414 HeapFree(GetProcessHeap(), 0, (LPVOID)mdsp32w->lpstrDrive);
415 HeapFree(GetProcessHeap(), 0, base);
416 }
417 break;
418 case MCI_WINDOW:
419 if (lParam) {
420 LPMCI_OVLY_WINDOW_PARMSW mowp32w = (LPMCI_OVLY_WINDOW_PARMSW)lParam;
421 HeapFree(GetProcessHeap(), 0, (LPVOID)mowp32w->lpstrText);
422 HeapFree(GetProcessHeap(), 0, mowp32w);
423 }
424 break;
425 case MCI_BREAK:
426 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
427 break;
428 case MCI_ESCAPE:
429 if (lParam) {
430 LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
431 HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
432 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
433 }
434 break;
435 case MCI_INFO:
436 if (lParam) {
437 LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
438 char *base = (char*)lParam - sizeof(LPMCI_INFO_PARMS16);
439 LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)base;
440
441 if (result == MMSYSERR_NOERROR)
442 WideCharToMultiByte(CP_ACP, 0,
443 mip32w->lpstrReturn, mip32w->dwRetSize,
444 MapSL(mip16->lpstrReturn), mip16->dwRetSize,
445 NULL, NULL);
446 mip16->dwRetSize = mip32w->dwRetSize; /* never update prior to NT? */
447 HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn);
448 HeapFree(GetProcessHeap(), 0, base);
449 }
450 break;
451 case MCI_SYSINFO:
452 if (lParam) {
453 MCI_SYSINFO_PARMSW *msip32w = (MCI_SYSINFO_PARMSW *)lParam;
454 char *base = (char*)lParam - sizeof(MCI_SYSINFO_PARMS16 *);
455 MCI_SYSINFO_PARMS16 *msip16 = *(MCI_SYSINFO_PARMS16 **)base;
456
457 if (dwFlags & MCI_SYSINFO_QUANTITY) {
458 DWORD *quantity = MapSL(msip16->lpstrReturn);
459
460 *quantity = *(DWORD *)msip32w->lpstrReturn;
461 }
462 else if (result == MMSYSERR_NOERROR) {
463 WideCharToMultiByte(CP_ACP, 0,
464 msip32w->lpstrReturn, msip32w->dwRetSize,
465 MapSL(msip16->lpstrReturn), msip16->dwRetSize,
466 NULL, NULL);
467 }
468
469 HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn);
470 HeapFree(GetProcessHeap(), 0, base);
471 }
472 break;
473 case MCI_SOUND:
474 if (lParam) {
475 LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
476 HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
477 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
478 }
479 break;
480 case MCI_OPEN:
481 case MCI_OPEN_DRIVER:
482 if (lParam) {
483 LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
484 char *base = (char*)lParam - sizeof(LPMCI_OPEN_PARMS16);
485 LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)base;
486
487 mop16->wDeviceID = mop32w->wDeviceID;
488 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
489 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
490 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
491 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
492 if( ( dwFlags & MCI_OPEN_ALIAS))
493 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
494 HeapFree(GetProcessHeap(), 0, base);
495 }
496 break;
497 default:
498 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
499 }
500 }
501
502 /* ###################################################
503 * # MCI #
504 * ###################################################
505 */
506
507 #include <pshpack1.h>
508 #define MCI_MAX_THUNKS 32
509
510 static struct mci_thunk
511 {
512 BYTE popl_eax; /* popl %eax (return address) */
513 BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
514 YIELDPROC16 yield16;
515 BYTE pushl_eax; /* pushl %eax */
516 BYTE jmp; /* ljmp MCI_Yield1632 */
517 DWORD callback;
518 MCIDEVICEID id;
519 } *MCI_Thunks;
520
521 #include <poppack.h>
522
523 static CRITICAL_SECTION mci_cs;
524 static CRITICAL_SECTION_DEBUG mci_critsect_debug =
525 {
526 0, 0, &mci_cs,
527 { &mci_critsect_debug.ProcessLocksList, &mci_critsect_debug.ProcessLocksList },
528 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mci_cs") }
529 };
530 static CRITICAL_SECTION mci_cs = { &mci_critsect_debug, -1, 0, 0, 0, 0 };
531
532 static UINT MCI_Yield1632(DWORD pfn16, MCIDEVICEID id, DWORD yield_data)
533 {
534 WORD args[8];
535
536 if (!pfn16)
537 {
538 MSG msg;
539 PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
540 return 0;
541 }
542
543 /* 16 bit func, call it */
544 TRACE("Function (16 bit) !\n");
545
546 args[2] = (MCIDEVICEID16)id;
547 args[1] = HIWORD(yield_data);
548 args[0] = LOWORD(yield_data);
549 return WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
550 }
551
552 /******************************************************************
553 * MCI_AddThunk
554 *
555 */
556 static struct mci_thunk* MCI_AddThunk(MCIDEVICEID id, YIELDPROC16 pfn16)
557 {
558 struct mci_thunk* thunk;
559
560 if (!MCI_Thunks)
561 {
562 MCI_Thunks = VirtualAlloc(NULL, MCI_MAX_THUNKS * sizeof(*MCI_Thunks), MEM_COMMIT,
563 PAGE_EXECUTE_READWRITE);
564 if (!MCI_Thunks) return NULL;
565 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
566 {
567 thunk->popl_eax = 0x58; /* popl %eax */
568 thunk->pushl_func = 0x68; /* pushl $pfn16 */
569 thunk->yield16 = 0;
570 thunk->pushl_eax = 0x50; /* pushl %eax */
571 thunk->jmp = 0xe9; /* jmp MCI_Yield1632 */
572 thunk->callback = (char *)MCI_Yield1632 - (char *)(&thunk->callback + 1);
573 thunk->id = 0;
574 }
575 }
576 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
577 {
578 if (thunk->yield16 == 0)
579 {
580 thunk->yield16 = pfn16;
581 thunk->id = id;
582 return thunk;
583 }
584 }
585 FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n");
586 return NULL;
587 }
588
589 /******************************************************************
590 * MCI_HasThunk
591 *
592 */
593 static struct mci_thunk* MCI_HasThunk(YIELDPROC pfn)
594 {
595 struct mci_thunk* thunk;
596
597 if (!MCI_Thunks) return NULL;
598 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
599 {
600 if ((YIELDPROC)thunk == pfn) return thunk;
601 }
602 return NULL;
603 }
604
605 /**************************************************************************
606 * mciSetYieldProc [MMSYSTEM.714]
607 */
608 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
609 {
610 struct mci_thunk* thunk;
611 BOOL ret;
612
613 TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
614
615 if (!(thunk = MCI_AddThunk(uDeviceID, fpYieldProc)))
616 return FALSE;
617 ret = mciSetYieldProc(uDeviceID, (YIELDPROC)thunk, dwYieldData);
618 if (!ret) thunk->yield16 = NULL;
619 return ret;
620 }
621
622 /**************************************************************************
623 * mciGetYieldProc [MMSYSTEM.716]
624 */
625 YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
626 {
627 YIELDPROC yield;
628 DWORD data;
629 struct mci_thunk* thunk;
630
631 TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
632
633 yield = mciGetYieldProc(uDeviceID, &data);
634 if (!yield || !(thunk = MCI_HasThunk(yield))) return NULL;
635
636 if (lpdwYieldData) *lpdwYieldData = data;
637 return thunk->yield16;
638 }
639
640 /**************************************************************************
641 * mciGetErrorString [MMSYSTEM.706]
642 */
643 BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
644 {
645 return mciGetErrorStringA(wError, lpstrBuffer, uLength);
646 }
647
648 /**************************************************************************
649 * mciDriverNotify [MMSYSTEM.711]
650 */
651 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
652 {
653 TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
654
655 return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID);
656 }
657
658 /**************************************************************************
659 * mciGetDriverData [MMSYSTEM.708]
660 */
661 DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
662 {
663 return mciGetDriverData(uDeviceID);
664 }
665
666 /**************************************************************************
667 * mciSetDriverData [MMSYSTEM.707]
668 */
669 BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
670 {
671 return mciSetDriverData(uDeviceID, data);
672 }
673
674 /**************************************************************************
675 * mciSendCommand [MMSYSTEM.701]
676 */
677 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD p2)
678 {
679 DWORD dwRet;
680 BOOL to32;
681 DWORD_PTR dwParam2 = p2;
682
683 TRACE("(%04X, %s, %08X, %08lX)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
684
685 switch (wMsg) {
686 case MCI_CLOSE:
687 case MCI_OPEN:
688 case MCI_SYSINFO:
689 case MCI_BREAK:
690 case MCI_SOUND:
691 to32 = TRUE;
692 break;
693 default:
694 /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be
695 * doing 16=>32W, then 32W=>16 conversions.
696 * We could directly call the 16bit driver if we had the information.
697 */
698 to32 = TRUE;
699 }
700 if (to32) {
701 MMSYSTEM_MapType res;
702
703 dwRet = MCIERR_INVALID_DEVICE_ID;
704
705 switch (res = MCI_MapMsg16To32W(wMsg, dwParam1, &dwParam2)) {
706 case MMSYSTEM_MAP_MSGERROR:
707 dwRet = MCIERR_DRIVER_INTERNAL;
708 break;
709 case MMSYSTEM_MAP_NOMEM:
710 TRACE("Problem mapping %s from 16 to 32\n", MCI_MessageToString(wMsg));
711 dwRet = MCIERR_OUT_OF_MEMORY;
712 break;
713 case MMSYSTEM_MAP_OK:
714 case MMSYSTEM_MAP_OKMEM:
715 dwRet = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
716 if (res == MMSYSTEM_MAP_OKMEM)
717 MCI_UnMapMsg16To32W(wMsg, dwParam1, dwParam2, dwRet);
718 break;
719 }
720 }
721 else
722 {
723 #if 0
724 if (wDevID == MCI_ALL_DEVICE_ID) {
725 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
726 dwRet = MCIERR_CANNOT_USE_ALL;
727 } else {
728 dwRet = SendDriverMessage(hdrv, wMsg, dwParam1, dwParam2);
729 }
730 #endif
731 }
732 if (wMsg == MCI_CLOSE && dwRet == 0 && MCI_Thunks)
733 {
734 /* free yield thunks, if any */
735 unsigned i;
736 for (i = 0; i < MCI_MAX_THUNKS; i++)
737 {
738 if (MCI_Thunks[i].id == wDevID)
739 MCI_Thunks[i].yield16 = NULL;
740 }
741 }
742 return dwRet;
743 }
744
745 /**************************************************************************
746 * mciGetDeviceID [MMSYSTEM.703]
747 */
748 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
749 {
750 TRACE("(\"%s\")\n", lpstrName);
751
752 return mciGetDeviceIDA(lpstrName);
753 }
754
755 /**************************************************************************
756 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
757 */
758 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
759 {
760 return mciGetDeviceIDFromElementIDA(dwElementID, lpstrType);
761 }
762
763 /**************************************************************************
764 * mciGetCreatorTask [MMSYSTEM.717]
765 */
766 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
767 {
768 return HTASK_16(mciGetCreatorTask(uDeviceID));
769 }
770
771 /**************************************************************************
772 * mciDriverYield [MMSYSTEM.710]
773 */
774 UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
775 {
776 return mciDriverYield(uDeviceID);
777 }
778
779 /**************************************************************************
780 * mciSendString [MMSYSTEM.702]
781 */
782 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
783 UINT16 uRetLen, HWND16 hwndCallback)
784 {
785 return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback));
786 }
787
788 /**************************************************************************
789 * mciLoadCommandResource [MMSYSTEM.705]
790 */
791 UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type)
792 {
793 TRACE("(%04x, %s, %x)!\n", hInst, resname, type);
794 return MCI_NO_COMMAND_TABLE;
795 }
796
797 /**************************************************************************
798 * mciFreeCommandResource [MMSYSTEM.713]
799 */
800 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
801 {
802 TRACE("(%04x)!\n", uTable);
803
804 return FALSE;
805 }
806
807 /**************************************************************************
808 * mciExecute [MMSYSTEM.712]
809 */
810 BOOL16 WINAPI mciExecute16(LPCSTR lpstrCommand)
811 {
812 return mciExecute(lpstrCommand);
813 }
Windows API implementation