?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
DOSFS_ToDosFCBFormat: fail if extension longer than 3 characters.
[wine/gsoc-2012-control.git] / dlls / winmm / mciwave / mciwave.c
blobc777786c335c65ca9f1fa499c22cc83262abd9c0
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3 * Sample Wine Driver for MCI wave forms
4 *
5 * Copyright 1994 Martin Ayotte
6 * 1999 Eric Pouech
7 */
8 /*
9 * FIXME:
10 * - record/play should and must be done asynchronous
11 */
12
13 #include "windef.h"
14 #include "wingdi.h"
15 #include "winuser.h"
16 #include "driver.h"
17 #include "mmddk.h"
18 #include "heap.h"
19 #include "debugtools.h"
20
21 DEFAULT_DEBUG_CHANNEL(mciwave)
22
23 typedef struct {
24 UINT wDevID;
25 HANDLE hWave;
26 int nUseCount; /* Incremented for each shared open */
27 BOOL fShareable; /* TRUE if first open was shareable */
28 WORD wNotifyDeviceID;/* MCI device ID with a pending notification */
29 HMMIO hFile; /* mmio file handle open as Element */
30 MCI_WAVE_OPEN_PARMSA openParms;
31 LPWAVEFORMATEX lpWaveFormat;
32 BOOL fInput; /* FALSE = Output, TRUE = Input */
33 volatile WORD dwStatus; /* one from MCI_MODE_xxxx */
34 DWORD dwMciTimeFormat;/* One of the supported MCI_FORMAT_xxxx */
35 DWORD dwFileOffset; /* Offset of chunk in mmio file */
36 DWORD dwLength; /* number of bytes in chunk for playing */
37 DWORD dwPosition; /* position in bytes in chunk for playing */
38 HANDLE hEvent; /* for synchronization */
39 DWORD dwEventCount; /* for synchronization */
40 } WINE_MCIWAVE;
41
42 /* ===================================================================
43 * ===================================================================
44 * FIXME: should be using the new mmThreadXXXX functions from WINMM
45 * instead of those
46 * it would require to add a wine internal flag to mmThreadCreate
47 * in order to pass a 32 bit function instead of a 16 bit one
48 * ===================================================================
49 * =================================================================== */
50
51 struct SCA {
52 UINT wDevID;
53 UINT wMsg;
54 DWORD dwParam1;
55 DWORD dwParam2;
56 BOOL allocatedCopy;
57 };
58
59 /**************************************************************************
60 * MCI_SCAStarter [internal]
61 */
62 static DWORD CALLBACK MCI_SCAStarter(LPVOID arg)
63 {
64 struct SCA* sca = (struct SCA*)arg;
65 DWORD ret;
66
67 TRACE("In thread before async command (%08x,%u,%08lx,%08lx)\n",
68 sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
69 ret = mciSendCommandA(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
70 TRACE("In thread after async command (%08x,%u,%08lx,%08lx)\n",
71 sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
72 if (sca->allocatedCopy)
73 HeapFree(GetProcessHeap(), 0, (LPVOID)sca->dwParam2);
74 HeapFree(GetProcessHeap(), 0, sca);
75 ExitThread(ret);
76 WARN("Should not happen ? what's wrong \n");
77 /* should not go after this point */
78 return ret;
79 }
80
81 /**************************************************************************
82 * MCI_SendCommandAsync [internal]
83 */
84 static DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1,
85 DWORD dwParam2, UINT size)
86 {
87 struct SCA* sca = HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA));
88
89 if (sca == 0)
90 return MCIERR_OUT_OF_MEMORY;
91
92 sca->wDevID = wDevID;
93 sca->wMsg = wMsg;
94 sca->dwParam1 = dwParam1;
95
96 if (size) {
97 sca->dwParam2 = (DWORD)HeapAlloc(GetProcessHeap(), 0, size);
98 if (sca->dwParam2 == 0) {
99 HeapFree(GetProcessHeap(), 0, sca);
100 return MCIERR_OUT_OF_MEMORY;
101 }
102 sca->allocatedCopy = TRUE;
103 /* copy structure passed by program in dwParam2 to be sure
104 * we can still use it whatever the program does
105 */
106 memcpy((LPVOID)sca->dwParam2, (LPVOID)dwParam2, size);
107 } else {
108 sca->dwParam2 = dwParam2;
109 sca->allocatedCopy = FALSE;
110 }
111
112 if (CreateThread(NULL, 0, MCI_SCAStarter, sca, 0, NULL) == 0) {
113 WARN("Couldn't allocate thread for async command handling, sending synchonously\n");
114 return MCI_SCAStarter(&sca);
115 }
116 return 0;
117 }
118
119 /*======================================================================*
120 * MCI WAVE implemantation *
121 *======================================================================*/
122
123 static DWORD WAVE_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
124
125 /**************************************************************************
126 * MCIWAVE_drvOpen [internal]
127 */
128 static DWORD WAVE_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
129 {
130 WINE_MCIWAVE* wmw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIWAVE));
131
132 if (!wmw)
133 return 0;
134
135 wmw->wDevID = modp->wDeviceID;
136 mciSetDriverData(wmw->wDevID, (DWORD)wmw);
137 modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
138 modp->wType = MCI_DEVTYPE_WAVEFORM_AUDIO;
139 return modp->wDeviceID;
140 }
141
142 /**************************************************************************
143 * MCIWAVE_drvClose [internal]
144 */
145 static DWORD WAVE_drvClose(DWORD dwDevID)
146 {
147 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)mciGetDriverData(dwDevID);
148
149 if (wmw) {
150 HeapFree(GetProcessHeap(), 0, wmw);
151 mciSetDriverData(dwDevID, 0);
152 return 1;
153 }
154 return 0;
155 }
156
157 /**************************************************************************
158 * WAVE_mciGetOpenDev [internal]
159 */
160 static WINE_MCIWAVE* WAVE_mciGetOpenDev(UINT wDevID)
161 {
162 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)mciGetDriverData(wDevID);
163
164 if (wmw == NULL || wmw->nUseCount == 0) {
165 WARN("Invalid wDevID=%u\n", wDevID);
166 return 0;
167 }
168 return wmw;
169 }
170
171 /**************************************************************************
172 * WAVE_ConvertByteToTimeFormat [internal]
173 */
174 static DWORD WAVE_ConvertByteToTimeFormat(WINE_MCIWAVE* wmw, DWORD val, LPDWORD lpRet)
175 {
176 DWORD ret = 0;
177
178 switch (wmw->dwMciTimeFormat) {
179 case MCI_FORMAT_MILLISECONDS:
180 ret = (val * 1000) / wmw->lpWaveFormat->nAvgBytesPerSec;
181 break;
182 case MCI_FORMAT_BYTES:
183 ret = val;
184 break;
185 case MCI_FORMAT_SAMPLES: /* FIXME: is this correct ? */
186 ret = (val * 8) / wmw->lpWaveFormat->wBitsPerSample;
187 break;
188 default:
189 WARN("Bad time format %lu!\n", wmw->dwMciTimeFormat);
190 }
191 TRACE("val=%lu=0x%08lx [tf=%lu] => ret=%lu\n", val, val, wmw->dwMciTimeFormat, ret);
192 *lpRet = 0;
193 return ret;
194 }
195
196 /**************************************************************************
197 * WAVE_ConvertTimeFormatToByte [internal]
198 */
199 static DWORD WAVE_ConvertTimeFormatToByte(WINE_MCIWAVE* wmw, DWORD val)
200 {
201 DWORD ret = 0;
202
203 switch (wmw->dwMciTimeFormat) {
204 case MCI_FORMAT_MILLISECONDS:
205 ret = (val * wmw->lpWaveFormat->nAvgBytesPerSec) / 1000;
206 break;
207 case MCI_FORMAT_BYTES:
208 ret = val;
209 break;
210 case MCI_FORMAT_SAMPLES: /* FIXME: is this correct ? */
211 ret = (val * wmw->lpWaveFormat->wBitsPerSample) / 8;
212 break;
213 default:
214 WARN("Bad time format %lu!\n", wmw->dwMciTimeFormat);
215 }
216 TRACE("val=%lu=0x%08lx [tf=%lu] => ret=%lu\n", val, val, wmw->dwMciTimeFormat, ret);
217 return ret;
218 }
219
220 /**************************************************************************
221 * WAVE_mciReadFmt [internal]
222 */
223 static DWORD WAVE_mciReadFmt(WINE_MCIWAVE* wmw, MMCKINFO* pckMainRIFF)
224 {
225 MMCKINFO mmckInfo;
226 long r;
227
228 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
229 if (mmioDescend(wmw->hFile, &mmckInfo, pckMainRIFF, MMIO_FINDCHUNK) != 0)
230 return MCIERR_INVALID_FILE;
231 TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
232 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
233
234 wmw->lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
235 r = mmioRead(wmw->hFile, (HPSTR)wmw->lpWaveFormat, mmckInfo.cksize);
236 if (r < sizeof(WAVEFORMAT))
237 return MCIERR_INVALID_FILE;
238
239 TRACE("wFormatTag=%04X !\n", wmw->lpWaveFormat->wFormatTag);
240 TRACE("nChannels=%d \n", wmw->lpWaveFormat->nChannels);
241 TRACE("nSamplesPerSec=%ld\n", wmw->lpWaveFormat->nSamplesPerSec);
242 TRACE("nAvgBytesPerSec=%ld\n", wmw->lpWaveFormat->nAvgBytesPerSec);
243 TRACE("nBlockAlign=%d \n", wmw->lpWaveFormat->nBlockAlign);
244 TRACE("wBitsPerSample=%u !\n", wmw->lpWaveFormat->wBitsPerSample);
245 if (r >= (long)sizeof(WAVEFORMATEX))
246 TRACE("cbSize=%u !\n", wmw->lpWaveFormat->cbSize);
247
248 mmioAscend(wmw->hFile, &mmckInfo, 0);
249 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
250 if (mmioDescend(wmw->hFile, &mmckInfo, pckMainRIFF, MMIO_FINDCHUNK) != 0) {
251 TRACE("can't find data chunk\n");
252 return MCIERR_INVALID_FILE;
253 }
254 TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
255 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
256 TRACE("nChannels=%d nSamplesPerSec=%ld\n",
257 wmw->lpWaveFormat->nChannels, wmw->lpWaveFormat->nSamplesPerSec);
258 wmw->dwLength = mmckInfo.cksize;
259 wmw->dwFileOffset = mmckInfo.dwDataOffset;
260 return 0;
261 }
262
263 /**************************************************************************
264 * WAVE_mciOpen [internal]
265 */
266 static DWORD WAVE_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMSA lpOpenParms)
267 {
268 DWORD dwRet = 0;
269 DWORD dwDeviceID;
270 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)mciGetDriverData(wDevID);
271
272 TRACE("(%04X, %08lX, %p)\n", wDevID, dwFlags, lpOpenParms);
273 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
274 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
275
276 if (dwFlags & MCI_OPEN_SHAREABLE)
277 return MCIERR_HARDWARE;
278
279 if (wmw->nUseCount > 0) {
280 /* The driver is already opened on this channel
281 * Wave driver cannot be shared
282 */
283 return MCIERR_DEVICE_OPEN;
284 }
285 wmw->nUseCount++;
286
287 dwDeviceID = lpOpenParms->wDeviceID;
288
289 wmw->fInput = FALSE;
290 wmw->hWave = 0;
291
292 TRACE("wDevID=%04X (lpParams->wDeviceID=%08lX)\n", wDevID, dwDeviceID);
293
294 if (dwFlags & MCI_OPEN_ELEMENT) {
295 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
296 /* could it be that (DWORD)lpOpenParms->lpstrElementName
297 * contains the hFile value ?
298 */
299 dwRet = MCIERR_UNRECOGNIZED_COMMAND;
300 } else {
301 LPCSTR lpstrElementName = lpOpenParms->lpstrElementName;
302
303 /*FIXME : what should be done id wmw->hFile is already != 0, or the driver is playin' */
304 TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpstrElementName);
305 if (lpstrElementName && (strlen(lpstrElementName) > 0)) {
306 wmw->hFile = mmioOpenA((LPSTR)lpstrElementName, NULL,
307 MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
308 if (wmw->hFile == 0) {
309 WARN("can't find file='%s' !\n", lpstrElementName);
310 dwRet = MCIERR_FILE_NOT_FOUND;
311 }
312 } else {
313 wmw->hFile = 0;
314 }
315 }
316 }
317 TRACE("hFile=%u\n", wmw->hFile);
318
319 memcpy(&wmw->openParms, lpOpenParms, sizeof(MCI_WAVE_OPEN_PARMSA));
320 wmw->wNotifyDeviceID = dwDeviceID;
321 wmw->dwStatus = MCI_MODE_NOT_READY; /* while loading file contents */
322
323 if (dwRet == 0 && wmw->hFile != 0) {
324 MMCKINFO ckMainRIFF;
325
326 if (mmioDescend(wmw->hFile, &ckMainRIFF, NULL, 0) != 0) {
327 dwRet = MCIERR_INVALID_FILE;
328 } else {
329 TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
330 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
331 if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
332 (ckMainRIFF.fccType != mmioFOURCC('W', 'A', 'V', 'E'))) {
333 dwRet = MCIERR_INVALID_FILE;
334 } else {
335 dwRet = WAVE_mciReadFmt(wmw, &ckMainRIFF);
336 }
337 }
338 } else {
339 wmw->dwLength = 0;
340 }
341 if (dwRet == 0) {
342 if (wmw->lpWaveFormat) {
343 switch (wmw->lpWaveFormat->wFormatTag) {
344 case WAVE_FORMAT_PCM:
345 if (wmw->lpWaveFormat->nAvgBytesPerSec !=
346 wmw->lpWaveFormat->nSamplesPerSec * wmw->lpWaveFormat->nBlockAlign) {
347 WARN("Incorrect nAvgBytesPerSec (%ld), setting it to %ld\n",
348 wmw->lpWaveFormat->nAvgBytesPerSec,
349 wmw->lpWaveFormat->nSamplesPerSec *
350 wmw->lpWaveFormat->nBlockAlign);
351 wmw->lpWaveFormat->nAvgBytesPerSec =
352 wmw->lpWaveFormat->nSamplesPerSec *
353 wmw->lpWaveFormat->nBlockAlign;
354 }
355 break;
356 }
357 }
358 wmw->dwPosition = 0;
359
360 wmw->dwStatus = MCI_MODE_STOP;
361 } else {
362 wmw->nUseCount--;
363 if (wmw->hFile != 0)
364 mmioClose(wmw->hFile, 0);
365 wmw->hFile = 0;
366 }
367 return dwRet;
368 }
369
370 /**************************************************************************
371 * WAVE_mciCue [internal]
372 */
373 static DWORD WAVE_mciCue(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
374 {
375 /*
376 FIXME
377
378 This routine is far from complete. At the moment only a check is done on the
379 MCI_WAVE_INPUT flag. No explicit check on MCI_WAVE_OUTPUT is done since that
380 is the default.
381
382 The flags MCI_NOTIFY (and the callback parameter in lpParms) and MCI_WAIT
383 are ignored
384 */
385
386 DWORD dwRet;
387 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
388
389 FIXME("(%u, %08lX, %p); likely to fail\n", wDevID, dwParam, lpParms);
390
391 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
392
393 /* always close elements ? */
394 if (wmw->hFile != 0) {
395 mmioClose(wmw->hFile, 0);
396 wmw->hFile = 0;
397 }
398
399 dwRet = MMSYSERR_NOERROR; /* assume success */
400
401 if ((dwParam & MCI_WAVE_INPUT) && !wmw->fInput) {
402 dwRet = waveOutClose(wmw->hWave);
403 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
404 wmw->fInput = TRUE;
405 } else if (wmw->fInput) {
406 dwRet = waveInClose(wmw->hWave);
407 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
408 wmw->fInput = FALSE;
409 }
410 wmw->hWave = 0;
411 return (dwRet == MMSYSERR_NOERROR) ? 0 : MCIERR_INTERNAL;
412 }
413
414 /**************************************************************************
415 * WAVE_mciStop [internal]
416 */
417 static DWORD WAVE_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
418 {
419 DWORD dwRet = 0;
420 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
421
422 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
423
424 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
425
426 /* wait for playback thread (if any) to exit before processing further */
427 switch (wmw->dwStatus) {
428 case MCI_MODE_PAUSE:
429 case MCI_MODE_PLAY:
430 case MCI_MODE_RECORD:
431 {
432 int oldStat = wmw->dwStatus;
433 wmw->dwStatus = MCI_MODE_NOT_READY;
434 if (oldStat == MCI_MODE_PAUSE)
435 dwRet = (wmw->fInput) ? waveInReset(wmw->hWave) : waveOutReset(wmw->hWave);
436 }
437 while (wmw->dwStatus != MCI_MODE_STOP)
438 Sleep(10);
439 break;
440 }
441
442 wmw->dwPosition = 0;
443
444 /* sanity resets */
445 wmw->dwStatus = MCI_MODE_STOP;
446
447 if ((dwFlags & MCI_NOTIFY) && lpParms) {
448 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
449 wmw->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
450 }
451
452 return dwRet;
453 }
454
455 /**************************************************************************
456 * WAVE_mciClose [internal]
457 */
458 static DWORD WAVE_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
459 {
460 DWORD dwRet = 0;
461 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
462
463 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
464
465 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
466
467 if (wmw->dwStatus != MCI_MODE_STOP) {
468 dwRet = WAVE_mciStop(wDevID, MCI_WAIT, lpParms);
469 }
470
471 wmw->nUseCount--;
472
473 if (wmw->nUseCount == 0) {
474 if (wmw->hFile != 0) {
475 mmioClose(wmw->hFile, 0);
476 wmw->hFile = 0;
477 }
478 }
479
480 HeapFree(GetProcessHeap(), 0, wmw->lpWaveFormat);
481 wmw->lpWaveFormat = NULL;
482
483 if ((dwFlags & MCI_NOTIFY) && lpParms) {
484 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
485 wmw->wNotifyDeviceID,
486 (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
487 }
488
489 return 0;
490 }
491
492 /**************************************************************************
493 * WAVE_mciPlayCallback [internal]
494 */
495 static void CALLBACK WAVE_mciPlayCallback(HWAVEOUT hwo, UINT uMsg,
496 DWORD dwInstance,
497 DWORD dwParam1, DWORD dwParam2)
498 {
499 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)dwInstance;
500
501 switch (uMsg) {
502 case WOM_OPEN:
503 case WOM_CLOSE:
504 break;
505 case WOM_DONE:
506 InterlockedIncrement(&wmw->dwEventCount);
507 TRACE("Returning waveHdr=%lx\n", dwParam1);
508 SetEvent(wmw->hEvent);
509 break;
510 default:
511 ERR("Unknown uMsg=%d\n", uMsg);
512 }
513 }
514
515 static void WAVE_mciPlayWaitDone(WINE_MCIWAVE* wmw)
516 {
517 for (;;) {
518 ResetEvent(wmw->hEvent);
519 if (InterlockedDecrement(&wmw->dwEventCount) >= 0) {
520 break;
521 }
522 InterlockedIncrement(&wmw->dwEventCount);
523
524 WaitForSingleObject(wmw->hEvent, INFINITE);
525 }
526 }
527
528 /**************************************************************************
529 * WAVE_mciPlay [internal]
530 */
531 static DWORD WAVE_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
532 {
533 DWORD end;
534 LONG bufsize, count, left;
535 DWORD dwRet = 0;
536 LPWAVEHDR waveHdr = NULL;
537 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
538 int whidx;
539
540 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
541
542 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
543 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
544
545 if (wmw->fInput) {
546 WARN("cannot play on input device\n");
547 return MCIERR_NONAPPLICABLE_FUNCTION;
548 }
549
550 if (wmw->hFile == 0) {
551 WARN("Can't play: no file='%s' !\n", wmw->openParms.lpstrElementName);
552 return MCIERR_FILE_NOT_FOUND;
553 }
554
555 if (wmw->dwStatus == MCI_MODE_PAUSE) {
556 /* FIXME: parameters (start/end) in lpParams may not be used */
557 return WAVE_mciResume(wDevID, dwFlags, (LPMCI_GENERIC_PARMS)lpParms);
558 }
559
560 /** This function will be called again by a thread when async is used.
561 * We have to set MCI_MODE_PLAY before we do this so that the app can spin
562 * on MCI_STATUS, so we have to allow it here if we're not going to start this thread.
563 */
564 if ((wmw->dwStatus != MCI_MODE_STOP) && ((wmw->dwStatus != MCI_MODE_PLAY) && (dwFlags & MCI_WAIT))) {
565 return MCIERR_INTERNAL;
566 }
567
568 wmw->dwStatus = MCI_MODE_PLAY;
569
570 if (!(dwFlags & MCI_WAIT)) {
571 return MCI_SendCommandAsync(wmw->wNotifyDeviceID, MCI_PLAY, dwFlags,
572 (DWORD)lpParms, sizeof(MCI_PLAY_PARMS));
573 }
574
575 end = 0xFFFFFFFF;
576 if (lpParms && (dwFlags & MCI_FROM)) {
577 wmw->dwPosition = WAVE_ConvertTimeFormatToByte(wmw, lpParms->dwFrom);
578 }
579 if (lpParms && (dwFlags & MCI_TO)) {
580 end = WAVE_ConvertTimeFormatToByte(wmw, lpParms->dwTo);
581 }
582
583 TRACE("Playing from byte=%lu to byte=%lu\n", wmw->dwPosition, end);
584
585 if (end <= wmw->dwPosition)
586 return TRUE;
587
588 #define WAVE_ALIGN_ON_BLOCK(wmw,v) \
589 ((((v) + (wmw)->lpWaveFormat->nBlockAlign - 1) / (wmw)->lpWaveFormat->nBlockAlign) * (wmw)->lpWaveFormat->nBlockAlign)
590
591 wmw->dwPosition = WAVE_ALIGN_ON_BLOCK(wmw, wmw->dwPosition);
592 wmw->dwLength = WAVE_ALIGN_ON_BLOCK(wmw, wmw->dwLength);
593 /* go back to begining of chunk plus the requested position */
594 /* FIXME: I'm not sure this is correct, notably because some data linked to
595 * the decompression state machine will not be correcly initialized.
596 * try it this way (other way would be to decompress from 0 up to dwPosition
597 * and to start sending to hWave when dwPosition is reached)
598 */
599 mmioSeek(wmw->hFile, wmw->dwFileOffset + wmw->dwPosition, SEEK_SET); /* >= 0 */
600
601 /* By default the device will be opened for output, the MCI_CUE function is there to
602 * change from output to input and back
603 */
604 /* FIXME: how to choose between several output channels ? here mapper is forced */
605 dwRet = waveOutOpen(&wmw->hWave, WAVE_MAPPER, wmw->lpWaveFormat,
606 (DWORD)WAVE_mciPlayCallback, (DWORD)wmw, CALLBACK_FUNCTION);
607
608 if (dwRet != 0) {
609 TRACE("Can't open low level audio device %ld\n", dwRet);
610 dwRet = MCIERR_DEVICE_OPEN;
611 wmw->hWave = 0;
612 goto cleanUp;
613 }
614
615 /* make it so that 3 buffers per second are needed */
616 bufsize = WAVE_ALIGN_ON_BLOCK(wmw, wmw->lpWaveFormat->nAvgBytesPerSec / 3);
617
618 waveHdr = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(WAVEHDR) + 2 * bufsize);
619 waveHdr[0].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR);
620 waveHdr[1].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR) + bufsize;
621 waveHdr[0].dwUser = waveHdr[1].dwUser = 0L;
622 waveHdr[0].dwLoops = waveHdr[1].dwLoops = 0L;
623 waveHdr[0].dwFlags = waveHdr[1].dwFlags = 0L;
624 waveHdr[0].dwBufferLength = waveHdr[1].dwBufferLength = bufsize;
625 if (waveOutPrepareHeader(wmw->hWave, &waveHdr[0], sizeof(WAVEHDR)) ||
626 waveOutPrepareHeader(wmw->hWave, &waveHdr[1], sizeof(WAVEHDR))) {
627 dwRet = MCIERR_INTERNAL;
628 goto cleanUp;
629 }
630
631 whidx = 0;
632 left = min(wmw->dwLength, end - wmw->dwPosition);
633 wmw->hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
634 wmw->dwEventCount = 1L; /* for first buffer */
635
636 TRACE("Playing (normalized) from byte=%lu for %lu bytes\n", wmw->dwPosition, left);
637
638 /* FIXME: this doesn't work if wmw->dwPosition != 0 */
639 while (left > 0 && wmw->dwStatus != MCI_MODE_STOP && wmw->dwStatus != MCI_MODE_NOT_READY) {
640 count = mmioRead(wmw->hFile, waveHdr[whidx].lpData, min(bufsize, left));
641 TRACE("mmioRead bufsize=%ld count=%ld\n", bufsize, count);
642 if (count < 1)
643 break;
644 /* count is always <= bufsize, so this is correct regarding the
645 * waveOutPrepareHeader function
646 */
647 waveHdr[whidx].dwBufferLength = count;
648 waveHdr[whidx].dwFlags &= ~WHDR_DONE;
649 TRACE("before WODM_WRITE lpWaveHdr=%p dwBufferLength=%lu dwBytesRecorded=%lu\n",
650 &waveHdr[whidx], waveHdr[whidx].dwBufferLength,
651 waveHdr[whidx].dwBytesRecorded);
652 dwRet = waveOutWrite(wmw->hWave, &waveHdr[whidx], sizeof(WAVEHDR));
653 left -= count;
654 wmw->dwPosition += count;
655 TRACE("after WODM_WRITE dwPosition=%lu\n", wmw->dwPosition);
656
657 WAVE_mciPlayWaitDone(wmw);
658 whidx ^= 1;
659 }
660
661 WAVE_mciPlayWaitDone(wmw); /* to balance first buffer */
662
663 /* just to get rid of some race conditions between play, stop and pause */
664 waveOutReset(wmw->hWave);
665
666 waveOutUnprepareHeader(wmw->hWave, &waveHdr[0], sizeof(WAVEHDR));
667 waveOutUnprepareHeader(wmw->hWave, &waveHdr[1], sizeof(WAVEHDR));
668
669 dwRet = 0;
670
671 cleanUp:
672 HeapFree(GetProcessHeap(), 0, waveHdr);
673
674 if (wmw->hWave) {
675 waveOutClose(wmw->hWave);
676 wmw->hWave = 0;
677 }
678 CloseHandle(wmw->hEvent);
679
680 if (lpParms && (dwFlags & MCI_NOTIFY)) {
681 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
682 wmw->wNotifyDeviceID,
683 dwRet ? MCI_NOTIFY_FAILURE : MCI_NOTIFY_SUCCESSFUL);
684 }
685
686 wmw->dwStatus = MCI_MODE_STOP;
687
688 return dwRet;
689 }
690
691 /**************************************************************************
692 * WAVE_mciRecord [internal]
693 */
694 static DWORD WAVE_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
695 {
696 int start, end;
697 LONG bufsize;
698 WAVEHDR waveHdr;
699 DWORD dwRet;
700 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
701
702 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
703
704 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
705 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
706
707 if (!wmw->fInput) {
708 WARN("cannot record on output device\n");
709 return MCIERR_NONAPPLICABLE_FUNCTION;
710 }
711
712 if (wmw->hFile == 0) {
713 WARN("can't find file='%s' !\n",
714 wmw->openParms.lpstrElementName);
715 return MCIERR_FILE_NOT_FOUND;
716 }
717 start = 1; end = 99999;
718 if (dwFlags & MCI_FROM) {
719 start = lpParms->dwFrom;
720 TRACE("MCI_FROM=%d \n", start);
721 }
722 if (dwFlags & MCI_TO) {
723 end = lpParms->dwTo;
724 TRACE("MCI_TO=%d \n", end);
725 }
726 bufsize = 64000;
727 waveHdr.lpData = HeapAlloc(GetProcessHeap(), 0, bufsize);
728 waveHdr.dwBufferLength = bufsize;
729 waveHdr.dwUser = 0L;
730 waveHdr.dwFlags = 0L;
731 waveHdr.dwLoops = 0L;
732 dwRet = waveInPrepareHeader(wmw->hWave, &waveHdr, sizeof(WAVEHDR));
733
734 for (;;) { /* FIXME: I don't see any waveInAddBuffer ? */
735 waveHdr.dwBytesRecorded = 0;
736 dwRet = waveInStart(wmw->hWave);
737 TRACE("waveInStart => lpWaveHdr=%p dwBytesRecorded=%lu\n",
738 &waveHdr, waveHdr.dwBytesRecorded);
739 if (waveHdr.dwBytesRecorded == 0) break;
740 }
741 dwRet = waveInUnprepareHeader(wmw->hWave, &waveHdr, sizeof(WAVEHDR));
742 HeapFree(GetProcessHeap(), 0, waveHdr.lpData);
743
744 if (dwFlags & MCI_NOTIFY) {
745 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
746 wmw->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
747 }
748 return 0;
749 }
750
751 /**************************************************************************
752 * WAVE_mciPause [internal]
753 */
754 static DWORD WAVE_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
755 {
756 DWORD dwRet;
757 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
758
759 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
760
761 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
762 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
763
764 if (wmw->dwStatus == MCI_MODE_PLAY) {
765 wmw->dwStatus = MCI_MODE_PAUSE;
766 }
767
768 if (wmw->fInput) dwRet = waveInStop(wmw->hWave);
769 else dwRet = waveOutPause(wmw->hWave);
770
771 return (dwRet == MMSYSERR_NOERROR) ? 0 : MCIERR_INTERNAL;
772 }
773
774 /**************************************************************************
775 * WAVE_mciResume [internal]
776 */
777 static DWORD WAVE_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
778 {
779 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
780 DWORD dwRet = 0;
781
782 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
783
784 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
785
786 if (wmw->dwStatus == MCI_MODE_PAUSE) {
787 wmw->dwStatus = MCI_MODE_PLAY;
788 }
789
790 if (wmw->fInput) dwRet = waveInStart(wmw->hWave);
791 else dwRet = waveOutRestart(wmw->hWave);
792 return (dwRet == MMSYSERR_NOERROR) ? 0 : MCIERR_INTERNAL;
793 }
794
795 /**************************************************************************
796 * WAVE_mciSeek [internal]
797 */
798 static DWORD WAVE_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
799 {
800 DWORD ret = 0;
801 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
802
803 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
804
805 if (lpParms == NULL) {
806 ret = MCIERR_NULL_PARAMETER_BLOCK;
807 } else if (wmw == NULL) {
808 ret = MCIERR_INVALID_DEVICE_ID;
809 } else {
810 WAVE_mciStop(wDevID, MCI_WAIT, 0);
811
812 if (dwFlags & MCI_SEEK_TO_START) {
813 wmw->dwPosition = 0;
814 } else if (dwFlags & MCI_SEEK_TO_END) {
815 wmw->dwPosition = wmw->dwLength;
816 } else if (dwFlags & MCI_TO) {
817 wmw->dwPosition = WAVE_ConvertTimeFormatToByte(wmw, lpParms->dwTo);
818 } else {
819 WARN("dwFlag doesn't tell where to seek to...\n");
820 return MCIERR_MISSING_PARAMETER;
821 }
822
823 TRACE("Seeking to position=%lu bytes\n", wmw->dwPosition);
824
825 if (dwFlags & MCI_NOTIFY) {
826 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
827 wmw->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
828 }
829 }
830 return ret;
831 }
832
833 /**************************************************************************
834 * WAVE_mciSet [internal]
835 */
836 static DWORD WAVE_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
837 {
838 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
839
840 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
841
842 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
843 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
844
845 if (dwFlags & MCI_SET_TIME_FORMAT) {
846 switch (lpParms->dwTimeFormat) {
847 case MCI_FORMAT_MILLISECONDS:
848 TRACE("MCI_FORMAT_MILLISECONDS !\n");
849 wmw->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
850 break;
851 case MCI_FORMAT_BYTES:
852 TRACE("MCI_FORMAT_BYTES !\n");
853 wmw->dwMciTimeFormat = MCI_FORMAT_BYTES;
854 break;
855 case MCI_FORMAT_SAMPLES:
856 TRACE("MCI_FORMAT_SAMPLES !\n");
857 wmw->dwMciTimeFormat = MCI_FORMAT_SAMPLES;
858 break;
859 default:
860 WARN("Bad time format %lu!\n", lpParms->dwTimeFormat);
861 return MCIERR_BAD_TIME_FORMAT;
862 }
863 }
864 if (dwFlags & MCI_SET_VIDEO) {
865 TRACE("No support for video !\n");
866 return MCIERR_UNSUPPORTED_FUNCTION;
867 }
868 if (dwFlags & MCI_SET_DOOR_OPEN) {
869 TRACE("No support for door open !\n");
870 return MCIERR_UNSUPPORTED_FUNCTION;
871 }
872 if (dwFlags & MCI_SET_DOOR_CLOSED) {
873 TRACE("No support for door close !\n");
874 return MCIERR_UNSUPPORTED_FUNCTION;
875 }
876 if (dwFlags & MCI_SET_AUDIO) {
877 if (dwFlags & MCI_SET_ON) {
878 TRACE("MCI_SET_ON audio !\n");
879 } else if (dwFlags & MCI_SET_OFF) {
880 TRACE("MCI_SET_OFF audio !\n");
881 } else {
882 WARN("MCI_SET_AUDIO without SET_ON or SET_OFF\n");
883 return MCIERR_BAD_INTEGER;
884 }
885
886 if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
887 TRACE("MCI_SET_AUDIO_ALL !\n");
888 if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
889 TRACE("MCI_SET_AUDIO_LEFT !\n");
890 if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
891 TRACE("MCI_SET_AUDIO_RIGHT !\n");
892 }
893 if (dwFlags & MCI_WAVE_INPUT)
894 TRACE("MCI_WAVE_INPUT !\n");
895 if (dwFlags & MCI_WAVE_OUTPUT)
896 TRACE("MCI_WAVE_OUTPUT !\n");
897 if (dwFlags & MCI_WAVE_SET_ANYINPUT)
898 TRACE("MCI_WAVE_SET_ANYINPUT !\n");
899 if (dwFlags & MCI_WAVE_SET_ANYOUTPUT)
900 TRACE("MCI_WAVE_SET_ANYOUTPUT !\n");
901 if (dwFlags & MCI_WAVE_SET_AVGBYTESPERSEC)
902 TRACE("MCI_WAVE_SET_AVGBYTESPERSEC !\n");
903 if (dwFlags & MCI_WAVE_SET_BITSPERSAMPLE)
904 TRACE("MCI_WAVE_SET_BITSPERSAMPLE !\n");
905 if (dwFlags & MCI_WAVE_SET_BLOCKALIGN)
906 TRACE("MCI_WAVE_SET_BLOCKALIGN !\n");
907 if (dwFlags & MCI_WAVE_SET_CHANNELS)
908 TRACE("MCI_WAVE_SET_CHANNELS !\n");
909 if (dwFlags & MCI_WAVE_SET_FORMATTAG)
910 TRACE("MCI_WAVE_SET_FORMATTAG !\n");
911 if (dwFlags & MCI_WAVE_SET_SAMPLESPERSEC)
912 TRACE("MCI_WAVE_SET_SAMPLESPERSEC !\n");
913 return 0;
914 }
915
916 /**************************************************************************
917 * WAVE_mciStatus [internal]
918 */
919 static DWORD WAVE_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
920 {
921 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
922 DWORD ret = 0;
923
924 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
925 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
926 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
927
928 if (dwFlags & MCI_STATUS_ITEM) {
929 switch (lpParms->dwItem) {
930 case MCI_STATUS_CURRENT_TRACK:
931 lpParms->dwReturn = 1;
932 TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
933 break;
934 case MCI_STATUS_LENGTH:
935 if (!wmw->hFile) {
936 lpParms->dwReturn = 0;
937 return MCIERR_UNSUPPORTED_FUNCTION;
938 }
939 /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
940 lpParms->dwReturn = WAVE_ConvertByteToTimeFormat(wmw, wmw->dwLength, &ret);
941 TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
942 break;
943 case MCI_STATUS_MODE:
944 TRACE("MCI_STATUS_MODE => %u\n", wmw->dwStatus);
945 lpParms->dwReturn = MAKEMCIRESOURCE(wmw->dwStatus, wmw->dwStatus);
946 ret = MCI_RESOURCE_RETURNED;
947 break;
948 case MCI_STATUS_MEDIA_PRESENT:
949 TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE!\n");
950 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
951 ret = MCI_RESOURCE_RETURNED;
952 break;
953 case MCI_STATUS_NUMBER_OF_TRACKS:
954 /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
955 lpParms->dwReturn = 1;
956 TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu!\n", lpParms->dwReturn);
957 break;
958 case MCI_STATUS_POSITION:
959 if (!wmw->hFile) {
960 lpParms->dwReturn = 0;
961 return MCIERR_UNSUPPORTED_FUNCTION;
962 }
963 /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
964 lpParms->dwReturn = WAVE_ConvertByteToTimeFormat(wmw,
965 (dwFlags & MCI_STATUS_START) ? 0 : wmw->dwPosition,
966 &ret);
967 TRACE("MCI_STATUS_POSITION %s => %lu\n",
968 (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
969 break;
970 case MCI_STATUS_READY:
971 lpParms->dwReturn = (wmw->dwStatus == MCI_MODE_NOT_READY) ?
972 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
973 TRACE("MCI_STATUS_READY => %u!\n", LOWORD(lpParms->dwReturn));
974 ret = MCI_RESOURCE_RETURNED;
975 break;
976 case MCI_STATUS_TIME_FORMAT:
977 lpParms->dwReturn = MAKEMCIRESOURCE(wmw->dwMciTimeFormat, wmw->dwMciTimeFormat);
978 TRACE("MCI_STATUS_TIME_FORMAT => %lu\n", lpParms->dwReturn);
979 ret = MCI_RESOURCE_RETURNED;
980 break;
981 case MCI_WAVE_INPUT:
982 TRACE("MCI_WAVE_INPUT !\n");
983 lpParms->dwReturn = 0;
984 ret = MCIERR_WAVE_INPUTUNSPECIFIED;
985 break;
986 case MCI_WAVE_OUTPUT:
987 TRACE("MCI_WAVE_OUTPUT !\n");
988 {
989 UINT id;
990 if (waveOutGetID(wmw->hWave, &id) == MMSYSERR_NOERROR) {
991 lpParms->dwReturn = id;
992 } else {
993 lpParms->dwReturn = 0;
994 ret = MCIERR_WAVE_INPUTUNSPECIFIED;
995 }
996 }
997 break;
998 case MCI_WAVE_STATUS_AVGBYTESPERSEC:
999 if (!wmw->hFile) {
1000 lpParms->dwReturn = 0;
1001 return MCIERR_UNSUPPORTED_FUNCTION;
1002 }
1003 lpParms->dwReturn = wmw->lpWaveFormat->nAvgBytesPerSec;
1004 TRACE("MCI_WAVE_STATUS_AVGBYTESPERSEC => %lu!\n", lpParms->dwReturn);
1005 break;
1006 case MCI_WAVE_STATUS_BITSPERSAMPLE:
1007 if (!wmw->hFile) {
1008 lpParms->dwReturn = 0;
1009 return MCIERR_UNSUPPORTED_FUNCTION;
1010 }
1011 lpParms->dwReturn = wmw->lpWaveFormat->wBitsPerSample;
1012 TRACE("MCI_WAVE_STATUS_BITSPERSAMPLE => %lu!\n", lpParms->dwReturn);
1013 break;
1014 case MCI_WAVE_STATUS_BLOCKALIGN:
1015 if (!wmw->hFile) {
1016 lpParms->dwReturn = 0;
1017 return MCIERR_UNSUPPORTED_FUNCTION;
1018 }
1019 lpParms->dwReturn = wmw->lpWaveFormat->nBlockAlign;
1020 TRACE("MCI_WAVE_STATUS_BLOCKALIGN => %lu!\n", lpParms->dwReturn);
1021 break;
1022 case MCI_WAVE_STATUS_CHANNELS:
1023 if (!wmw->hFile) {
1024 lpParms->dwReturn = 0;
1025 return MCIERR_UNSUPPORTED_FUNCTION;
1026 }
1027 lpParms->dwReturn = wmw->lpWaveFormat->nChannels;
1028 TRACE("MCI_WAVE_STATUS_CHANNELS => %lu!\n", lpParms->dwReturn);
1029 break;
1030 case MCI_WAVE_STATUS_FORMATTAG:
1031 if (!wmw->hFile) {
1032 lpParms->dwReturn = 0;
1033 return MCIERR_UNSUPPORTED_FUNCTION;
1034 }
1035 lpParms->dwReturn = wmw->lpWaveFormat->wFormatTag;
1036 TRACE("MCI_WAVE_FORMATTAG => %lu!\n", lpParms->dwReturn);
1037 break;
1038 case MCI_WAVE_STATUS_LEVEL:
1039 TRACE("MCI_WAVE_STATUS_LEVEL !\n");
1040 lpParms->dwReturn = 0xAAAA5555;
1041 break;
1042 case MCI_WAVE_STATUS_SAMPLESPERSEC:
1043 if (!wmw->hFile) {
1044 lpParms->dwReturn = 0;
1045 return MCIERR_UNSUPPORTED_FUNCTION;
1046 }
1047 lpParms->dwReturn = wmw->lpWaveFormat->nSamplesPerSec;
1048 TRACE("MCI_WAVE_STATUS_SAMPLESPERSEC => %lu!\n", lpParms->dwReturn);
1049 break;
1050 default:
1051 WARN("unknown command %08lX !\n", lpParms->dwItem);
1052 return MCIERR_UNRECOGNIZED_COMMAND;
1053 }
1054 }
1055 if (dwFlags & MCI_NOTIFY) {
1056 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
1057 wmw->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
1058 }
1059 return ret;
1060 }
1061
1062 /**************************************************************************
1063 * WAVE_mciGetDevCaps [internal]
1064 */
1065 static DWORD WAVE_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
1066 LPMCI_GETDEVCAPS_PARMS lpParms)
1067 {
1068 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1069 DWORD ret = 0;
1070
1071 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1072
1073 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1074 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
1075
1076 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
1077 switch(lpParms->dwItem) {
1078 case MCI_GETDEVCAPS_DEVICE_TYPE:
1079 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_WAVEFORM_AUDIO, MCI_DEVTYPE_WAVEFORM_AUDIO);
1080 ret = MCI_RESOURCE_RETURNED;
1081 break;
1082 case MCI_GETDEVCAPS_HAS_AUDIO:
1083 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1084 ret = MCI_RESOURCE_RETURNED;
1085 break;
1086 case MCI_GETDEVCAPS_HAS_VIDEO:
1087 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1088 ret = MCI_RESOURCE_RETURNED;
1089 break;
1090 case MCI_GETDEVCAPS_USES_FILES:
1091 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1092 ret = MCI_RESOURCE_RETURNED;
1093 break;
1094 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
1095 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1096 ret = MCI_RESOURCE_RETURNED;
1097 break;
1098 case MCI_GETDEVCAPS_CAN_RECORD:
1099 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1100 ret = MCI_RESOURCE_RETURNED;
1101 break;
1102 case MCI_GETDEVCAPS_CAN_EJECT:
1103 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1104 ret = MCI_RESOURCE_RETURNED;
1105 break;
1106 case MCI_GETDEVCAPS_CAN_PLAY:
1107 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1108 ret = MCI_RESOURCE_RETURNED;
1109 break;
1110 case MCI_GETDEVCAPS_CAN_SAVE:
1111 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1112 ret = MCI_RESOURCE_RETURNED;
1113 break;
1114 case MCI_WAVE_GETDEVCAPS_INPUTS:
1115 lpParms->dwReturn = 1;
1116 break;
1117 case MCI_WAVE_GETDEVCAPS_OUTPUTS:
1118 lpParms->dwReturn = 1;
1119 break;
1120 default:
1121 FIXME("Unknown capability (%08lx) !\n", lpParms->dwItem);
1122 return MCIERR_UNRECOGNIZED_COMMAND;
1123 }
1124 } else {
1125 WARN("No GetDevCaps-Item !\n");
1126 return MCIERR_UNRECOGNIZED_COMMAND;
1127 }
1128 return ret;
1129 }
1130
1131 /**************************************************************************
1132 * WAVE_mciInfo [internal]
1133 */
1134 static DWORD WAVE_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
1135 {
1136 DWORD ret = 0;
1137 LPCSTR str = 0;
1138 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1139
1140 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1141
1142 if (lpParms == NULL || lpParms->lpstrReturn == NULL) {
1143 ret = MCIERR_NULL_PARAMETER_BLOCK;
1144 } else if (wmw == NULL) {
1145 ret = MCIERR_INVALID_DEVICE_ID;
1146 } else {
1147 TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
1148
1149 switch (dwFlags & ~(MCI_WAIT|MCI_NOTIFY)) {
1150 case MCI_INFO_PRODUCT:
1151 str = "Wine's audio player";
1152 break;
1153 case MCI_INFO_FILE:
1154 str = wmw->openParms.lpstrElementName;
1155 break;
1156 case MCI_WAVE_INPUT:
1157 str = "Wine Wave In";
1158 break;
1159 case MCI_WAVE_OUTPUT:
1160 str = "Wine Wave Out";
1161 break;
1162 default:
1163 WARN("Don't know this info command (%lu)\n", dwFlags);
1164 ret = MCIERR_UNRECOGNIZED_COMMAND;
1165 }
1166 }
1167 if (str) {
1168 if (strlen(str) + 1 > lpParms->dwRetSize) {
1169 ret = MCIERR_PARAM_OVERFLOW;
1170 } else {
1171 lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize);
1172 }
1173 } else {
1174 lpParms->lpstrReturn[0] = 0;
1175 }
1176
1177 return ret;
1178 }
1179
1180 /**************************************************************************
1181 * MCIWAVE_DriverProc [sample driver]
1182 */
1183 LONG CALLBACK MCIWAVE_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
1184 DWORD dwParam1, DWORD dwParam2)
1185 {
1186 TRACE("(%08lX, %04X, %08lX, %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 WAVE_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
1193 case DRV_CLOSE: return WAVE_drvClose(dwDevID);
1194 case DRV_ENABLE: return 1;
1195 case DRV_DISABLE: return 1;
1196 case DRV_QUERYCONFIGURE: return 1;
1197 case DRV_CONFIGURE: MessageBoxA(0, "Sample MultiMedia Driver !", "OSS Driver", MB_OK); return 1;
1198 case DRV_INSTALL: return DRVCNF_RESTART;
1199 case DRV_REMOVE: return DRVCNF_RESTART;
1200 case MCI_OPEN_DRIVER: return WAVE_mciOpen (dwDevID, dwParam1, (LPMCI_WAVE_OPEN_PARMSA) dwParam2);
1201 case MCI_CLOSE_DRIVER: return WAVE_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1202 case MCI_CUE: return WAVE_mciCue (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1203 case MCI_PLAY: return WAVE_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1204 case MCI_RECORD: return WAVE_mciRecord (dwDevID, dwParam1, (LPMCI_RECORD_PARMS) dwParam2);
1205 case MCI_STOP: return WAVE_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1206 case MCI_SET: return WAVE_mciSet (dwDevID, dwParam1, (LPMCI_SET_PARMS) dwParam2);
1207 case MCI_PAUSE: return WAVE_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1208 case MCI_RESUME: return WAVE_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1209 case MCI_STATUS: return WAVE_mciStatus (dwDevID, dwParam1, (LPMCI_STATUS_PARMS) dwParam2);
1210 case MCI_GETDEVCAPS: return WAVE_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1211 case MCI_INFO: return WAVE_mciInfo (dwDevID, dwParam1, (LPMCI_INFO_PARMSA) dwParam2);
1212 case MCI_SEEK: return WAVE_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1213 /* commands that should be supported */
1214 case MCI_LOAD:
1215 case MCI_SAVE:
1216 case MCI_FREEZE:
1217 case MCI_PUT:
1218 case MCI_REALIZE:
1219 case MCI_UNFREEZE:
1220 case MCI_UPDATE:
1221 case MCI_WHERE:
1222 case MCI_STEP:
1223 case MCI_SPIN:
1224 case MCI_ESCAPE:
1225 case MCI_COPY:
1226 case MCI_CUT:
1227 case MCI_DELETE:
1228 case MCI_PASTE:
1229 FIXME("Unsupported yet command [%lu]\n", wMsg);
1230 break;
1231 case MCI_WINDOW:
1232 TRACE("Unsupported command [%lu]\n", wMsg);
1233 break;
1234 case MCI_OPEN:
1235 case MCI_CLOSE:
1236 ERR("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1237 break;
1238 default:
1239 FIXME("is probably wrong msg [%lu]\n", wMsg);
1240 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1241 }
1242 return MCIERR_UNRECOGNIZED_COMMAND;
1243 }
GSOC 2012 project to enhance the control panel