mci.c 76 KB
Newer Older
1 2 3 4
/*
 * MCI internal functions
 *
 * Copyright 1998/1999 Eric Pouech
5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 20
 */

21 22 23 24 25 26 27 28 29 30 31 32 33
/* TODO:
 * - implement WINMM (32bit) multitasking and use it in all MCI drivers
 *   instead of the home grown one 
 * - 16bit mmTaskXXX functions are currently broken because the 16
 *   loader does not support binary command lines => provide Wine's
 *   own mmtask.tsk not using binary command line.
 * - correctly handle the MCI_ALL_DEVICE_ID in functions.
 * - finish mapping 16 <=> 32 of MCI structures and commands
 * - implement auto-open feature (ie, when a string command is issued
 *   for a not yet opened device, MCI automatically opens it) 
 * - use a default registry setting to replace the [mci] section in
 *   configuration file (layout of info in registry should be compatible
 *   with all Windows' version - which use different layouts of course)
34 35 36 37 38 39
 * - implement automatic open
 *      + only works on string interface, on regular devices (don't work on all
 *        nor custom devices)
 * - command table handling isn't thread safe
 */

40
#include <stdlib.h>
41
#include <stdarg.h>
42
#include <stdio.h>
43 44
#include <string.h>

45
#include "windef.h"
46
#include "winbase.h"
47
#include "wingdi.h"
48
#include "mmsystem.h"
49
#include "winuser.h"
50
#include "winnls.h"
51
#include "winreg.h"
52
#include "wownt32.h"
53 54

#include "digitalv.h"
55
#include "winemm.h"
56

57
#include "wine/debug.h"
58

59
WINE_DEFAULT_DEBUG_CHANNEL(mci);
60

61 62
/* First MCI valid device ID (0 means error) */
#define MCI_MAGIC 0x0001
63

64
/* MCI settings */
65 66 67 68 69 70
static const WCHAR wszHklmMci  [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','M','C','I',0};
static const WCHAR wszNull     [] = {0};
static const WCHAR wszAll      [] = {'A','L','L',0};
static const WCHAR wszMci      [] = {'M','C','I',0};
static const WCHAR wszOpen     [] = {'o','p','e','n',0};
static const WCHAR wszSystemIni[] = {'s','y','s','t','e','m','.','i','n','i',0};
71

72 73
static WINE_MCIDRIVER *MciDrivers;

74
static UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data);
75
static UINT MCI_SetCommandTable(HGLOBAL hMem, UINT uDevType);
76

77
/* dup a string and uppercase it */
78
static inline LPWSTR str_dup_upper( LPCWSTR str )
79
{
80
    INT len = (lstrlenW(str) + 1) * sizeof(WCHAR);
81
    LPWSTR p = HeapAlloc( GetProcessHeap(), 0, len );
82 83 84
    if (p)
    {
        memcpy( p, str, len );
85
        CharUpperW( p );
86 87 88 89
    }
    return p;
}

90 91 92
/**************************************************************************
 * 				MCI_GetDriver			[internal]
 */
93
static LPWINE_MCIDRIVER	MCI_GetDriver(UINT wDevID)
94 95 96
{
    LPWINE_MCIDRIVER	wmd = 0;

97 98
    EnterCriticalSection(&WINMM_cs);
    for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) {
99 100
	if (wmd->wDeviceID == wDevID)
	    break;
101
    }
102
    LeaveCriticalSection(&WINMM_cs);
103 104 105 106 107 108
    return wmd;
}

/**************************************************************************
 * 				MCI_GetDriverFromString		[internal]
 */
109
static UINT MCI_GetDriverFromString(LPCWSTR lpstrName)
110 111 112 113 114 115
{
    LPWINE_MCIDRIVER	wmd;
    UINT		ret = 0;

    if (!lpstrName)
	return 0;
116

117
    if (!wcsicmp(lpstrName, wszAll))
118
	return MCI_ALL_DEVICE_ID;
119

120 121
    EnterCriticalSection(&WINMM_cs);
    for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) {
122
	if (wmd->lpstrAlias && wcsicmp(wmd->lpstrAlias, lpstrName) == 0) {
123 124 125
	    ret = wmd->wDeviceID;
	    break;
	}
126
    }
127
    LeaveCriticalSection(&WINMM_cs);
128

129 130 131 132 133 134
    return ret;
}

/**************************************************************************
 * 			MCI_MessageToString			[internal]
 */
135
static const char* MCI_MessageToString(UINT wMsg)
136 137
{
#define CASE(s) case (s): return #s
138

139
    switch (wMsg) {
140 141 142 143 144 145 146 147 148 149 150 151 152
        CASE(DRV_LOAD);
        CASE(DRV_ENABLE);
        CASE(DRV_OPEN);
        CASE(DRV_CLOSE);
        CASE(DRV_DISABLE);
        CASE(DRV_FREE);
        CASE(DRV_CONFIGURE);
        CASE(DRV_QUERYCONFIGURE);
        CASE(DRV_INSTALL);
        CASE(DRV_REMOVE);
        CASE(DRV_EXITSESSION);
        CASE(DRV_EXITAPPLICATION);
        CASE(DRV_POWER);
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
	CASE(MCI_BREAK);
	CASE(MCI_CLOSE);
	CASE(MCI_CLOSE_DRIVER);
	CASE(MCI_COPY);
	CASE(MCI_CUE);
	CASE(MCI_CUT);
	CASE(MCI_DELETE);
	CASE(MCI_ESCAPE);
	CASE(MCI_FREEZE);
	CASE(MCI_PAUSE);
	CASE(MCI_PLAY);
	CASE(MCI_GETDEVCAPS);
	CASE(MCI_INFO);
	CASE(MCI_LOAD);
	CASE(MCI_OPEN);
	CASE(MCI_OPEN_DRIVER);
	CASE(MCI_PASTE);
	CASE(MCI_PUT);
	CASE(MCI_REALIZE);
	CASE(MCI_RECORD);
	CASE(MCI_RESUME);
	CASE(MCI_SAVE);
	CASE(MCI_SEEK);
	CASE(MCI_SET);
Jörg Höhle's avatar
Jörg Höhle committed
177
	CASE(MCI_SOUND);
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
	CASE(MCI_SPIN);
	CASE(MCI_STATUS);
	CASE(MCI_STEP);
	CASE(MCI_STOP);
	CASE(MCI_SYSINFO);
	CASE(MCI_UNFREEZE);
	CASE(MCI_UPDATE);
	CASE(MCI_WHERE);
	CASE(MCI_WINDOW);
	/* constants for digital video */
	CASE(MCI_CAPTURE);
	CASE(MCI_MONITOR);
	CASE(MCI_RESERVE);
	CASE(MCI_SETAUDIO);
	CASE(MCI_SIGNAL);
	CASE(MCI_SETVIDEO);
	CASE(MCI_QUALITY);
	CASE(MCI_LIST);
	CASE(MCI_UNDO);
	CASE(MCI_CONFIGURE);
	CASE(MCI_RESTORE);
#undef CASE
    default:
201
        return wine_dbg_sprintf("MCI_<<%04X>>", wMsg);
202 203 204
    }
}

205
static LPWSTR MCI_strdupAtoW( LPCSTR str )
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
{
    LPWSTR ret;
    INT len;

    if (!str) return NULL;
    len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
    ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
    if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
    return ret;
}

static int MCI_MapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2)
{
    if (msg < DRV_RESERVED) return 0;

    switch (msg)
    {
    case MCI_CLOSE:
    case MCI_CONFIGURE:
    case MCI_PLAY:
    case MCI_SEEK:
    case MCI_STOP:
    case MCI_PAUSE:
    case MCI_GETDEVCAPS:
    case MCI_SPIN:
    case MCI_SET:
    case MCI_STEP:
    case MCI_RECORD:
    case MCI_BREAK:
    case MCI_STATUS:
    case MCI_CUE:
    case MCI_REALIZE:
    case MCI_PUT:
    case MCI_WHERE:
    case MCI_FREEZE:
    case MCI_UNFREEZE:
    case MCI_CUT:
    case MCI_COPY:
    case MCI_PASTE:
    case MCI_UPDATE:
    case MCI_RESUME:
    case MCI_DELETE:
248 249
    case MCI_MONITOR:
    case MCI_SIGNAL:
250
    case MCI_UNDO:
251 252 253
        return 0;

    case MCI_OPEN:
254 255 256 257
        {   /* MCI_ANIM_OPEN_PARMS is the largest known MCI_OPEN_PARMS
             * structure, larger than MCI_WAVE_OPEN_PARMS */
            MCI_ANIM_OPEN_PARMSA *mci_openA = (MCI_ANIM_OPEN_PARMSA*)*dwParam2;
            MCI_ANIM_OPEN_PARMSW *mci_openW;
258 259
            DWORD_PTR *ptr;

260
            ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD_PTR) + sizeof(*mci_openW));
261 262 263 264
            if (!ptr) return -1;

            *ptr++ = *dwParam2; /* save the previous pointer */
            *dwParam2 = (DWORD_PTR)ptr;
265
            mci_openW = (MCI_ANIM_OPEN_PARMSW *)ptr;
266 267 268 269 270 271 272

            if (dwParam1 & MCI_NOTIFY)
                mci_openW->dwCallback = mci_openA->dwCallback;

            if (dwParam1 & MCI_OPEN_TYPE)
            {
                if (dwParam1 & MCI_OPEN_TYPE_ID)
273
                    mci_openW->lpstrDeviceType = (LPCWSTR)mci_openA->lpstrDeviceType;
274 275 276 277 278 279
                else
                    mci_openW->lpstrDeviceType = MCI_strdupAtoW(mci_openA->lpstrDeviceType);
            }
            if (dwParam1 & MCI_OPEN_ELEMENT)
            {
                if (dwParam1 & MCI_OPEN_ELEMENT_ID)
280
                    mci_openW->lpstrElementName = (LPCWSTR)mci_openA->lpstrElementName;
281 282 283 284 285
                else
                    mci_openW->lpstrElementName = MCI_strdupAtoW(mci_openA->lpstrElementName);
            }
            if (dwParam1 & MCI_OPEN_ALIAS)
                mci_openW->lpstrAlias = MCI_strdupAtoW(mci_openA->lpstrAlias);
286 287 288 289
            /* We don't know how many DWORD follow, as
             * the structure depends on the device. */
            if (HIWORD(dwParam1))
                memcpy(&mci_openW->dwStyle, &mci_openA->dwStyle, sizeof(MCI_ANIM_OPEN_PARMSW) - sizeof(MCI_OPEN_PARMSW));
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
        }
        return 1;

    case MCI_WINDOW:
        if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
        {
            MCI_ANIM_WINDOW_PARMSA *mci_windowA = (MCI_ANIM_WINDOW_PARMSA *)*dwParam2;
            MCI_ANIM_WINDOW_PARMSW *mci_windowW;

            mci_windowW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowW));
            if (!mci_windowW) return -1;

            *dwParam2 = (DWORD_PTR)mci_windowW;

            mci_windowW->lpstrText = MCI_strdupAtoW(mci_windowA->lpstrText);

            if (dwParam1 & MCI_NOTIFY)
                mci_windowW->dwCallback = mci_windowA->dwCallback;
            if (dwParam1 & MCI_ANIM_WINDOW_HWND)
                mci_windowW->hWnd = mci_windowA->hWnd;
            if (dwParam1 & MCI_ANIM_WINDOW_STATE)
                mci_windowW->nCmdShow = mci_windowA->nCmdShow;

            return 1;
        }
        return 0;

    case MCI_SYSINFO:
318
        if (dwParam1 & (MCI_SYSINFO_INSTALLNAME | MCI_SYSINFO_NAME))
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
        {
            MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)*dwParam2;
            MCI_SYSINFO_PARMSW *mci_sysinfoW;
            DWORD_PTR *ptr;

            ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoW) + sizeof(DWORD_PTR));
            if (!ptr) return -1;

            *ptr++ = *dwParam2; /* save the previous pointer */
            *dwParam2 = (DWORD_PTR)ptr;
            mci_sysinfoW = (MCI_SYSINFO_PARMSW *)ptr;

            if (dwParam1 & MCI_NOTIFY)
                mci_sysinfoW->dwCallback = mci_sysinfoA->dwCallback;

334
            /* Size is measured in numbers of characters, despite what MSDN says. */
335
            mci_sysinfoW->dwRetSize = mci_sysinfoA->dwRetSize;
336
            mci_sysinfoW->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_sysinfoW->dwRetSize * sizeof(WCHAR));
337 338 339 340
            mci_sysinfoW->dwNumber = mci_sysinfoA->dwNumber;
            mci_sysinfoW->wDeviceType = mci_sysinfoA->wDeviceType;
            return 1;
        }
341
        return 0;
342 343
    case MCI_INFO:
        {
344 345
            MCI_DGV_INFO_PARMSA *mci_infoA = (MCI_DGV_INFO_PARMSA *)*dwParam2;
            MCI_DGV_INFO_PARMSW *mci_infoW;
346 347 348 349 350 351 352
            DWORD_PTR *ptr;

            ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_infoW) + sizeof(DWORD_PTR));
            if (!ptr) return -1;

            *ptr++ = *dwParam2; /* save the previous pointer */
            *dwParam2 = (DWORD_PTR)ptr;
