1 /*
2 * Digital video MCI Wine Driver
3 *
4 * Copyright 1999, 2000 Eric POUECH
5 * Copyright 2003 Dmitry Timoshkov
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 /* TODO list :
23 * - handling of palettes
24 * - recording (which input devices ?), a cam recorder ?
25 * - lots of messages still need to be handled (cf FIXME)
26 * - synchronization between audio and video (especially for interleaved
27 * files)
28 * - robustness when reading file can be enhanced
29 * - reimplement the AVI handling part with avifile DLL because
30 * "open @1122334 type avivideo alias a" expects an AVIFile/Stream
31 * and MCI_DGV_SET|STATUS_SPEED maps to Rate/Scale
32 * - some files appear to have more than one audio stream (we only play the
33 * first one)
34 * - some files contain an index of audio/video frame. Better use it,
35 * instead of rebuilding it (AVIFile does that already)
36 * - stopping while playing a file with sound blocks until all buffered
37 * audio is played... still should be stopped ASAP
38 */
39
40 #include <string.h>
41 #include "private_mciavi.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
45
46 static DWORD MCIAVI_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS);
47
48 /*======================================================================*
49 * MCI AVI implementation *
50 *======================================================================*/
51
52 HINSTANCE MCIAVI_hInstance = 0;
53
54 /***********************************************************************
55 * DllMain (MCIAVI.0)
56 */
DllMain(HINSTANCE hInstDLL,DWORD fdwReason,LPVOID fImpLoad)57 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
58 {
59 switch (fdwReason) {
60 case DLL_PROCESS_ATTACH:
61 DisableThreadLibraryCalls(hInstDLL);
62 MCIAVI_hInstance = hInstDLL;
63 break;
64 }
65 return TRUE;
66 }
67
68 /**************************************************************************
69 * MCIAVI_drvOpen [internal]
70 */
MCIAVI_drvOpen(LPCWSTR str,LPMCI_OPEN_DRIVER_PARMSW modp)71 static DWORD MCIAVI_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
72 {
73 WINE_MCIAVI* wma;
74 static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
75
76 TRACE("%s, %p\n", debugstr_w(str), modp);
77
78 /* session instance */
79 if (!modp) return 0xFFFFFFFF;
80
81 if (!MCIAVI_RegisterClass()) return 0;
82
83 wma = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIAVI));
84 if (!wma)
85 return 0;
86
87 InitializeCriticalSection(&wma->cs);
88 wma->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINE_MCIAVI.cs");
89 wma->hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
90 wma->wDevID = modp->wDeviceID;
91 wma->wCommandTable = mciLoadCommandResource(MCIAVI_hInstance, mciAviWStr, 0);
92 wma->dwStatus = MCI_MODE_NOT_READY;
93 modp->wCustomCommandTable = wma->wCommandTable;
94 modp->wType = MCI_DEVTYPE_DIGITAL_VIDEO;
95 mciSetDriverData(wma->wDevID, (DWORD_PTR)wma);
96
97 return modp->wDeviceID;
98 }
99
100 /**************************************************************************
101 * MCIAVI_drvClose [internal]
102 */
MCIAVI_drvClose(DWORD dwDevID)103 static DWORD MCIAVI_drvClose(DWORD dwDevID)
104 {
105 WINE_MCIAVI *wma;
106
107 TRACE("%04x\n", dwDevID);
108
109 /* finish all outstanding things */
110 MCIAVI_mciClose(dwDevID, MCI_WAIT, NULL);
111
112 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
113
114 if (wma) {
115 MCIAVI_UnregisterClass();
116
117 EnterCriticalSection(&wma->cs);
118
119 mciSetDriverData(dwDevID, 0);
120 mciFreeCommandResource(wma->wCommandTable);
121
122 CloseHandle(wma->hStopEvent);
123
124 LeaveCriticalSection(&wma->cs);
125 wma->cs.DebugInfo->Spare[0] = 0;
126 DeleteCriticalSection(&wma->cs);
127
128 HeapFree(GetProcessHeap(), 0, wma);
129 return 1;
130 }
131 return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
132 }
133
134 /**************************************************************************
135 * MCIAVI_drvConfigure [internal]
136 */
MCIAVI_drvConfigure(DWORD dwDevID)137 static DWORD MCIAVI_drvConfigure(DWORD dwDevID)
138 {
139 WINE_MCIAVI *wma;
140
141 TRACE("%04x\n", dwDevID);
142
143 MCIAVI_mciStop(dwDevID, MCI_WAIT, NULL);
144
145 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
146
147 if (wma) {
148 MessageBoxA(0, "Sample AVI Wine Driver !", "MM-Wine Driver", MB_OK);
149 return 1;
150 }
151 return 0;
152 }
153
154 /**************************************************************************
155 * MCIAVI_mciGetOpenDev [internal]
156 */
MCIAVI_mciGetOpenDev(UINT wDevID)157 WINE_MCIAVI* MCIAVI_mciGetOpenDev(UINT wDevID)
158 {
159 WINE_MCIAVI* wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
160
161 if (wma == NULL || wma->nUseCount == 0) {
162 WARN("Invalid wDevID=%u\n", wDevID);
163 return 0;
164 }
165 return wma;
166 }
167
MCIAVI_CleanUp(WINE_MCIAVI * wma)168 static void MCIAVI_CleanUp(WINE_MCIAVI* wma)
169 {
170 /* to prevent handling in WindowProc */
171 wma->dwStatus = MCI_MODE_NOT_READY;
172 if (wma->hFile) {
173 mmioClose(wma->hFile, 0);
174 wma->hFile = 0;
175
176 HeapFree(GetProcessHeap(), 0, wma->lpFileName);
177 wma->lpFileName = NULL;
178
179 HeapFree(GetProcessHeap(), 0, wma->lpVideoIndex);
180 wma->lpVideoIndex = NULL;
181 HeapFree(GetProcessHeap(), 0, wma->lpAudioIndex);
182 wma->lpAudioIndex = NULL;
183 if (wma->hic) ICClose(wma->hic);
184 wma->hic = 0;
185 HeapFree(GetProcessHeap(), 0, wma->inbih);
186 wma->inbih = NULL;
187 HeapFree(GetProcessHeap(), 0, wma->outbih);
188 wma->outbih = NULL;
189 HeapFree(GetProcessHeap(), 0, wma->indata);
190 wma->indata = NULL;
191 HeapFree(GetProcessHeap(), 0, wma->outdata);
192 wma->outdata = NULL;
193 if (wma->hbmFrame) DeleteObject(wma->hbmFrame);
194 wma->hbmFrame = 0;
195 if (wma->hWnd) DestroyWindow(wma->hWnd);
196 wma->hWnd = 0;
197
198 HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
199 wma->lpWaveFormat = 0;
200
201 memset(&wma->mah, 0, sizeof(wma->mah));
202 memset(&wma->ash_video, 0, sizeof(wma->ash_video));
203 memset(&wma->ash_audio, 0, sizeof(wma->ash_audio));
204 wma->dwCurrVideoFrame = wma->dwCurrAudioBlock = 0;
205 wma->dwCachedFrame = -1;
206 }
207 }
208
209 /***************************************************************************
210 * MCIAVI_mciOpen [internal]
211 */
MCIAVI_mciOpen(UINT wDevID,DWORD dwFlags,LPMCI_DGV_OPEN_PARMSW lpOpenParms)212 static DWORD MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags,
213 LPMCI_DGV_OPEN_PARMSW lpOpenParms)
214 {
215 WINE_MCIAVI *wma;
216 LRESULT dwRet = 0;
217
218 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
219
220 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
221
222 wma = (WINE_MCIAVI *)mciGetDriverData(wDevID);
223 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
224
225 EnterCriticalSection(&wma->cs);
226
227 if (wma->nUseCount > 0) {
228 /* The driver is already open on this channel */
229 /* If the driver was opened shareable before and this open specifies */
230 /* shareable then increment the use count */
231 if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
232 ++wma->nUseCount;
233 else
234 {
235 LeaveCriticalSection(&wma->cs);
236 return MCIERR_MUST_USE_SHAREABLE;
237 }
238 } else {
239 wma->nUseCount = 1;
240 wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
241 }
242
243 wma->dwStatus = MCI_MODE_NOT_READY;
244
245 if (dwFlags & MCI_OPEN_ELEMENT) {
246 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
247 /* could it be that (DWORD)lpOpenParms->lpstrElementName
248 * contains the hFile value ?
249 */
250 dwRet = MCIERR_UNRECOGNIZED_COMMAND;
251 } else if (lpOpenParms->lpstrElementName && lpOpenParms->lpstrElementName[0]) {
252 /* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */
253 TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
254
255 wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
256 lstrcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
257
258 if (lpOpenParms->lpstrElementName[0] == '@') {
259 /* The file name @11223344 encodes an AVIFile handle in decimal notation
260 * in Win3.1 and w2k/NT, but this feature is absent in win95 (KB140750).
261 * wma->hFile = LongToHandle(wcstol(lpOpenParms->lpstrElementName+1, NULL, 10)); */
262 FIXME("Using AVIFile/Stream %s NIY\n", debugstr_w(lpOpenParms->lpstrElementName));
263 }
264 wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
265 MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
266
267 if (wma->hFile == 0) {
268 WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
269 dwRet = MCIERR_FILE_NOT_FOUND;
270 } else {
271 if (!MCIAVI_GetInfo(wma))
272 dwRet = MCIERR_INVALID_FILE;
273 else if (!MCIAVI_OpenVideo(wma))
274 dwRet = MCIERR_CANNOT_LOAD_DRIVER;
275 else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms))
276 dwRet = MCIERR_CREATEWINDOW;
277 }
278 } else {
279 FIXME("Don't record yet\n");
280 dwRet = MCIERR_UNSUPPORTED_FUNCTION;
281 }
282 }
283
284 if (dwRet == 0) {
285 TRACE("lpOpenParms->wDeviceID = %04x\n", lpOpenParms->wDeviceID);
286
287 wma->dwStatus = MCI_MODE_STOP;
288 wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
289 } else {
290 MCIAVI_CleanUp(wma);
291 }
292
293 LeaveCriticalSection(&wma->cs);
294
295 if (!dwRet && (dwFlags & MCI_NOTIFY)) {
296 mciDriverNotify(HWND_32(LOWORD(lpOpenParms->dwCallback)),
297 wDevID, MCI_NOTIFY_SUCCESSFUL);
298 }
299 return dwRet;
300 }
301
302 /***************************************************************************
303 * MCIAVI_mciClose [internal]
304 */
MCIAVI_mciClose(UINT wDevID,DWORD dwFlags,LPMCI_GENERIC_PARMS lpParms)305 DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
306 {
307 WINE_MCIAVI *wma;
308 DWORD dwRet = 0;
309
310 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
311
312 wma = MCIAVI_mciGetOpenDev(wDevID);
313 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
314
315 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
316
317 EnterCriticalSection(&wma->cs);
318
319 if (wma->nUseCount == 1) {
320 MCIAVI_CleanUp(wma);
321
322 if ((dwFlags & MCI_NOTIFY) && lpParms) {
323 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
324 wDevID,
325 MCI_NOTIFY_SUCCESSFUL);
326 }
327 LeaveCriticalSection(&wma->cs);
328 return dwRet;
329 }
330 wma->nUseCount--;
331
332 LeaveCriticalSection(&wma->cs);
333 return dwRet;
334 }
335
currenttime_us(void)336 static double currenttime_us(void)
337 {
338 LARGE_INTEGER lc, lf;
339 QueryPerformanceCounter(&lc);
340 QueryPerformanceFrequency(&lf);
341 return (lc.QuadPart * 1000000) / lf.QuadPart;
342 }
343
344 /***************************************************************************
345 * MCIAVI_player [internal]
346 */
MCIAVI_player(WINE_MCIAVI * wma,DWORD dwFlags,LPMCI_PLAY_PARMS lpParms)347 static DWORD MCIAVI_player(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
348 {
349 DWORD dwRet;
350 LPWAVEHDR waveHdr = NULL;
351 unsigned i, nHdr = 0;
352 DWORD numEvents = 1;
353 HANDLE events[2];
354 double next_frame_us;
355 BOOL wait_audio = TRUE;
356
357 EnterCriticalSection(&wma->cs);
358
359 if (wma->dwToVideoFrame <= wma->dwCurrVideoFrame)
360 {
361 dwRet = 0;
362 goto mci_play_done;
363 }
364
365 events[0] = wma->hStopEvent;
366 if (wma->lpWaveFormat) {
367 if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
368 {
369 /* can't play audio */
370 HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
371 wma->lpWaveFormat = NULL;
372 }
373 else
374 {
375 /* fill the queue with as many wave headers as possible */
376 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
377 events[1] = wma->hEvent;
378 numEvents = 2;
379 }
380 }
381
382 next_frame_us = currenttime_us();
383 while (wma->dwStatus == MCI_MODE_PLAY)
384 {
385 HDC hDC;
386 double tc, delta;
387 DWORD ret;
388
389 tc = currenttime_us();
390
391 hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
392 if (hDC)
393 {
394 while(next_frame_us <= tc && wma->dwCurrVideoFrame < wma->dwToVideoFrame){
395 double dur;
396 dur = MCIAVI_PaintFrame(wma, hDC);
397 ++wma->dwCurrVideoFrame;
398 if(!dur)
399 break;
400 next_frame_us += dur;
401 TRACE("next_frame: %f\n", next_frame_us);
402 }
403 ReleaseDC(wma->hWndPaint, hDC);
404 }
405 if (wma->dwCurrVideoFrame >= wma->dwToVideoFrame)
406 {
407 if (!(dwFlags & MCI_DGV_PLAY_REPEAT))
408 break;
409 TRACE("repeat media as requested\n");
410 wma->dwCurrVideoFrame = wma->dwCurrAudioBlock = 0;
411 }
412
413 if (wma->lpWaveFormat)
414 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
415
416 tc = currenttime_us();
417 if (tc < next_frame_us)
418 delta = next_frame_us - tc;
419 else
420 delta = 0;
421
422 /* check if the playback was cancelled */
423 if ((wma->mci_break.flags & MCI_BREAK_KEY) &&
424 (GetAsyncKeyState(wma->mci_break.parms.nVirtKey) & 0x8000))
425 {
426 if (!(wma->mci_break.flags & MCI_BREAK_HWND) ||
427 GetForegroundWindow() == wma->mci_break.parms.hwndBreak)
428 {
429 /* we queue audio blocks ahead so ignore them otherwise the audio
430 * will keep playing until the buffer is empty */
431 wait_audio = FALSE;
432
433 TRACE("playback cancelled using break key\n");
434 break;
435 }
436 }
437
438 LeaveCriticalSection(&wma->cs);
439 ret = WaitForMultipleObjects(numEvents, events, FALSE, delta / 1000);
440 EnterCriticalSection(&wma->cs);
441 if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
442 }
443
444 if (wma->lpWaveFormat)
445 {
446 if (wait_audio)
447 while (wma->dwEventCount != nHdr - 1)
448 {
449 LeaveCriticalSection(&wma->cs);
450 Sleep(100);
451 EnterCriticalSection(&wma->cs);
452 }
453
454 /* just to get rid of some race conditions between play, stop and pause */
455 LeaveCriticalSection(&wma->cs);
456 waveOutReset(wma->hWave);
457 EnterCriticalSection(&wma->cs);
458
459 for (i = 0; i < nHdr; i++)
460 waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
461 }
462
463 dwRet = 0;
464
465 if (wma->lpWaveFormat) {
466 HeapFree(GetProcessHeap(), 0, waveHdr);
467
468 if (wma->hWave) {
469 LeaveCriticalSection(&wma->cs);
470 waveOutClose(wma->hWave);
471 EnterCriticalSection(&wma->cs);
472 wma->hWave = 0;
473 }
474 CloseHandle(wma->hEvent);
475 }
476
477 mci_play_done:
478 wma->dwStatus = MCI_MODE_STOP;
479
480 if (dwFlags & MCI_NOTIFY) {
481 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
482 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
483 wma->wDevID, MCI_NOTIFY_SUCCESSFUL);
484 }
485 LeaveCriticalSection(&wma->cs);
486 return dwRet;
487 }
488
489 struct MCIAVI_play_data
490 {
491 WINE_MCIAVI *wma;
492 DWORD flags;
493 MCI_PLAY_PARMS params; /* FIXME: notify via wma->hCallback like the other MCI drivers */
494 };
495
496 /*
497 * MCIAVI_mciPlay_thread
498 *
499 * FIXME: probably should use a common worker thread created at the driver
500 * load time and queue all async commands to it.
501 */
MCIAVI_mciPlay_thread(LPVOID arg)502 static DWORD WINAPI MCIAVI_mciPlay_thread(LPVOID arg)
503 {
504 struct MCIAVI_play_data *data = (struct MCIAVI_play_data *)arg;
505 DWORD ret;
506
507 TRACE("In thread before async play command (id %u, flags %08x)\n", data->wma->wDevID, data->flags);
508 ret = MCIAVI_player(data->wma, data->flags, &data->params);
509 TRACE("In thread after async play command (id %u, flags %08x)\n", data->wma->wDevID, data->flags);
510
511 HeapFree(GetProcessHeap(), 0, data);
512 return ret;
513 }
514
515 /*
516 * MCIAVI_mciPlay_async
517 */
MCIAVI_mciPlay_async(WINE_MCIAVI * wma,DWORD dwFlags,LPMCI_PLAY_PARMS lpParams)518 static DWORD MCIAVI_mciPlay_async(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParams)
519 {
520 HANDLE handle;
521 struct MCIAVI_play_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct MCIAVI_play_data));
522
523 if (!data) return MCIERR_OUT_OF_MEMORY;
524
525 data->wma = wma;
526 data->flags = dwFlags;
527 if (dwFlags & MCI_NOTIFY)
528 data->params.dwCallback = lpParams->dwCallback;
529
530 if (!(handle = CreateThread(NULL, 0, MCIAVI_mciPlay_thread, data, 0, NULL)))
531 {
532 WARN("Couldn't create thread for async play, playing synchronously\n");
533 return MCIAVI_mciPlay_thread(data);
534 }
535 SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
536 CloseHandle(handle);
537 return 0;
538 }
539
540 /***************************************************************************
541 * MCIAVI_mciPlay [internal]
542 */
MCIAVI_mciPlay(UINT wDevID,DWORD dwFlags,LPMCI_PLAY_PARMS lpParms)543 static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
544 {
545 WINE_MCIAVI *wma;
546 DWORD dwRet;
547 DWORD dwFromFrame, dwToFrame;
548
549 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
550
551 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
552
553 wma = MCIAVI_mciGetOpenDev(wDevID);
554 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
555 if (dwFlags & MCI_DGV_PLAY_REVERSE) return MCIERR_UNSUPPORTED_FUNCTION;
556 if (dwFlags & MCI_TEST) return 0;
557
558 if (dwFlags & (MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLBY2))
559 FIXME("Unsupported flag %08x\n", dwFlags);
560
561 EnterCriticalSection(&wma->cs);
562
563 if (!wma->hFile)
564 {
565 LeaveCriticalSection(&wma->cs);
566 return MCIERR_FILE_NOT_FOUND;
567 }
568 if (!wma->hWndPaint)
569 {
570 LeaveCriticalSection(&wma->cs);
571 return MCIERR_NO_WINDOW;
572 }
573
574 dwFromFrame = wma->dwCurrVideoFrame;
575 dwToFrame = wma->dwPlayableVideoFrames - 1;
576
577 if (dwFlags & MCI_FROM) {
578 dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
579 }
580 if (dwFlags & MCI_TO) {
581 dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
582 }
583 if (dwToFrame >= wma->dwPlayableVideoFrames)
584 dwToFrame = wma->dwPlayableVideoFrames - 1;
585
586 TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
587
588 wma->dwCurrVideoFrame = dwFromFrame;
589 wma->dwToVideoFrame = dwToFrame;
590
591 LeaveCriticalSection(&wma->cs);
592
593 if (dwFlags & MCI_MCIAVI_PLAY_FULLSCREEN)
594 {
595 HMONITOR mon = MonitorFromWindow(wma->hWndPaint, MONITOR_DEFAULTTONEAREST);
596 MONITORINFO mi;
597 mi.cbSize = sizeof(mi);
598 GetMonitorInfoA(mon, &mi);
599 wma->hWndPaint = CreateWindowA("STATIC", NULL, WS_POPUP | WS_VISIBLE, mi.rcMonitor.left,
600 mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left, mi.rcMonitor.bottom - mi.rcMonitor.top,
601 NULL, NULL, NULL, 0);
602 }
603 /* if not fullscreen ensure the window is visible */
604 else if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
605 ShowWindow(wma->hWndPaint, SW_SHOWNA);
606
607 EnterCriticalSection(&wma->cs);
608
609 /* if already playing exit */
610 if (wma->dwStatus == MCI_MODE_PLAY)
611 {
612 LeaveCriticalSection(&wma->cs);
613 return 0;
614 }
615
616 wma->dwStatus = MCI_MODE_PLAY;
617
618 LeaveCriticalSection(&wma->cs);
619
620 if (dwFlags & MCI_WAIT)
621 return MCIAVI_player(wma, dwFlags, lpParms);
622
623 dwRet = MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
624
625 if (dwRet) {
626 EnterCriticalSection(&wma->cs);
627 wma->dwStatus = MCI_MODE_STOP;
628 LeaveCriticalSection(&wma->cs);
629 }
630 return dwRet;
631 }
632
633 /***************************************************************************
634 * MCIAVI_mciStop [internal]
635 */
MCIAVI_mciStop(UINT wDevID,DWORD dwFlags,LPMCI_GENERIC_PARMS lpParms)636 static DWORD MCIAVI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
637 {
638 WINE_MCIAVI *wma;
639 DWORD dwRet = 0;
640
641 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
642
643 wma = MCIAVI_mciGetOpenDev(wDevID);
644 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
645 if (dwFlags & MCI_TEST) return 0;
646
647 EnterCriticalSection(&wma->cs);
648
649 TRACE("current status %04x\n", wma->dwStatus);
650
651 switch (wma->dwStatus) {
652 case MCI_MODE_PLAY:
653 case MCI_MODE_RECORD:
654 LeaveCriticalSection(&wma->cs);
655 SetEvent(wma->hStopEvent);
656 EnterCriticalSection(&wma->cs);
657 /* fall through */
658 case MCI_MODE_PAUSE:
659 /* Since our wave notification callback takes the lock,
660 * we must release it before resetting the device */
661 LeaveCriticalSection(&wma->cs);
662 dwRet = waveOutReset(wma->hWave);
663 EnterCriticalSection(&wma->cs);
664 /* fall through */
665 default:
666 do /* one more chance for an async thread to finish */
667 {
668 LeaveCriticalSection(&wma->cs);
669 Sleep(10);
670 EnterCriticalSection(&wma->cs);
671 } while (wma->dwStatus != MCI_MODE_STOP);
672
673 break;
674
675 case MCI_MODE_NOT_READY:
676 break;
677 }
678
679 if ((dwFlags & MCI_NOTIFY) && lpParms) {
680 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
681 wDevID, MCI_NOTIFY_SUCCESSFUL);
682 }
683 LeaveCriticalSection(&wma->cs);
684 return dwRet;
685 }
686
687 /***************************************************************************
688 * MCIAVI_mciPause [internal]
689 */
MCIAVI_mciPause(UINT wDevID,DWORD dwFlags,LPMCI_GENERIC_PARMS lpParms)690 static DWORD MCIAVI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
691 {
692 WINE_MCIAVI *wma;
693
694 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
695
696 wma = MCIAVI_mciGetOpenDev(wDevID);
697 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
698 if (dwFlags & MCI_TEST) return 0;
699
700 EnterCriticalSection(&wma->cs);
701
702 if (wma->dwStatus == MCI_MODE_PLAY)
703 wma->dwStatus = MCI_MODE_PAUSE;
704
705 if (wma->lpWaveFormat) {
706 LeaveCriticalSection(&wma->cs);
707 return waveOutPause(wma->hWave);
708 }
709
710 LeaveCriticalSection(&wma->cs);
711 return 0;
712 }
713
714 /***************************************************************************
715 * MCIAVI_mciResume [internal]
716 */
MCIAVI_mciResume(UINT wDevID,DWORD dwFlags,LPMCI_GENERIC_PARMS lpParms)717 static DWORD MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
718 {
719 WINE_MCIAVI *wma;
720
721 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
722
723 wma = MCIAVI_mciGetOpenDev(wDevID);
724 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
725 if (dwFlags & MCI_TEST) return 0;
726
727 EnterCriticalSection(&wma->cs);
728
729 if (wma->dwStatus == MCI_MODE_PAUSE)
730 wma->dwStatus = MCI_MODE_PLAY;
731
732 if (wma->lpWaveFormat) {
733 LeaveCriticalSection(&wma->cs);
734 return waveOutRestart(wma->hWave);
735 }
736
737 LeaveCriticalSection(&wma->cs);
738 return 0;
739 }
740
741 /***************************************************************************
742 * MCIAVI_mciSeek [internal]
743 */
MCIAVI_mciSeek(UINT wDevID,DWORD dwFlags,LPMCI_SEEK_PARMS lpParms)744 static DWORD MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
745 {
746 WINE_MCIAVI *wma;
747 DWORD position;
748
749 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
750
751 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
752
753 wma = MCIAVI_mciGetOpenDev(wDevID);
754 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
755
756 position = dwFlags & (MCI_SEEK_TO_START|MCI_SEEK_TO_END|MCI_TO);
757 if (!position) return MCIERR_MISSING_PARAMETER;
758 if (position&(position-1)) return MCIERR_FLAGS_NOT_COMPATIBLE;
759
760 if (dwFlags & MCI_TO) {
761 position = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
762 if (position >= wma->dwPlayableVideoFrames)
763 return MCIERR_OUTOFRANGE;
764 } else if (dwFlags & MCI_SEEK_TO_START) {
765 position = 0;
766 } else {
767 position = wma->dwPlayableVideoFrames - 1;
768 }
769 if (dwFlags & MCI_TEST) return 0;
770
771 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
772
773 EnterCriticalSection(&wma->cs);
774
775 wma->dwCurrVideoFrame = position;
776 TRACE("Seeking to frame=%u\n", wma->dwCurrVideoFrame);
777
778 if (dwFlags & MCI_NOTIFY) {
779 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
780 wDevID, MCI_NOTIFY_SUCCESSFUL);
781 }
782 LeaveCriticalSection(&wma->cs);
783 return 0;
784 }
785
786 /*****************************************************************************
787 * MCIAVI_mciLoad [internal]
788 */
MCIAVI_mciLoad(UINT wDevID,DWORD dwFlags,LPMCI_DGV_LOAD_PARMSW lpParms)789 static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lpParms)
790 {
791 WINE_MCIAVI *wma;
792
793 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
794
795 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
796
797 wma = MCIAVI_mciGetOpenDev(wDevID);
798 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
799
800 return MCIERR_UNSUPPORTED_FUNCTION; /* like w2k */
801 }
802
803 /******************************************************************************
804 * MCIAVI_mciRealize [internal]
805 */
MCIAVI_mciRealize(UINT wDevID,DWORD dwFlags,LPMCI_GENERIC_PARMS lpParms)806 static DWORD MCIAVI_mciRealize(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
807 {
808 WINE_MCIAVI *wma;
809
810 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
811
812 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
813
814 wma = MCIAVI_mciGetOpenDev(wDevID);
815 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
816 if (dwFlags & MCI_TEST) return 0;
817
818 return 0;
819 }
820
821 /******************************************************************************
822 * MCIAVI_mciUpdate [internal]
823 */
MCIAVI_mciUpdate(UINT wDevID,DWORD dwFlags,LPMCI_DGV_UPDATE_PARMS lpParms)824 static DWORD MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
825 {
826 WINE_MCIAVI *wma;
827
828 TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
829
830 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
831
832 wma = MCIAVI_mciGetOpenDev(wDevID);
833 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
834 /* Ignore MCI_TEST flag. */
835
836 EnterCriticalSection(&wma->cs);
837
838 if (dwFlags & MCI_DGV_UPDATE_HDC)
839 MCIAVI_PaintFrame(wma, lpParms->hDC);
840
841 LeaveCriticalSection(&wma->cs);
842
843 return 0;
844 }
845
846 /******************************************************************************
847 * MCIAVI_mciStep [internal]
848 */
MCIAVI_mciStep(UINT wDevID,DWORD dwFlags,LPMCI_DGV_STEP_PARMS lpParms)849 static DWORD MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
850 {
851 WINE_MCIAVI *wma;
852 DWORD position;
853 int delta = 1;
854
855 TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
856
857 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
858
859 wma = MCIAVI_mciGetOpenDev(wDevID);
860 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
861
862 if (dwFlags & MCI_DGV_STEP_FRAMES) delta = lpParms->dwFrames;
863 if (dwFlags & MCI_DGV_STEP_REVERSE) delta = -delta;
864 position = wma->dwCurrVideoFrame + delta;
865 if (position >= wma->dwPlayableVideoFrames) return MCIERR_OUTOFRANGE;
866 if (dwFlags & MCI_TEST) return 0;
867
868 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
869
870 EnterCriticalSection(&wma->cs);
871
872 wma->dwCurrVideoFrame = position;
873 TRACE("Stepping to frame=%u\n", wma->dwCurrVideoFrame);
874
875 if (dwFlags & MCI_NOTIFY) {
876 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
877 wDevID, MCI_NOTIFY_SUCCESSFUL);
878 }
879 LeaveCriticalSection(&wma->cs);
880 return 0;
881 }
882
883 /******************************************************************************
884 * MCIAVI_mciCue [internal]
885 */
MCIAVI_mciCue(UINT wDevID,DWORD dwFlags,LPMCI_DGV_CUE_PARMS lpParms)886 static DWORD MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
887 {
888 WINE_MCIAVI *wma;
889
890 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
891
892 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
893
894 wma = MCIAVI_mciGetOpenDev(wDevID);
895 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
896 if (dwFlags & MCI_DGV_CUE_INPUT) return MCIERR_UNSUPPORTED_FUNCTION;
897 if (dwFlags & MCI_TEST) return 0;
898
899 return 0;
900 }
901
902 /******************************************************************************
903 * MCIAVI_mciBreak [internal]
904 */
MCIAVI_mciBreak(UINT wDevID,DWORD dwFlags,LPMCI_BREAK_PARMS lpParms)905 static DWORD MCIAVI_mciBreak(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
906 {
907 WINE_MCIAVI *wma;
908
909 TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
910
911 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
912
913 wma = MCIAVI_mciGetOpenDev(wDevID);
914 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
915
916 EnterCriticalSection(&wma->cs);
917
918 wma->mci_break.flags = dwFlags;
919 wma->mci_break.parms = *lpParms;
920
921 LeaveCriticalSection(&wma->cs);
922
923 return 0;
924 }
925
926 /******************************************************************************
927 * MCIAVI_mciSetAudio [internal]
928 */
MCIAVI_mciSetAudio(UINT wDevID,DWORD dwFlags,LPMCI_DGV_SETAUDIO_PARMSW lpParms)929 static DWORD MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
930 {
931 WINE_MCIAVI *wma;
932
933 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
934
935 FIXME("(%04x, %08x, %p) Item %04x: stub\n", wDevID, dwFlags, lpParms, dwFlags & MCI_DGV_SETAUDIO_ITEM ? lpParms->dwItem : 0);
936
937 wma = MCIAVI_mciGetOpenDev(wDevID);
938 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
939
940 return 0;
941 }
942
943 /******************************************************************************
944 * MCIAVI_mciSignal [internal]
945 */
MCIAVI_mciSignal(UINT wDevID,DWORD dwFlags,LPMCI_DGV_SIGNAL_PARMS lpParms)946 static DWORD MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
947 {
948 WINE_MCIAVI *wma;
949
950 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
951
952 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
953
954 wma = MCIAVI_mciGetOpenDev(wDevID);
955 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
956
957 return 0;
958 }
959
960 /******************************************************************************
961 * MCIAVI_mciSetVideo [internal]
962 */
MCIAVI_mciSetVideo(UINT wDevID,DWORD dwFlags,LPMCI_DGV_SETVIDEO_PARMSW lpParms)963 static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSW lpParms)
964 {
965 WINE_MCIAVI *wma;
966
967 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
968
969 FIXME("(%04x, %08x, %p) Item %04x: stub\n", wDevID, dwFlags, lpParms, dwFlags & MCI_DGV_SETVIDEO_ITEM ? lpParms->dwItem : 0);
970
971 wma = MCIAVI_mciGetOpenDev(wDevID);
972 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
973
974 return 0;
975 }
976
977 /******************************************************************************
978 * MCIAVI_mciConfigure [internal]
979 */
MCIAVI_mciConfigure(UINT wDevID,DWORD dwFlags,LPMCI_GENERIC_PARMS lpParms)980 static DWORD MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
981 {
982 WINE_MCIAVI *wma;
983
984 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
985
986 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
987
988 wma = MCIAVI_mciGetOpenDev(wDevID);
989 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
990 if (dwFlags & MCI_TEST) return 0;
991
992 return 0;
993 }
994
995 /*======================================================================*
996 * MCI AVI entry points *
997 *======================================================================*/
998
999 /**************************************************************************
1000 * DriverProc (MCIAVI.@)
1001 */
MCIAVI_DriverProc(DWORD_PTR dwDevID,HDRVR hDriv,UINT wMsg,LPARAM dwParam1,LPARAM dwParam2)1002 LRESULT CALLBACK MCIAVI_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1003 LPARAM dwParam1, LPARAM dwParam2)
1004 {
1005 TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
1006 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1007
1008 switch (wMsg) {
1009 case DRV_LOAD: return 1;
1010 case DRV_FREE: return 1;
1011 case DRV_OPEN: return MCIAVI_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
1012 case DRV_CLOSE: return MCIAVI_drvClose(dwDevID);
1013 case DRV_ENABLE: return 1;
1014 case DRV_DISABLE: return 1;
1015 case DRV_QUERYCONFIGURE: return 1;
1016 case DRV_CONFIGURE: return MCIAVI_drvConfigure(dwDevID);
1017 case DRV_INSTALL: return DRVCNF_RESTART;
1018 case DRV_REMOVE: return DRVCNF_RESTART;
1019 }
1020
1021 /* session instance */
1022 if (dwDevID == 0xFFFFFFFF) return 1;
1023
1024 switch (wMsg) {
1025 case MCI_OPEN_DRIVER: return MCIAVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
1026 case MCI_CLOSE_DRIVER: return MCIAVI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1027 case MCI_PLAY: return MCIAVI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1028 case MCI_STOP: return MCIAVI_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1029 case MCI_SET: return MCIAVI_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
1030 case MCI_PAUSE: return MCIAVI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1031 case MCI_RESUME: return MCIAVI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1032 case MCI_STATUS: return MCIAVI_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
1033 case MCI_GETDEVCAPS: return MCIAVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1034 case MCI_INFO: return MCIAVI_mciInfo (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSW) dwParam2);
1035 case MCI_SEEK: return MCIAVI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1036 case MCI_PUT: return MCIAVI_mciPut (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS) dwParam2);
1037 case MCI_WINDOW: return MCIAVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW) dwParam2);
1038 case MCI_LOAD: return MCIAVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSW) dwParam2);
1039 case MCI_REALIZE: return MCIAVI_mciRealize (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1040 case MCI_UPDATE: return MCIAVI_mciUpdate (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS) dwParam2);
1041 case MCI_WHERE: return MCIAVI_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1042 case MCI_STEP: return MCIAVI_mciStep (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS) dwParam2);
1043 case MCI_CUE: return MCIAVI_mciCue (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS) dwParam2);
1044 case MCI_BREAK: return MCIAVI_mciBreak (dwDevID, dwParam1, (LPMCI_BREAK_PARMS) dwParam2);
1045 /* Digital Video specific */
1046 case MCI_SETAUDIO: return MCIAVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
1047 case MCI_SIGNAL: return MCIAVI_mciSignal (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS) dwParam2);
1048 case MCI_SETVIDEO: return MCIAVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSW) dwParam2);
1049 case MCI_CONFIGURE: return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1050
1051 /* no editing, recording, saving, locking without inputs */
1052 case MCI_CAPTURE:
1053 case MCI_COPY:
1054 case MCI_CUT:
1055 case MCI_DELETE:
1056 case MCI_FREEZE:
1057 case MCI_LIST:
1058 case MCI_MONITOR:
1059 case MCI_PASTE:
1060 case MCI_QUALITY:
1061 case MCI_RECORD:
1062 case MCI_RESERVE:
1063 case MCI_RESTORE:
1064 case MCI_SAVE:
1065 case MCI_UNDO:
1066 case MCI_UNFREEZE:
1067 TRACE("Unsupported function [0x%x] flags=%08x\n", wMsg, (DWORD)dwParam1);
1068 return MCIERR_UNSUPPORTED_FUNCTION;
1069 case MCI_SPIN:
1070 case MCI_ESCAPE:
1071 WARN("Unsupported command [0x%x] %08x\n", wMsg, (DWORD)dwParam1);
1072 break;
1073 case MCI_OPEN:
1074 case MCI_CLOSE:
1075 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1076 break;
1077 default:
1078 TRACE("Sending msg [%u] to default driver proc\n", wMsg);
1079 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1080 }
1081 return MCIERR_UNRECOGNIZED_COMMAND;
1082 }
1083