?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Moved SystemHeap allocations to the process heap.
[wine.git] / dlls / winmm / mci.c
blob737652e9960a5b553ec85330a07d5f9308c5bf17
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * MCI internal functions
5 *
6 * Copyright 1998/1999 Eric Pouech
7 */
8
9 #include <stdlib.h>
10 #include <stdio.h>
11 #include <string.h>
12
13 #include "winbase.h"
14 #include "windef.h"
15 #include "wingdi.h"
16 #include "winuser.h"
17 #include "heap.h"
18 #include "driver.h"
19 #include "winemm.h"
20 #include "selectors.h"
21 #include "digitalv.h"
22 #include "options.h"
23 #include "wine/winbase16.h"
24 #include "debugtools.h"
25
26 DEFAULT_DEBUG_CHANNEL(mci);
27
28 static int MCI_InstalledCount;
29 static LPSTR MCI_lpInstallNames = NULL;
30
31 /* First MCI valid device ID (0 means error) */
32 #define MCI_MAGIC 0x0001
33
34 /**************************************************************************
35 * MCI_GetDriver [internal]
36 */
37 LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID)
38 {
39 LPWINE_MCIDRIVER wmd = 0;
40 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
41
42 EnterCriticalSection(&iData->cs);
43 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
44 if (wmd->wDeviceID == wDevID)
45 break;
46 }
47 LeaveCriticalSection(&iData->cs);
48 return wmd;
49 }
50
51 /**************************************************************************
52 * MCI_GetDriverFromString [internal]
53 */
54 UINT MCI_GetDriverFromString(LPCSTR lpstrName)
55 {
56 LPWINE_MCIDRIVER wmd;
57 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
58 UINT ret = 0;
59
60 if (!lpstrName)
61 return 0;
62
63 if (!lstrcmpiA(lpstrName, "ALL"))
64 return MCI_ALL_DEVICE_ID;
65
66 EnterCriticalSection(&iData->cs);
67 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
68 if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) {
69 ret = wmd->wDeviceID;
70 break;
71 }
72
73 if (wmd->lpstrDeviceType && strcmp(wmd->lpstrDeviceType, lpstrName) == 0) {
74 ret = wmd->wDeviceID;
75 break;
76 }
77
78 if (wmd->lpstrAlias && strcmp(wmd->lpstrAlias, lpstrName) == 0) {
79 ret = wmd->wDeviceID;
80 break;
81 }
82 }
83 LeaveCriticalSection(&iData->cs);
84
85 return ret;
86 }
87
88 /**************************************************************************
89 * MCI_MessageToString [internal]
90 */
91 const char* MCI_MessageToString(UINT16 wMsg)
92 {
93 static char buffer[100];
94
95 #define CASE(s) case (s): return #s
96
97 switch (wMsg) {
98 CASE(MCI_BREAK);
99 CASE(MCI_CLOSE);
100 CASE(MCI_CLOSE_DRIVER);
101 CASE(MCI_COPY);
102 CASE(MCI_CUE);
103 CASE(MCI_CUT);
104 CASE(MCI_DELETE);
105 CASE(MCI_ESCAPE);
106 CASE(MCI_FREEZE);
107 CASE(MCI_PAUSE);
108 CASE(MCI_PLAY);
109 CASE(MCI_GETDEVCAPS);
110 CASE(MCI_INFO);
111 CASE(MCI_LOAD);
112 CASE(MCI_OPEN);
113 CASE(MCI_OPEN_DRIVER);
114 CASE(MCI_PASTE);
115 CASE(MCI_PUT);
116 CASE(MCI_REALIZE);
117 CASE(MCI_RECORD);
118 CASE(MCI_RESUME);
119 CASE(MCI_SAVE);
120 CASE(MCI_SEEK);
121 CASE(MCI_SET);
122 CASE(MCI_SPIN);
123 CASE(MCI_STATUS);
124 CASE(MCI_STEP);
125 CASE(MCI_STOP);
126 CASE(MCI_SYSINFO);
127 CASE(MCI_UNFREEZE);
128 CASE(MCI_UPDATE);
129 CASE(MCI_WHERE);
130 CASE(MCI_WINDOW);
131 /* constants for digital video */
132 CASE(MCI_CAPTURE);
133 CASE(MCI_MONITOR);
134 CASE(MCI_RESERVE);
135 CASE(MCI_SETAUDIO);
136 CASE(MCI_SIGNAL);
137 CASE(MCI_SETVIDEO);
138 CASE(MCI_QUALITY);
139 CASE(MCI_LIST);
140 CASE(MCI_UNDO);
141 CASE(MCI_CONFIGURE);
142 CASE(MCI_RESTORE);
143 #undef CASE
144 default:
145 sprintf(buffer, "MCI_<<%04X>>", wMsg);
146 return buffer;
147 }
148 }
149
150 /**************************************************************************
151 * MCI_GetDevTypeFromFileName [internal]
152 */
153 static DWORD MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len)
154 {
155 LPSTR tmp;
156
157 if ((tmp = strrchr(fileName, '.'))) {
158 GetProfileStringA("mci extensions", tmp + 1, "*", buf, len);
159 if (strcmp(buf, "*") != 0) {
160 return 0;
161 }
162 TRACE("No [mci extensions] entry for '%s' found.\n", tmp);
163 }
164 return MCIERR_EXTENSION_NOT_FOUND;
165 }
166
167 #define MAX_MCICMDTABLE 20
168 #define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE
169
170 typedef struct tagWINE_MCICMDTABLE {
171 HANDLE hMem;
172 UINT uDevType;
173 LPCSTR lpTable;
174 UINT nVerbs; /* number of verbs in command table */
175 LPCSTR* aVerbs; /* array of verbs to speed up the verb look up process */
176 } WINE_MCICMDTABLE, *LPWINE_MCICMDTABLE;
177 WINE_MCICMDTABLE S_MciCmdTable[MAX_MCICMDTABLE];
178
179 /**************************************************************************
180 * MCI_IsCommandTableValid [internal]
181 */
182 static BOOL MCI_IsCommandTableValid(UINT uTbl)
183 {
184 LPCSTR lmem, str;
185 DWORD flg;
186 WORD eid;
187 int idx = 0;
188 BOOL inCst = FALSE;
189
190 TRACE("Dumping cmdTbl=%d [hMem=%08x devType=%d]\n",
191 uTbl, S_MciCmdTable[uTbl].hMem, S_MciCmdTable[uTbl].uDevType);
192
193 if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].hMem || !S_MciCmdTable[uTbl].lpTable)
194 return FALSE;
195
196 lmem = S_MciCmdTable[uTbl].lpTable;
197 do {
198 do {
199 str = lmem;
200 lmem += strlen(lmem) + 1;
201 flg = *(LPDWORD)lmem;
202 eid = *(LPWORD)(lmem + sizeof(DWORD));
203 lmem += sizeof(DWORD) + sizeof(WORD);
204 idx ++;
205 /* EPP TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); */
206 switch (eid) {
207 case MCI_COMMAND_HEAD: if (!*str || !flg) return FALSE; idx = 0; break; /* check unicity of str in table */
208 case MCI_STRING: if (inCst) return FALSE; break;
209 case MCI_INTEGER: if (!*str) return FALSE; break;
210 case MCI_END_COMMAND: if (*str || flg || idx == 0) return FALSE; idx = 0; break;
211 case MCI_RETURN: if (*str || idx != 1) return FALSE; break;
212 case MCI_FLAG: if (!*str) return FALSE; break;
213 case MCI_END_COMMAND_LIST: if (*str || flg) return FALSE; idx = 0; break;
214 case MCI_RECT: if (!*str || inCst) return FALSE; break;
215 case MCI_CONSTANT: if (inCst) return FALSE; inCst = TRUE; break;
216 case MCI_END_CONSTANT: if (*str || flg || !inCst) return FALSE; inCst = FALSE; break;
217 default: return FALSE;
218 }
219 } while (eid != MCI_END_COMMAND_LIST);
220 } while (eid != MCI_END_COMMAND_LIST);
221 return TRUE;
222 }
223
224 /**************************************************************************
225 * MCI_DumpCommandTable [internal]
226 */
227 static BOOL MCI_DumpCommandTable(UINT uTbl)
228 {
229 LPCSTR lmem;
230 LPCSTR str;
231 DWORD flg;
232 WORD eid;
233
234 if (!MCI_IsCommandTableValid(uTbl)) {
235 ERR("Ooops: %d is not valid\n", uTbl);
236 return FALSE;
237 }
238
239 lmem = S_MciCmdTable[uTbl].lpTable;
240 do {
241 do {
242 str = lmem;
243 lmem += strlen(lmem) + 1;
244 flg = *(LPDWORD)lmem;
245 eid = *(LPWORD)(lmem + sizeof(DWORD));
246 TRACE("cmd='%s' %08lx %04x\n", str, flg, eid);
247 lmem += sizeof(DWORD) + sizeof(WORD);
248 } while (eid != MCI_END_COMMAND && eid != MCI_END_COMMAND_LIST);
249 TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : "");
250 } while (eid != MCI_END_COMMAND_LIST);
251 return TRUE;
252 }
253
254 static UINT MCI_SetCommandTable(LPWINE_MM_IDATA iData, HANDLE hMem, UINT uDevType);
255
256 /**************************************************************************
257 * MCI_GetCommandTable [internal]
258 */
259 static UINT MCI_GetCommandTable(LPWINE_MM_IDATA iData, UINT uDevType)
260 {
261 UINT uTbl;
262 char buf[32];
263 LPSTR str = NULL;
264
265 /* first look up existing for existing devType */
266 for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
267 if (S_MciCmdTable[uTbl].hMem && S_MciCmdTable[uTbl].uDevType == uDevType)
268 return uTbl;
269 }
270
271 /* well try to load id */
272 if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) {
273 if (LoadStringA(iData->hWinMM32Instance, uDevType, buf, sizeof(buf))) {
274 str = buf;
275 }
276 } else if (uDevType == 0) {
277 str = "CORE";
278 }
279 uTbl = MCI_NO_COMMAND_TABLE;
280 if (str) {
281 HRSRC hRsrc = FindResourceA(iData->hWinMM32Instance, str, (LPCSTR)RT_RCDATAA);
282 HANDLE hMem = 0;
283
284 if (hRsrc) hMem = LoadResource(iData->hWinMM32Instance, hRsrc);
285 if (hMem) {
286 uTbl = MCI_SetCommandTable(iData, hMem, uDevType);
287 } else {
288 WARN("No command table found in resource %04x[%s]\n",
289 iData->hWinMM32Instance, str);
290 }
291 }
292 TRACE("=> %d\n", uTbl);
293 return uTbl;
294 }
295
296 /**************************************************************************
297 * MCI_SetCommandTable [internal]
298 */
299 static UINT MCI_SetCommandTable(LPWINE_MM_IDATA iData, HANDLE hMem,
300 UINT uDevType)
301 {
302 int uTbl;
303 static BOOL bInitDone = FALSE;
304
305 /* <HACK>
306 * The CORE command table must be loaded first, so that MCI_GetCommandTable()
307 * can be called with 0 as a uDevType to retrieve it.
308 * </HACK>
309 */
310 if (!bInitDone) {
311 bInitDone = TRUE;
312 for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
313 S_MciCmdTable[uTbl].hMem = 0;
314 }
315 MCI_GetCommandTable(iData, 0);
316 }
317
318 for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
319 if (S_MciCmdTable[uTbl].hMem == 0) {
320 LPCSTR lmem, str;
321 WORD eid;
322 WORD count;
323
324 S_MciCmdTable[uTbl].hMem = hMem;
325 S_MciCmdTable[uTbl].uDevType = uDevType;
326 S_MciCmdTable[uTbl].lpTable = LockResource(hMem);
327
328 if (TRACE_ON(mci)) {
329 MCI_DumpCommandTable(uTbl);
330 }
331
332 /* create the verbs table */
333 /* get # of entries */
334 lmem = S_MciCmdTable[uTbl].lpTable;
335 count = 0;
336 do {
337 lmem += strlen(lmem) + 1;
338 eid = *(LPWORD)(lmem + sizeof(DWORD));
339 lmem += sizeof(DWORD) + sizeof(WORD);
340 if (eid == MCI_COMMAND_HEAD)
341 count++;
342 } while (eid != MCI_END_COMMAND_LIST);
343
344 S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCSTR));
345 S_MciCmdTable[uTbl].nVerbs = count;
346
347 lmem = S_MciCmdTable[uTbl].lpTable;
348 count = 0;
349 do {
350 str = lmem;
351 lmem += strlen(lmem) + 1;
352 eid = *(LPWORD)(lmem + sizeof(DWORD));
353 lmem += sizeof(DWORD) + sizeof(WORD);
354 if (eid == MCI_COMMAND_HEAD)
355 S_MciCmdTable[uTbl].aVerbs[count++] = str;
356 } while (eid != MCI_END_COMMAND_LIST);
357 /* assert(count == S_MciCmdTable[uTbl].nVerbs); */
358 return uTbl;
359 }
360 }
361
362 return MCI_NO_COMMAND_TABLE;
363 }
364
365 /**************************************************************************
366 * MCI_DeleteCommandTable [internal]
367 */
368 static BOOL MCI_DeleteCommandTable(UINT uTbl)
369 {
370 if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].hMem)
371 return FALSE;
372
373 FreeResource16(S_MciCmdTable[uTbl].hMem);
374 S_MciCmdTable[uTbl].hMem = 0;
375 if (S_MciCmdTable[uTbl].aVerbs) {
376 HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTbl].aVerbs);
377 S_MciCmdTable[uTbl].aVerbs = 0;
378 }
379 return TRUE;
380 }
381
382 /**************************************************************************
383 * MCI_UnLoadMciDriver [internal]
384 */
385 static BOOL MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData, LPWINE_MCIDRIVER wmd)
386 {
387 LPWINE_MCIDRIVER* tmp;
388
389 if (!wmd)
390 return TRUE;
391
392 if (wmd->hDrv)
393 CloseDriver(wmd->hDrv, 0, 0);
394
395 if (wmd->dwPrivate != 0)
396 WARN("Unloading mci driver with non nul dwPrivate field\n");
397
398 EnterCriticalSection(&iData->cs);
399 for (tmp = &iData->lpMciDrvs; *tmp; tmp = &(*tmp)->lpNext) {
400 if (*tmp == wmd) {
401 *tmp = wmd->lpNext;
402 break;
403 }
404 }
405 LeaveCriticalSection(&iData->cs);
406
407 HeapFree(GetProcessHeap(), 0, wmd->lpstrDeviceType);
408 HeapFree(GetProcessHeap(), 0, wmd->lpstrAlias);
409 HeapFree(GetProcessHeap(), 0, wmd->lpstrElementName);
410
411 HeapFree(GetProcessHeap(), 0, wmd);
412 return TRUE;
413 }
414
415 /**************************************************************************
416 * MCI_LoadMciDriver [internal]
417 */
418 static DWORD MCI_LoadMciDriver(LPWINE_MM_IDATA iData, LPCSTR _strDevTyp,
419 LPWINE_MCIDRIVER* lpwmd)
420 {
421 LPSTR strDevTyp = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, _strDevTyp));
422 LPWINE_MCIDRIVER wmd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
423 MCI_OPEN_DRIVER_PARMSA modp;
424 DWORD dwRet = 0;
425 HDRVR hDrv = 0;
426
427 if (!wmd || !strDevTyp) {
428 dwRet = MCIERR_OUT_OF_MEMORY;
429 goto errCleanUp;
430 }
431
432 EnterCriticalSection(&iData->cs);
433 /* wmd must be inserted in list before sending opening the driver, coz' it
434 * may want to lookup at wDevID
435 */
436 wmd->lpNext = iData->lpMciDrvs;
437 iData->lpMciDrvs = wmd;
438
439 for (modp.wDeviceID = MCI_MAGIC;
440 MCI_GetDriver(modp.wDeviceID) != 0;
441 modp.wDeviceID++);
442
443 wmd->wDeviceID = modp.wDeviceID;
444 wmd->lpfnYieldProc = MCI_DefYieldProc;
445 wmd->dwYieldData = VK_CANCEL;
446 wmd->hCreatorTask = GetCurrentTask();
447
448 LeaveCriticalSection(&iData->cs);
449
450 TRACE("wDevID=%04X \n", modp.wDeviceID);
451
452 modp.lpstrParams = NULL;
453
454 hDrv = OpenDriverA(strDevTyp, "mci", (LPARAM)&modp);
455
456 if (!hDrv) {
457 FIXME("Couldn't load driver for type %s.\n"
458 "If you don't have a windows installation accessible from Wine,\n"
459 "you perhaps forgot to create a [mci] section in system.ini\n",
460 strDevTyp);
461 dwRet = MCIERR_DEVICE_NOT_INSTALLED;
462 goto errCleanUp;
463 }
464
465 /* FIXME: should also check that module's description is of the form
466 * MODULENAME:[MCI] comment
467 */
468
469 wmd->hDrv = hDrv;
470 /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
471 wmd->uSpecificCmdTable = LOWORD(modp.wCustomCommandTable);
472 wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED;
473
474 TRACE("Loaded driver %x (%s), type is %d, cmdTable=%08x\n",
475 hDrv, strDevTyp, modp.wType, modp.wCustomCommandTable);
476
477 wmd->lpstrDeviceType = strDevTyp;
478 wmd->wType = modp.wType;
479
480 TRACE("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
481 modp.wDeviceID, modp.wType, modp.wDeviceID);
482 *lpwmd = wmd;
483 return 0;
484 errCleanUp:
485 MCI_UnLoadMciDriver(iData, wmd);
486 HeapFree(GetProcessHeap(), 0, strDevTyp);
487 *lpwmd = 0;
488 return dwRet;
489 }
490
491 /**************************************************************************
492 * MCI_FinishOpen [internal]
493 */
494 static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms,
495 DWORD dwParam)
496 {
497 if (dwParam & MCI_OPEN_ELEMENT)
498 wmd->lpstrElementName = HEAP_strdupA(GetProcessHeap(), 0,
499 lpParms->lpstrElementName);
500
501 if (dwParam & MCI_OPEN_ALIAS)
502 wmd->lpstrAlias = HEAP_strdupA(GetProcessHeap(), 0, lpParms->lpstrAlias);
503
504 lpParms->wDeviceID = wmd->wDeviceID;
505
506 return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam,
507 (DWORD)lpParms);
508 }
509
510 /**************************************************************************
511 * MCI_FindCommand [internal]
512 */
513 static LPCSTR MCI_FindCommand(UINT uTbl, LPCSTR verb)
514 {
515 UINT idx;
516
517 if (uTbl >= MAX_MCICMDTABLE || S_MciCmdTable[uTbl].hMem == 0)
518 return NULL;
519
520 /* another improvement would be to have the aVerbs array sorted,
521 * so that we could use a dichotomic search on it, rather than this dumb
522 * array look up
523 */
524 for (idx = 0; idx < S_MciCmdTable[uTbl].nVerbs; idx++) {
525 if (strcmp(S_MciCmdTable[uTbl].aVerbs[idx], verb) == 0)
526 return S_MciCmdTable[uTbl].aVerbs[idx];
527 }
528
529 return NULL;
530 }
531
532 /**************************************************************************
533 * MCI_GetReturnType [internal]
534 */
535 static DWORD MCI_GetReturnType(LPCSTR lpCmd)
536 {
537 lpCmd += strlen(lpCmd) + 1 + sizeof(DWORD) + sizeof(WORD);
538 if (*lpCmd == '\0' && *(LPWORD)(lpCmd + 1 + sizeof(DWORD)) == MCI_RETURN) {
539 return *(LPDWORD)(lpCmd + 1);
540 }
541 return 0L;
542 }
543
544 /**************************************************************************
545 * MCI_GetMessage [internal]
546 */
547 static WORD MCI_GetMessage(LPCSTR lpCmd)
548 {
549 return (WORD)*(LPDWORD)(lpCmd + strlen(lpCmd) + 1);
550 }
551
552 /**************************************************************************
553 * MCI_GetDWord [internal]
554 */
555 static BOOL MCI_GetDWord(LPDWORD data, LPSTR* ptr)
556 {
557 DWORD val;
558 LPSTR ret;
559
560 val = strtoul(*ptr, &ret, 0);
561
562 switch (*ret) {
563 case '\0': break;
564 case ' ': ret++; break;
565 default: return FALSE;
566 }
567
568 *data |= val;
569 *ptr = ret;
570 return TRUE;
571 }
572
573 /**************************************************************************
574 * MCI_GetString [internal]
575 */
576 static DWORD MCI_GetString(LPSTR* str, LPSTR* args)
577 {
578 LPSTR ptr = *args;
579
580 /* see if we have a quoted string */
581 if (*ptr == '"') {
582 ptr = strchr(*str = ptr + 1, '"');
583 if (!ptr) return MCIERR_NO_CLOSING_QUOTE;
584 /* FIXME: shall we escape \" from string ?? */
585 if (ptr[-1] == '\\') TRACE("Ooops: un-escaped \"\n");
586 *ptr++ = '\0'; /* remove trailing " */
587 if (*ptr != ' ' && *ptr != '\0') return MCIERR_EXTRA_CHARACTERS;
588 *ptr++ = '\0';
589 } else {
590 ptr = strchr(ptr, ' ');
591
592 if (ptr) {
593 *ptr++ = '\0';
594 } else {
595 ptr = *args + strlen(*args);
596 }
597 *str = *args;
598 }
599
600 *args = ptr;
601 return 0;
602 }
603
604 #define MCI_DATA_SIZE 16
605
606 /**************************************************************************
607 * MCI_ParseOptArgs [internal]
608 */
609 static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCSTR lpCmd,
610 LPSTR args, LPDWORD dwFlags)
611 {
612 int len, offset;
613 LPCSTR lmem, str;
614 DWORD dwRet, flg, cflg = 0;
615 WORD eid;
616 BOOL inCst, found;
617
618 /* loop on arguments */
619 while (*args) {
620 lmem = lpCmd;
621 found = inCst = FALSE;
622 offset = _offset;
623 TRACE("args='%s' offset=%d\n", args, offset);
624
625 do { /* loop on options for command table for the requested verb */
626 str = lmem;
627 lmem += (len = strlen(lmem)) + 1;
628 flg = *(LPDWORD)lmem;
629 eid = *(LPWORD)(lmem + sizeof(DWORD));
630 lmem += sizeof(DWORD) + sizeof(WORD);
631 /* EPP TRACE("\tcmd='%s' inCst=%s\n", str, inCst ? "Y" : "N"); */
632
633 switch (eid) {
634 case MCI_CONSTANT:
635 inCst = TRUE; cflg = flg; break;
636 case MCI_END_CONSTANT:
637 /* there may be additional integral values after flag in constant */
638 if (inCst && MCI_GetDWord(&(data[offset]), &args)) {
639 *dwFlags |= cflg;
640 }
641 inCst = FALSE; cflg = 0;
642 break;
643 }
644
645 if (strncasecmp(args, str, len) == 0 &&
646 (args[len] == 0 || args[len] == ' ')) {
647 /* store good values into data[] */
648 args += len;
649 if (*args == ' ') args++;
650 found = TRUE;
651
652 switch (eid) {
653 case MCI_COMMAND_HEAD:
654 case MCI_RETURN:
655 case MCI_END_COMMAND:
656 case MCI_END_COMMAND_LIST:
657 case MCI_CONSTANT: /* done above */
658 case MCI_END_CONSTANT: /* done above */
659 break;
660 case MCI_FLAG:
661 *dwFlags |= flg;
662 break;
663 case MCI_INTEGER:
664 if (inCst) {
665 data[offset] |= flg;
666 *dwFlags |= cflg;
667 inCst = FALSE;
668 } else {
669 *dwFlags |= flg;
670 if (!MCI_GetDWord(&(data[offset]), &args)) {
671 return MCIERR_BAD_INTEGER;
672 }
673 }
674 break;
675 case MCI_RECT:
676 /* store rect in data (offset...offset+3) */
677 *dwFlags |= flg;
678 if (!MCI_GetDWord(&(data[offset+0]), &args) ||
679 !MCI_GetDWord(&(data[offset+1]), &args) ||
680 !MCI_GetDWord(&(data[offset+2]), &args) ||
681 !MCI_GetDWord(&(data[offset+3]), &args)) {
682 ERR("Bad rect '%s'\n", args);
683 return MCIERR_BAD_INTEGER;
684 }
685 break;
686 case MCI_STRING:
687 *dwFlags |= flg;
688 if ((dwRet = MCI_GetString((LPSTR*)&data[offset], &args)))
689 return dwRet;
690 break;
691 default: ERR("oops");
692 }
693 /* exit inside while loop */
694 eid = MCI_END_COMMAND;
695 } else {
696 /* have offset incremented if needed */
697 switch (eid) {
698 case MCI_COMMAND_HEAD:
699 case MCI_RETURN:
700 case MCI_END_COMMAND:
701 case MCI_END_COMMAND_LIST:
702 case MCI_CONSTANT:
703 case MCI_FLAG: break;
704 case MCI_INTEGER: if (!inCst) offset++; break;
705 case MCI_END_CONSTANT:
706 case MCI_STRING: offset++; break;
707 case MCI_RECT: offset += 4; break;
708 default: ERR("oops");
709 }
710 }
711 } while (eid != MCI_END_COMMAND);
712 if (!found) {
713 TRACE("Optarg '%s' not found\n", args);
714 return MCIERR_UNRECOGNIZED_COMMAND;
715 }
716 if (offset == MCI_DATA_SIZE) {
717 ERR("Internal data[] buffer overflow\n");
718 return MCIERR_PARSER_INTERNAL;
719 }
720 }
721 return 0;
722 }
723
724 /**************************************************************************
725 * MCI_HandleReturnValues [internal]
726 */
727 static DWORD MCI_HandleReturnValues(LPWINE_MM_IDATA iData, DWORD dwRet,
728 LPWINE_MCIDRIVER wmd, LPCSTR lpCmd, LPDWORD data,
729 LPSTR lpstrRet, UINT uRetLen)
730 {
731 if (lpstrRet) {
732 switch (MCI_GetReturnType(lpCmd)) {
733 case 0: /* nothing to return */
734 break;
735 case MCI_INTEGER:
736 switch (dwRet & 0xFFFF0000ul) {
737 case 0:
738 case MCI_INTEGER_RETURNED:
739 wsnprintfA(lpstrRet, uRetLen, "%ld", data[1]);
740 break;
741 case MCI_RESOURCE_RETURNED:
742 /* return string which ID is HIWORD(data[1]),
743 * string is loaded from mmsystem.dll */
744 LoadStringA(iData->hWinMM32Instance, HIWORD(data[1]),
745 lpstrRet, uRetLen);
746 break;
747 case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
748 /* return string which ID is HIWORD(data[1]),
749 * string is loaded from driver */
750 LoadStringA(wmd->hDrv, HIWORD(data[1]), lpstrRet, uRetLen);
751 break;
752 case MCI_COLONIZED3_RETURN:
753 wsnprintfA(lpstrRet, uRetLen, "%d:%d:%d",
754 LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
755 LOBYTE(HIWORD(data[1])));
756 break;
757 case MCI_COLONIZED4_RETURN:
758 wsnprintfA(lpstrRet, uRetLen, "%d:%d:%d:%d",
759 LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
760 LOBYTE(HIWORD(data[1])), HIBYTE(HIWORD(data[1])));
761 break;
762 default: ERR("Ooops (%04X)\n", HIWORD(dwRet));
763 }
764 break;
765 case MCI_STRING:
766 switch (dwRet & 0xFFFF0000ul) {
767 case 0:
768 /* nothing to do data[1] == lpstrRet */
769 break;
770 case MCI_INTEGER_RETURNED:
771 data[1] = *(LPDWORD)lpstrRet;
772 wsnprintfA(lpstrRet, uRetLen, "%ld", data[1]);
773 break;
774 default:
775 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
776 break;
777 }
778 break;
779 case MCI_RECT:
780 if (dwRet & 0xFFFF0000ul)
781 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
782 wsnprintfA(lpstrRet, uRetLen, "%ld %ld %ld %ld",
783 data[1], data[2], data[3], data[4]);
784 break;
785 default: ERR("oops\n");
786 }
787 }
788 return LOWORD(dwRet);
789 }
790
791 /**************************************************************************
792 * mciSendStringA [MMSYSTEM.702][WINMM.51]
793 */
794 DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet,
795 UINT uRetLen, HWND hwndCallback)
796 {
797 LPSTR verb, dev, args;
798 LPWINE_MCIDRIVER wmd = 0;
799 DWORD dwFlags = 0, dwRet = 0;
800 int offset = 0;
801 DWORD data[MCI_DATA_SIZE];
802 LPCSTR lpCmd = 0;
803 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
804
805 TRACE("('%s', %p, %d, %X)\n", lpstrCommand, lpstrRet, uRetLen, hwndCallback);
806
807 /* format is <command> <device> <optargs> */
808 if (!(verb = HEAP_strdupA(GetProcessHeap(), 0, lpstrCommand)))
809 return MCIERR_OUT_OF_MEMORY;
810
811 memset(data, 0, sizeof(data));
812
813 if (!(args = strchr(verb, ' '))) {
814 dwRet = MCIERR_MISSING_DEVICE_NAME;
815 goto errCleanUp;
816 }
817 *args++ = '\0';
818 if ((dwRet = MCI_GetString(&dev, &args))) {
819 goto errCleanUp;
820 }
821
822 /* case dev == 'new' has to be handled */
823 if (!strcasecmp(dev, "new")) {
824 FIXME("'new': NIY as device name\n");
825 dwRet = MCIERR_MISSING_DEVICE_NAME;
826 goto errCleanUp;
827 }
828
829 /* otherwise, try to grab devType from open */
830 if (!strcmp(verb, "open")) {
831 LPSTR devType, tmp;
832
833 if ((devType = strchr(dev, '!')) != NULL) {
834 *devType++ = '\0';
835 tmp = devType; devType = dev; dev = tmp;
836
837 dwFlags |= MCI_OPEN_TYPE;
838 data[2] = (DWORD)devType;
839 devType = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, devType));
840 } else {
841 if ((devType = strstr(args, "type ")) != NULL) {
842 devType += 5;
843 tmp = strchr(devType, ' ');
844 if (tmp) *tmp = '\0';
845 devType = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, devType));
846 if (tmp) *tmp = ' ';
847 /* dwFlags and data[2] will be correctly set in ParseOpt loop */
848 } else {
849 char buf[32];
850 if ((dwRet = MCI_GetDevTypeFromFileName(dev, buf, sizeof(buf))))
851 goto errCleanUp;
852
853 devType = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, buf));
854 }
855 dwFlags |= MCI_OPEN_ELEMENT;
856 data[3] = (DWORD)dev;
857 }
858 dwRet = MCI_LoadMciDriver(iData, devType, &wmd);
859 HeapFree(GetProcessHeap(), 0, devType);
860 if (dwRet) {
861 MCI_UnLoadMciDriver(iData, wmd);
862 goto errCleanUp;
863 }
864 } else {
865 wmd = MCI_GetDriver(mciGetDeviceIDA(dev));
866 if (!wmd) {
867 FIXME("Oooch: couldn't find driver for '%s' in '%s'; automatic open is NIY\n",
868 dev, lpstrCommand);
869 dwRet = MCIERR_INVALID_DEVICE_ID;
870 goto errCleanUp;
871 }
872 }
873
874 /* get the verb in the different command tables */
875 /* try the device specific command table */
876 if (wmd) lpCmd = MCI_FindCommand(wmd->uSpecificCmdTable, verb);
877 /* try the type specific command table */
878 if (!lpCmd) {
879 if (wmd && wmd->uTypeCmdTable == MCI_COMMAND_TABLE_NOT_LOADED)
880 wmd->uTypeCmdTable = MCI_GetCommandTable(iData, wmd->wType);
881 if (wmd && wmd->uTypeCmdTable != MCI_NO_COMMAND_TABLE)
882 lpCmd = MCI_FindCommand(wmd->uTypeCmdTable, verb);
883 }
884 /* try core command table */
885 if (!lpCmd) lpCmd = MCI_FindCommand(MCI_GetCommandTable(iData, 0), verb);
886
887 if (!lpCmd) {
888 TRACE("Command '%s' not found!\n", verb);
889 dwRet = MCIERR_UNRECOGNIZED_COMMAND;
890 goto errCleanUp;
891 }
892
893 /* set up call back */
894 if (hwndCallback != 0) {
895 dwFlags |= MCI_NOTIFY;
896 data[0] = (DWORD)hwndCallback;
897 }
898
899 /* set return information */
900 switch (MCI_GetReturnType(lpCmd)) {
901 case 0: offset = 1; break;
902 case MCI_INTEGER: offset = 2; break;
903 case MCI_STRING: data[1] = (DWORD)lpstrRet; data[2] = uRetLen; offset = 3; break;
904 case MCI_RECT: offset = 5; break;
905 default: ERR("oops\n");
906 }
907
908 TRACE("verb='%s' on dev='%s'; offset=%d\n", verb, dev, offset);
909
910 if ((dwRet = MCI_ParseOptArgs(data, offset, lpCmd, args, &dwFlags)))
911 goto errCleanUp;
912
913 if (lpstrRet && uRetLen) *lpstrRet = '\0';
914
915 #define STR_OF(_x) (IsBadReadPtr((char*)_x,1)?"?":(char*)(_x))
916 TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n",
917 wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags,
918 data[0], STR_OF(data[0]), data[1], STR_OF(data[1]),
919 data[2], STR_OF(data[2]), data[3], STR_OF(data[3]),
920 data[4], STR_OF(data[4]), data[5], STR_OF(data[5]));
921 #undef STR_OF
922
923 if (strcmp(verb, "open") == 0) {
924 if ((dwRet = MCI_FinishOpen(wmd, (LPMCI_OPEN_PARMSA)data, dwFlags)))
925 MCI_UnLoadMciDriver(iData, wmd);
926 /* FIXME: notification is not properly shared across two opens */
927 } else {
928 dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD)data, TRUE);
929 }
930 TRACE("=> 1/ %lx (%s)\n", dwRet, lpstrRet);
931 if (dwRet) goto errCleanUp;
932
933 dwRet = MCI_HandleReturnValues(iData, dwRet, wmd, lpCmd, data, lpstrRet, uRetLen);
934 TRACE("=> 2/ %lx (%s)\n", dwRet, lpstrRet);
935
936 errCleanUp:
937 HeapFree(GetProcessHeap(), 0, verb);
938 return dwRet;
939 }
940
941 /**************************************************************************
942 * mciSendStringW [WINMM.52]
943 */
944 DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPSTR lpstrRet,
945 UINT uRetLen, HWND hwndCallback)
946 {
947 LPSTR lpstrCommand;
948 UINT ret;
949
950 /* FIXME: is there something to do with lpstrReturnString ? */
951 lpstrCommand = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrCommand);
952 ret = mciSendStringA(lpstrCommand, lpstrRet, uRetLen, hwndCallback);
953 HeapFree(GetProcessHeap(), 0, lpstrCommand);
954 return ret;
955 }
956
957 /**************************************************************************
958 * mciSendString16 [MMSYSTEM.702]
959 */
960 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
961 UINT16 uRetLen, HWND16 hwndCallback)
962 {
963 return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, hwndCallback);
964 }
965
966 /**************************************************************************
967 * mciExecute [WINMM.38]
968 */
969 DWORD WINAPI mciExecute(LPCSTR lpstrCommand)
970 {
971 char strRet[256];
972 DWORD ret;
973
974 TRACE("(%s)!\n", lpstrCommand);
975
976 ret = mciSendString16(lpstrCommand, strRet, sizeof(strRet), 0);
977 if (ret != 0) {
978 if (!mciGetErrorStringA(ret, strRet, sizeof(strRet))) {
979 sprintf(strRet, "Unknown MCI error (%ld)", ret);
980 }
981 MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
982 }
983 /* FIXME: what shall I return ? */
984 return 0;
985 }
986
987 /**************************************************************************
988 * mciLoadCommandResource [MMSYSTEM.705]
989 */
990 UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hInst, LPCSTR resname, UINT16 type)
991 {
992 HRSRC hRsrc = 0;
993 HGLOBAL hMem;
994 UINT16 ret = MCI_NO_COMMAND_TABLE;
995 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
996
997 TRACE("(%04x, %s, %d)!\n", hInst, resname, type);
998
999 /* if file exists "resname.mci", then load resource "resname" from it
1000 * otherwise directly from driver
1001 * We don't support it (who uses this feature ?), but we check anyway
1002 */
1003 if (!type) {
1004 char buf[128];
1005 OFSTRUCT ofs;
1006
1007 strcat(strcpy(buf, resname), ".mci");
1008 if (OpenFile(buf, &ofs, OF_EXIST) != HFILE_ERROR) {
1009 FIXME("NIY: command table to be loaded from '%s'\n", ofs.szPathName);
1010 }
1011 }
1012 if (!(hRsrc = FindResourceA(hInst, resname, (LPCSTR)RT_RCDATAA))) {
1013 WARN("No command table found in resource\n");
1014 } else if ((hMem = LoadResource(hInst, hRsrc))) {
1015 ret = MCI_SetCommandTable(iData, hMem, type);
1016 } else {
1017 WARN("Couldn't load resource.\n");
1018 }
1019 TRACE("=> %04x\n", ret);
1020 return ret;
1021 }
1022
1023 /**************************************************************************
1024 * mciFreeCommandResource [MMSYSTEM.713]
1025 */
1026 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
1027 {
1028 TRACE("(%04x)!\n", uTable);
1029
1030 return MCI_DeleteCommandTable(uTable);
1031 }
1032
1033 /**************************************************************************
1034 * mciLoadCommandResource [WINMM.48]
1035 *
1036 * Strangely, this function only exists as an UNICODE one.
1037 */
1038 UINT WINAPI mciLoadCommandResource(HINSTANCE hinst, LPCWSTR resNameW, UINT type)
1039 {
1040 LPSTR resNameA;
1041 UINT ret;
1042
1043 TRACE("(%04x, %s, %d)!\n", hinst, debugstr_w(resNameW), type);
1044
1045 resNameA = HEAP_strdupWtoA(GetProcessHeap(), 0, resNameW);
1046 ret = mciLoadCommandResource16(hinst, resNameA, type);
1047 HeapFree(GetProcessHeap(), 0, resNameA);
1048 return ret;
1049 }
1050
1051 /**************************************************************************
1052 * mciFreeCommandResource [WINMM.39]
1053 */
1054 BOOL WINAPI mciFreeCommandResource(UINT uTable)
1055 {
1056 TRACE("(%08x)!\n", uTable);
1057
1058 return mciFreeCommandResource16(uTable);
1059 }
1060
1061 typedef enum {
1062 MCI_MAP_NOMEM, /* ko, memory problem */
1063 MCI_MAP_MSGERROR, /* ko, unknown message */
1064 MCI_MAP_OK, /* ok, no memory allocated. to be sent to the proc. */
1065 MCI_MAP_OKMEM, /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
1066 MCI_MAP_PASS /* not handled (no memory allocated) to be sent to the driver */
1067 } MCI_MapType;
1068
1069 /**************************************************************************
1070 * MCI_MapMsg16To32A [internal]
1071 */
1072 static MCI_MapType MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
1073 {
1074 if (*lParam == 0)
1075 return MCI_MAP_OK;
1076 /* FIXME: to add also (with seg/linear modifications to do):
1077 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1078 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1079 */
1080 switch (wMsg) {
1081 /* case MCI_CAPTURE */
1082 case MCI_CLOSE:
1083 case MCI_CLOSE_DRIVER:
1084 /* case MCI_CONFIGURE:*/
1085 case MCI_COPY:
1086 case MCI_CUE:
1087 case MCI_CUT:
1088 case MCI_DELETE:
1089 case MCI_FREEZE:
1090 case MCI_GETDEVCAPS:
1091 /* case MCI_INDEX: */
1092 /* case MCI_MARK: */
1093 /* case MCI_MONITOR: */
1094 case MCI_PASTE:
1095 case MCI_PAUSE:
1096 case MCI_PLAY:
1097 case MCI_PUT:
1098 case MCI_REALIZE:
1099 case MCI_RECORD:
1100 case MCI_RESUME:
1101 case MCI_SEEK:
1102 case MCI_SET:
1103 /* case MCI_SETTIMECODE:*/
1104 /* case MCI_SIGNAL:*/
1105 case MCI_SPIN:
1106 case MCI_STATUS: /* FIXME: is wrong for digital video */
1107 case MCI_STEP:
1108 case MCI_STOP:
1109 /* case MCI_UNDO: */
1110 case MCI_UNFREEZE:
1111 case MCI_UPDATE:
1112 case MCI_WHERE:
1113 *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
1114 return MCI_MAP_OK;
1115 case MCI_WINDOW:
1116 /* in fact, I would also need the dwFlags... to see
1117 * which members of lParam are effectively used
1118 */
1119 *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
1120 FIXME("Current mapping may be wrong\n");
1121 break;
1122 case MCI_BREAK:
1123 {
1124 LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
1125 LPMCI_BREAK_PARMS16 mbp16 = PTR_SEG_TO_LIN(*lParam);
1126
1127 if (mbp32) {
1128 mbp32->dwCallback = mbp16->dwCallback;
1129 mbp32->nVirtKey = mbp16->nVirtKey;
1130 mbp32->hwndBreak = mbp16->hwndBreak;
1131 } else {
1132 return MCI_MAP_NOMEM;
1133 }
1134 *lParam = (DWORD)mbp32;
1135 }
1136 return MCI_MAP_OKMEM;
1137 case MCI_ESCAPE:
1138 {
1139 LPMCI_VD_ESCAPE_PARMSA mvep32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA));
1140 LPMCI_VD_ESCAPE_PARMS16 mvep16 = PTR_SEG_TO_LIN(*lParam);
1141
1142 if (mvep32a) {
1143 mvep32a->dwCallback = mvep16->dwCallback;
1144 mvep32a->lpstrCommand = PTR_SEG_TO_LIN(mvep16->lpstrCommand);
1145 } else {
1146 return MCI_MAP_NOMEM;
1147 }
1148 *lParam = (DWORD)mvep32a;
1149 }
1150 return MCI_MAP_OKMEM;
1151 case MCI_INFO:
1152 {
1153 LPMCI_INFO_PARMSA mip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA));
1154 LPMCI_INFO_PARMS16 mip16 = PTR_SEG_TO_LIN(*lParam);
1155
1156 /* FIXME this is wrong if device is of type
1157 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
1158 */
1159 if (mip32a) {
1160 mip32a->dwCallback = mip16->dwCallback;
1161 mip32a->lpstrReturn = PTR_SEG_TO_LIN(mip16->lpstrReturn);
1162 mip32a->dwRetSize = mip16->dwRetSize;
1163 } else {
1164 return MCI_MAP_NOMEM;
1165 }
1166 *lParam = (DWORD)mip32a;
1167 }
1168 return MCI_MAP_OKMEM;
1169 case MCI_OPEN:
1170 case MCI_OPEN_DRIVER:
1171 {
1172 LPMCI_OPEN_PARMSA mop32a = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD));
1173 LPMCI_OPEN_PARMS16 mop16 = PTR_SEG_TO_LIN(*lParam);
1174
1175 if (mop32a) {
1176 *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
1177 mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
1178 mop32a->dwCallback = mop16->dwCallback;
1179 mop32a->wDeviceID = mop16->wDeviceID;
1180 mop32a->lpstrDeviceType = PTR_SEG_TO_LIN(mop16->lpstrDeviceType);
1181 mop32a->lpstrElementName = PTR_SEG_TO_LIN(mop16->lpstrElementName);
1182 mop32a->lpstrAlias = PTR_SEG_TO_LIN(mop16->lpstrAlias);
1183 /* copy extended information if any...
1184 * FIXME: this may seg fault if initial structure does not contain them and
1185 * the reads after msip16 fail under LDT limits...
1186 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1187 * should not take care of extended parameters, and should be used by MCI_Open
1188 * to fetch uDevType. When, this is known, the mapping for sending the
1189 * MCI_OPEN_DRIVER shall be done depending on uDevType.
1190 */
1191 memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD));
1192 } else {
1193 return MCI_MAP_NOMEM;
1194 }
1195 *lParam = (DWORD)mop32a;
1196 }
1197 return MCI_MAP_OKMEM;
1198 case MCI_SYSINFO:
1199 {
1200 LPMCI_SYSINFO_PARMSA msip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA));
1201 LPMCI_SYSINFO_PARMS16 msip16 = PTR_SEG_TO_LIN(*lParam);
1202
1203 if (msip32a) {
1204 msip32a->dwCallback = msip16->dwCallback;
1205 msip32a->lpstrReturn = PTR_SEG_TO_LIN(msip16->lpstrReturn);
1206 msip32a->dwRetSize = msip16->dwRetSize;
1207 msip32a->dwNumber = msip16->dwNumber;
1208 msip32a->wDeviceType = msip16->wDeviceType;
1209 } else {
1210 return MCI_MAP_NOMEM;
1211 }
1212 *lParam = (DWORD)msip32a;
1213 }
1214 return MCI_MAP_OKMEM;
1215 case DRV_LOAD:
1216 case DRV_ENABLE:
1217 case DRV_OPEN:
1218 case DRV_CLOSE:
1219 case DRV_DISABLE:
1220 case DRV_FREE:
1221 case DRV_CONFIGURE:
1222 case DRV_QUERYCONFIGURE:
1223 case DRV_INSTALL:
1224 case DRV_REMOVE:
1225 case DRV_EXITSESSION:
1226 case DRV_EXITAPPLICATION:
1227 case DRV_POWER:
1228 FIXME("This is a hack\n");
1229 return MCI_MAP_OK;
1230
1231 default:
1232 WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
1233 }
1234 return MCI_MAP_MSGERROR;
1235 }
1236
1237 /**************************************************************************
1238 * MCI_UnMapMsg16To32A [internal]
1239 */
1240 static MCI_MapType MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
1241 {
1242 switch (wMsg) {
1243 /* case MCI_CAPTURE */
1244 case MCI_CLOSE:
1245 case MCI_CLOSE_DRIVER:
1246 /* case MCI_CONFIGURE:*/
1247 case MCI_COPY:
1248 case MCI_CUE:
1249 case MCI_CUT:
1250 case MCI_DELETE:
1251 case MCI_FREEZE:
1252 case MCI_GETDEVCAPS:
1253 /* case MCI_INDEX: */
1254 /* case MCI_MARK: */
1255 /* case MCI_MONITOR: */
1256 case MCI_PASTE:
1257 case MCI_PAUSE:
1258 case MCI_PLAY:
1259 case MCI_PUT:
1260 case MCI_REALIZE:
1261 case MCI_RECORD:
1262 case MCI_RESUME:
1263 case MCI_SEEK:
1264 case MCI_SET:
1265 /* case MCI_SETTIMECODE:*/
1266 /* case MCI_SIGNAL:*/
1267 case MCI_SPIN:
1268 case MCI_STATUS:
1269 case MCI_STEP:
1270 case MCI_STOP:
1271 /* case MCI_UNDO: */
1272 case MCI_UNFREEZE:
1273 case MCI_UPDATE:
1274 case MCI_WHERE:
1275 return MCI_MAP_OK;
1276
1277 case MCI_WINDOW:
1278 /* FIXME ?? see Map function */
1279 return MCI_MAP_OK;
1280
1281 case MCI_BREAK:
1282 case MCI_ESCAPE:
1283 case MCI_INFO:
1284 case MCI_SYSINFO:
1285 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
1286 return MCI_MAP_OK;
1287 case MCI_OPEN:
1288 case MCI_OPEN_DRIVER:
1289 if (lParam) {
1290 LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)lParam;
1291 LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16));
1292
1293 mop16->wDeviceID = mop32a->wDeviceID;
1294 if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
1295 FIXME("bad free line=%d\n", __LINE__);
1296 }
1297 return MCI_MAP_OK;
1298 case DRV_LOAD:
1299 case DRV_ENABLE:
1300 case DRV_OPEN:
1301 case DRV_CLOSE:
1302 case DRV_DISABLE:
1303 case DRV_FREE:
1304 case DRV_CONFIGURE:
1305 case DRV_QUERYCONFIGURE:
1306 case DRV_INSTALL:
1307 case DRV_REMOVE:
1308 case DRV_EXITSESSION:
1309 case DRV_EXITAPPLICATION:
1310 case DRV_POWER:
1311 FIXME("This is a hack\n");
1312 return MCI_MAP_OK;
1313 default:
1314 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
1315 }
1316 return MCI_MAP_MSGERROR;
1317 }
1318
1319 /*
1320 * 0000 stop
1321 * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
1322 * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
1323 * 0100
1324 * 0101
1325 * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
1326 * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
1327 * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
1328 */
1329
1330 /**************************************************************************
1331 * MCI_MsgMapper32To16_Create [internal]
1332 *
1333 * Helper for MCI_MapMsg32ATo16.
1334 * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
1335 * segmented pointer.
1336 * map contains a list of action to be performed for the mapping (see list
1337 * above)
1338 * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
1339 */
1340 static MCI_MapType MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
1341 {
1342 void* lp = SEGPTR_ALLOC((keep ? sizeof(void**) : 0) + size16);
1343 LPBYTE p16, p32;
1344
1345 if (!lp) {
1346 return MCI_MAP_NOMEM;
1347 }
1348 p32 = (LPBYTE)(*ptr);
1349 if (keep) {
1350 *(void**)lp = *ptr;
1351 p16 = (LPBYTE)lp + sizeof(void**);
1352 *ptr = (char*)SEGPTR_GET(lp) + sizeof(void**);
1353 } else {
1354 p16 = lp;
1355 *ptr = (void*)SEGPTR_GET(lp);
1356 }
1357
1358 if (map == 0) {
1359 memcpy(p16, p32, size16);
1360 } else {
1361 unsigned nibble;
1362 unsigned sz;
1363
1364 while (map & 0xF) {
1365 nibble = map & 0xF;
1366 if (nibble & 0x8) {
1367 sz = (nibble & 7) + 1;
1368 memcpy(p16, p32, sz);
1369 p16 += sz;
1370 p32 += sz;
1371 size16 -= sz; /* DEBUG only */
1372 } else {
1373 switch (nibble) {
1374 case 0x1: *( LPINT16)p16 = ( INT16)*( LPINT16)p32; p16 += 2; p32 += 4; size16 -= 2; break;
1375 case 0x2: *(LPUINT16)p16 = (UINT16)*(LPUINT16)p32; p16 += 2; p32 += 4; size16 -= 2; break;
1376 case 0x6: *(LPDWORD)p16 = 0; p16 += 4; p32 += 4; size16 -= 4; break;
1377 case 0x7: *(LPDWORD)p16 = SEGPTR_GET(SEGPTR_STRDUP(*(LPSTR*)p32));p16 += 4; p32 += 4; size16 -= 4; break;
1378 default: FIXME("Unknown nibble for mapping (%x)\n", nibble);
1379 }
1380 }
1381 map >>= 4;
1382 }
1383 if (size16 != 0) /* DEBUG only */
1384 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1385 }
1386 return MCI_MAP_OKMEM;
1387 }
1388
1389 /**************************************************************************
1390 * MCI_MsgMapper32To16_Destroy [internal]
1391 *
1392 * Helper for MCI_UnMapMsg32ATo16.
1393 */
1394 static MCI_MapType MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
1395 {
1396 if (ptr) {
1397 void* msg16 = PTR_SEG_TO_LIN(ptr);
1398 void* alloc;
1399 LPBYTE p32, p16;
1400 unsigned nibble;
1401
1402 if (kept) {
1403 alloc = (char*)msg16 - sizeof(void**);
1404 p32 = *(void**)alloc;
1405 p16 = msg16;
1406
1407 if (map == 0) {
1408 memcpy(p32, p16, size16);
1409 } else {
1410 while (map & 0xF) {
1411 nibble = map & 0xF;
1412 if (nibble & 0x8) {
1413 memcpy(p32, p16, (nibble & 7) + 1);
1414 p16 += (nibble & 7) + 1;
1415 p32 += (nibble & 7) + 1;
1416 size16 -= (nibble & 7) + 1;
1417 } else {
1418 switch (nibble) {
1419 case 0x1: *( LPINT)p32 = *( LPINT16)p16; p16 += 2; p32 += 4; size16 -= 2; break;
1420 case 0x2: *(LPUINT)p32 = *(LPUINT16)p16; p16 += 2; p32 += 4; size16 -= 2; break;
1421 case 0x6: p16 += 4; p32 += 4; size16 -= 4; break;
1422 case 0x7: strcpy(*(LPSTR*)p32, PTR_SEG_TO_LIN(*(DWORD*)p16));
1423 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(*(DWORD*)p16))) {
1424 FIXME("bad free line=%d\n", __LINE__);
1425 }
1426 p16 += 4; p32 += 4; size16 -= 4; break;
1427 default: FIXME("Unknown nibble for mapping (%x)\n", nibble);
1428 }
1429 }
1430 map >>= 4;
1431 }
1432 if (size16 != 0) /* DEBUG only */
1433 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1434 }
1435 } else {
1436 alloc = msg16;
1437 }
1438
1439 if (!SEGPTR_FREE(alloc)) {
1440 FIXME("bad free line=%d\n", __LINE__);
1441 }
1442 }
1443 return MCI_MAP_OK;
1444 }
1445
1446 /**************************************************************************
1447 * MCI_MapMsg32ATo16 [internal]
1448 *
1449 * Map a 32-A bit MCI message to a 16 bit MCI message.
1450 */
1451 static MCI_MapType MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
1452 {
1453 int size;
1454 BOOLEAN keep = FALSE;
1455 DWORD map = 0;
1456
1457 if (*lParam == 0)
1458 return MCI_MAP_OK;
1459
1460 /* FIXME: to add also (with seg/linear modifications to do):
1461 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1462 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1463 */
1464 switch (wMsg) {
1465 case MCI_BREAK:
1466 size = sizeof(MCI_BREAK_PARMS);
1467 break;
1468 /* case MCI_CAPTURE */
1469 case MCI_CLOSE:
1470 case MCI_CLOSE_DRIVER:
1471 size = sizeof(MCI_GENERIC_PARMS);
1472 break;
1473 /* case MCI_CONFIGURE:*/
1474 /* case MCI_COPY: */
1475 case MCI_CUE:
1476 switch (uDevType) {
1477 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
1478 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1479 default: size = sizeof(MCI_GENERIC_PARMS); break;
1480 }
1481 break;
1482 /* case MCI_CUT:*/
1483 case MCI_DELETE:
1484 switch (uDevType) {
1485 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break;
1486 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
1487 default: size = sizeof(MCI_GENERIC_PARMS); break;
1488 }
1489 break;
1490 /* case MCI_ESCAPE: */
1491 case MCI_FREEZE:
1492 switch (uDevType) {
1493 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break;
1494 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
1495 default: size = sizeof(MCI_GENERIC_PARMS); break;
1496 }
1497 break;
1498 case MCI_GETDEVCAPS:
1499 keep = TRUE;
1500 size = sizeof(MCI_GETDEVCAPS_PARMS);
1501 break;
1502 /* case MCI_INDEX: */
1503 case MCI_INFO:
1504 {
1505 LPMCI_INFO_PARMSA mip32a = (LPMCI_INFO_PARMSA)(*lParam);
1506 char* ptr;
1507 LPMCI_INFO_PARMS16 mip16;
1508
1509 switch (uDevType) {
1510 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
1511 default: size = sizeof(MCI_INFO_PARMS16); break;
1512 }
1513 ptr = SEGPTR_ALLOC(sizeof(LPMCI_INFO_PARMSA) + size);
1514
1515 if (ptr) {
1516 *(LPMCI_INFO_PARMSA*)ptr = mip32a;
1517 mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSA));
1518 mip16->dwCallback = mip32a->dwCallback;
1519 mip16->lpstrReturn = (LPSTR)SEGPTR_GET(SEGPTR_ALLOC(mip32a->dwRetSize));
1520 mip16->dwRetSize = mip32a->dwRetSize;
1521 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
1522 ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
1523 }
1524 } else {
1525 return MCI_MAP_NOMEM;
1526 }
1527 *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_INFO_PARMSA);
1528 }
1529 return MCI_MAP_OKMEM;
1530 /* case MCI_MARK: */
1531 /* case MCI_MONITOR: */
1532 case MCI_OPEN:
1533 case MCI_OPEN_DRIVER:
1534 {
1535 LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
1536 char* ptr = SEGPTR_ALLOC(sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
1537 LPMCI_OPEN_PARMS16 mop16;
1538
1539
1540 if (ptr) {
1541 *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
1542 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
1543 mop16->dwCallback = mop32a->dwCallback;
1544 mop16->wDeviceID = mop32a->wDeviceID;
1545 if (dwFlags & MCI_OPEN_TYPE) {
1546 if (dwFlags & MCI_OPEN_TYPE_ID) {
1547 /* dword "transparent" value */
1548 mop16->lpstrDeviceType = mop32a->lpstrDeviceType;
1549 } else {
1550 /* string */
1551 mop16->lpstrDeviceType = mop32a->lpstrDeviceType ? (LPSTR)SEGPTR_GET(SEGPTR_STRDUP(mop32a->lpstrDeviceType)) : 0;
1552 }
1553 } else {
1554 /* nuthin' */
1555 mop16->lpstrDeviceType = 0;
1556 }
1557 if (dwFlags & MCI_OPEN_ELEMENT) {
1558 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
1559 mop16->lpstrElementName = mop32a->lpstrElementName;
1560 } else {
1561 mop16->lpstrElementName = mop32a->lpstrElementName ? (LPSTR)SEGPTR_GET(SEGPTR_STRDUP(mop32a->lpstrElementName)) : 0;
1562 }
1563 } else {
1564 mop16->lpstrElementName = 0;
1565 }
1566 if (dwFlags & MCI_OPEN_ALIAS) {
1567 mop16->lpstrAlias = mop32a->lpstrAlias ? (LPSTR)SEGPTR_GET(SEGPTR_STRDUP(mop32a->lpstrAlias)) : 0;
1568 } else {
1569 mop16->lpstrAlias = 0;
1570 }
1571 /* copy extended information if any...
1572 * FIXME: this may seg fault if initial structure does not contain them and
1573 * the reads after msip16 fail under LDT limits...
1574 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1575 * should not take care of extended parameters, and should be used by MCI_Open
1576 * to fetch uDevType. When, this is known, the mapping for sending the
1577 * MCI_OPEN_DRIVER shall be done depending on uDevType.
1578 */
1579 memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
1580 } else {
1581 return MCI_MAP_NOMEM;
1582 }
1583 *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_OPEN_PARMSA);
1584 }
1585 return MCI_MAP_OKMEM;
1586 /* case MCI_PASTE:*/
1587 case MCI_PAUSE:
1588 size = sizeof(MCI_GENERIC_PARMS);
1589 break;
1590 case MCI_PLAY:
1591 size = sizeof(MCI_PLAY_PARMS);
1592 break;
1593 case MCI_PUT:
1594 switch (uDevType) {
1595 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
1596 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
1597 default: size = sizeof(MCI_GENERIC_PARMS); break;
1598 }
1599 break;
1600 case MCI_REALIZE:
1601 size = sizeof(MCI_GENERIC_PARMS);
1602 break;
1603 case MCI_RECORD:
1604 switch (uDevType) {
1605 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break;
1606 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1607 default: size = sizeof(MCI_RECORD_PARMS); break;
1608 }
1609 break;
1610 case MCI_RESUME:
1611 size = sizeof(MCI_GENERIC_PARMS);
1612 break;
1613 case MCI_SEEK:
1614 switch (uDevType) {
1615 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1616 default: size = sizeof(MCI_SEEK_PARMS); break;
1617 }
1618 break;
1619 case MCI_SET:
1620 switch (uDevType) {
1621 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
1622 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1623 case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
1624 /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
1625 * so not doing anything should work...
1626 */
1627 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break;
1628 default: size = sizeof(MCI_SET_PARMS); break;
1629 }
1630 break;
1631 /* case MCI_SETTIMECODE:*/
1632 /* case MCI_SIGNAL:*/
1633 case MCI_SPIN:
1634 size = sizeof(MCI_SET_PARMS);
1635 break;
1636 case MCI_STATUS:
1637 keep = TRUE;
1638 switch (uDevType) {
1639 /* FIXME:
1640 * don't know if buffer for value is the one passed thru lpstrDevice
1641 * or is provided by MCI driver.
1642 * Assuming solution 2: provided by MCI driver, so zeroing on entry
1643 */
1644 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break;
1645 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1646 default: size = sizeof(MCI_STATUS_PARMS); break;
1647 }
1648 break;
1649 case MCI_STEP:
1650 switch (uDevType) {
1651 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
1652 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1653 case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
1654 default: size = sizeof(MCI_GENERIC_PARMS); break;
1655 }
1656 break;
1657 case MCI_STOP:
1658 size = sizeof(MCI_SET_PARMS);
1659 break;
1660 case MCI_SYSINFO:
1661 {
1662 LPMCI_SYSINFO_PARMSA msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
1663 char* ptr = SEGPTR_ALLOC(sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16));
1664 LPMCI_SYSINFO_PARMS16 msip16;
1665
1666 if (ptr) {
1667 *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
1668 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
1669
1670 msip16->dwCallback = msip32a->dwCallback;
1671 msip16->lpstrReturn = (LPSTR)SEGPTR_GET(SEGPTR_ALLOC(msip32a->dwRetSize));
1672 msip16->dwRetSize = msip32a->dwRetSize;
1673 msip16->dwNumber = msip32a->dwNumber;
1674 msip16->wDeviceType = msip32a->wDeviceType;
1675 } else {
1676 return MCI_MAP_NOMEM;
1677 }
1678 *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
1679 }
1680 return MCI_MAP_OKMEM;
1681 /* case MCI_UNDO: */
1682 case MCI_UNFREEZE:
1683 switch (uDevType) {
1684 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
1685 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break;
1686 default: size = sizeof(MCI_GENERIC_PARMS); break;
1687 }
1688 break;
1689 case MCI_UPDATE:
1690 switch (uDevType) {
1691 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break;
1692 default: size = sizeof(MCI_GENERIC_PARMS); break;
1693 }
1694 break;
1695 case MCI_WHERE:
1696 switch (uDevType) {
1697 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
1698 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
1699 default: size = sizeof(MCI_GENERIC_PARMS); break;
1700 }
1701 break;
1702 case MCI_WINDOW:
1703 switch (uDevType) {
1704 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break;
1705 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break;
1706 default: size = sizeof(MCI_GENERIC_PARMS); break;
1707 }
1708 break;
1709 case DRV_LOAD:
1710 case DRV_ENABLE:
1711 case DRV_OPEN:
1712 case DRV_CLOSE:
1713 case DRV_DISABLE:
1714 case DRV_FREE:
1715 case DRV_CONFIGURE:
1716 case DRV_QUERYCONFIGURE:
1717 case DRV_INSTALL:
1718 case DRV_REMOVE:
1719 case DRV_EXITSESSION:
1720 case DRV_EXITAPPLICATION:
1721 case DRV_POWER:
1722 return MCI_MAP_PASS;
1723
1724 default:
1725 WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
1726 return MCI_MAP_MSGERROR;
1727 }
1728 return MCI_MsgMapper32To16_Create((void**)lParam, size, map, keep);
1729 }
1730
1731 /**************************************************************************
1732 * MCI_UnMapMsg32ATo16 [internal]
1733 */
1734 static MCI_MapType MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
1735 {
1736 int size = 0;
1737 BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
1738 DWORD map = 0;
1739
1740 switch (wMsg) {
1741 case MCI_BREAK:
1742 break;
1743 /* case MCI_CAPTURE */
1744 case MCI_CLOSE:
1745 case MCI_CLOSE_DRIVER:
1746 break;
1747 /* case MCI_CONFIGURE:*/
1748 /* case MCI_COPY: */
1749 case MCI_CUE:
1750 break;
1751 /* case MCI_CUT: */
1752 case MCI_DELETE:
1753 break;
1754 /* case MCI_ESCAPE: */
1755 case MCI_FREEZE:
1756 break;
1757 case MCI_GETDEVCAPS:
1758 kept = TRUE;
1759 size = sizeof(MCI_GETDEVCAPS_PARMS);
1760 break;
1761 /* case MCI_INDEX: */
1762 case MCI_INFO:
1763 {
1764 LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(lParam);
1765 LPMCI_INFO_PARMSA mip32a = *(LPMCI_INFO_PARMSA*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSA));
1766
1767 memcpy(mip32a->lpstrReturn, PTR_SEG_TO_LIN(mip16->lpstrReturn), mip32a->dwRetSize);
1768
1769 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(mip16->lpstrReturn)))
1770 FIXME("bad free line=%d\n", __LINE__);
1771 if (!SEGPTR_FREE((char*)mip16 - sizeof(LPMCI_INFO_PARMSA)))
1772 FIXME("bad free line=%d\n", __LINE__);
1773 }
1774 return MCI_MAP_OK;
1775 /* case MCI_MARK: */
1776 /* case MCI_MONITOR: */
1777 case MCI_OPEN:
1778 case MCI_OPEN_DRIVER:
1779 if (lParam) {
1780 LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)PTR_SEG_TO_LIN(lParam);
1781 LPMCI_OPEN_PARMSA mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
1782
1783 mop32a->wDeviceID = mop16->wDeviceID;
1784 if ((dwFlags & MCI_OPEN_TYPE) && !
1785 (dwFlags & MCI_OPEN_TYPE_ID) &&
1786 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16->lpstrDeviceType)))
1787 FIXME("bad free line=%d\n", __LINE__);
1788 if ((dwFlags & MCI_OPEN_ELEMENT) &&
1789 !(dwFlags & MCI_OPEN_ELEMENT_ID) &&
1790 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16->lpstrElementName)))
1791 FIXME("bad free line=%d\n", __LINE__);
1792 if ((dwFlags & MCI_OPEN_ALIAS) &&
1793 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16->lpstrAlias)))
1794 FIXME("bad free line=%d\n", __LINE__);
1795
1796 if (!SEGPTR_FREE((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA)))
1797 FIXME("bad free line=%d\n", __LINE__);
1798 }
1799 return MCI_MAP_OK;
1800 /* case MCI_PASTE:*/
1801 case MCI_PAUSE:
1802 break;
1803 case MCI_PLAY:
1804 break;
1805 case MCI_PUT:
1806 break;
1807 case MCI_REALIZE:
1808 break;
1809 case MCI_RECORD:
1810 break;
1811 case MCI_RESUME:
1812 break;
1813 case MCI_SEEK:
1814 break;
1815 case MCI_SET:
1816 break;
1817 /* case MCI_SETTIMECODE:*/
1818 /* case MCI_SIGNAL:*/
1819 case MCI_SPIN:
1820 break;
1821 case MCI_STATUS:
1822 kept = TRUE;
1823 switch (uDevType) {
1824 case MCI_DEVTYPE_DIGITAL_VIDEO:
1825 if (lParam) {
1826 LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)PTR_SEG_TO_LIN(lParam);
1827 LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
1828
1829 if (mdsp16) {
1830 mdsp32a->dwReturn = mdsp16->dwReturn;
1831 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
1832 TRACE("MCI_STATUS (DGV) lpstrDrive=%p\n", mdsp16->lpstrDrive);
1833 TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)PTR_SEG_TO_LIN(mdsp16->lpstrDrive));
1834
1835 /* FIXME: see map function */
1836 strcpy(mdsp32a->lpstrDrive, (LPSTR)PTR_SEG_TO_LIN(mdsp16->lpstrDrive));
1837 }
1838
1839 if (!SEGPTR_FREE((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA)))
1840 FIXME("bad free line=%d\n", __LINE__);
1841 } else {
1842 return MCI_MAP_NOMEM;
1843 }
1844 }
1845 return MCI_MAP_OKMEM;
1846 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1847 default: size = sizeof(MCI_STATUS_PARMS); break;
1848 }
1849 break;
1850 case MCI_STEP:
1851 break;
1852 case MCI_STOP:
1853 break;
1854 case MCI_SYSINFO:
1855 if (lParam) {
1856 LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)PTR_SEG_TO_LIN(lParam);
1857 LPMCI_SYSINFO_PARMSA msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
1858
1859 if (msip16) {
1860 msip16->dwCallback = msip32a->dwCallback;
1861 memcpy(msip32a->lpstrReturn, PTR_SEG_TO_LIN(msip16->lpstrReturn), msip32a->dwRetSize);
1862 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(msip16->lpstrReturn)))
1863 FIXME("bad free line=%d\n", __LINE__);
1864
1865 if (!SEGPTR_FREE((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA)))
1866 FIXME("bad free line=%d\n", __LINE__);
1867 } else {
1868 return MCI_MAP_NOMEM;
1869 }
1870 }
1871 return MCI_MAP_OKMEM;
1872 /* case MCI_UNDO: */
1873 case MCI_UNFREEZE:
1874 break;
1875 case MCI_UPDATE:
1876 break;
1877 case MCI_WHERE:
1878 switch (uDevType) {
1879 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
1880 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
1881 default: break;
1882 }
1883 break;
1884 case MCI_WINDOW:
1885 switch (uDevType) {
1886 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break;
1887 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break;
1888 default: break;
1889 }
1890 /* FIXME: see map function */
1891 break;
1892
1893 case DRV_LOAD:
1894 case DRV_ENABLE:
1895 case DRV_OPEN:
1896 case DRV_CLOSE:
1897 case DRV_DISABLE:
1898 case DRV_FREE:
1899 case DRV_CONFIGURE:
1900 case DRV_QUERYCONFIGURE:
1901 case DRV_INSTALL:
1902 case DRV_REMOVE:
1903 case DRV_EXITSESSION:
1904 case DRV_EXITAPPLICATION:
1905 case DRV_POWER:
1906 FIXME("This is a hack\n");
1907 return MCI_MAP_PASS;
1908 default:
1909 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
1910 return MCI_MAP_MSGERROR;
1911 }
1912 return MCI_MsgMapper32To16_Destroy((void*)lParam, size, map, kept);
1913 }
1914
1915 /**************************************************************************
1916 * MCI_SendCommandFrom32 [internal]
1917 */
1918 DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
1919 {
1920 DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
1921 LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);
1922
1923 if (!wmd) {
1924 dwRet = MCIERR_INVALID_DEVICE_ID;
1925 } else {
1926 switch (GetDriverFlags(wmd->hDrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) {
1927 case WINE_GDF_EXIST|WINE_GDF_16BIT:
1928 {
1929 MCI_MapType res;
1930
1931 switch (res = MCI_MapMsg32ATo16(wmd->wType, wMsg, dwParam1, &dwParam2)) {
1932 case MCI_MAP_MSGERROR:
1933 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
1934 dwRet = MCIERR_DRIVER_INTERNAL;
1935 break;
1936 case MCI_MAP_NOMEM:
1937 TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg));
1938 dwRet = MCIERR_OUT_OF_MEMORY;
1939 break;
1940 case MCI_MAP_OK:
1941 case MCI_MAP_OKMEM:
1942 dwRet = SendDriverMessage16(wmd->hDrv, wMsg, dwParam1, dwParam2);
1943 if (res == MCI_MAP_OKMEM)
1944 MCI_UnMapMsg32ATo16(wmd->wType, wMsg, dwParam1, dwParam2);
1945 break;
1946 case MCI_MAP_PASS:
1947 dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
1948 break;
1949 }
1950 }
1951 break;
1952 case WINE_GDF_EXIST:
1953 dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
1954 break;
1955 default:
1956 WARN("Unknown driver %u\n", wmd->hDrv);
1957 dwRet = MCIERR_DRIVER_INTERNAL;
1958 }
1959 }
1960 return dwRet;
1961 }
1962
1963 /**************************************************************************
1964 * MCI_SendCommandFrom16 [internal]
1965 */
1966 DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
1967 {
1968 DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
1969 LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);
1970
1971 if (!wmd) {
1972 dwRet = MCIERR_INVALID_DEVICE_ID;
1973 } else {
1974 MCI_MapType res;
1975
1976 switch (GetDriverFlags(wmd->hDrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) {
1977 case WINE_GDF_EXIST|WINE_GDF_16BIT:
1978 dwRet = SendDriverMessage16(wmd->hDrv, wMsg, dwParam1, dwParam2);
1979 break;
1980 case WINE_GDF_EXIST:
1981 switch (res = MCI_MapMsg16To32A(wmd->wType, wMsg, &dwParam2)) {
1982 case MCI_MAP_MSGERROR:
1983 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
1984 dwRet = MCIERR_DRIVER_INTERNAL;
1985 break;
1986 case MCI_MAP_NOMEM:
1987 TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg));
1988 dwRet = MCIERR_OUT_OF_MEMORY;
1989 break;
1990 case MCI_MAP_OK:
1991 case MCI_MAP_OKMEM:
1992 dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
1993 if (res == MCI_MAP_OKMEM)
1994 MCI_UnMapMsg16To32A(wmd->wType, wMsg, dwParam2);
1995 break;
1996 case MCI_MAP_PASS:
1997 dwRet = SendDriverMessage16(wmd->hDrv, wMsg, dwParam1, dwParam2);
1998 break;
1999 }
2000 break;
2001 default:
2002 WARN("Unknown driver %u\n", wmd->hDrv);
2003 dwRet = MCIERR_DRIVER_INTERNAL;
2004 }
2005 }
2006 return dwRet;
2007 }
2008
2009 /**************************************************************************
2010 * MCI_Open [internal]
2011 */
2012 static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
2013 {
2014 char strDevTyp[128];
2015 DWORD dwRet;
2016 LPWINE_MCIDRIVER wmd;
2017 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
2018
2019 TRACE("(%08lX, %p)\n", dwParam, lpParms);
2020 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
2021
2022 /* only two low bytes are generic, the other ones are dev type specific */
2023 #define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
2024 MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
2025 MCI_NOTIFY|MCI_WAIT)
2026 if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0) {
2027 FIXME("Unsupported yet dwFlags=%08lX\n", dwParam & ~WINE_MCIDRIVER_SUPP);
2028 }
2029 #undef WINE_MCIDRIVER_SUPP
2030
2031 strDevTyp[0] = 0;
2032
2033 if (dwParam & MCI_OPEN_TYPE) {
2034 if (dwParam & MCI_OPEN_TYPE_ID) {
2035 WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
2036
2037 if (uDevType < MCI_DEVTYPE_FIRST ||
2038 uDevType > MCI_DEVTYPE_LAST ||
2039 !LoadStringA(iData->hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp))) {
2040 dwRet = MCIERR_BAD_INTEGER;
2041 goto errCleanUp;
2042 }
2043 } else {
2044 LPSTR ptr;
2045 if (lpParms->lpstrDeviceType == NULL) {
2046 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2047 goto errCleanUp;
2048 }
2049 strcpy(strDevTyp, lpParms->lpstrDeviceType);
2050 ptr = strchr(strDevTyp, '!');
2051 if (ptr) {
2052 /* this behavior is not documented in windows. However, since, in
2053 * some occasions, MCI_OPEN handling is translated by WinMM into
2054 * a call to mciSendString("open <type>"); this code shall be correct
2055 */
2056 if (dwParam & MCI_OPEN_ELEMENT) {
2057 ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
2058 lpParms->lpstrElementName, strDevTyp);
2059 dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
2060 goto errCleanUp;
2061 }
2062 dwParam |= MCI_OPEN_ELEMENT;
2063 *ptr++ = 0;
2064 /* FIXME: not a good idea to write in user supplied buffer */
2065 lpParms->lpstrElementName = ptr;
2066 }
2067
2068 }
2069 TRACE("devType='%s' !\n", strDevTyp);
2070 }
2071
2072 if (dwParam & MCI_OPEN_ELEMENT) {
2073 TRACE("lpstrElementName='%s'\n", lpParms->lpstrElementName);
2074
2075 if (dwParam & MCI_OPEN_ELEMENT_ID) {
2076 FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
2077 dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
2078 goto errCleanUp;
2079 }
2080
2081 if (!lpParms->lpstrElementName) {
2082 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2083 goto errCleanUp;
2084 }
2085
2086 /* type, if given as a parameter, supersedes file extension */
2087 if (!strDevTyp[0] &&
2088 MCI_GetDevTypeFromFileName(lpParms->lpstrElementName,
2089 strDevTyp, sizeof(strDevTyp))) {
2090 if (GetDriveTypeA(lpParms->lpstrElementName) != DRIVE_CDROM) {
2091 dwRet = MCIERR_EXTENSION_NOT_FOUND;
2092 goto errCleanUp;
2093 }
2094 /* FIXME: this will not work if several CDROM drives are installed on the machine */
2095 strcpy(strDevTyp, "CDAUDIO");
2096 }
2097 }
2098
2099 if (strDevTyp[0] == 0) {
2100 FIXME("Couldn't load driver\n");
2101 dwRet = MCIERR_INVALID_DEVICE_NAME;
2102 goto errCleanUp;
2103 }
2104
2105 if (dwParam & MCI_OPEN_ALIAS) {
2106 TRACE("Alias='%s' !\n", lpParms->lpstrAlias);
2107 if (!lpParms->lpstrAlias) {
2108 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2109 goto errCleanUp;
2110 }
2111 }
2112
2113 if ((dwRet = MCI_LoadMciDriver(iData, strDevTyp, &wmd))) {
2114 goto errCleanUp;
2115 }
2116
2117 if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) {
2118 TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet);
2119 /* FIXME: is dwRet the correct ret code ? */
2120 goto errCleanUp;
2121 }
2122
2123 /* only handled devices fall through */
2124 TRACE("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet);
2125
2126 if (dwParam & MCI_NOTIFY)
2127 mciDriverNotify16(lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL);
2128
2129 return 0;
2130 errCleanUp:
2131 MCI_UnLoadMciDriver(iData, wmd);
2132
2133 if (dwParam & MCI_NOTIFY)
2134 mciDriverNotify16(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE);
2135 return dwRet;
2136 }
2137
2138 /**************************************************************************
2139 * MCI_Close [internal]
2140 */
2141 static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
2142 {
2143 DWORD dwRet;
2144 LPWINE_MCIDRIVER wmd;
2145 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
2146
2147 TRACE("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
2148
2149 if (wDevID == MCI_ALL_DEVICE_ID) {
2150 LPWINE_MCIDRIVER next;
2151
2152 EnterCriticalSection(&iData->cs);
2153 /* FIXME: shall I notify once after all is done, or for
2154 * each of the open drivers ? if the latest, which notif
2155 * to return when only one fails ?
2156 */
2157 for (wmd = iData->lpMciDrvs; wmd; ) {
2158 next = wmd->lpNext;
2159 MCI_Close(wmd->wDeviceID, dwParam, lpParms);
2160 wmd = next;
2161 }
2162 LeaveCriticalSection(&iData->cs);
2163 return 0;
2164 }
2165
2166 if (!(wmd = MCI_GetDriver(wDevID))) {
2167 return MCIERR_INVALID_DEVICE_ID;
2168 }
2169
2170 dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
2171
2172 MCI_UnLoadMciDriver(iData, wmd);
2173
2174 if (dwParam & MCI_NOTIFY)
2175 mciDriverNotify16(lpParms->dwCallback, wDevID,
2176 (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
2177
2178 return dwRet;
2179 }
2180
2181 /**************************************************************************
2182 * MCI_WriteString [internal]
2183 */
2184 DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
2185 {
2186 DWORD ret = 0;
2187
2188 if (lpSrcStr) {
2189 if (dstSize <= strlen(lpSrcStr)) {
2190 lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
2191 ret = MCIERR_PARAM_OVERFLOW;
2192 } else {
2193 strcpy(lpDstStr, lpSrcStr);
2194 }
2195 } else {
2196 *lpDstStr = 0;
2197 }
2198 return ret;
2199 }
2200
2201 /**************************************************************************
2202 * MCI_Sysinfo [internal]
2203 */
2204 static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
2205 {
2206 DWORD ret = MCIERR_INVALID_DEVICE_ID;
2207 LPWINE_MCIDRIVER wmd;
2208 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
2209
2210 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
2211
2212 TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
2213 uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
2214
2215 switch (dwFlags & ~MCI_SYSINFO_OPEN) {
2216 case MCI_SYSINFO_QUANTITY:
2217 {
2218 DWORD cnt = 0;
2219
2220 if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST ||
2221 lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
2222 if (dwFlags & MCI_SYSINFO_OPEN) {
2223 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
2224 EnterCriticalSection(&iData->cs);
2225 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
2226 cnt++;
2227 }
2228 LeaveCriticalSection(&iData->cs);
2229 } else {
2230 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
2231 cnt = MCI_InstalledCount;
2232 }
2233 } else {
2234 if (dwFlags & MCI_SYSINFO_OPEN) {
2235 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n",
2236 lpParms->wDeviceType);
2237 EnterCriticalSection(&iData->cs);
2238 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
2239 if (wmd->wType == lpParms->wDeviceType)
2240 cnt++;
2241 }
2242 LeaveCriticalSection(&iData->cs);
2243 } else {
2244 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n",
2245 lpParms->wDeviceType);
2246 FIXME("Don't know how to get # of MCI devices of a given type\n");
2247 cnt = 1;
2248 }
2249 }
2250 *(DWORD*)lpParms->lpstrReturn = cnt;
2251 }
2252 TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
2253 ret = MCI_INTEGER_RETURNED;
2254 break;
2255 case MCI_SYSINFO_INSTALLNAME:
2256 TRACE("MCI_SYSINFO_INSTALLNAME \n");
2257 if ((wmd = MCI_GetDriver(uDevID))) {
2258 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize,
2259 wmd->lpstrDeviceType);
2260 } else {
2261 *lpParms->lpstrReturn = 0;
2262 ret = MCIERR_INVALID_DEVICE_ID;
2263 }
2264 TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
2265 break;
2266 case MCI_SYSINFO_NAME:
2267 TRACE("MCI_SYSINFO_NAME\n");
2268 if (dwFlags & MCI_SYSINFO_OPEN) {
2269 FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
2270 ret = MCIERR_UNRECOGNIZED_COMMAND;
2271 } else if (lpParms->dwNumber > MCI_InstalledCount) {
2272 ret = MCIERR_OUTOFRANGE;
2273 } else {
2274 DWORD count = lpParms->dwNumber;
2275 LPSTR ptr = MCI_lpInstallNames;
2276
2277 while (--count > 0) ptr += strlen(ptr) + 1;
2278 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
2279 }
2280 TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
2281 break;
2282 default:
2283 TRACE("Unsupported flag value=%08lx\n", dwFlags);
2284 ret = MCIERR_UNRECOGNIZED_COMMAND;
2285 }
2286 return ret;
2287 }
2288
2289 /**************************************************************************
2290 * MCI_Break [internal]
2291 */
2292 static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
2293 {
2294 DWORD dwRet = 0;
2295
2296 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
2297
2298 if (dwFlags & MCI_NOTIFY)
2299 mciDriverNotify16(lpParms->dwCallback, wDevID,
2300 (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
2301
2302 return dwRet;
2303 }
2304
2305 /**************************************************************************
2306 * MCI_SendCommand [internal]
2307 */
2308 DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1,
2309 DWORD dwParam2, BOOL bFrom32)
2310 {
2311 DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND;
2312
2313 switch (wMsg) {
2314 case MCI_OPEN:
2315 if (bFrom32) {
2316 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
2317 } else {
2318 switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2319 case MCI_MAP_OK:
2320 case MCI_MAP_OKMEM:
2321 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
2322 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2323 break;
2324 default: break; /* so that gcc does not bark */
2325 }
2326 }
2327 break;
2328 case MCI_CLOSE:
2329 if (bFrom32) {
2330 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2331 } else {
2332 switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2333 case MCI_MAP_OK:
2334 case MCI_MAP_OKMEM:
2335 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2336 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2337 break;
2338 default: break; /* so that gcc does not bark */
2339 }
2340 }
2341 break;
2342 case MCI_SYSINFO:
2343 if (bFrom32) {
2344 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
2345 } else {
2346 switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2347 case MCI_MAP_OK:
2348 case MCI_MAP_OKMEM:
2349 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
2350 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2351 break;
2352 default: break; /* so that gcc doesnot bark */
2353 }
2354 }
2355 break;
2356 case MCI_BREAK:
2357 if (bFrom32) {
2358 dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
2359 } else {
2360 switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2361 case MCI_MAP_OK:
2362 case MCI_MAP_OKMEM:
2363 dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
2364 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2365 break;
2366 default: break; /* so that gcc does not bark */
2367 }
2368 }
2369 break;
2370 case MCI_SOUND:
2371 /* FIXME: it seems that MCI_SOUND needs the same handling as MCI_BREAK
2372 * but I couldn't get any doc on this MCI message
2373 */
2374 break;
2375 default:
2376 if (wDevID == MCI_ALL_DEVICE_ID) {
2377 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
2378 dwRet = MCIERR_CANNOT_USE_ALL;
2379 } else {
2380 dwRet = (bFrom32) ?
2381 MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2) :
2382 MCI_SendCommandFrom16(wDevID, wMsg, dwParam1, dwParam2);
2383 }
2384 break;
2385 }
2386 return dwRet;
2387 }
2388
2389 /**************************************************************************
2390 * MCI_CleanUp [internal]
2391 *
2392 * Some MCI commands need to be cleaned-up (when not called from
2393 * mciSendString), because MCI drivers return extra information for string
2394 * transformation. This function gets rid of them.
2395 */
2396 LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2, BOOL bIs32)
2397 {
2398 if (LOWORD(dwRet))
2399 return LOWORD(dwRet);
2400
2401 switch (wMsg) {
2402 case MCI_GETDEVCAPS:
2403 switch (dwRet & 0xFFFF0000ul) {
2404 case 0:
2405 case MCI_COLONIZED3_RETURN:
2406 case MCI_COLONIZED4_RETURN:
2407 case MCI_INTEGER_RETURNED:
2408 /* nothing to do */
2409 break;
2410 case MCI_RESOURCE_RETURNED:
2411 case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
2412 {
2413 LPMCI_GETDEVCAPS_PARMS lmgp;
2414
2415 lmgp = (LPMCI_GETDEVCAPS_PARMS)(bIs32 ? (void*)dwParam2 : PTR_SEG_TO_LIN(dwParam2));
2416 TRACE("Changing %08lx to %08lx\n", lmgp->dwReturn, (DWORD)LOWORD(lmgp->dwReturn));
2417 lmgp->dwReturn = LOWORD(lmgp->dwReturn);
2418 }
2419 break;
2420 default:
2421 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2422 HIWORD(dwRet), MCI_MessageToString(wMsg));
2423 }
2424 break;
2425 case MCI_STATUS:
2426 switch (dwRet & 0xFFFF0000ul) {
2427 case 0:
2428 case MCI_COLONIZED3_RETURN:
2429 case MCI_COLONIZED4_RETURN:
2430 case MCI_INTEGER_RETURNED:
2431 /* nothing to do */
2432 break;
2433 case MCI_RESOURCE_RETURNED:
2434 case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
2435 {
2436 LPMCI_STATUS_PARMS lsp;
2437
2438 lsp = (LPMCI_STATUS_PARMS)(bIs32 ? (void*)dwParam2 : PTR_SEG_TO_LIN(dwParam2));
2439 TRACE("Changing %08lx to %08lx\n", lsp->dwReturn, (DWORD)LOWORD(lsp->dwReturn));
2440 lsp->dwReturn = LOWORD(lsp->dwReturn);
2441 }
2442 break;
2443 default:
2444 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2445 HIWORD(dwRet), MCI_MessageToString(wMsg));
2446 }
2447 break;
2448 case MCI_SYSINFO:
2449 switch (dwRet & 0xFFFF0000ul) {
2450 case 0:
2451 case MCI_INTEGER_RETURNED:
2452 /* nothing to do */
2453 break;
2454 default:
2455 FIXME("Unsupported value for hiword (%04x)\n", HIWORD(dwRet));
2456 }
2457 break;
2458 default:
2459 if (HIWORD(dwRet)) {
2460 FIXME("Got non null hiword for dwRet=0x%08lx for command %s\n",
2461 dwRet, MCI_MessageToString(wMsg));
2462 }
2463 break;
2464 }
2465 return LOWORD(dwRet);
2466 }
2467
2468 /**************************************************************************
2469 * MULTIMEDIA_MciInit [internal]
2470 *
2471 * Initializes the MCI internal variables.
2472 *
2473 */
2474 BOOL MULTIMEDIA_MciInit(void)
2475 {
2476 LPSTR ptr1, ptr2;
2477
2478 MCI_InstalledCount = 0;
2479 ptr1 = MCI_lpInstallNames = HeapAlloc(GetProcessHeap(), 0, 2048);
2480
2481 if (!MCI_lpInstallNames)
2482 return FALSE;
2483
2484 /* FIXME: should do also some registry diving here ? */
2485 if (PROFILE_GetWineIniString("options", "mci", "", MCI_lpInstallNames, 2048) > 0) {
2486 TRACE("Wine => '%s' \n", ptr1);
2487 while ((ptr2 = strchr(ptr1, ':')) != 0) {
2488 *ptr2++ = 0;
2489 TRACE("---> '%s' \n", ptr1);
2490 MCI_InstalledCount++;
2491 ptr1 = ptr2;
2492 }
2493 MCI_InstalledCount++;
2494 TRACE("---> '%s' \n", ptr1);
2495 ptr1 += strlen(ptr1) + 1;
2496 } else {
2497 GetPrivateProfileStringA("mci", NULL, "", MCI_lpInstallNames, 2048, "SYSTEM.INI");
2498 while (strlen(ptr1) > 0) {
2499 TRACE("---> '%s' \n", ptr1);
2500 ptr1 += strlen(ptr1) + 1;
2501 MCI_InstalledCount++;
2502 }
2503 }
2504 return TRUE;
2505 }
2506
Windows API implementation