353
            mci_infoW = (MCI_DGV_INFO_PARMSW *)ptr;
354 355 356 357

            if (dwParam1 & MCI_NOTIFY)
                mci_infoW->dwCallback = mci_infoA->dwCallback;

358
            /* Size is measured in numbers of characters. */
359
            mci_infoW->dwRetSize = mci_infoA->dwRetSize;
360
            mci_infoW->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mci_infoW->dwRetSize * sizeof(WCHAR));
361 362
            if (dwParam1 & MCI_DGV_INFO_ITEM)
                mci_infoW->dwItem = mci_infoA->dwItem;
363 364 365 366
            return 1;
        }
    case MCI_SAVE:
    case MCI_LOAD:
367 368 369 370 371
    case MCI_CAPTURE:
    case MCI_RESTORE:
        {   /* All these commands have the same layout: callback + string + optional rect */
            MCI_OVLY_LOAD_PARMSA *mci_loadA = (MCI_OVLY_LOAD_PARMSA *)*dwParam2;
            MCI_OVLY_LOAD_PARMSW *mci_loadW;
372 373 374 375 376 377 378 379

            mci_loadW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_loadW));
            if (!mci_loadW) return -1;

            *dwParam2 = (DWORD_PTR)mci_loadW;
            if (dwParam1 & MCI_NOTIFY)
                mci_loadW->dwCallback = mci_loadA->dwCallback;
            mci_loadW->lpfilename = MCI_strdupAtoW(mci_loadA->lpfilename);
380 381 382 383 384
            if ((MCI_SAVE    == msg && dwParam1 & MCI_DGV_RECT) ||
                (MCI_LOAD    == msg && dwParam1 & MCI_OVLY_RECT) ||
                (MCI_CAPTURE == msg && dwParam1 & MCI_DGV_CAPTURE_AT) ||
                (MCI_RESTORE == msg && dwParam1 & MCI_DGV_RESTORE_AT))
                mci_loadW->rc = mci_loadA->rc;
385 386
            return 1;
        }
387
    case MCI_SOUND:
388
    case MCI_ESCAPE:
389
        {   /* All these commands have the same layout: callback + string */
390 391 392 393 394 395 396 397 398 399 400 401
            MCI_VD_ESCAPE_PARMSA *mci_vd_escapeA = (MCI_VD_ESCAPE_PARMSA *)*dwParam2;
            MCI_VD_ESCAPE_PARMSW *mci_vd_escapeW;

            mci_vd_escapeW = HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_vd_escapeW));
            if (!mci_vd_escapeW) return -1;

            *dwParam2 = (DWORD_PTR)mci_vd_escapeW;
            if (dwParam1 & MCI_NOTIFY)
                mci_vd_escapeW->dwCallback = mci_vd_escapeA->dwCallback;
            mci_vd_escapeW->lpstrCommand = MCI_strdupAtoW(mci_vd_escapeA->lpstrCommand);
            return 1;
        }
402 403 404 405 406 407 408 409 410
    case MCI_SETAUDIO:
    case MCI_SETVIDEO:
        if (!(dwParam1 & (MCI_DGV_SETVIDEO_QUALITY | MCI_DGV_SETVIDEO_ALG
                        | MCI_DGV_SETAUDIO_QUALITY | MCI_DGV_SETAUDIO_ALG)))
            return 0;
        /* fall through to default */
    case MCI_RESERVE:
    case MCI_QUALITY:
    case MCI_LIST:
411 412
    default:
        FIXME("Message %s needs translation\n", MCI_MessageToString(msg));
413
        return 0; /* pass through untouched */
414 415 416
    }
}

417
static void MCI_UnmapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2,
418 419 420 421 422 423 424 425
                              DWORD result)
{
    switch (msg)
    {
    case MCI_OPEN:
        {
            DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
            MCI_OPEN_PARMSA *mci_openA = (MCI_OPEN_PARMSA *)*ptr;
426
            MCI_OPEN_PARMSW *mci_openW = (MCI_OPEN_PARMSW *)dwParam2;
427 428 429 430 431 432

            mci_openA->wDeviceID = mci_openW->wDeviceID;

            if (dwParam1 & MCI_OPEN_TYPE)
            {
                if (!(dwParam1 & MCI_OPEN_TYPE_ID))
433
                    HeapFree(GetProcessHeap(), 0, (LPWSTR)mci_openW->lpstrDeviceType);
434 435 436 437
            }
            if (dwParam1 & MCI_OPEN_ELEMENT)
            {
                if (!(dwParam1 & MCI_OPEN_ELEMENT_ID))
438
                    HeapFree(GetProcessHeap(), 0, (LPWSTR)mci_openW->lpstrElementName);
439 440
            }
            if (dwParam1 & MCI_OPEN_ALIAS)
441
                HeapFree(GetProcessHeap(), 0, (LPWSTR)mci_openW->lpstrAlias);
442 443 444 445 446 447 448 449 450 451 452 453 454 455
            HeapFree(GetProcessHeap(), 0, ptr);
        }
        break;
    case MCI_WINDOW:
        if (dwParam1 & MCI_ANIM_WINDOW_TEXT)
        {
            MCI_ANIM_WINDOW_PARMSW *mci_windowW = (MCI_ANIM_WINDOW_PARMSW *)dwParam2;

            HeapFree(GetProcessHeap(), 0, (void*)mci_windowW->lpstrText);
            HeapFree(GetProcessHeap(), 0, mci_windowW);
        }
        break;

    case MCI_SYSINFO:
456
        if (dwParam1 & (MCI_SYSINFO_INSTALLNAME | MCI_SYSINFO_NAME))
457 458 459
        {
            DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
            MCI_SYSINFO_PARMSA *mci_sysinfoA = (MCI_SYSINFO_PARMSA *)*ptr;
460
            MCI_SYSINFO_PARMSW *mci_sysinfoW = (MCI_SYSINFO_PARMSW *)dwParam2;
461 462 463

            if (!result)
            {
464
                WideCharToMultiByte(CP_ACP, 0,
465
                                    mci_sysinfoW->lpstrReturn, -1,
466 467
                                    mci_sysinfoA->lpstrReturn, mci_sysinfoA->dwRetSize,
                                    NULL, NULL);
468 469 470 471 472 473 474 475 476 477
            }

            HeapFree(GetProcessHeap(), 0, mci_sysinfoW->lpstrReturn);
            HeapFree(GetProcessHeap(), 0, ptr);
        }
        break;
    case MCI_INFO:
        {
            DWORD_PTR *ptr = (DWORD_PTR *)dwParam2 - 1;
            MCI_INFO_PARMSA *mci_infoA = (MCI_INFO_PARMSA *)*ptr;
478
            MCI_INFO_PARMSW *mci_infoW = (MCI_INFO_PARMSW *)dwParam2;
479 480 481 482

            if (!result)
            {
                WideCharToMultiByte(CP_ACP, 0,
483
                                    mci_infoW->lpstrReturn, -1,
484 485 486 487 488 489 490 491 492 493
                                    mci_infoA->lpstrReturn, mci_infoA->dwRetSize,
                                    NULL, NULL);
            }

            HeapFree(GetProcessHeap(), 0, mci_infoW->lpstrReturn);
            HeapFree(GetProcessHeap(), 0, ptr);
        }
        break;
    case MCI_SAVE:
    case MCI_LOAD:
494 495 496 497
    case MCI_CAPTURE:
    case MCI_RESTORE:
        {   /* All these commands have the same layout: callback + string + optional rect */
            MCI_OVLY_LOAD_PARMSW *mci_loadW = (MCI_OVLY_LOAD_PARMSW *)dwParam2;
498 499 500 501 502

            HeapFree(GetProcessHeap(), 0, (void*)mci_loadW->lpfilename);
            HeapFree(GetProcessHeap(), 0, mci_loadW);
        }
        break;
503
    case MCI_SOUND:
504
    case MCI_ESCAPE:
505
        {   /* All these commands have the same layout: callback + string */
506 507 508 509 510 511 512 513 514 515 516 517 518
            MCI_VD_ESCAPE_PARMSW *mci_vd_escapeW = (MCI_VD_ESCAPE_PARMSW *)dwParam2;

            HeapFree(GetProcessHeap(), 0, (void*)mci_vd_escapeW->lpstrCommand);
            HeapFree(GetProcessHeap(), 0, mci_vd_escapeW);
        }
        break;

    default:
        FIXME("Message %s needs unmapping\n", MCI_MessageToString(msg));
        break;
    }
}

519 520 521
/**************************************************************************
 * 				MCI_GetDevTypeFromFileName	[internal]
 */
522
static	DWORD	MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPWSTR buf, UINT len)
523
{
524
    LPCWSTR	tmp;
525
    HKEY	hKey;
526 527 528
    static const WCHAR keyW[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\',
                                 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
                                 'M','C','I',' ','E','x','t','e','n','s','i','o','n','s',0};
529
    if ((tmp = wcsrchr(fileName, '.'))) {
530
	if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, keyW,
531 532
			   0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) {
	    DWORD dwLen = len;
533
	    LONG lRet = RegQueryValueExW( hKey, tmp + 1, 0, 0, (void*)buf, &dwLen ); 
534 535 536
	    RegCloseKey( hKey );
	    if (lRet == ERROR_SUCCESS) return 0;
        }
537
	TRACE("No ...\\MCI Extensions entry for %s found.\n", debugstr_w(tmp));
538 539 540 541
    }
    return MCIERR_EXTENSION_NOT_FOUND;
}

542 543 544 545 546 547 548 549
/**************************************************************************
 * 				MCI_GetDevTypeFromResource	[internal]
 */
static	UINT	MCI_GetDevTypeFromResource(LPCWSTR lpstrName)
{
    WCHAR	buf[32];
    UINT	uDevType;
    for (uDevType = MCI_DEVTYPE_FIRST; uDevType <= MCI_DEVTYPE_LAST; uDevType++) {
550
	if (LoadStringW(hWinMM32Instance, uDevType, buf, ARRAY_SIZE(buf))) {
551
	    /* FIXME: ignore digits suffix */
552
	    if (!wcsicmp(buf, lpstrName))
553 554 555 556 557 558
		return uDevType;
	}
    }
    return 0;
}

559 560 561 562
#define	MAX_MCICMDTABLE			20
#define MCI_COMMAND_TABLE_NOT_LOADED	0xFFFE

typedef struct tagWINE_MCICMDTABLE {
563
    UINT		uDevType;
564
    HGLOBAL             hMem;
565
    const BYTE*		lpTable;
566
    UINT		nVerbs;		/* number of verbs in command table */
567
    LPCWSTR*		aVerbs;		/* array of verbs to speed up the verb look up process */
568
} WINE_MCICMDTABLE, *LPWINE_MCICMDTABLE;
569 570

static WINE_MCICMDTABLE S_MciCmdTable[MAX_MCICMDTABLE];
571 572 573 574 575 576

/**************************************************************************
 * 				MCI_IsCommandTableValid		[internal]
 */
static	BOOL		MCI_IsCommandTableValid(UINT uTbl)
{
577 578
    const BYTE* lmem;
    LPCWSTR     str;
579 580 581 582 583
    DWORD	flg;
    WORD	eid;
    int		idx = 0;
    BOOL	inCst = FALSE;

584 585
    TRACE("Dumping cmdTbl=%d [lpTable=%p devType=%d]\n",
	  uTbl, S_MciCmdTable[uTbl].lpTable, S_MciCmdTable[uTbl].uDevType);
586

587
    if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].lpTable)
588 589 590 591
	return FALSE;

    lmem = S_MciCmdTable[uTbl].lpTable;
    do {
592
        str = (LPCWSTR)lmem;
593
        lmem += (lstrlenW(str) + 1) * sizeof(WCHAR);
594 595 596 597 598 599 600 601
        flg = *(const DWORD*)lmem;
        eid = *(const WORD*)(lmem + sizeof(DWORD));
        lmem += sizeof(DWORD) + sizeof(WORD);
        idx ++;
        /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */
        switch (eid) {
        case MCI_COMMAND_HEAD:          if (!*str || !flg) return FALSE; idx = 0;		break;	/* check unicity of str in table */
        case MCI_STRING:                if (inCst) return FALSE;				break;
602 603 604
        case MCI_HWND:                  /* Occurs inside MCI_CONSTANT as in "window handle default" */
        case MCI_HPAL:
        case MCI_HDC:
605 606 607 608 609 610 611 612 613 614
        case MCI_INTEGER:               if (!*str) return FALSE;				break;
        case MCI_END_COMMAND:           if (*str || flg || idx == 0) return FALSE; idx = 0;	break;
        case MCI_RETURN:		if (*str || idx != 1) return FALSE;			break;
        case MCI_FLAG:		        if (!*str) return FALSE;				break;
        case MCI_END_COMMAND_LIST:	if (*str || flg) return FALSE;	idx = 0;		break;
        case MCI_RECT:		        if (!*str || inCst) return FALSE;			break;
        case MCI_CONSTANT:              if (inCst) return FALSE; inCst = TRUE;			break;
        case MCI_END_CONSTANT:	        if (*str || flg || !inCst) return FALSE; inCst = FALSE; break;
        default:			return FALSE;
        }
615 616 617 618 619 620 621 622 623
    } while (eid != MCI_END_COMMAND_LIST);
    return TRUE;
}

