?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 149f0a5527ac85057a8ef03858d34d91c36f97e8
[wine/hacks.git] / dlls / mciavi32 / mciavi.c
blob8613bff205629923ba3214fa43e6cc2992979586
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 * - better move the AVI handling part to avifile DLL and make use of it
30 * - some files appear to have more than one audio stream (we only play the
31 * first one)
32 * - some files contain an index of audio/video frame. Better use it,
33 * instead of rebuilding it
34 * - stopping while playing a file with sound blocks until all buffered
35 * audio is played... still should be stopped ASAP
36 */
37
38 #include <string.h>
39 #include "private_mciavi.h"
40 #include "wine/debug.h"
41 #include "wine/unicode.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
44
45 static DWORD MCIAVI_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS);
46
47 /*======================================================================*
48 * MCI AVI implementation *
49 *======================================================================*/
50
51 HINSTANCE MCIAVI_hInstance = 0;
52
53 /***********************************************************************
54 * DllMain (MCIAVI.0)
55 */
56 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
57 {
58 switch (fdwReason) {
59 case DLL_PROCESS_ATTACH:
60 DisableThreadLibraryCalls(hInstDLL);
61 MCIAVI_hInstance = hInstDLL;
62 break;
63 }
64 return TRUE;
65 }
66
67 /**************************************************************************
68 * MCIAVI_drvOpen [internal]
69 */
70 static DWORD MCIAVI_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
71 {
72 WINE_MCIAVI* wma;
73 static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
74
75 TRACE("%s, %p\n", debugstr_w(str), modp);
76
77 /* session instance */
78 if (!modp) return 0xFFFFFFFF;
79
80 if (!MCIAVI_RegisterClass()) return 0;
81
82 wma = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIAVI));
83 if (!wma)
84 return 0;
85
86 InitializeCriticalSection(&wma->cs);
87 wma->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINE_MCIAVI.cs");
88 wma->ack_event = CreateEventW(NULL, FALSE, FALSE, NULL);
89 wma->hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
90 wma->wDevID = modp->wDeviceID;
91 wma->wCommandTable = mciLoadCommandResource(MCIAVI_hInstance, mciAviWStr, 0);
92 modp->wCustomCommandTable = wma->wCommandTable;
93 modp->wType = MCI_DEVTYPE_DIGITAL_VIDEO;
94 mciSetDriverData(wma->wDevID, (DWORD_PTR)wma);
95
96 return modp->wDeviceID;
97 }
98
99 /**************************************************************************
100 * MCIAVI_drvClose [internal]
101 */
102 static DWORD MCIAVI_drvClose(DWORD dwDevID)
103 {
104 WINE_MCIAVI *wma;
105
106 TRACE("%04x\n", dwDevID);
107
108 /* finish all outstanding things */
109 MCIAVI_mciClose(dwDevID, MCI_WAIT, NULL);
110
111 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
112
113 if (wma) {
114 MCIAVI_UnregisterClass();
115
116 EnterCriticalSection(&wma->cs);
117
118 mciSetDriverData(dwDevID, 0);
119 mciFreeCommandResource(wma->wCommandTable);
120
121 CloseHandle(wma->ack_event);
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 */
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 */
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
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 */
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 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
221
222 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
223
224 wma = (WINE_MCIAVI *)mciGetDriverData(wDevID);
225 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
226
227 EnterCriticalSection(&wma->cs);
228
229 if (wma->nUseCount > 0) {
230 /* The driver is already open on this channel */
231 /* If the driver was opened shareable before and this open specifies */
232 /* shareable then increment the use count */
233 if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
234 ++wma->nUseCount;
235 else
236 {
237 LeaveCriticalSection(&wma->cs);
238 return MCIERR_MUST_USE_SHAREABLE;
239 }
240 } else {
241 wma->nUseCount = 1;
242 wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
243 }
244
245 wma->dwStatus = MCI_MODE_NOT_READY;
246
247 if (dwFlags & MCI_OPEN_ELEMENT) {
248 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
249 /* could it be that (DWORD)lpOpenParms->lpstrElementName
250 * contains the hFile value ?
251 */
252 dwRet = MCIERR_UNRECOGNIZED_COMMAND;
253 } else if (lpOpenParms->lpstrElementName && lpOpenParms->lpstrElementName[0]) {
254 /* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */
255 TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
256
257 wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
258 strcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
259
260 wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
261 MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
262
263 if (wma->hFile == 0) {
264 WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
265 dwRet = MCIERR_FILE_NOT_FOUND;
266 } else {
267 if (!MCIAVI_GetInfo(wma))
268 dwRet = MCIERR_INVALID_FILE;
269 else if (!MCIAVI_OpenVideo(wma))
270 dwRet = MCIERR_CANNOT_LOAD_DRIVER;
271 else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms))
272 dwRet = MCIERR_CREATEWINDOW;
273 }
274 } else {
275 FIXME("Don't record yet\n");
276 dwRet = MCIERR_UNSUPPORTED_FUNCTION;
277 }
278 }
279
280 if (dwRet == 0) {
281 TRACE("lpOpenParms->wDeviceID = %04x\n", lpOpenParms->wDeviceID);
282
283 wma->dwStatus = MCI_MODE_STOP;
284 wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
285 } else {
286 MCIAVI_CleanUp(wma);
287 }
288
289 LeaveCriticalSection(&wma->cs);
290 return dwRet;
291 }
292
293 /***************************************************************************
294 * MCIAVI_mciClose [internal]
295 */
296 DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
297 {
298 WINE_MCIAVI *wma;
299 DWORD dwRet = 0;
300
301 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
302
303 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
304
305 wma = MCIAVI_mciGetOpenDev(wDevID);
306 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
307
308 EnterCriticalSection(&wma->cs);
309
310 if (wma->nUseCount == 1) {
311 if (wma->dwStatus != MCI_MODE_STOP)
312 dwRet = MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
313 MCIAVI_CleanUp(wma);
314
315 if ((dwFlags & MCI_NOTIFY) && lpParms) {
316 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
317 wDevID,
318 MCI_NOTIFY_SUCCESSFUL);
319 }
320 LeaveCriticalSection(&wma->cs);
321 return dwRet;
322 }
323 wma->nUseCount--;
324
325 LeaveCriticalSection(&wma->cs);
326 return dwRet;
327 }
328
329 static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms);
330
331 struct MCIAVI_play_data
332 {
333 MCIDEVICEID wDevID;
334 DWORD flags;
335 MCI_PLAY_PARMS params;
336 };
337
338 /*
339 * MCIAVI_mciPlay_thread
340 *
341 * FIXME: probably should use a common worker thread created at the driver
342 * load time and queue all async commands to it.
343 */
344 static DWORD WINAPI MCIAVI_mciPlay_thread(LPVOID arg)
345 {
346 struct MCIAVI_play_data *data = (struct MCIAVI_play_data *)arg;
347 DWORD ret;
348
349 TRACE("In thread before async play command (id %08x, flags %08x)\n", data->wDevID, data->flags);
350 ret = MCIAVI_mciPlay(data->wDevID, data->flags | MCI_WAIT, &data->params);
351 TRACE("In thread after async play command (id %08x, flags %08x)\n", data->wDevID, data->flags);
352
353 HeapFree(GetProcessHeap(), 0, data);
354 return ret;
355 }
356
357 /*
358 * MCIAVI_mciPlay_async
359 */
360 static DWORD MCIAVI_mciPlay_async(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParams)
361 {
362 HANDLE handle, ack_event = wma->ack_event;
363 struct MCIAVI_play_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct MCIAVI_play_data));
364
365 if (!data) return MCIERR_OUT_OF_MEMORY;
366
367 data->wDevID = wma->wDevID;
368 data->flags = dwFlags;
369 data->params = *lpParams;
370
371 if (!(handle = CreateThread(NULL, 0, MCIAVI_mciPlay_thread, data, 0, NULL)))
372 {
373 WARN("Couldn't create thread for async play, playing synchronously\n");
374 return MCIAVI_mciPlay_thread(data);
375 }
376 SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
377 CloseHandle(handle);
378 /* wait until the thread starts up, so the app could see a changed status */
379 WaitForSingleObject(ack_event, INFINITE);
380 TRACE("Async play has started\n");
381 return 0;
382 }
383
384 /***************************************************************************
385 * MCIAVI_mciPlay [internal]
386 */
387 static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
388 {
389 WINE_MCIAVI *wma;
390 DWORD frameTime;
391 DWORD dwRet;
392 LPWAVEHDR waveHdr = NULL;
393 unsigned i, nHdr = 0;
394 DWORD dwFromFrame, dwToFrame;
395 DWORD numEvents = 1;
396 HANDLE events[2];
397
398 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
399
400 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
401
402 wma = MCIAVI_mciGetOpenDev(wDevID);
403 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
404
405 EnterCriticalSection(&wma->cs);
406
407 if (!wma->hFile)
408 {
409 LeaveCriticalSection(&wma->cs);
410 return MCIERR_FILE_NOT_FOUND;
411 }
412 if (!wma->hWndPaint)
413 {
414 LeaveCriticalSection(&wma->cs);
415 return MCIERR_NO_WINDOW;
416 }
417
418 LeaveCriticalSection(&wma->cs);
419
420 if (!(dwFlags & MCI_WAIT))
421 return MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
422
423 if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
424 ShowWindow(wma->hWndPaint, SW_SHOWNA);
425
426 EnterCriticalSection(&wma->cs);
427
428 dwFromFrame = wma->dwCurrVideoFrame;
429 dwToFrame = wma->dwPlayableVideoFrames - 1;
430
431 if (lpParms && (dwFlags & MCI_FROM)) {
432 dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
433 }
434 if (lpParms && (dwFlags & MCI_TO)) {
435 dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
436 }
437 if (dwToFrame >= wma->dwPlayableVideoFrames)
438 dwToFrame = wma->dwPlayableVideoFrames - 1;
439
440 TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
441
442 wma->dwCurrVideoFrame = dwFromFrame;
443 wma->dwToVideoFrame = dwToFrame;
444
445 /* if already playing exit */
446 if (wma->dwStatus == MCI_MODE_PLAY)
447 {
448 LeaveCriticalSection(&wma->cs);
449 SetEvent(wma->ack_event);
450 return 0;
451 }
452
453 if (wma->dwToVideoFrame <= wma->dwCurrVideoFrame)
454 {
455 dwRet = 0;
456 SetEvent(wma->ack_event);
457 goto mci_play_done;
458 }
459
460 wma->dwStatus = MCI_MODE_PLAY;
461 /* signal the state change */
462 SetEvent(wma->ack_event);
463
464 if (dwFlags & (MCI_DGV_PLAY_REPEAT|MCI_DGV_PLAY_REVERSE|MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN))
465 FIXME("Unsupported flag %08x\n", dwFlags);
466
467 /* time is in microseconds, we should convert it to milliseconds */
468 frameTime = (wma->mah.dwMicroSecPerFrame + 500) / 1000;
469
470 events[0] = wma->hStopEvent;
471 if (wma->lpWaveFormat) {
472 if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
473 {
474 /* can't play audio */
475 HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
476 wma->lpWaveFormat = NULL;
477 }
478 else
479 {
480 /* fill the queue with as many wave headers as possible */
481 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
482 events[1] = wma->hEvent;
483 numEvents = 2;
484 }
485 }
486
487 while (wma->dwStatus == MCI_MODE_PLAY)
488 {
489 HDC hDC;
490 DWORD tc, delta;
491 DWORD ret;
492
493 tc = GetTickCount();
494
495 hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
496 if (hDC)
497 {
498 MCIAVI_PaintFrame(wma, hDC);
499 ReleaseDC(wma->hWndPaint, hDC);
500 }
501
502 if (wma->lpWaveFormat)
503 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
504
505 delta = GetTickCount() - tc;
506 if (delta < frameTime)
507 delta = frameTime - delta;
508 else
509 delta = 0;
510
511 LeaveCriticalSection(&wma->cs);
512 ret = WaitForMultipleObjects(numEvents, events, FALSE, delta);
513 EnterCriticalSection(&wma->cs);
514 if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
515
516 if (wma->dwCurrVideoFrame < dwToFrame)
517 wma->dwCurrVideoFrame++;
518 else
519 break;
520 }
521
522 if (wma->lpWaveFormat) {
523 while (wma->dwEventCount != nHdr - 1)
524 {
525 LeaveCriticalSection(&wma->cs);
526 Sleep(100);
527 EnterCriticalSection(&wma->cs);
528 }
529
530 /* just to get rid of some race conditions between play, stop and pause */
531 LeaveCriticalSection(&wma->cs);
532 waveOutReset(wma->hWave);
533 EnterCriticalSection(&wma->cs);
534
535 for (i = 0; i < nHdr; i++)
536 waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
537 }
538
539 dwRet = 0;
540
541 if (wma->lpWaveFormat) {
542 HeapFree(GetProcessHeap(), 0, waveHdr);
543
544 if (wma->hWave) {
545 LeaveCriticalSection(&wma->cs);
546 waveOutClose(wma->hWave);
547 EnterCriticalSection(&wma->cs);
548 wma->hWave = 0;
549 }
550 CloseHandle(wma->hEvent);
551 }
552
553 mci_play_done:
554 wma->dwStatus = MCI_MODE_STOP;
555
556 if (lpParms && (dwFlags & MCI_NOTIFY)) {
557 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
558 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
559 wDevID, MCI_NOTIFY_SUCCESSFUL);
560 }
561 LeaveCriticalSection(&wma->cs);
562 return dwRet;
563 }
564
565 /***************************************************************************
566 * MCIAVI_mciRecord [internal]
567 */
568 static DWORD MCIAVI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECORD_PARMS lpParms)
569 {
570 WINE_MCIAVI *wma;
571
572 FIXME("(%04x, %08X, %p) : stub\n", wDevID, dwFlags, lpParms);
573
574 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
575
576 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
577
578 wma = MCIAVI_mciGetOpenDev(wDevID);
579 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
580
581 EnterCriticalSection(&wma->cs);
582 wma->dwStatus = MCI_MODE_RECORD;
583 LeaveCriticalSection(&wma->cs);
584 return 0;
585 }
586
587 /***************************************************************************
588 * MCIAVI_mciStop [internal]
589 */
590 static DWORD MCIAVI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
591 {
592 WINE_MCIAVI *wma;
593 DWORD dwRet = 0;
594
595 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
596
597 wma = MCIAVI_mciGetOpenDev(wDevID);
598 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
599
600 EnterCriticalSection(&wma->cs);
601
602 TRACE("current status %04x\n", wma->dwStatus);
603
604 switch (wma->dwStatus) {
605 case MCI_MODE_PLAY:
606 case MCI_MODE_RECORD:
607 LeaveCriticalSection(&wma->cs);
608 SetEvent(wma->hStopEvent);
609 EnterCriticalSection(&wma->cs);
610 /* fall through */
611 case MCI_MODE_PAUSE:
612 /* Since our wave notification callback takes the lock,
613 * we must release it before resetting the device */
614 LeaveCriticalSection(&wma->cs);
615 dwRet = waveOutReset(wma->hWave);
616 EnterCriticalSection(&wma->cs);
617 /* fall through */
618 default:
619 do /* one more chance for an async thread to finish */
620 {
621 LeaveCriticalSection(&wma->cs);
622 Sleep(10);
623 EnterCriticalSection(&wma->cs);
624 } while (wma->dwStatus != MCI_MODE_STOP);
625
626 break;
627
628 case MCI_MODE_NOT_READY:
629 break;
630 }
631
632 if ((dwFlags & MCI_NOTIFY) && lpParms) {
633 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
634 wDevID, MCI_NOTIFY_SUCCESSFUL);
635 }
636 LeaveCriticalSection(&wma->cs);
637 return dwRet;
638 }
639
640 /***************************************************************************
641 * MCIAVI_mciPause [internal]
642 */
643 static DWORD MCIAVI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
644 {
645 WINE_MCIAVI *wma;
646
647 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
648
649 wma = MCIAVI_mciGetOpenDev(wDevID);
650 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
651
652 EnterCriticalSection(&wma->cs);
653
654 if (wma->dwStatus == MCI_MODE_PLAY)
655 wma->dwStatus = MCI_MODE_PAUSE;
656
657 if (wma->lpWaveFormat) {
658 LeaveCriticalSection(&wma->cs);
659 return waveOutPause(wma->hWave);
660 }
661
662 LeaveCriticalSection(&wma->cs);
663 return 0;
664 }
665
666 /***************************************************************************
667 * MCIAVI_mciResume [internal]
668 */
669 static DWORD MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
670 {
671 WINE_MCIAVI *wma;
672
673 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
674
675 wma = MCIAVI_mciGetOpenDev(wDevID);
676 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
677
678 EnterCriticalSection(&wma->cs);
679
680 if (wma->dwStatus == MCI_MODE_PAUSE)
681 wma->dwStatus = MCI_MODE_PLAY;
682
683 if (wma->lpWaveFormat) {
684 LeaveCriticalSection(&wma->cs);
685 return waveOutRestart(wma->hWave);
686 }
687
688 LeaveCriticalSection(&wma->cs);
689 return 0;
690 }
691
692 /***************************************************************************
693 * MCIAVI_mciSeek [internal]
694 */
695 static DWORD MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
696 {
697 WINE_MCIAVI *wma;
698
699 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
700
701 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
702
703 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
704
705 wma = MCIAVI_mciGetOpenDev(wDevID);
706 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
707
708 EnterCriticalSection(&wma->cs);
709
710 if (dwFlags & MCI_SEEK_TO_START) {
711 wma->dwCurrVideoFrame = 0;
712 } else if (dwFlags & MCI_SEEK_TO_END) {
713 wma->dwCurrVideoFrame = wma->dwPlayableVideoFrames - 1;
714 } else if (dwFlags & MCI_TO) {
715 if (lpParms->dwTo > wma->dwPlayableVideoFrames - 1)
716 lpParms->dwTo = wma->dwPlayableVideoFrames - 1;
717 wma->dwCurrVideoFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
718 } else {
719 WARN("dwFlag doesn't tell where to seek to...\n");
720 LeaveCriticalSection(&wma->cs);
721 return MCIERR_MISSING_PARAMETER;
722 }
723
724 TRACE("Seeking to frame=%u bytes\n", wma->dwCurrVideoFrame);
725
726 if (dwFlags & MCI_NOTIFY) {
727 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
728 wDevID, MCI_NOTIFY_SUCCESSFUL);
729 }
730 LeaveCriticalSection(&wma->cs);
731 return 0;
732 }
733
734 /*****************************************************************************
735 * MCIAVI_mciLoad [internal]
736 */
737 static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lpParms)
738 {
739 WINE_MCIAVI *wma;
740
741 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
742
743 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
744
745 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
746
747 wma = MCIAVI_mciGetOpenDev(wDevID);
748 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
749
750 return 0;
751 }
752
753 /******************************************************************************
754 * MCIAVI_mciSave [internal]
755 */
756 static DWORD MCIAVI_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SAVE_PARMSW lpParms)
757 {
758 WINE_MCIAVI *wma;
759
760 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
761
762 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
763
764 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
765
766 wma = MCIAVI_mciGetOpenDev(wDevID);
767 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
768
769 return 0;
770 }
771
772 /******************************************************************************
773 * MCIAVI_mciFreeze [internal]
774 */
775 static DWORD MCIAVI_mciFreeze(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
776 {
777 WINE_MCIAVI *wma;
778
779 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
780
781 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
782
783 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
784
785 wma = MCIAVI_mciGetOpenDev(wDevID);
786 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
787
788 return 0;
789 }
790
791 /******************************************************************************
792 * MCIAVI_mciRealize [internal]
793 */
794 static DWORD MCIAVI_mciRealize(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
795 {
796 WINE_MCIAVI *wma;
797
798 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
799
800 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
801
802 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
803
804 wma = MCIAVI_mciGetOpenDev(wDevID);
805 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
806
807 return 0;
808 }
809
810 /******************************************************************************
811 * MCIAVI_mciUnFreeze [internal]
812 */
813 static DWORD MCIAVI_mciUnFreeze(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
814 {
815 WINE_MCIAVI *wma;
816
817 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
818
819 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
820
821 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
822
823 wma = MCIAVI_mciGetOpenDev(wDevID);
824 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
825
826 return 0;
827 }
828
829 /******************************************************************************
830 * MCIAVI_mciUpdate [internal]
831 */
832 static DWORD MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
833 {
834 WINE_MCIAVI *wma;
835
836 TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
837
838 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
839
840 wma = MCIAVI_mciGetOpenDev(wDevID);
841 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
842
843 EnterCriticalSection(&wma->cs);
844
845 if (dwFlags & MCI_DGV_UPDATE_HDC)
846 MCIAVI_PaintFrame(wma, lpParms->hDC);
847
848 LeaveCriticalSection(&wma->cs);
849
850 return 0;
851 }
852
853 /******************************************************************************
854 * MCIAVI_mciStep [internal]
855 */
856 static DWORD MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
857 {
858 WINE_MCIAVI *wma;
859
860 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
861
862 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
863
864 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
865
866 wma = MCIAVI_mciGetOpenDev(wDevID);
867 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
868
869 return 0;
870 }
871
872 /******************************************************************************
873 * MCIAVI_mciCopy [internal]
874 */
875 static DWORD MCIAVI_mciCopy(UINT wDevID, DWORD dwFlags, LPMCI_DGV_COPY_PARMS lpParms)
876 {
877 WINE_MCIAVI *wma;
878
879 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
880
881 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
882
883 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
884
885 wma = MCIAVI_mciGetOpenDev(wDevID);
886 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
887
888 return 0;
889 }
890
891 /******************************************************************************
892 * MCIAVI_mciCut [internal]
893 */
894 static DWORD MCIAVI_mciCut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUT_PARMS lpParms)
895 {
896 WINE_MCIAVI *wma;
897
898 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
899
900 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
901
902 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
903
904 wma = MCIAVI_mciGetOpenDev(wDevID);
905 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
906
907 return 0;
908 }
909
910 /******************************************************************************
911 * MCIAVI_mciDelete [internal]
912 */
913 static DWORD MCIAVI_mciDelete(UINT wDevID, DWORD dwFlags, LPMCI_DGV_DELETE_PARMS lpParms)
914 {
915 WINE_MCIAVI *wma;
916
917 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
918
919 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
920
921 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
922
923 wma = MCIAVI_mciGetOpenDev(wDevID);
924 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
925
926 return 0;
927 }
928
929 /******************************************************************************
930 * MCIAVI_mciPaste [internal]
931 */
932 static DWORD MCIAVI_mciPaste(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PASTE_PARMS lpParms)
933 {
934 WINE_MCIAVI *wma;
935
936 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
937
938 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
939
940 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
941
942 wma = MCIAVI_mciGetOpenDev(wDevID);
943 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
944
945 return 0;
946 }
947
948 /******************************************************************************
949 * MCIAVI_mciCue [internal]
950 */
951 static DWORD MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
952 {
953 WINE_MCIAVI *wma;
954
955 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
956
957 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
958
959 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
960
961 wma = MCIAVI_mciGetOpenDev(wDevID);
962 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
963
964 return 0;
965 }
966
967 /******************************************************************************
968 * MCIAVI_mciCapture [internal]
969 */
970 static DWORD MCIAVI_mciCapture(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CAPTURE_PARMSW lpParms)
971 {
972 WINE_MCIAVI *wma;
973
974 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
975
976 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
977
978 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
979
980 wma = MCIAVI_mciGetOpenDev(wDevID);
981 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
982
983 return 0;
984 }
985
986 /******************************************************************************
987 * MCIAVI_mciMonitor [internal]
988 */
989 static DWORD MCIAVI_mciMonitor(UINT wDevID, DWORD dwFlags, LPMCI_DGV_MONITOR_PARMS lpParms)
990 {
991 WINE_MCIAVI *wma;
992
993 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
994
995 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
996
997 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
998
999 wma = MCIAVI_mciGetOpenDev(wDevID);
1000 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1001
1002 return 0;
1003 }
1004
1005 /******************************************************************************
1006 * MCIAVI_mciReserve [internal]
1007 */
1008 static DWORD MCIAVI_mciReserve(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESERVE_PARMSW lpParms)
1009 {
1010 WINE_MCIAVI *wma;
1011
1012 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1013
1014 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1015
1016 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1017
1018 wma = MCIAVI_mciGetOpenDev(wDevID);
1019 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1020
1021 return 0;
1022 }
1023
1024 /******************************************************************************
1025 * MCIAVI_mciSetAudio [internal]
1026 */
1027 static DWORD MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
1028 {
1029 WINE_MCIAVI *wma;
1030
1031 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1032
1033 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1034
1035 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1036
1037 wma = MCIAVI_mciGetOpenDev(wDevID);
1038 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1039
1040 return 0;
1041 }
1042
1043 /******************************************************************************
1044 * MCIAVI_mciSignal [internal]
1045 */
1046 static DWORD MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
1047 {
1048 WINE_MCIAVI *wma;
1049
1050 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1051
1052 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1053
1054 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1055
1056 wma = MCIAVI_mciGetOpenDev(wDevID);
1057 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1058
1059 return 0;
1060 }
1061
1062 /******************************************************************************
1063 * MCIAVI_mciSetVideo [internal]
1064 */
1065 static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSW lpParms)
1066 {
1067 WINE_MCIAVI *wma;
1068
1069 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1070
1071 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1072
1073 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1074
1075 wma = MCIAVI_mciGetOpenDev(wDevID);
1076 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1077
1078 return 0;
1079 }
1080
1081 /******************************************************************************
1082 * MCIAVI_mciQuality [internal]
1083 */
1084 static DWORD MCIAVI_mciQuality(UINT wDevID, DWORD dwFlags, LPMCI_DGV_QUALITY_PARMSW lpParms)
1085 {
1086 WINE_MCIAVI *wma;
1087
1088 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1089
1090 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1091
1092 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1093
1094 wma = MCIAVI_mciGetOpenDev(wDevID);
1095 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1096
1097 return 0;
1098 }
1099
1100 /******************************************************************************
1101 * MCIAVI_mciList [internal]
1102 */
1103 static DWORD MCIAVI_mciList(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LIST_PARMSW lpParms)
1104 {
1105 WINE_MCIAVI *wma;
1106
1107 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1108
1109 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1110
1111 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1112
1113 wma = MCIAVI_mciGetOpenDev(wDevID);
1114 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1115
1116 return 0;
1117 }
1118
1119 /******************************************************************************
1120 * MCIAVI_mciUndo [internal]
1121 */
1122 static DWORD MCIAVI_mciUndo(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1123 {
1124 WINE_MCIAVI *wma;
1125
1126 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1127
1128 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1129
1130 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1131
1132 wma = MCIAVI_mciGetOpenDev(wDevID);
1133 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1134
1135 return 0;
1136 }
1137
1138 /******************************************************************************
1139 * MCIAVI_mciConfigure [internal]
1140 */
1141 static DWORD MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1142 {
1143 WINE_MCIAVI *wma;
1144
1145 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1146
1147 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1148
1149 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1150
1151 wma = MCIAVI_mciGetOpenDev(wDevID);
1152 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1153
1154 return 0;
1155 }
1156
1157 /******************************************************************************
1158 * MCIAVI_mciRestore [internal]
1159 */
1160 static DWORD MCIAVI_mciRestore(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESTORE_PARMSW lpParms)
1161 {
1162 WINE_MCIAVI *wma;
1163
1164 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1165
1166 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1167
1168 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1169
1170 wma = MCIAVI_mciGetOpenDev(wDevID);
1171 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1172
1173 return 0;
1174 }
1175
1176 /*======================================================================*
1177 * MCI AVI entry points *
1178 *======================================================================*/
1179
1180 /**************************************************************************
1181 * DriverProc (MCIAVI.@)
1182 */
1183 LRESULT CALLBACK MCIAVI_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1184 LPARAM dwParam1, LPARAM dwParam2)
1185 {
1186 TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
1187 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1188
1189 switch (wMsg) {
1190 case DRV_LOAD: return 1;
1191 case DRV_FREE: return 1;
1192 case DRV_OPEN: return MCIAVI_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
1193 case DRV_CLOSE: return MCIAVI_drvClose(dwDevID);
1194 case DRV_ENABLE: return 1;
1195 case DRV_DISABLE: return 1;
1196 case DRV_QUERYCONFIGURE: return 1;
1197 case DRV_CONFIGURE: return MCIAVI_drvConfigure(dwDevID);
1198 case DRV_INSTALL: return DRVCNF_RESTART;
1199 case DRV_REMOVE: return DRVCNF_RESTART;
1200 }
1201
1202 /* session instance */
1203 if (dwDevID == 0xFFFFFFFF) return 1;
1204
1205 switch (wMsg) {
1206 case MCI_OPEN_DRIVER: return MCIAVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
1207 case MCI_CLOSE_DRIVER: return MCIAVI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1208 case MCI_PLAY: return MCIAVI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1209 case MCI_RECORD: return MCIAVI_mciRecord (dwDevID, dwParam1, (LPMCI_DGV_RECORD_PARMS) dwParam2);
1210 case MCI_STOP: return MCIAVI_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1211 case MCI_SET: return MCIAVI_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
1212 case MCI_PAUSE: return MCIAVI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1213 case MCI_RESUME: return MCIAVI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1214 case MCI_STATUS: return MCIAVI_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
1215 case MCI_GETDEVCAPS: return MCIAVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1216 case MCI_INFO: return MCIAVI_mciInfo (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSW) dwParam2);
1217 case MCI_SEEK: return MCIAVI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1218 case MCI_PUT: return MCIAVI_mciPut (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS) dwParam2);
1219 case MCI_WINDOW: return MCIAVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW) dwParam2);
1220 case MCI_LOAD: return MCIAVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSW) dwParam2);
1221 case MCI_SAVE: return MCIAVI_mciSave (dwDevID, dwParam1, (LPMCI_DGV_SAVE_PARMSW) dwParam2);
1222 case MCI_FREEZE: return MCIAVI_mciFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1223 case MCI_REALIZE: return MCIAVI_mciRealize (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1224 case MCI_UNFREEZE: return MCIAVI_mciUnFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1225 case MCI_UPDATE: return MCIAVI_mciUpdate (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS) dwParam2);
1226 case MCI_WHERE: return MCIAVI_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1227 case MCI_STEP: return MCIAVI_mciStep (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS) dwParam2);
1228 case MCI_COPY: return MCIAVI_mciCopy (dwDevID, dwParam1, (LPMCI_DGV_COPY_PARMS) dwParam2);
1229 case MCI_CUT: return MCIAVI_mciCut (dwDevID, dwParam1, (LPMCI_DGV_CUT_PARMS) dwParam2);
1230 case MCI_DELETE: return MCIAVI_mciDelete (dwDevID, dwParam1, (LPMCI_DGV_DELETE_PARMS) dwParam2);
1231 case MCI_PASTE: return MCIAVI_mciPaste (dwDevID, dwParam1, (LPMCI_DGV_PASTE_PARMS) dwParam2);
1232 case MCI_CUE: return MCIAVI_mciCue (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS) dwParam2);
1233 /* Digital Video specific */
1234 case MCI_CAPTURE: return MCIAVI_mciCapture (dwDevID, dwParam1, (LPMCI_DGV_CAPTURE_PARMSW) dwParam2);
1235 case MCI_MONITOR: return MCIAVI_mciMonitor (dwDevID, dwParam1, (LPMCI_DGV_MONITOR_PARMS) dwParam2);
1236 case MCI_RESERVE: return MCIAVI_mciReserve (dwDevID, dwParam1, (LPMCI_DGV_RESERVE_PARMSW) dwParam2);
1237 case MCI_SETAUDIO: return MCIAVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
1238 case MCI_SIGNAL: return MCIAVI_mciSignal (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS) dwParam2);
1239 case MCI_SETVIDEO: return MCIAVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSW) dwParam2);
1240 case MCI_QUALITY: return MCIAVI_mciQuality (dwDevID, dwParam1, (LPMCI_DGV_QUALITY_PARMSW) dwParam2);
1241 case MCI_LIST: return MCIAVI_mciList (dwDevID, dwParam1, (LPMCI_DGV_LIST_PARMSW) dwParam2);
1242 case MCI_UNDO: return MCIAVI_mciUndo (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1243 case MCI_CONFIGURE: return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1244 case MCI_RESTORE: return MCIAVI_mciRestore (dwDevID, dwParam1, (LPMCI_DGV_RESTORE_PARMSW) dwParam2);
1245
1246 case MCI_SPIN:
1247 case MCI_ESCAPE:
1248 WARN("Unsupported command [%u]\n", wMsg);
1249 break;
1250 case MCI_OPEN:
1251 case MCI_CLOSE:
1252 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1253 break;
1254 default:
1255 TRACE("Sending msg [%u] to default driver proc\n", wMsg);
1256 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1257 }
1258 return MCIERR_UNRECOGNIZED_COMMAND;
1259 }
useful hacks and other patches not (yet) suitable for mainline