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