/**************************************************************************
 * 				MCI_DumpCommandTable		[internal]
 */
static	BOOL		MCI_DumpCommandTable(UINT uTbl)
{
624 625
    const BYTE*	lmem;
    LPCWSTR	str;
626
    WORD	eid;
627

628 629 630 631 632 633 634 635
    if (!MCI_IsCommandTableValid(uTbl)) {
	ERR("Ooops: %d is not valid\n", uTbl);
	return FALSE;
    }

    lmem = S_MciCmdTable[uTbl].lpTable;
    do {
	do {
636
	    /* DWORD flg; */
637
	    str = (LPCWSTR)lmem;
638
	    lmem += (lstrlenW(str) + 1) * sizeof(WCHAR);
639
	    /* flg = *(const DWORD*)lmem; */
Eric Pouech's avatar
Eric Pouech committed
640
	    eid = *(const WORD*)(lmem + sizeof(DWORD));
641
            /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */
642 643
	    lmem += sizeof(DWORD) + sizeof(WORD);
	} while (eid != MCI_END_COMMAND && eid != MCI_END_COMMAND_LIST);
644
        /* EPP TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : ""); */
645 646 647 648 649 650 651 652
    } while (eid != MCI_END_COMMAND_LIST);
    return TRUE;
}


/**************************************************************************
 * 				MCI_GetCommandTable		[internal]
 */
653
static	UINT		MCI_GetCommandTable(UINT uDevType)
654 655
{
    UINT	uTbl;
656 657
    WCHAR	buf[32];
    LPCWSTR	str = NULL;
658

659 660
    /* first look up existing for existing devType */
    for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
661
	if (S_MciCmdTable[uTbl].lpTable && S_MciCmdTable[uTbl].uDevType == uDevType)
662
	    return uTbl;
663 664 665 666
    }

    /* well try to load id */
    if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) {
667
	if (LoadStringW(hWinMM32Instance, uDevType, buf, ARRAY_SIZE(buf))) {
668 669 670
	    str = buf;
	}
    } else if (uDevType == 0) {
671 672
        static const WCHAR wszCore[] = {'C','O','R','E',0};
	str = wszCore;
673 674 675
    }
    uTbl = MCI_NO_COMMAND_TABLE;
    if (str) {
676
	HRSRC 	hRsrc = FindResourceW(hWinMM32Instance, str, (LPCWSTR)RT_RCDATA);
677 678
	HANDLE	hMem = 0;

679
	if (hRsrc) hMem = LoadResource(hWinMM32Instance, hRsrc);
680
	if (hMem) {
681
	    uTbl = MCI_SetCommandTable(hMem, uDevType);
682
	} else {
683
	    WARN("No command table found in resource %p[%s]\n",
684
		 hWinMM32Instance, debugstr_w(str));
685 686 687 688 689 690 691 692 693
	}
    }
    TRACE("=> %d\n", uTbl);
    return uTbl;
}

/**************************************************************************
 * 				MCI_SetCommandTable		[internal]
 */
694
static UINT MCI_SetCommandTable(HGLOBAL hMem, UINT uDevType)
695
{
696 697 698 699 700 701 702 703 704 705
    int		        uTbl;
    static	BOOL	bInitDone = FALSE;

    /* <HACK>
     * The CORE command table must be loaded first, so that MCI_GetCommandTable()
     * can be called with 0 as a uDevType to retrieve it.
     * </HACK>
     */
    if (!bInitDone) {
	bInitDone = TRUE;
706
	MCI_GetCommandTable(0);
707
    }
708
    TRACE("(%p, %u)\n", hMem, uDevType);
709
    for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
710
	if (!S_MciCmdTable[uTbl].lpTable) {
711 712
	    const BYTE* lmem;
	    LPCWSTR 	str;
713 714 715
	    WORD	eid;
	    WORD	count;

716
	    S_MciCmdTable[uTbl].uDevType = uDevType;
717 718
	    S_MciCmdTable[uTbl].lpTable = LockResource(hMem);
	    S_MciCmdTable[uTbl].hMem = hMem;
719 720 721 722

	    if (TRACE_ON(mci)) {
		MCI_DumpCommandTable(uTbl);
	    }
723 724 725 726 727 728

	    /* create the verbs table */
	    /* get # of entries */
	    lmem = S_MciCmdTable[uTbl].lpTable;
	    count = 0;
	    do {
729
		str = (LPCWSTR)lmem;
730
		lmem += (lstrlenW(str) + 1) * sizeof(WCHAR);
Eric Pouech's avatar
Eric Pouech committed
731
		eid = *(const WORD*)(lmem + sizeof(DWORD));
732 733 734 735 736
		lmem += sizeof(DWORD) + sizeof(WORD);
		if (eid == MCI_COMMAND_HEAD)
		    count++;
	    } while (eid != MCI_END_COMMAND_LIST);

737
	    S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCWSTR));
738 739 740 741 742
	    S_MciCmdTable[uTbl].nVerbs = count;

	    lmem = S_MciCmdTable[uTbl].lpTable;
	    count = 0;
	    do {
743
		str = (LPCWSTR)lmem;
744
		lmem += (lstrlenW(str) + 1) * sizeof(WCHAR);
Eric Pouech's avatar
Eric Pouech committed
745
		eid = *(const WORD*)(lmem + sizeof(DWORD));
746 747 748 749 750
		lmem += sizeof(DWORD) + sizeof(WORD);
		if (eid == MCI_COMMAND_HEAD)
		    S_MciCmdTable[uTbl].aVerbs[count++] = str;
	    } while (eid != MCI_END_COMMAND_LIST);
	    /* assert(count == S_MciCmdTable[uTbl].nVerbs); */
751 752 753 754 755 756 757 758 759 760
	    return uTbl;
	}
    }

    return MCI_NO_COMMAND_TABLE;
}

/**************************************************************************
 * 				MCI_UnLoadMciDriver		[internal]
 */
761
static	BOOL	MCI_UnLoadMciDriver(LPWINE_MCIDRIVER wmd)
762
{
763
    LPWINE_MCIDRIVER*		tmp;
764 765 766 767

    if (!wmd)
	return TRUE;

768
    CloseDriver(wmd->hDriver, 0, 0);
769 770 771 772

    if (wmd->dwPrivate != 0)
	WARN("Unloading mci driver with non nul dwPrivate field\n");

773 774
    EnterCriticalSection(&WINMM_cs);
    for (tmp = &MciDrivers; *tmp; tmp = &(*tmp)->lpNext) {
775 776 777 778 779
	if (*tmp == wmd) {
	    *tmp = wmd->lpNext;
	    break;
	}
    }
780
    LeaveCriticalSection(&WINMM_cs);
781 782 783 784 785 786 787

    HeapFree(GetProcessHeap(), 0, wmd->lpstrDeviceType);
    HeapFree(GetProcessHeap(), 0, wmd->lpstrAlias);

    HeapFree(GetProcessHeap(), 0, wmd);
    return TRUE;
}
788

789 790 791
/**************************************************************************
 * 				MCI_OpenMciDriver		[internal]
 */
792
static	BOOL	MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCWSTR drvTyp, DWORD_PTR lp)
793
{
794
    WCHAR	libName[128];
795

796
    if (!DRIVER_GetLibName(drvTyp, wszMci, libName, sizeof(libName)))
797 798 799
	return FALSE;

    /* First load driver */
800 801
    wmd->hDriver = (HDRVR)DRIVER_TryOpenDriver32(libName, lp);
    return wmd->hDriver != NULL;
802 803
}

804 805 806
/**************************************************************************
 * 				MCI_LoadMciDriver		[internal]
 */
807
static	DWORD	MCI_LoadMciDriver(LPCWSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd)
808
{
809
    LPWSTR			strDevTyp = str_dup_upper(_strDevTyp);
810
    LPWINE_MCIDRIVER		wmd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
811
    MCI_OPEN_DRIVER_PARMSW	modp;
812
    DWORD			dwRet = 0;
813

814 815 816 817
    if (!wmd || !strDevTyp) {
	dwRet = MCIERR_OUT_OF_MEMORY;
	goto errCleanUp;
    }
818

819 820
    wmd->lpfnYieldProc = MCI_DefYieldProc;
    wmd->dwYieldData = VK_CANCEL;
821
    wmd->CreatorThread = GetCurrentThreadId();
822

823
    EnterCriticalSection(&WINMM_cs);
Austin English's avatar
Austin English committed
824
    /* wmd must be inserted in list before sending opening the driver, because it
825 826
     * may want to lookup at wDevID
     */
827 828
    wmd->lpNext = MciDrivers;
    MciDrivers = wmd;
829

830 831
    for (modp.wDeviceID = MCI_MAGIC;
	 MCI_GetDriver(modp.wDeviceID) != 0;
832 833 834 835
	 modp.wDeviceID++);

    wmd->wDeviceID = modp.wDeviceID;

836
    LeaveCriticalSection(&WINMM_cs);
837

838
    TRACE("wDevID=%04X\n", modp.wDeviceID);
839 840

    modp.lpstrParams = NULL;
841

842
    if (!MCI_OpenMciDriver(wmd, strDevTyp, (DWORD_PTR)&modp)) {
843 844 845
	/* silence warning if all is used... some bogus program use commands like
	 * 'open all'...
	 */
846
	if (wcsicmp(strDevTyp, wszAll) == 0) {
847 848
	    dwRet = MCIERR_CANNOT_USE_ALL;
	} else {
849
	    FIXME("Couldn't load driver for type %s.\n",
850
		  debugstr_w(strDevTyp));
851 852
	    dwRet = MCIERR_DEVICE_NOT_INSTALLED;
	}
853
	goto errCleanUp;
854
    }
855

856 857 858 859 860 861 862 863
    /* FIXME: should also check that module's description is of the form
     * MODULENAME:[MCI] comment
     */

    /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
    wmd->uSpecificCmdTable = LOWORD(modp.wCustomCommandTable);
    wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED;

864
    TRACE("Loaded driver %p (%s), type is %d, cmdTable=%08x\n",
865
	  wmd->hDriver, debugstr_w(strDevTyp), modp.wType, modp.wCustomCommandTable);
866

867 868 869
    wmd->lpstrDeviceType = strDevTyp;
    wmd->wType = modp.wType;

870
    TRACE("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
871 872 873 874
	  modp.wDeviceID, modp.wType, modp.wDeviceID);
    *lpwmd = wmd;
    return 0;
errCleanUp:
875
    MCI_UnLoadMciDriver(wmd);
876 877 878 879
    HeapFree(GetProcessHeap(), 0, strDevTyp);
    *lpwmd = 0;
    return dwRet;
}
880

881 882 883 884 885 886 887 888 889
/**************************************************************************
 * 			MCI_SendCommandFrom32			[internal]
 */
static DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
    DWORD		dwRet = MCIERR_INVALID_DEVICE_ID;
    LPWINE_MCIDRIVER	wmd = MCI_GetDriver(wDevID);

    if (wmd) {
890 891 892
        if(wmd->CreatorThread != GetCurrentThreadId())
            return MCIERR_INVALID_DEVICE_NAME;

893
        dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
894 895 896 897
    }
    return dwRet;
}

898 899
/**************************************************************************
 * 			MCI_FinishOpen				[internal]
900 901 902 903 904 905 906
 *
 * Three modes of operation:
 * 1 open foo.ext ...        -> OPEN_ELEMENT with lpstrElementName=foo.ext
 *   open sequencer!foo.ext     same         with lpstrElementName=foo.ext
 * 2 open new type waveaudio -> OPEN_ELEMENT with empty ("") lpstrElementName
 * 3 open sequencer          -> OPEN_ELEMENT unset, and
 *   capability sequencer       (auto-open)  likewise
907
 */
908
static	DWORD	MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSW lpParms,
909 910
			       DWORD dwParam)
{
911 912
    LPCWSTR alias = NULL;
    /* Open always defines an alias for further reference */
913
    if (dwParam & MCI_OPEN_ALIAS) {         /* open ... alias */
914
        alias = lpParms->lpstrAlias;
915 916 917
        if (MCI_GetDriverFromString(alias))
            return MCIERR_DUPLICATE_ALIAS;
    } else {
918 919 920 921 922
        if ((dwParam & MCI_OPEN_ELEMENT)    /* open file.wav */
            && !(dwParam & MCI_OPEN_ELEMENT_ID))
            alias = lpParms->lpstrElementName;
        else if (dwParam & MCI_OPEN_TYPE )  /* open cdaudio */
            alias = wmd->lpstrDeviceType;
923 924
        if (alias && MCI_GetDriverFromString(alias))
            return MCIERR_DEVICE_OPEN;
925
    }
926
    if (alias) {
927
        wmd->lpstrAlias = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(alias)+1) * sizeof(WCHAR));
