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