928
        if (!wmd->lpstrAlias) return MCIERR_OUT_OF_MEMORY;
929
        lstrcpyW( wmd->lpstrAlias, alias);
930 931
        /* In most cases, natives adds MCI_OPEN_ALIAS to the flags passed to the driver.
         * Don't.  The drivers don't care about the winmm alias. */
932
    }
933 934
    lpParms->wDeviceID = wmd->wDeviceID;

935
    return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam,
936
				 (DWORD_PTR)lpParms);
937 938 939 940 941
}

/**************************************************************************
 * 				MCI_FindCommand		[internal]
 */
942
static	LPCWSTR		MCI_FindCommand(UINT uTbl, LPCWSTR verb)
943
{
944
    UINT	idx;
945

946
    if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].lpTable)
947 948
	return NULL;

949 950 951 952 953
    /* another improvement would be to have the aVerbs array sorted,
     * so that we could use a dichotomic search on it, rather than this dumb
     * array look up
     */
    for (idx = 0; idx < S_MciCmdTable[uTbl].nVerbs; idx++) {
954
	if (wcsicmp(S_MciCmdTable[uTbl].aVerbs[idx], verb) == 0)
955 956
	    return S_MciCmdTable[uTbl].aVerbs[idx];
    }
957 958 959 960 961 962 963

    return NULL;
}

/**************************************************************************
 * 				MCI_GetReturnType		[internal]
 */
964
static	DWORD		MCI_GetReturnType(LPCWSTR lpCmd)
965
{
966
    lpCmd = (LPCWSTR)((const BYTE*)(lpCmd + lstrlenW(lpCmd) + 1) + sizeof(DWORD) + sizeof(WORD));
967
    if (*lpCmd == '\0' && *(const WORD*)((const BYTE*)(lpCmd + 1) + sizeof(DWORD)) == MCI_RETURN) {
Eric Pouech's avatar
Eric Pouech committed
968
	return *(const DWORD*)(lpCmd + 1);
969 970 971 972 973 974 975
    }
    return 0L;
}

/**************************************************************************
 * 				MCI_GetMessage			[internal]
 */
976
static	WORD		MCI_GetMessage(LPCWSTR lpCmd)
977
{
978
    return (WORD)*(const DWORD*)(lpCmd + lstrlenW(lpCmd) + 1);
979 980 981 982
}

/**************************************************************************
 * 				MCI_GetDWord			[internal]
983 984 985
 *
 * Accept 0 -1 255 255:0 255:255:255:255 :::1 1::: 2::3 ::4: 12345678
 * Refuse -1:0 0:-1 :: 256:0 1:256 0::::1
986
 */
987
static	BOOL		MCI_GetDWord(DWORD* data, LPWSTR* ptr)
988
{
989 990 991 992 993 994 995 996
    LPWSTR	ret = *ptr;
    DWORD	total = 0, shift = 0;
    BOOL	sign = FALSE, digits = FALSE;

    while (*ret == ' ' || *ret == '\t') ret++;
    if (*ret == '-') {
	ret++;
	sign = TRUE;
997
    }
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
    for(;;) {
	DWORD	val = 0;
	while ('0' <= *ret && *ret <= '9') {
	    val = *ret++ - '0' + 10 * val;
	    digits = TRUE;
	}
	switch (*ret) {
	case '\0':	break;
	case '\t':
	case ' ':	ret++; break;
	default:	return FALSE;
	case ':':
	    if ((val >= 256) || (shift >= 24))	return FALSE;
	    total |= val << shift;
	    shift += 8;
	    ret++;
	    continue;
	}
1016

1017 1018 1019 1020 1021 1022 1023
	if (!digits)				return FALSE;
	if (shift && (val >= 256 || sign))	return FALSE;
	total |= val << shift;
	*data = sign ? -total : total;
	*ptr = ret;
	return TRUE;
    }
1024 1025 1026 1027 1028
}

/**************************************************************************
 * 				MCI_GetString		[internal]
 */
1029
static	DWORD	MCI_GetString(LPWSTR* str, LPWSTR* args)
1030
{
1031
    LPWSTR      ptr = *args;
1032 1033 1034

    /* see if we have a quoted string */
    if (*ptr == '"') {
1035
	ptr = wcschr(*str = ptr + 1, '"');
1036 1037 1038 1039 1040 1041
	if (!ptr) return MCIERR_NO_CLOSING_QUOTE;
	/* FIXME: shall we escape \" from string ?? */
	if (ptr[-1] == '\\') TRACE("Ooops: un-escaped \"\n");
	*ptr++ = '\0'; /* remove trailing " */
	if (*ptr != ' ' && *ptr != '\0') return MCIERR_EXTRA_CHARACTERS;
    } else {
1042
	ptr = wcschr(ptr, ' ');
1043 1044 1045 1046

	if (ptr) {
	    *ptr++ = '\0';
	} else {
1047
	    ptr = *args + lstrlenW(*args);
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
	}
	*str = *args;
    }

    *args = ptr;
    return 0;
}

#define	MCI_DATA_SIZE	16

/**************************************************************************
 * 				MCI_ParseOptArgs		[internal]
 */
1061
static	DWORD	MCI_ParseOptArgs(DWORD* data, int _offset, LPCWSTR lpCmd,
1062
				 LPWSTR args, LPDWORD dwFlags)
1063 1064
{
    int		len, offset;
1065 1066
    const char* lmem;
    LPCWSTR     str;
1067 1068 1069 1070 1071 1072
    DWORD	dwRet, flg, cflg = 0;
    WORD	eid;
    BOOL	inCst, found;

    /* loop on arguments */
    while (*args) {
1073
	lmem = (const char*)lpCmd;
1074 1075
	found = inCst = FALSE;
	offset = _offset;
1076 1077 1078

	/* skip any leading white space(s) */
	while (*args == ' ') args++;
1079
	TRACE("args=%s\n", debugstr_w(args));
1080

1081
	do { /* loop on options for command table for the requested verb */
1082
	    str = (LPCWSTR)lmem;
1083
	    lmem += ((len = lstrlenW(str)) + 1) * sizeof(WCHAR);
Eric Pouech's avatar
Eric Pouech committed
1084 1085
	    flg = *(const DWORD*)lmem;
	    eid = *(const WORD*)(lmem + sizeof(DWORD));
1086
	    lmem += sizeof(DWORD) + sizeof(WORD);
1087
            /* TRACE("\tcmd=%s inCst=%c eid=%04x\n", debugstr_w(str), inCst ? 'Y' : 'N', eid); */
1088

1089
	    switch (eid) {
1090
	    case MCI_CONSTANT:
1091
		inCst = TRUE;	cflg = flg;	break;
1092
	    case MCI_END_CONSTANT:
1093 1094 1095 1096
		/* there may be additional integral values after flag in constant */
		if (inCst && MCI_GetDWord(&(data[offset]), &args)) {
		    *dwFlags |= cflg;
		}
1097
		inCst = FALSE;	cflg = 0;
1098
		break;
1099 1100
	    case MCI_RETURN:
		if (offset != _offset) {
1101
		    FIXME("MCI_RETURN not in first position\n");
1102 1103
		    return MCIERR_PARSER_INTERNAL;
		}
1104 1105
	    }

1106
	    if (wcsnicmp(args, str, len) == 0 &&
1107
                ((eid == MCI_STRING && len == 0) || args[len] == 0 || args[len] == ' ')) {
1108 1109
		/* store good values into data[] */
		args += len;
1110
		while (*args == ' ') args++;
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
		found = TRUE;

		switch (eid) {
		case MCI_COMMAND_HEAD:
		case MCI_RETURN:
		case MCI_END_COMMAND:
		case MCI_END_COMMAND_LIST:
		case MCI_CONSTANT: 	/* done above */
		case MCI_END_CONSTANT:  /* done above */
		    break;
1121
		case MCI_FLAG:
1122
		    *dwFlags |= flg;
1123
		    TRACE("flag=%08x\n", flg);
1124
		    break;
1125 1126 1127
		case MCI_HWND:
		case MCI_HPAL:
		case MCI_HDC:
1128 1129 1130 1131 1132
		case MCI_INTEGER:
		    if (inCst) {
			data[offset] |= flg;
			*dwFlags |= cflg;
			inCst = FALSE;
1133
			TRACE("flag=%08x constant=%08x\n", cflg, flg);
1134 1135 1136 1137 1138
		    } else {
			*dwFlags |= flg;
			if (!MCI_GetDWord(&(data[offset]), &args)) {
			    return MCIERR_BAD_INTEGER;
			}
1139
			TRACE("flag=%08x int=%d\n", flg, data[offset]);
1140 1141
		    }
		    break;
1142
		case MCI_RECT:
1143
		    /* store rect in data (offset..offset+3) */
1144 1145 1146 1147 1148 1149 1150
		    *dwFlags |= flg;
		    if (!MCI_GetDWord(&(data[offset+0]), &args) ||
			!MCI_GetDWord(&(data[offset+1]), &args) ||
			!MCI_GetDWord(&(data[offset+2]), &args) ||
			!MCI_GetDWord(&(data[offset+3]), &args)) {
			return MCIERR_BAD_INTEGER;
		    }
1151
		    TRACE("flag=%08x for rectangle\n", flg);
1152 1153 1154
		    break;
		case MCI_STRING:
		    *dwFlags |= flg;
1155
		    if ((dwRet = MCI_GetString((LPWSTR*)&data[offset], &args)))
1156
			return dwRet;
1157
		    TRACE("flag=%08x string=%s\n", flg, debugstr_w(*(LPWSTR*)&data[offset]));
1158
		    break;
1159
		default:	ERR("oops\n");
1160
		}
1161 1162
		/* exit inside while loop, except if just entered in constant area definition */
		if (!inCst || eid != MCI_CONSTANT) eid = MCI_END_COMMAND;
1163 1164 1165 1166 1167 1168 1169 1170 1171
	    } else {
		/* have offset incremented if needed */
		switch (eid) {
		case MCI_COMMAND_HEAD:
		case MCI_RETURN:
		case MCI_END_COMMAND:
		case MCI_END_COMMAND_LIST:
		case MCI_CONSTANT:
		case MCI_FLAG:			break;
1172 1173 1174
		case MCI_HWND:
		case MCI_HPAL:
		case MCI_HDC:			if (!inCst) offset += sizeof(HANDLE)/sizeof(DWORD); break;
1175
		case MCI_INTEGER:		if (!inCst) offset++;	break;
1176 1177
		case MCI_END_CONSTANT:		offset++; break;
		case MCI_STRING:		offset += sizeof(LPWSTR)/sizeof(DWORD); break;
1178
		case MCI_RECT:			offset += 4; break;
1179
		default:			ERR("oops\n");
1180 1181 1182 1183
		}
	    }
	} while (eid != MCI_END_COMMAND);
	if (!found) {
1184
	    WARN("Optarg %s not found\n", debugstr_w(args));
1185 1186 1187
	    return MCIERR_UNRECOGNIZED_COMMAND;
	}
	if (offset == MCI_DATA_SIZE) {
1188
	    FIXME("Internal data[] buffer overflow\n");
1189 1190 1191 1192 1193 1194 1195 1196 1197
	    return MCIERR_PARSER_INTERNAL;
	}
    }
    return 0;
}

/**************************************************************************
 * 				MCI_HandleReturnValues	[internal]
 */
1198
static	DWORD	MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD retType,
1199
                                       MCI_GENERIC_PARMS *params, LPWSTR lpstrRet, UINT uRetLen)
1200
{
1201 1202
    static const WCHAR fmt_d  [] = {'%','d',0};
    static const WCHAR fmt_d4 [] = {'%','d',' ','%','d',' ','%','d',' ','%','d',0};
1203 1204
    static const WCHAR wszCol3[] = {'%','0','2','d',':','%','0','2','d',':','%','0','2','d',0};
    static const WCHAR wszCol4[] = {'%','0','2','d',':','%','0','2','d',':','%','0','2','d',':','%','0','2','d',0};
1205

1206
    if (lpstrRet) {
1207
	switch (retType) {
1208 1209
	case 0: /* nothing to return */
	    break;
1210
	case MCI_INTEGER:
1211 1212
        {
            DWORD data = *(DWORD *)(params + 1);
1213 1214 1215
	    switch (dwRet & 0xFFFF0000ul) {
	    case 0:
	    case MCI_INTEGER_RETURNED:
1216
		swprintf(lpstrRet, uRetLen, fmt_d, data);
1217 1218
		break;
	    case MCI_RESOURCE_RETURNED:
1219
		/* return string which ID is HIWORD(data),
1220
		 * string is loaded from mmsystem.dll */
1221
		LoadStringW(hWinMM32Instance, HIWORD(data), lpstrRet, uRetLen);
1222 1223
		break;
	    case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
1224
		/* return string which ID is HIWORD(data),
1225
		 * string is loaded from driver */
1226
		/* FIXME: this is wrong for a 16 bit handle */
1227
		LoadStringW(GetDriverModuleHandle(wmd->hDriver),
1228
			    HIWORD(data), lpstrRet, uRetLen);
1229 1230
		break;
	    case MCI_COLONIZED3_RETURN:
1231
		swprintf(lpstrRet, uRetLen, wszCol3,
1232 1233
			  LOBYTE(LOWORD(data)), HIBYTE(LOWORD(data)),
			  LOBYTE(HIWORD(data)));
1234 1235
		break;
	    case MCI_COLONIZED4_RETURN:
1236
		swprintf(lpstrRet, uRetLen, wszCol4,
1237 1238
			  LOBYTE(LOWORD(data)), HIBYTE(LOWORD(data)),
			  LOBYTE(HIWORD(data)), HIBYTE(HIWORD(data)));
1239 1240 1241 1242
		break;
	    default:	ERR("Ooops (%04X)\n", HIWORD(dwRet));
	    }
	    break;
1243
        }
1244 1245 1246 1247 1248 1249 1250 1251
#ifdef MCI_INTEGER64
	case MCI_INTEGER64:
        {
	    static const WCHAR fmt_ld [] = {'%','l','d',0};
	    DWORD_PTR data = *(DWORD_PTR *)(params + 1);
	    switch (dwRet & 0xFFFF0000ul) {
	    case 0:
	    case MCI_INTEGER_RETURNED:
1252
		swprintf(lpstrRet, uRetLen, fmt_ld, data);
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
		break;
	    case MCI_RESOURCE_RETURNED:
		/* return string which ID is HIWORD(data),
		 * string is loaded from mmsystem.dll */
		LoadStringW(hWinMM32Instance, HIWORD(data), lpstrRet, uRetLen);
		break;
	    case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
		/* return string which ID is HIWORD(data),
		 * string is loaded from driver */
		/* FIXME: this is wrong for a 16 bit handle */
		LoadStringW(GetDriverModuleHandle(wmd->hDriver),
			    HIWORD(data), lpstrRet, uRetLen);
		break;
	    case MCI_COLONIZED3_RETURN:
1267
		swprintf(lpstrRet, uRetLen, wszCol3,
1268 1269 1270 1271
			  LOBYTE(LOWORD(data)), HIBYTE(LOWORD(data)),
			  LOBYTE(HIWORD(data)));
		break;
	    case MCI_COLONIZED4_RETURN:
1272
		swprintf(lpstrRet, uRetLen, wszCol4,
1273 1274 1275 1276 1277 1278 1279 1280
			  LOBYTE(LOWORD(data)), HIBYTE(LOWORD(data)),
			  LOBYTE(HIWORD(data)), HIBYTE(HIWORD(data)));
		break;
	    default:	ERR("Ooops (%04X)\n", HIWORD(dwRet));
	    }
	    break;
        }
#endif
1281
	case MCI_STRING:
1282 1283
	    switch (dwRet & 0xFFFF0000ul) {
	    case 0:
1284
		/* nothing to do data[0] == lpstrRet */
1285 1286
		break;
	    case MCI_INTEGER_RETURNED:
1287 1288 1289
            {
                DWORD *data = (DWORD *)(params + 1);
		*data = *(LPDWORD)lpstrRet;
1290
		swprintf(lpstrRet, uRetLen, fmt_d, *data);
1291
		break;
1292
            }
1293 1294 1295 1296 1297
	    default:
		WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
		break;
	    }
	    break;
1298
	case MCI_RECT:
1299 1300
        {
            DWORD *data = (DWORD *)(params + 1);
1301
	    if (dwRet & 0xFFFF0000ul)
1302
		WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
1303
	    swprintf(lpstrRet, uRetLen, fmt_d4, data[0], data[1], data[2], data[3]);
1304
	    break;
1305
        }
1306
	default:		FIXME("Unknown MCI return type %d\n", retType);
1307 1308 1309 1310 1311 1312
	}
    }
    return LOWORD(dwRet);
}

/**************************************************************************
1313
 * 				mciSendStringW		[WINMM.@]
1314
 */
1315
DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
1316 1317
			    UINT uRetLen, HWND hwndCallback)
{
1318
    LPWSTR		verb, dev, args, devType = NULL;
1319
    LPWINE_MCIDRIVER	wmd = 0;
1320
    MCIDEVICEID		uDevID, auto_open = 0;
1321 1322
    DWORD		dwFlags = 0, dwRet = 0;
    int			offset = 0;
1323
    DWORD		retType;
1324
    LPCWSTR		lpCmd = 0;
1325
    WORD		wMsg = 0;
1326 1327
    static const WCHAR  wszNew[] = {'n','e','w',0};
    static const WCHAR  wszSAliasS[] = {' ','a','l','i','a','s',' ',0};
1328
    static const WCHAR  wszTypeS[]   = {'t','y','p','e',' ',0};
1329 1330 1331 1332 1333 1334 1335 1336
    union
    {
        MCI_GENERIC_PARMS  generic;
        MCI_OPEN_PARMSW    open;
        MCI_SOUND_PARMSW   sound;
        MCI_SYSINFO_PARMSW sysinfo;
        DWORD              dw[MCI_DATA_SIZE];
    } data;
1337

1338 1339
    TRACE("(%s, %p, %d, %p)\n", 
          debugstr_w(lpstrCommand), lpstrRet, uRetLen, hwndCallback);
1340
    if (lpstrRet && uRetLen) *lpstrRet = '\0';
1341

1342 1343 1344
    if (!lpstrCommand[0])
        return MCIERR_MISSING_COMMAND_STRING;

1345
    /* format is <command> <device> <optargs> */
1346
    if (!(verb = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(lpstrCommand)+1) * sizeof(WCHAR))))
1347
	return MCIERR_OUT_OF_MEMORY;
1348
    lstrcpyW( verb, lpstrCommand );
1349
    CharLowerW(verb);
1350

1351
    memset(&data, 0, sizeof(data));
1352

1353
    if (!(args = wcschr(verb, ' '))) {
1354 1355 1356 1357 1358 1359 1360
	dwRet = MCIERR_MISSING_DEVICE_NAME;
	goto errCleanUp;
    }
    *args++ = '\0';
    if ((dwRet = MCI_GetString(&dev, &args))) {
	goto errCleanUp;
    }
1361
    uDevID = wcsicmp(dev, wszAll) ? 0 : MCI_ALL_DEVICE_ID;
1362

1363
    /* Determine devType from open */
1364
    if (!wcscmp(verb, wszOpen)) {
1365
	LPWSTR	tmp;
1366
        WCHAR	buf[128];
1367

1368
	/* case dev == 'new' has to be handled */
1369
	if (!wcscmp(dev, wszNew)) {
1370
	    dev = 0;
1371
	    if ((devType = wcsstr(args, wszTypeS)) != NULL) {
1372
		devType += 5;
1373
		tmp = wcschr(devType, ' ');
1374 1375 1376 1377 1378 1379 1380 1381 1382
		if (tmp) *tmp = '\0';
		devType = str_dup_upper(devType);
		if (tmp) *tmp = ' ';
		/* dwFlags and data[2] will be correctly set in ParseOpt loop */
	    } else {
		WARN("open new requires device type\n");
		dwRet = MCIERR_MISSING_DEVICE_NAME;
		goto errCleanUp;
	    }
1383 1384
	    dwFlags |= MCI_OPEN_ELEMENT;
	    data.open.lpstrElementName = &wszNull[0];
1385
	} else if ((devType = wcschr(dev, '!')) != NULL) {
1386
	    *devType++ = '\0';
1387 1388 1389
	    tmp = devType; devType = dev; dev = tmp;

	    dwFlags |= MCI_OPEN_TYPE;
1390
	    data.open.lpstrDeviceType = devType;
1391
	    devType = str_dup_upper(devType);
1392
	    dwFlags |= MCI_OPEN_ELEMENT;
1393
	    data.open.lpstrElementName = dev;
1394 1395
	} else if (DRIVER_GetLibName(dev, wszMci, buf, sizeof(buf))) {
            /* this is the name of a mci driver's type */
1396
	    tmp = wcschr(dev, ' ');
1397
	    if (tmp) *tmp = '\0';
1398
	    data.open.lpstrDeviceType = dev;
1399
	    devType = str_dup_upper(dev);
1400 1401
	    if (tmp) *tmp = ' ';
	    dwFlags |= MCI_OPEN_TYPE;
1402
	} else {
1403
	    if ((devType = wcsstr(args, wszTypeS)) != NULL) {
1404
		devType += 5;
1405
		tmp = wcschr(devType, ' ');
1406
		if (tmp) *tmp = '\0';
1407
		devType = str_dup_upper(devType);
1408
		if (tmp) *tmp = ' ';
1409
		/* dwFlags and lpstrDeviceType will be correctly set in ParseOpt loop */
1410 1411 1412 1413
	    } else {
		if ((dwRet = MCI_GetDevTypeFromFileName(dev, buf, sizeof(buf))))
		    goto errCleanUp;

1414
		devType = str_dup_upper(buf);
1415 1416
	    }
	    dwFlags |= MCI_OPEN_ELEMENT;
1417
	    data.open.lpstrElementName = dev;
1418
	}
1419 1420 1421 1422
	if (MCI_ALL_DEVICE_ID == uDevID) {
	    dwRet = MCIERR_CANNOT_USE_ALL;
	    goto errCleanUp;
	}
1423
	if (!wcsstr(args, wszSAliasS) && !dev) {
1424 1425
	    dwRet = MCIERR_NEW_REQUIRES_ALIAS;
	    goto errCleanUp;
1426 1427
	}

1428
	dwRet = MCI_LoadMciDriver(devType, &wmd);
1429 1430
	if (dwRet == MCIERR_DEVICE_NOT_INSTALLED)
	    dwRet = MCIERR_INVALID_DEVICE_NAME;
1431
	if (dwRet)
1432
	    goto errCleanUp;
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
    } else if ((MCI_ALL_DEVICE_ID != uDevID) && !(wmd = MCI_GetDriver(mciGetDeviceIDW(dev)))
	       && (lpCmd = MCI_FindCommand(MCI_GetCommandTable(0), verb))) {
	/* auto-open uses the core command table */
	switch (MCI_GetMessage(lpCmd)) {
	case MCI_SOUND:   /* command does not use a device name */
	case MCI_SYSINFO:
	    break;
	case MCI_CLOSE:   /* don't auto-open for close */
	case MCI_BREAK:   /* no auto-open for system commands */
	    dwRet = MCIERR_INVALID_DEVICE_NAME;
1443
	    goto errCleanUp;
1444 1445 1446 1447 1448
	    break;
	default:
	    {
		static const WCHAR wszOpenWait[] = {'o','p','e','n',' ','%','s',' ','w','a','i','t',0};
		WCHAR   buf[138], retbuf[6];
1449
		swprintf(buf, ARRAY_SIZE(buf), wszOpenWait, dev);
1450
		/* open via mciSendString handles quoting, dev!file syntax and alias creation */
1451
		if ((dwRet = mciSendStringW(buf, retbuf, ARRAY_SIZE(retbuf), 0)) != 0)
1452
		    goto errCleanUp;
1453
		auto_open = wcstoul(retbuf, NULL, 10);
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
		TRACE("auto-opened %u for %s\n", auto_open, debugstr_w(dev));

		/* FIXME: test for notify flag (how to preparse?) before opening */
		wmd = MCI_GetDriver(auto_open);
		if (!wmd) {
		    ERR("No auto-open device %u\n", auto_open);
		    dwRet = MCIERR_INVALID_DEVICE_ID;
		    goto errCleanUp;
		}
	    }
1464
	}
1465 1466 1467
    }

    /* get the verb in the different command tables */
1468 1469 1470 1471 1472 1473
    if (wmd) {
	/* try the device specific command table */
	lpCmd = MCI_FindCommand(wmd->uSpecificCmdTable, verb);
	if (!lpCmd) {
	    /* try the type specific command table */
	    if (wmd->uTypeCmdTable == MCI_COMMAND_TABLE_NOT_LOADED)
1474
		wmd->uTypeCmdTable = MCI_GetCommandTable(wmd->wType);
1475 1476 1477
	    if (wmd->uTypeCmdTable != MCI_NO_COMMAND_TABLE)
		lpCmd = MCI_FindCommand(wmd->uTypeCmdTable, verb);
	}
1478 1479
    }
    /* try core command table */
1480
    if (!lpCmd) lpCmd = MCI_FindCommand(MCI_GetCommandTable(0), verb);
1481 1482

    if (!lpCmd) {
1483
	TRACE("Command %s not found!\n", debugstr_w(verb));
1484 1485 1486
	dwRet = MCIERR_UNRECOGNIZED_COMMAND;
	goto errCleanUp;
    }
1487
    wMsg = MCI_GetMessage(lpCmd);
1488 1489

    /* set return information */
1490
    offset = sizeof(data.generic);
1491
    switch (retType = MCI_GetReturnType(lpCmd)) {
1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
    case 0:
        break;
    case MCI_INTEGER:
        offset += sizeof(DWORD);
        break;
    case MCI_STRING:
        data.sysinfo.lpstrReturn = lpstrRet;
        data.sysinfo.dwRetSize = uRetLen;
        offset = FIELD_OFFSET( MCI_SYSINFO_PARMSW, dwNumber );
        break;
    case MCI_RECT:
        offset += 4 * sizeof(DWORD);
        break;
1505 1506 1507 1508 1509
#ifdef MCI_INTEGER64
    case MCI_INTEGER64:
	offset += sizeof(DWORD_PTR);
        break;
#endif
1510
    default:
1511 1512 1513
	FIXME("Unknown MCI return type %d\n", retType);
	dwRet = MCIERR_PARSER_INTERNAL;
	goto errCleanUp;
1514 1515
    }

1516 1517
    TRACE("verb=%s on dev=%s; offset=%d\n", 
          debugstr_w(verb), debugstr_w(dev), offset);
1518

1519
    if ((dwRet = MCI_ParseOptArgs(data.dw, offset / sizeof(DWORD), lpCmd, args, &dwFlags)))
1520 1521
	goto errCleanUp;

1522
    /* set up call back */
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
    if (auto_open) {
	if (dwFlags & MCI_NOTIFY) {
	    dwRet = MCIERR_NOTIFY_ON_AUTO_OPEN;
	    goto errCleanUp;
	}
	/* FIXME: the command should get its own notification window set up and
	 * ask for device closing while processing the notification mechanism.
	 * hwndCallback = ...
	 * dwFlags |= MCI_NOTIFY;
	 * In the meantime special-case all commands but PLAY and RECORD below. */
    }
1534
    if (dwFlags & MCI_NOTIFY) {
1535
	data.generic.dwCallback = (DWORD_PTR)hwndCallback;
1536 1537
    }

1538 1539
    switch (wMsg) {
    case MCI_OPEN:
1540
	if (wcscmp(verb, wszOpen)) {
1541
	    FIXME("Cannot open with command %s\n", debugstr_w(verb));
1542
	    dwRet = MCIERR_DRIVER_INTERNAL;
1543 1544 1545 1546 1547 1548 1549 1550 1551
	    wMsg = 0;
	    goto errCleanUp;
	}
	break;
    case MCI_SYSINFO:
	/* Requirements on dev depend on the flags:
	 * alias with INSTALLNAME, name like "digitalvideo"
	 * with QUANTITY and NAME. */
	{
1552
	    data.sysinfo.wDeviceType = MCI_ALL_DEVICE_ID;
1553 1554 1555
	    if (uDevID != MCI_ALL_DEVICE_ID) {
		if (dwFlags & MCI_SYSINFO_INSTALLNAME)
		    wmd = MCI_GetDriver(mciGetDeviceIDW(dev));
1556
		else if (!(data.sysinfo.wDeviceType = MCI_GetDevTypeFromResource(dev))) {
1557 1558 1559 1560 1561 1562
		    dwRet = MCIERR_DEVICE_TYPE_REQUIRED;
		    goto errCleanUp;
		}
	    }
	}
	break;
Jörg Höhle's avatar
Jörg Höhle committed
1563 1564 1565
    case MCI_SOUND:
	/* FIXME: name is optional, "sound" is a valid command.
	 * FIXME: Parse "sound notify" as flag, not as name. */
1566
	data.sound.lpstrSoundName = dev;
Jörg Höhle's avatar
Jörg Höhle committed
1567 1568
	dwFlags |= MCI_SOUND_NAME;
	break;
1569 1570
    }

1571
    TRACE("[%d, %s, %08x, %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x]\n",
1572
	  wmd ? wmd->wDeviceID : uDevID, MCI_MessageToString(wMsg), dwFlags,
1573 1574
	  data.dw[0], data.dw[1], data.dw[2], data.dw[3], data.dw[4],
	  data.dw[5], data.dw[6], data.dw[7], data.dw[8], data.dw[9]);
1575

1576
    if (wMsg == MCI_OPEN) {
1577
	if ((dwRet = MCI_FinishOpen(wmd, &data.open, dwFlags)))
1578
	    goto errCleanUp;
1579 1580
	/* FIXME: notification is not properly shared across two opens */
    } else {
1581
	dwRet = MCI_SendCommand(wmd ? wmd->wDeviceID : uDevID, wMsg, dwFlags, (DWORD_PTR)&data);
1582
    }
1583
    if (!LOWORD(dwRet)) {
1584
	TRACE("=> 1/ %x (%s)\n", dwRet, debugstr_w(lpstrRet));
1585 1586
	dwRet = MCI_HandleReturnValues(dwRet, wmd, retType, &data.generic, lpstrRet, uRetLen);
	TRACE("=> 2/ %x (%s)\n", dwRet, debugstr_w(lpstrRet));
1587 1588
    } else
	TRACE("=> %x\n", dwRet);
1589 1590

errCleanUp:
1591 1592 1593 1594 1595 1596 1597
    if (auto_open) {
	/* PLAY and RECORD are the only known non-immediate commands */
	if (LOWORD(dwRet) || !(wMsg == MCI_PLAY || wMsg == MCI_RECORD))
	    MCI_SendCommand(auto_open, MCI_CLOSE, 0, 0);
	else
	    FIXME("leaking auto-open device %u\n", auto_open);
    }
1598 1599
    if (wMsg == MCI_OPEN && LOWORD(dwRet) && wmd)
	MCI_UnLoadMciDriver(wmd);
1600
    HeapFree(GetProcessHeap(), 0, devType);
1601 1602 1603 1604 1605
    HeapFree(GetProcessHeap(), 0, verb);
    return dwRet;
}

/**************************************************************************
1606
 * 				mciSendStringA			[WINMM.@]
1607
 */
1608
DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet,
1609
			    UINT uRetLen, HWND hwndCallback)
1610
{
1611 1612
    LPWSTR 	lpwstrCommand;
    LPWSTR      lpwstrRet = NULL;
1613
    UINT	ret;
1614
    INT len;
1615

1616
    /* FIXME: is there something to do with lpstrReturnString ? */
1617 1618 1619 1620
    len = MultiByteToWideChar( CP_ACP, 0, lpstrCommand, -1, NULL, 0 );
    lpwstrCommand = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
    MultiByteToWideChar( CP_ACP, 0, lpstrCommand, -1, lpwstrCommand, len );
    if (lpstrRet)
1621
    {
1622
        if (uRetLen) *lpstrRet = '\0'; /* NT-w2k3 use memset(lpstrRet, 0, uRetLen); */
1623
        lpwstrRet = HeapAlloc(GetProcessHeap(), 0, uRetLen * sizeof(WCHAR));
1624 1625 1626 1627
        if (!lpwstrRet) {
            HeapFree( GetProcessHeap(), 0, lpwstrCommand );
            return MCIERR_OUT_OF_MEMORY;
        }
1628
    }
1629
    ret = mciSendStringW(lpwstrCommand, lpwstrRet, uRetLen, hwndCallback);
1630
    if (!ret && lpwstrRet)
1631 1632 1633
        WideCharToMultiByte( CP_ACP, 0, lpwstrRet, -1, lpstrRet, uRetLen, NULL, NULL );
    HeapFree(GetProcessHeap(), 0, lpwstrCommand);
    HeapFree(GetProcessHeap(), 0, lpwstrRet);
1634
    return ret;
1635 1636
}

1637
/**************************************************************************
1638
 * 				mciExecute			[WINMM.@]
1639
 */
1640
BOOL WINAPI mciExecute(LPCSTR lpstrCommand)
1641 1642 1643
{
    char	strRet[256];
    DWORD	ret;
1644

1645 1646
    TRACE("(%s)!\n", lpstrCommand);

1647
    ret = mciSendStringA(lpstrCommand, strRet, sizeof(strRet), 0);
1648 1649
    if (ret != 0) {
	if (!mciGetErrorStringA(ret, strRet, sizeof(strRet))) {
1650
	    sprintf(strRet, "Unknown MCI error (%d)", ret);
1651
	}
1652
	MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
1653 1654
    }
    /* FIXME: what shall I return ? */
1655
    return TRUE;
1656
}
1657

1658
/**************************************************************************
1659
 *                    	mciLoadCommandResource  		[WINMM.@]
1660
 *
1661
 * Strangely, this function only exists as a UNICODE one.
1662
 */
1663
UINT WINAPI mciLoadCommandResource(HINSTANCE hInst, LPCWSTR resNameW, UINT type)
1664
{
1665 1666 1667
    UINT        ret = MCI_NO_COMMAND_TABLE;
    HRSRC	hRsrc = 0;
    HGLOBAL     hMem;
1668

1669
    TRACE("(%p, %s, %d)!\n", hInst, debugstr_w(resNameW), type);
1670

1671
    /* if a file named "resname.mci" exits, then load resource "resname" from it
1672 1673 1674 1675
     * otherwise directly from driver
     * We don't support it (who uses this feature ?), but we check anyway
     */
    if (!type) {
1676 1677
#if 0
        /* FIXME: we should put this back into order, but I never found a program
1678
         * actually using this feature, so we may not need it
1679
         */
1680 1681 1682 1683 1684 1685 1686 1687
	char		buf[128];
	OFSTRUCT       	ofs;

	strcat(strcpy(buf, resname), ".mci");
	if (OpenFile(buf, &ofs, OF_EXIST) != HFILE_ERROR) {
	    FIXME("NIY: command table to be loaded from '%s'\n", ofs.szPathName);
	}
#endif
1688
    }
1689 1690 1691 1692
    if ((hRsrc = FindResourceW(hInst, resNameW, (LPWSTR)RT_RCDATA)) &&
        (hMem = LoadResource(hInst, hRsrc))) {
        ret = MCI_SetCommandTable(hMem, type);
        FreeResource(hMem);
1693
    }
1694 1695
    else WARN("No command table found in module for %s\n", debugstr_w(resNameW));

1696 1697 1698 1699
    TRACE("=> %04x\n", ret);
    return ret;
}

1700
/**************************************************************************
1701
 *                    	mciFreeCommandResource			[WINMM.@]
1702
 */
1703
BOOL WINAPI mciFreeCommandResource(UINT uTable)
1704
{
1705 1706
    TRACE("(%08x)!\n", uTable);

1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
    if (uTable >= MAX_MCICMDTABLE || !S_MciCmdTable[uTable].lpTable)
	return FALSE;

    FreeResource(S_MciCmdTable[uTable].hMem);
    S_MciCmdTable[uTable].hMem = NULL;
    S_MciCmdTable[uTable].lpTable = NULL;
    HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTable].aVerbs);
    S_MciCmdTable[uTable].aVerbs = 0;
    S_MciCmdTable[uTable].nVerbs = 0;
    return TRUE;
1717 1718 1719 1720 1721
}

/**************************************************************************
 * 			MCI_Open				[internal]
 */
1722
static	DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms)
1723
{
1724
    WCHAR			strDevTyp[128];
1725
    DWORD 			dwRet;
1726
    LPWINE_MCIDRIVER		wmd = NULL;
1727

1728
    TRACE("(%08X, %p)\n", dwParam, lpParms);
1729
    if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1730 1731

    /* only two low bytes are generic, the other ones are dev type specific */
1732
#define WINE_MCIDRIVER_SUPP	(0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
1733 1734
                         MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
                         MCI_NOTIFY|MCI_WAIT)
1735
    if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0)
1736
        FIXME("Unsupported yet dwFlags=%08X\n", dwParam);
1737
#undef WINE_MCIDRIVER_SUPP
1738 1739 1740

    strDevTyp[0] = 0;

1741 1742
    if (dwParam & MCI_OPEN_TYPE) {
	if (dwParam & MCI_OPEN_TYPE_ID) {
1743
	    WORD uDevType = LOWORD(lpParms->lpstrDeviceType);
1744

1745 1746
	    if (uDevType < MCI_DEVTYPE_FIRST || uDevType > MCI_DEVTYPE_LAST ||
		!LoadStringW(hWinMM32Instance, uDevType, strDevTyp, ARRAY_SIZE(strDevTyp))) {
1747 1748 1749 1750
		dwRet = MCIERR_BAD_INTEGER;
		goto errCleanUp;
	    }
	} else {
1751
	    LPWSTR	ptr;
1752 1753 1754 1755
	    if (lpParms->lpstrDeviceType == NULL) {
		dwRet = MCIERR_NULL_PARAMETER_BLOCK;
		goto errCleanUp;
	    }
1756 1757
	    lstrcpyW(strDevTyp, lpParms->lpstrDeviceType);
	    ptr = wcschr(strDevTyp, '!');
1758 1759 1760 1761 1762 1763 1764
	    if (ptr) {
		/* this behavior is not documented in windows. However, since, in
		 * some occasions, MCI_OPEN handling is translated by WinMM into
		 * a call to mciSendString("open <type>"); this code shall be correct
		 */
		if (dwParam & MCI_OPEN_ELEMENT) {
		    ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
1765 1766
			debugstr_w(lpParms->lpstrElementName), 
                        debugstr_w(strDevTyp));
1767 1768 1769 1770 1771 1772 1773 1774
		    dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
		    goto errCleanUp;
		}
		dwParam |= MCI_OPEN_ELEMENT;
		*ptr++ = 0;
		/* FIXME: not a good idea to write in user supplied buffer */
		lpParms->lpstrElementName = ptr;
	    }
1775

1776
	}
1777
	TRACE("devType=%s !\n", debugstr_w(strDevTyp));
1778 1779
    }

1780
    if (dwParam & MCI_OPEN_ELEMENT) {
1781
	TRACE("lpstrElementName=%s\n", debugstr_w(lpParms->lpstrElementName));
1782 1783 1784 1785 1786 1787 1788

	if (dwParam & MCI_OPEN_ELEMENT_ID) {
	    FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
	    dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
	    goto errCleanUp;
	}

1789 1790 1791 1792 1793
	if (!lpParms->lpstrElementName) {
	    dwRet = MCIERR_NULL_PARAMETER_BLOCK;
	    goto errCleanUp;
	}

1794
	/* type, if given as a parameter, supersedes file extension */
1795 1796
	if (!strDevTyp[0] &&
	    MCI_GetDevTypeFromFileName(lpParms->lpstrElementName,
1797
				       strDevTyp, sizeof(strDevTyp))) {
1798 1799
            static const WCHAR wszCdAudio[] = {'C','D','A','U','D','I','O',0};
	    if (GetDriveTypeW(lpParms->lpstrElementName) != DRIVE_CDROM) {
1800 1801
		dwRet = MCIERR_EXTENSION_NOT_FOUND;
		goto errCleanUp;
1802
	    }
1803
	    /* FIXME: this will not work if several CDROM drives are installed on the machine */
1804
	    lstrcpyW(strDevTyp, wszCdAudio);
1805 1806
	}
    }
1807

1808
    if (strDevTyp[0] == 0) {
1809
	FIXME("Couldn't load driver\n");
1810
	dwRet = MCIERR_INVALID_DEVICE_NAME;
1811
	goto errCleanUp;
1812
    }
1813

1814
    if (dwParam & MCI_OPEN_ALIAS) {
1815
	TRACE("Alias=%s !\n", debugstr_w(lpParms->lpstrAlias));
1816 1817 1818 1819 1820
	if (!lpParms->lpstrAlias) {
	    dwRet = MCIERR_NULL_PARAMETER_BLOCK;
	    goto errCleanUp;
	}
    }
1821

1822
    if ((dwRet = MCI_LoadMciDriver(strDevTyp, &wmd))) {
1823
	goto errCleanUp;
1824
    }
1825

1826
    if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) {
1827
	TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08x], closing\n", dwRet);
1828 1829
	/* FIXME: is dwRet the correct ret code ? */
	goto errCleanUp;
1830
    }
1831 1832

    /* only handled devices fall through */
1833
    TRACE("wDevID=%04X wDeviceID=%d dwRet=%d\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet);
1834
    return 0;
1835

1836
errCleanUp:
1837
    if (wmd) MCI_UnLoadMciDriver(wmd);
1838 1839 1840 1841 1842 1843
    return dwRet;
}

/**************************************************************************
 * 			MCI_Close				[internal]
 */
1844
static	DWORD MCI_Close(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
1845
{
1846 1847 1848
    DWORD		dwRet;
    LPWINE_MCIDRIVER	wmd;

1849
    TRACE("(%04x, %08X, %p)\n", wDevID, dwParam, lpParms);
1850

1851
    /* Every device must handle MCI_NOTIFY on its own. */
1852
    if ((UINT16)wDevID == (UINT16)MCI_ALL_DEVICE_ID) {
1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866
	while (MciDrivers) {
            /* Retrieve the device ID under lock, but send the message without,
             * the driver might be calling some winmm functions from another
             * thread before being fully stopped.
             */
            EnterCriticalSection(&WINMM_cs);
            if (!MciDrivers)
            {
                LeaveCriticalSection(&WINMM_cs);
                break;
            }
            wDevID = MciDrivers->wDeviceID;
            LeaveCriticalSection(&WINMM_cs);
            MCI_Close(wDevID, dwParam, lpParms);
1867
	}
1868 1869 1870 1871 1872
	return 0;
    }

    if (!(wmd = MCI_GetDriver(wDevID))) {
	return MCIERR_INVALID_DEVICE_ID;
1873 1874
    }

1875 1876 1877
    if(wmd->CreatorThread != GetCurrentThreadId())
        return MCIERR_INVALID_DEVICE_NAME;

1878
    dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD_PTR)lpParms);
1879

1880
    MCI_UnLoadMciDriver(wmd);
1881

1882 1883 1884 1885 1886 1887
    return dwRet;
}

/**************************************************************************
 * 			MCI_WriteString				[internal]
 */
1888
static DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr)
1889
{
1890
    DWORD	ret = 0;
1891

1892
    if (lpSrcStr) {
1893
	if (dstSize <= lstrlenW(lpSrcStr)) {
1894 1895
	    ret = MCIERR_PARAM_OVERFLOW;
	} else {
1896
	    lstrcpyW(lpDstStr, lpSrcStr);
1897
	}
1898
    } else {
1899
	*lpDstStr = 0;
1900 1901 1902 1903 1904 1905 1906
    }
    return ret;
}

/**************************************************************************
 * 			MCI_Sysinfo				[internal]
 */
1907
static	DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParms)
1908
{
1909
    DWORD		ret = MCIERR_INVALID_DEVICE_ID, cnt = 0;
1910
    WCHAR		buf[2048], *s, *p;
1911
    LPWINE_MCIDRIVER	wmd;
1912
    HKEY		hKey;
1913

1914 1915
    if (lpParms == NULL)			return MCIERR_NULL_PARAMETER_BLOCK;
    if (lpParms->lpstrReturn == NULL)		return MCIERR_PARAM_OVERFLOW;
1916

1917 1918
    TRACE("(%08x, %08X, %p[num=%d, wDevTyp=%u])\n",
	  uDevID, dwFlags, lpParms, lpParms->dwNumber, lpParms->wDeviceType);
1919 1920
    if ((WORD)MCI_ALL_DEVICE_ID == LOWORD(uDevID))
	uDevID = MCI_ALL_DEVICE_ID; /* Be compatible with Win9x */
1921

1922
    switch (dwFlags & ~(MCI_SYSINFO_OPEN|MCI_NOTIFY|MCI_WAIT)) {
1923
    case MCI_SYSINFO_QUANTITY:
1924 1925 1926 1927 1928
	if (lpParms->dwRetSize < sizeof(DWORD))
	    return MCIERR_PARAM_OVERFLOW;
	/* Win9x returns 0 for 0 < uDevID < (UINT16)MCI_ALL_DEVICE_ID */
	if (uDevID == MCI_ALL_DEVICE_ID) {
	    /* wDeviceType == MCI_ALL_DEVICE_ID is not recognized. */
1929 1930
	    if (dwFlags & MCI_SYSINFO_OPEN) {
		TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
1931 1932
		EnterCriticalSection(&WINMM_cs);
		for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) {
1933
		    cnt++;
1934
		}
1935
		LeaveCriticalSection(&WINMM_cs);
1936
	    } else {
1937
		TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
1938
		if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci,
1939
			  	   0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) {
1940
		    RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
1941
		    RegCloseKey( hKey );
1942
		}
1943
		if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, ARRAY_SIZE(buf), wszSystemIni))
1944
		    for (s = buf; *s; s += lstrlenW(s) + 1) cnt++;
1945 1946 1947
	    }
	} else {
	    if (dwFlags & MCI_SYSINFO_OPEN) {
1948
		TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %d\n", lpParms->wDeviceType);
1949 1950
		EnterCriticalSection(&WINMM_cs);
		for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) {
1951 1952
		    if (wmd->wType == lpParms->wDeviceType) cnt++;
		}
1953
		LeaveCriticalSection(&WINMM_cs);
1954
	    } else {
1955
		TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %d\n", lpParms->wDeviceType);
1956
		FIXME("Don't know how to get # of MCI devices of a given type\n");
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967
		/* name = LoadStringW(hWinMM32Instance, LOWORD(lpParms->wDeviceType))
		 * then lookup registry and/or system.ini for name, ignoring digits suffix */
		switch (LOWORD(lpParms->wDeviceType)) {
		case MCI_DEVTYPE_CD_AUDIO:
		case MCI_DEVTYPE_WAVEFORM_AUDIO:
		case MCI_DEVTYPE_SEQUENCER:
		    cnt = 1;
		    break;
		default: /* "digitalvideo" gets 0 because it's not in the registry */
		    cnt = 0;
		}
1968 1969
	    }
	}
1970
	*(DWORD*)lpParms->lpstrReturn = cnt;
1971
	TRACE("(%d) => '%d'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
1972
	ret = MCI_INTEGER_RETURNED;
1973
	/* return ret; Only Win9x sends a notification in this case. */
1974 1975
	break;
    case MCI_SYSINFO_INSTALLNAME:
1976
	TRACE("MCI_SYSINFO_INSTALLNAME\n");
1977
	if ((wmd = MCI_GetDriver(uDevID))) {
1978
	    ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize,
1979
				  wmd->lpstrDeviceType);
1980
	} else {
1981 1982
	    ret = (uDevID == MCI_ALL_DEVICE_ID)
		? MCIERR_CANNOT_USE_ALL : MCIERR_INVALID_DEVICE_NAME;
1983
	}
1984
	TRACE("(%d) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn));
1985 1986
	break;
    case MCI_SYSINFO_NAME:
1987
	s = NULL;
1988
	if (dwFlags & MCI_SYSINFO_OPEN) {
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
	    /* Win9x returns 0 for 0 < uDevID < (UINT16)MCI_ALL_DEVICE_ID */
	    TRACE("MCI_SYSINFO_NAME: nth alias of type %d\n",
		  uDevID == MCI_ALL_DEVICE_ID ? MCI_ALL_DEVICE_ID : lpParms->wDeviceType);
	    EnterCriticalSection(&WINMM_cs);
	    for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) {
		/* wDeviceType == MCI_ALL_DEVICE_ID is not recognized. */
		if (uDevID == MCI_ALL_DEVICE_ID ||
		    lpParms->wDeviceType == wmd->wType) {
		    cnt++;
		    if (cnt == lpParms->dwNumber) {
			s = wmd->lpstrAlias;
			break;
		    }
		}
	    }
	    LeaveCriticalSection(&WINMM_cs);
2005
	    ret = s ? MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, s) : MCIERR_OUTOFRANGE;
2006 2007
	} else if (MCI_ALL_DEVICE_ID == uDevID) {
	    TRACE("MCI_SYSINFO_NAME: device #%d\n", lpParms->dwNumber);
2008 2009 2010 2011 2012
	    if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci, 0, 
                               KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) {
		if (RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 
                                      0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS && 
                    lpParms->dwNumber <= cnt) {
2013
		    DWORD bufLen = ARRAY_SIZE(buf);
2014 2015 2016
		    if (RegEnumKeyExW(hKey, lpParms->dwNumber - 1, 
                                      buf, &bufLen, 0, 0, 0, 0) == ERROR_SUCCESS)
                        s = buf;
2017 2018 2019 2020
		}
	        RegCloseKey( hKey );
	    }
	    if (!s) {
2021
		if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, ARRAY_SIZE(buf), wszSystemIni)) {
2022
		    for (p = buf; *p; p += lstrlenW(p) + 1, cnt++) {
2023
                        TRACE("%d: %s\n", cnt, debugstr_w(p));
2024 2025 2026 2027 2028 2029 2030
			if (cnt == lpParms->dwNumber - 1) {
			    s = p;
			    break;
			}
		    }
		}
	    }
2031
	    ret = s ? MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, s) : MCIERR_OUTOFRANGE;
2032 2033 2034 2035 2036 2037 2038 2039
	} else {
	    FIXME("MCI_SYSINFO_NAME: nth device of type %d\n", lpParms->wDeviceType);
	    /* Cheating: what is asked for is the nth device from the registry. */
	    if (1 != lpParms->dwNumber || /* Handle only one of each kind. */
		lpParms->wDeviceType < MCI_DEVTYPE_FIRST || lpParms->wDeviceType > MCI_DEVTYPE_LAST)
		ret = MCIERR_OUTOFRANGE;
	    else {
		LoadStringW(hWinMM32Instance, LOWORD(lpParms->wDeviceType),
2040
			    lpParms->lpstrReturn, lpParms->dwRetSize);
2041 2042
		ret = 0;
	    }
2043
	}
2044
	TRACE("(%d) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn));
2045 2046
	break;
    default:
2047
	TRACE("Unsupported flag value=%08x\n", dwFlags);
2048
	ret = MCIERR_UNRECOGNIZED_KEYWORD;
2049
    }
2050 2051
    if ((dwFlags & MCI_NOTIFY) && HRESULT_CODE(ret)==0)
	mciDriverNotify((HWND)lpParms->dwCallback, uDevID, MCI_NOTIFY_SUCCESSFUL);
2052 2053 2054
    return ret;
}

2055 2056 2057
/**************************************************************************
 * 			MCI_Break				[internal]
 */
2058
static	DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
2059
{
2060 2061
    DWORD dwRet;

2062 2063
    if (lpParms == NULL)
        return MCIERR_NULL_PARAMETER_BLOCK;
2064

2065 2066 2067 2068 2069
    TRACE("(%08x, %08X, vkey %04X, hwnd %p)\n", wDevID, dwFlags,
          lpParms->nVirtKey, lpParms->hwndBreak);

    dwRet = MCI_SendCommandFrom32(wDevID, MCI_BREAK, dwFlags, (DWORD_PTR)lpParms);
    if (!dwRet && (dwFlags & MCI_NOTIFY))
2070
        mciDriverNotify((HWND)lpParms->dwCallback, wDevID, MCI_NOTIFY_SUCCESSFUL);
2071
    return dwRet;
2072
}
2073

2074 2075 2076
/**************************************************************************
 * 			MCI_Sound				[internal]
 */
2077
static	DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMSW lpParms)
2078
{
Jörg Höhle's avatar
Jörg Höhle committed
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090
    DWORD	dwRet;

    if (dwFlags & MCI_SOUND_NAME) {
	if (lpParms == NULL)	return MCIERR_NULL_PARAMETER_BLOCK;
	else dwRet = PlaySoundW(lpParms->lpstrSoundName, NULL,
				SND_ALIAS    | (dwFlags & MCI_WAIT ? SND_SYNC : SND_ASYNC))
		? 0 : MCIERR_HARDWARE;
    } else   dwRet = PlaySoundW((LPCWSTR)SND_ALIAS_SYSTEMDEFAULT, NULL,
				SND_ALIAS_ID | (dwFlags & MCI_WAIT ? SND_SYNC : SND_ASYNC))
		? 0 : MCIERR_HARDWARE;

    if (!dwRet && lpParms && (dwFlags & MCI_NOTIFY))
2091
        mciDriverNotify((HWND)lpParms->dwCallback, wDevID, MCI_NOTIFY_SUCCESSFUL);
2092 2093 2094
    return dwRet;
}

2095 2096 2097
/**************************************************************************
 * 			MCI_SendCommand				[internal]
 */
2098
DWORD	MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2099 2100 2101 2102 2103
{
    DWORD		dwRet = MCIERR_UNRECOGNIZED_COMMAND;

    switch (wMsg) {
    case MCI_OPEN:
2104
        dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSW)dwParam2);
2105 2106
	break;
    case MCI_CLOSE:
2107
        dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2108 2109
	break;
    case MCI_SYSINFO:
2110
        dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSW)dwParam2);
2111 2112
	break;
    case MCI_BREAK:
2113
        dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
2114 2115
	break;
    case MCI_SOUND:
2116
        dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2);
2117 2118
	break;
    default:
2119
      if ((UINT16)wDevID == (UINT16)MCI_ALL_DEVICE_ID) {
2120 2121 2122
	    FIXME("unhandled MCI_ALL_DEVICE_ID\n");
	    dwRet = MCIERR_CANNOT_USE_ALL;
	} else {
2123
	    dwRet = MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2);
2124
	}
2125 2126 2127 2128 2129
	break;
    }
    return dwRet;
}

2130 2131 2132
/**************************************************************************
 * 				MCI_CleanUp			[internal]
 *
2133
 * Some MCI commands need to be cleaned-up (when not called from
2134
 * mciSendString), because MCI drivers return extra information for string
2135
 * transformation. This function gets rid of them.
2136
 */
2137
static LRESULT	MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD_PTR dwParam2)
2138
{
2139
    if (LOWORD(dwRet))
2140 2141
	return LOWORD(dwRet);

2142 2143 2144 2145 2146 2147 2148
    switch (wMsg) {
    case MCI_GETDEVCAPS:
	switch (dwRet & 0xFFFF0000ul) {
	case 0:
	case MCI_COLONIZED3_RETURN:
	case MCI_COLONIZED4_RETURN:
	case MCI_INTEGER_RETURNED:
2149 2150 2151 2152
	    /* nothing to do */
	    break;
	case MCI_RESOURCE_RETURNED:
	case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
2153
	    {
2154
		LPMCI_GETDEVCAPS_PARMS	lmgp;
2155

2156
		lmgp = (LPMCI_GETDEVCAPS_PARMS)dwParam2;
2157
		TRACE("Changing %08x to %08x\n", lmgp->dwReturn, LOWORD(lmgp->dwReturn));
2158
		lmgp->dwReturn = LOWORD(lmgp->dwReturn);
2159
	    }
2160 2161
	    break;
	default:
2162
	    FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2163
		  HIWORD(dwRet), MCI_MessageToString(wMsg));
2164 2165 2166 2167 2168 2169 2170 2171
	}
	break;
    case MCI_STATUS:
	switch (dwRet & 0xFFFF0000ul) {
	case 0:
	case MCI_COLONIZED3_RETURN:
	case MCI_COLONIZED4_RETURN:
	case MCI_INTEGER_RETURNED:
2172 2173 2174 2175
	    /* nothing to do */
	    break;
	case MCI_RESOURCE_RETURNED:
	case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
2176
	    {
2177
		LPMCI_STATUS_PARMS	lsp;
2178

2179 2180
		lsp = (LPMCI_STATUS_PARMS)dwParam2;
		TRACE("Changing %08lx to %08x\n", lsp->dwReturn, LOWORD(lsp->dwReturn));
2181 2182 2183 2184
		lsp->dwReturn = LOWORD(lsp->dwReturn);
	    }
	    break;
	default:
2185
	    FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2186 2187 2188 2189 2190 2191 2192
		  HIWORD(dwRet), MCI_MessageToString(wMsg));
	}
	break;
    case MCI_SYSINFO:
	switch (dwRet & 0xFFFF0000ul) {
	case 0:
	case MCI_INTEGER_RETURNED:
2193
	    /* nothing to do */
2194 2195
	    break;
	default:
2196
	    FIXME("Unsupported value for hiword (%04x)\n", HIWORD(dwRet));
2197 2198 2199
	}
	break;
    default:
2200
	if (HIWORD(dwRet)) {
2201
	    FIXME("Got non null hiword for dwRet=0x%08lx for command %s\n",
2202
		  dwRet, MCI_MessageToString(wMsg));
2203
	}
2204 2205
	break;
    }
2206
    return LOWORD(dwRet);
2207
}
2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218

/**************************************************************************
 * 				mciGetErrorStringW		[WINMM.@]
 */
BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength)
{
    BOOL		ret = FALSE;

    if (lpstrBuffer != NULL && uLength > 0 &&
	wError >= MCIERR_BASE && wError <= MCIERR_CUSTOM_DRIVER_BASE) {

2219
	if (LoadStringW(hWinMM32Instance, wError, lpstrBuffer, uLength) > 0) {
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
	    ret = TRUE;
	}
    }
    return ret;
}

/**************************************************************************
 * 				mciGetErrorStringA		[WINMM.@]
 */
BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength)
{
    BOOL		ret = FALSE;

    if (lpstrBuffer != NULL && uLength > 0 &&
	dwError >= MCIERR_BASE && dwError <= MCIERR_CUSTOM_DRIVER_BASE) {

2236
	if (LoadStringA(hWinMM32Instance, dwError, lpstrBuffer, uLength) > 0) {
2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255
	    ret = TRUE;
	}
    }
    return ret;
}

/**************************************************************************
 *			mciDriverNotify				[WINMM.@]
 */
BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus)
{
    TRACE("(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);

    return PostMessageW(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
}

/**************************************************************************
 * 			mciGetDriverData			[WINMM.@]
 */
2256
DWORD_PTR WINAPI mciGetDriverData(MCIDEVICEID uDeviceID)
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
{
    LPWINE_MCIDRIVER	wmd;

    TRACE("(%04x)\n", uDeviceID);

    wmd = MCI_GetDriver(uDeviceID);

    if (!wmd) {
	WARN("Bad uDeviceID\n");
	return 0L;
    }

    return wmd->dwPrivate;
}

/**************************************************************************
 * 			mciSetDriverData			[WINMM.@]
 */
2275
BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD_PTR data)
2276 2277 2278
{
    LPWINE_MCIDRIVER	wmd;

2279
    TRACE("(%04x, %08lx)\n", uDeviceID, data);
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302

    wmd = MCI_GetDriver(uDeviceID);

    if (!wmd) {
	WARN("Bad uDeviceID\n");
	return FALSE;
    }

    wmd->dwPrivate = data;
    return TRUE;
}

/**************************************************************************
 * 				mciSendCommandW			[WINMM.@]
 *
 */
DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
    DWORD	dwRet;

    TRACE("(%08x, %s, %08lx, %08lx)\n",
	  wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);

2303
    dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2);
2304
    dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2);
2305
    TRACE("=> %08x\n", dwRet);
2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323
    return dwRet;
}

/**************************************************************************
 * 				mciSendCommandA			[WINMM.@]
 */
DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
    DWORD ret;
    int mapped;

    TRACE("(%08x, %s, %08lx, %08lx)\n",
	  wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);

    mapped = MCI_MapMsgAtoW(wMsg, dwParam1, &dwParam2);
    if (mapped == -1)
    {
        FIXME("message %04x mapping failed\n", wMsg);
2324
        return MCIERR_OUT_OF_MEMORY;
2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358
    }
    ret = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
    if (mapped)
        MCI_UnmapMsgAtoW(wMsg, dwParam1, dwParam2, ret);
    return ret;
}

/**************************************************************************
 * 				mciGetDeviceIDA    		[WINMM.@]
 */
UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName)
{
    LPWSTR w = MCI_strdupAtoW(lpstrName);
    UINT ret = MCIERR_OUT_OF_MEMORY;

    if (w)
    {
        ret = mciGetDeviceIDW(w);
        HeapFree(GetProcessHeap(), 0, w);
    }
    return ret;
}

/**************************************************************************
 * 				mciGetDeviceIDW		       	[WINMM.@]
 */
UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
{
    return MCI_GetDriverFromString(lpwstrName); 
}

/**************************************************************************
 * 				MCI_DefYieldProc	       	[internal]
 */
2359
static UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
2360 2361
{
    INT16	ret;
2362
    MSG		msg;
2363

2364
    TRACE("(0x%04x, 0x%08x)\n", wDevID, data);
2365 2366 2367

    if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) ||
	(GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
2368
        PeekMessageW(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384
	ret = 0;
    } else {
	msg.hwnd = HWND_32(HIWORD(data));
	while (!PeekMessageW(&msg, msg.hwnd, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
	ret = -1;
    }
    return ret;
}

/**************************************************************************
 * 				mciSetYieldProc			[WINMM.@]
 */
BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
{
    LPWINE_MCIDRIVER	wmd;

2385
    TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421

    if (!(wmd = MCI_GetDriver(uDeviceID))) {
	WARN("Bad uDeviceID\n");
	return FALSE;
    }

    wmd->lpfnYieldProc = fpYieldProc;
    wmd->dwYieldData   = dwYieldData;

    return TRUE;
}

/**************************************************************************
 * 				mciGetDeviceIDFromElementIDA	[WINMM.@]
 */
UINT WINAPI mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType)
{
    LPWSTR w = MCI_strdupAtoW(lpstrType);
    UINT ret = 0;

    if (w)
    {
        ret = mciGetDeviceIDFromElementIDW(dwElementID, w);
        HeapFree(GetProcessHeap(), 0, w);
    }
    return ret;
}

/**************************************************************************
 * 				mciGetDeviceIDFromElementIDW	[WINMM.@]
 */
UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
{
    /* FIXME: that's rather strange, there is no
     * mciGetDeviceIDFromElementID32A in winmm.spec
     */
2422
    FIXME("(%u, %s) stub\n", dwElementID, debugstr_w(lpstrType));
2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
    return 0;
}

/**************************************************************************
 * 				mciGetYieldProc			[WINMM.@]
 */
YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD* lpdwYieldData)
{
    LPWINE_MCIDRIVER	wmd;

    TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);

    if (!(wmd = MCI_GetDriver(uDeviceID))) {
	WARN("Bad uDeviceID\n");
	return NULL;
    }
    if (!wmd->lpfnYieldProc) {
	WARN("No proc set\n");
	return NULL;
    }
2443
    if (lpdwYieldData) *lpdwYieldData = wmd->dwYieldData;
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454
    return wmd->lpfnYieldProc;
}

/**************************************************************************
 * 				mciGetCreatorTask		[WINMM.@]
 */
HTASK WINAPI mciGetCreatorTask(MCIDEVICEID uDeviceID)
{
    LPWINE_MCIDRIVER	wmd;
    HTASK ret = 0;

2455
    if ((wmd = MCI_GetDriver(uDeviceID))) ret = (HTASK)(DWORD_PTR)wmd->CreatorThread;
2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470

    TRACE("(%u) => %p\n", uDeviceID, ret);
    return ret;
}

/**************************************************************************
 * 			mciDriverYield				[WINMM.@]
 */
UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID)
{
    LPWINE_MCIDRIVER	wmd;
    UINT		ret = 0;

    TRACE("(%04x)\n", uDeviceID);

2471
    if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc) {
2472 2473
        MSG msg;
        PeekMessageW(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
2474 2475 2476 2477 2478 2479
    } else {
	ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData);
    }

    return ret;
}