?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement VerSetConditionMask by forwarding to ntdll.
[wine/hacks.git] / dlls / winmm / mciwave / mciwave.c
blob3c19c8b42646697a81d7a6c9705b3fdea0e8213f
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,2000 Eric Pouech
7 * 2000 Francois Jacques
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #include "winerror.h"
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wingdi.h"
28 #include "winuser.h"
29 #include "mmddk.h"
30 #include "wownt32.h"
31 #include "digitalv.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(mciwave);
35
36 typedef struct {
37 UINT wDevID;
38 HANDLE hWave;
39 int nUseCount; /* Incremented for each shared open */
40 BOOL fShareable; /* TRUE if first open was shareable */
41 HMMIO hFile; /* mmio file handle open as Element */
42 MCI_WAVE_OPEN_PARMSA openParms;
43 WAVEFORMATEX wfxRef;
44 LPWAVEFORMATEX lpWaveFormat;
45 BOOL fInput; /* FALSE = Output, TRUE = Input */
46 volatile WORD dwStatus; /* one from MCI_MODE_xxxx */
47 DWORD dwMciTimeFormat;/* One of the supported MCI_FORMAT_xxxx */
48 DWORD dwRemaining; /* remaining bytes to play or record */
49 DWORD dwPosition; /* position in bytes in chunk */
50 HANDLE hEvent; /* for synchronization */
51 DWORD dwEventCount; /* for synchronization */
52 BOOL bTemporaryFile; /* temporary file (MCI_RECORD) */
53 MMCKINFO ckMainRIFF; /* main RIFF chunk */
54 MMCKINFO ckWaveData; /* data chunk */
55 } WINE_MCIWAVE;
56
57 /* ===================================================================
58 * ===================================================================
59 * FIXME: should be using the new mmThreadXXXX functions from WINMM
60 * instead of those
61 * it would require to add a wine internal flag to mmThreadCreate
62 * in order to pass a 32 bit function instead of a 16 bit one
63 * ===================================================================
64 * =================================================================== */
65
66 struct SCA {
67 UINT wDevID;
68 UINT wMsg;
69 DWORD dwParam1;
70 DWORD dwParam2;
71 };
72
73 /**************************************************************************
74 * MCI_SCAStarter [internal]
75 */
76 static DWORD CALLBACK MCI_SCAStarter(LPVOID arg)
77 {
78 struct SCA* sca = (struct SCA*)arg;
79 DWORD ret;
80
81 TRACE("In thread before async command (%08x,%u,%08lx,%08lx)\n",
82 sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
83 ret = mciSendCommandA(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
84 TRACE("In thread after async command (%08x,%u,%08lx,%08lx)\n",
85 sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
86 HeapFree(GetProcessHeap(), 0, sca);
87 ExitThread(ret);
88 WARN("Should not happen ? what's wrong \n");
89 /* should not go after this point */
90 return ret;
91 }
92
93 /**************************************************************************
94 * MCI_SendCommandAsync [internal]
95 */
96 static DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1,
97 DWORD dwParam2, UINT size)
98 {
99 struct SCA* sca = HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA) + size);
100
101 if (sca == 0)
102 return MCIERR_OUT_OF_MEMORY;
103
104 sca->wDevID = wDevID;
105 sca->wMsg = wMsg;
106 sca->dwParam1 = dwParam1;
107
108 if (size && dwParam2) {
109 sca->dwParam2 = (DWORD)sca + sizeof(struct SCA);
110 /* copy structure passed by program in dwParam2 to be sure
111 * we can still use it whatever the program does
112 */
113 memcpy((LPVOID)sca->dwParam2, (LPVOID)dwParam2, size);
114 } else {
115 sca->dwParam2 = dwParam2;
116 }
117
118 if (CreateThread(NULL, 0, MCI_SCAStarter, sca, 0, NULL) == 0) {
119 WARN("Couldn't allocate thread for async command handling, sending synchonously\n");
120 return MCI_SCAStarter(&sca);
121 }
122 return 0;
123 }
124
125 /*======================================================================*
126 * MCI WAVE implemantation *
127 *======================================================================*/
128
129 static DWORD WAVE_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
130
131 /**************************************************************************
132 * MCIWAVE_drvOpen [internal]
133 */
134 static DWORD WAVE_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
135 {
136 WINE_MCIWAVE* wmw;
137
138 if (modp == NULL) return 0xFFFFFFFF;
139
140 wmw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIWAVE));
141
142 if (!wmw)
143 return 0;
144
145 wmw->wDevID = modp->wDeviceID;
146 mciSetDriverData(wmw->wDevID, (DWORD)wmw);
147 modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
148 modp->wType = MCI_DEVTYPE_WAVEFORM_AUDIO;
149
150 wmw->wfxRef.wFormatTag = WAVE_FORMAT_PCM;
151 wmw->wfxRef.nChannels = 1; /* MONO */
152 wmw->wfxRef.nSamplesPerSec = 11025;
153 wmw->wfxRef.nAvgBytesPerSec = 11025;
154 wmw->wfxRef.nBlockAlign = 1;
155 wmw->wfxRef.wBitsPerSample = 8;
156 wmw->wfxRef.cbSize = 0; /* don't care */
157
158 return modp->wDeviceID;
159 }
160
161 /**************************************************************************
162 * MCIWAVE_drvClose [internal]
163 */
164 static DWORD WAVE_drvClose(DWORD dwDevID)
165 {
166 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)mciGetDriverData(dwDevID);
167
168 if (wmw) {
169 HeapFree(GetProcessHeap(), 0, wmw);
170 mciSetDriverData(dwDevID, 0);
171 return 1;
172 }
173 return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
174 }
175
176 /**************************************************************************
177 * WAVE_mciGetOpenDev [internal]
178 */
179 static WINE_MCIWAVE* WAVE_mciGetOpenDev(UINT wDevID)
180 {
181 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)mciGetDriverData(wDevID);
182
183 if (wmw == NULL || wmw->nUseCount == 0) {
184 WARN("Invalid wDevID=%u\n", wDevID);
185 return 0;
186 }
187 return wmw;
188 }
189
190 /**************************************************************************
191 * WAVE_ConvertByteToTimeFormat [internal]
192 */
193 static DWORD WAVE_ConvertByteToTimeFormat(WINE_MCIWAVE* wmw, DWORD val, LPDWORD lpRet)
194 {
195 DWORD ret = 0;
196
197 switch (wmw->dwMciTimeFormat) {
198 case MCI_FORMAT_MILLISECONDS:
199 ret = MulDiv(val,1000,wmw->lpWaveFormat->nAvgBytesPerSec);
200 break;
201 case MCI_FORMAT_BYTES:
202 ret = val;
203 break;
204 case MCI_FORMAT_SAMPLES: /* FIXME: is this correct ? */
205 ret = (val * 8) / wmw->lpWaveFormat->wBitsPerSample;
206 break;
207 default:
208 WARN("Bad time format %lu!\n", wmw->dwMciTimeFormat);
209 }
210 TRACE("val=%lu=0x%08lx [tf=%lu] => ret=%lu\n", val, val, wmw->dwMciTimeFormat, ret);
211 *lpRet = 0;
212 return ret;
213 }
214
215 /**************************************************************************
216 * WAVE_ConvertTimeFormatToByte [internal]
217 */
218 static DWORD WAVE_ConvertTimeFormatToByte(WINE_MCIWAVE* wmw, DWORD val)
219 {
220 DWORD ret = 0;
221
222 switch (wmw->dwMciTimeFormat) {
223 case MCI_FORMAT_MILLISECONDS:
224 ret = (val * wmw->lpWaveFormat->nAvgBytesPerSec) / 1000;
225 break;
226 case MCI_FORMAT_BYTES:
227 ret = val;
228 break;
229 case MCI_FORMAT_SAMPLES: /* FIXME: is this correct ? */
230 ret = (val * wmw->lpWaveFormat->wBitsPerSample) / 8;
231 break;
232 default:
233 WARN("Bad time format %lu!\n", wmw->dwMciTimeFormat);
234 }
235 TRACE("val=%lu=0x%08lx [tf=%lu] => ret=%lu\n", val, val, wmw->dwMciTimeFormat, ret);
236 return ret;
237 }
238
239 /**************************************************************************
240 * WAVE_mciReadFmt [internal]
241 */
242 static DWORD WAVE_mciReadFmt(WINE_MCIWAVE* wmw, MMCKINFO* pckMainRIFF)
243 {
244 MMCKINFO mmckInfo;
245 long r;
246
247 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
248 if (mmioDescend(wmw->hFile, &mmckInfo, pckMainRIFF, MMIO_FINDCHUNK) != 0)
249 return MCIERR_INVALID_FILE;
250 TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
251 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
252
253 wmw->lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
254 r = mmioRead(wmw->hFile, (HPSTR)wmw->lpWaveFormat, mmckInfo.cksize);
255 if (r < sizeof(WAVEFORMAT))
256 return MCIERR_INVALID_FILE;
257
258 TRACE("wFormatTag=%04X !\n", wmw->lpWaveFormat->wFormatTag);
259 TRACE("nChannels=%d \n", wmw->lpWaveFormat->nChannels);
260 TRACE("nSamplesPerSec=%ld\n", wmw->lpWaveFormat->nSamplesPerSec);
261 TRACE("nAvgBytesPerSec=%ld\n", wmw->lpWaveFormat->nAvgBytesPerSec);
262 TRACE("nBlockAlign=%d \n", wmw->lpWaveFormat->nBlockAlign);
263 TRACE("wBitsPerSample=%u !\n", wmw->lpWaveFormat->wBitsPerSample);
264 if (r >= (long)sizeof(WAVEFORMATEX))
265 TRACE("cbSize=%u !\n", wmw->lpWaveFormat->cbSize);
266
267 mmioAscend(wmw->hFile, &mmckInfo, 0);
268 wmw->ckWaveData.ckid = mmioFOURCC('d', 'a', 't', 'a');
269 if (mmioDescend(wmw->hFile, &wmw->ckWaveData, pckMainRIFF, MMIO_FINDCHUNK) != 0) {
270 TRACE("can't find data chunk\n");
271 return MCIERR_INVALID_FILE;
272 }
273 TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
274 (LPSTR)&wmw->ckWaveData.ckid, (LPSTR)&wmw->ckWaveData.fccType, wmw->ckWaveData.cksize);
275 TRACE("nChannels=%d nSamplesPerSec=%ld\n",
276 wmw->lpWaveFormat->nChannels, wmw->lpWaveFormat->nSamplesPerSec);
277
278 return 0;
279 }
280
281 /**************************************************************************
282 * WAVE_mciCreateRIFFSkeleton [internal]
283 */
284 static DWORD WAVE_mciCreateRIFFSkeleton(WINE_MCIWAVE* wmw)
285 {
286 MMCKINFO ckWaveFormat;
287
288 LPMMCKINFO lpckRIFF = &(wmw->ckMainRIFF);
289 LPMMCKINFO lpckWaveData = &(wmw->ckWaveData);
290 LPWAVEFORMATEX lpWaveFormat = wmw->lpWaveFormat;
291
292
293 HMMIO hmmio = wmw->hFile;
294
295 lpckRIFF->ckid = FOURCC_RIFF;
296 lpckRIFF->fccType = mmioFOURCC('W', 'A', 'V', 'E');
297 lpckRIFF->cksize = 0;
298
299 if (MMSYSERR_NOERROR != mmioCreateChunk(hmmio, lpckRIFF, MMIO_CREATERIFF))
300 goto err;
301
302 ckWaveFormat.fccType = 0;
303 ckWaveFormat.ckid = mmioFOURCC('f', 'm', 't', ' ');
304 ckWaveFormat.cksize = 16;
305
306 if (!lpWaveFormat)
307 {
308 /* FIXME: for non PCM formats, the size of the waveFormat has to be
309 * gotten
310 */
311 lpWaveFormat = wmw->lpWaveFormat = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*lpWaveFormat));
312
313 memcpy(lpWaveFormat, &wmw->wfxRef, sizeof(wmw->wfxRef));
314 }
315
316 if (MMSYSERR_NOERROR != mmioCreateChunk(hmmio, &ckWaveFormat, 0))
317 goto err;
318
319 /* only the first 16 bytes are serialized */
320 /* wrong... for non PCM, the whole waveFormat is stored
321 */
322 if (-1 == mmioWrite(hmmio, (HPCSTR) lpWaveFormat, 16))
323 goto err;
324
325 if (MMSYSERR_NOERROR != mmioAscend(hmmio, &ckWaveFormat, 0))
326 goto err;
327
328 lpckWaveData->cksize = 0;
329 lpckWaveData->fccType = 0;
330 lpckWaveData->ckid = mmioFOURCC('d', 'a', 't', 'a');
331
332 /* create data chunk */
333 if (MMSYSERR_NOERROR != mmioCreateChunk(hmmio, lpckWaveData, 0))
334 goto err;
335
336 return 0;
337
338 err:
339 HeapFree(GetProcessHeap(), 0, wmw->lpWaveFormat);
340 return MCIERR_INVALID_FILE;
341 }
342
343 /**************************************************************************
344 * WAVE_mciOpen [internal]
345 */
346 static DWORD WAVE_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMSA lpOpenParms)
347 {
348 DWORD dwRet = 0;
349 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)mciGetDriverData(wDevID);
350 CHAR* pszTmpFileName = 0;
351
352 TRACE("(%04X, %08lX, %p)\n", wDevID, dwFlags, lpOpenParms);
353 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
354 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
355
356 if (dwFlags & MCI_OPEN_SHAREABLE)
357 return MCIERR_HARDWARE;
358
359 if (wmw->nUseCount > 0) {
360 /* The driver is already opened on this channel
361 * Wave driver cannot be shared
362 */
363 return MCIERR_DEVICE_OPEN;
364 }
365
366 wmw->nUseCount++;
367
368 wmw->fInput = FALSE;
369 wmw->hWave = 0;
370 wmw->dwStatus = MCI_MODE_NOT_READY;
371
372 TRACE("wDevID=%04X (lpParams->wDeviceID=%08X)\n", wDevID, lpOpenParms->wDeviceID);
373
374 if (dwFlags & MCI_OPEN_ELEMENT) {
375 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
376 /* could it be that (DWORD)lpOpenParms->lpstrElementName
377 * contains the hFile value ?
378 */
379 dwRet = MCIERR_UNRECOGNIZED_COMMAND;
380 } else {
381 if (strlen(lpOpenParms->lpstrElementName) > 0) {
382 lpOpenParms->lpstrElementName = lpOpenParms->lpstrElementName;
383
384 /* FIXME : what should be done id wmw->hFile is already != 0, or the driver is playin' */
385 TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpOpenParms->lpstrElementName);
386
387 if (lpOpenParms->lpstrElementName && (strlen(lpOpenParms->lpstrElementName) > 0)) {
388 wmw->hFile = mmioOpenA((LPSTR)lpOpenParms->lpstrElementName, NULL,
389 MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READWRITE);
390
391 if (wmw->hFile == 0) {
392 WARN("can't find file='%s' !\n", lpOpenParms->lpstrElementName);
393 dwRet = MCIERR_FILE_NOT_FOUND;
394 }
395 else
396 {
397 LPMMCKINFO lpckMainRIFF = &wmw->ckMainRIFF;
398
399 /* make sure we're are the beginning of the file */
400 mmioSeek(wmw->hFile, 0, SEEK_SET);
401
402 /* first reading of this file. read the waveformat chunk */
403 if (mmioDescend(wmw->hFile, lpckMainRIFF, NULL, 0) != 0) {
404 dwRet = MCIERR_INVALID_FILE;
405 } else {
406 TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
407 (LPSTR)&(lpckMainRIFF->ckid),
408 (LPSTR) &(lpckMainRIFF->fccType),
409 (lpckMainRIFF->cksize));
410
411 if ((lpckMainRIFF->ckid != FOURCC_RIFF) ||
412 lpckMainRIFF->fccType != mmioFOURCC('W', 'A', 'V', 'E')) {
413 dwRet = MCIERR_INVALID_FILE;
414 } else {
415 dwRet = WAVE_mciReadFmt(wmw, lpckMainRIFF);
416 }
417 }
418 }
419 }
420 else {
421 wmw->hFile = 0;
422 }
423 }
424 else {
425 CHAR szTmpPath[MAX_PATH];
426 CHAR szPrefix[4] = "TMP\0";
427
428 pszTmpFileName = HeapAlloc(GetProcessHeap(),
429 HEAP_ZERO_MEMORY,
430 MAX_PATH * sizeof(*pszTmpFileName));
431
432 if (!GetTempPathA(sizeof(szTmpPath), szTmpPath)) {
433 WARN("can't retrieve temp path!\n");
434 HeapFree(GetProcessHeap(), 0, pszTmpFileName);
435 return MCIERR_FILE_NOT_FOUND;
436 }
437
438 if (!GetTempFileNameA(szTmpPath, szPrefix, 0, pszTmpFileName)) {
439 WARN("can't retrieve temp file name!\n");
440 HeapFree(GetProcessHeap(), 0, pszTmpFileName);
441 return MCIERR_FILE_NOT_FOUND;
442 }
443
444 wmw->bTemporaryFile = TRUE;
445
446 TRACE("MCI_OPEN_ELEMENT '%s' !\n", pszTmpFileName);
447
448 if (pszTmpFileName && (strlen(pszTmpFileName) > 0)) {
449
450 wmw->hFile = mmioOpenA(pszTmpFileName, NULL,
451 MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_CREATE);
452
453 if (wmw->hFile == 0) {
454 /* temporary file could not be created. clean filename. */
455 HeapFree(GetProcessHeap(), 0, pszTmpFileName);
456 WARN("can't create file='%s' !\n", pszTmpFileName);
457 dwRet = MCIERR_FILE_NOT_FOUND;
458 }
459 }
460 }
461 }
462 }
463
464 TRACE("hFile=%p\n", wmw->hFile);
465
466 memcpy(&wmw->openParms, lpOpenParms, sizeof(MCI_WAVE_OPEN_PARMSA));
467
468 if (wmw->bTemporaryFile == TRUE)
469 {
470 /* Additional openParms is temporary file's name */
471 wmw->openParms.lpstrElementName = pszTmpFileName;
472 }
473
474 if (dwRet == 0) {
475 if (wmw->lpWaveFormat) {
476 switch (wmw->lpWaveFormat->wFormatTag) {
477 case WAVE_FORMAT_PCM:
478 if (wmw->lpWaveFormat->nAvgBytesPerSec !=
479 wmw->lpWaveFormat->nSamplesPerSec * wmw->lpWaveFormat->nBlockAlign) {
480 WARN("Incorrect nAvgBytesPerSec (%ld), setting it to %ld\n",
481 wmw->lpWaveFormat->nAvgBytesPerSec,
482 wmw->lpWaveFormat->nSamplesPerSec *
483 wmw->lpWaveFormat->nBlockAlign);
484 wmw->lpWaveFormat->nAvgBytesPerSec =
485 wmw->lpWaveFormat->nSamplesPerSec *
486 wmw->lpWaveFormat->nBlockAlign;
487 }
488 break;
489 }
490 }
491 wmw->dwPosition = 0;
492
493 wmw->dwStatus = MCI_MODE_STOP;
494 } else {
495 wmw->nUseCount--;
496 if (wmw->hFile != 0)
497 mmioClose(wmw->hFile, 0);
498 wmw->hFile = 0;
499 }
500 return dwRet;
501 }
502
503 /**************************************************************************
504 * WAVE_mciCue [internal]
505 */
506 static DWORD WAVE_mciCue(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
507 {
508 /*
509 FIXME
510
511 This routine is far from complete. At the moment only a check is done on the
512 MCI_WAVE_INPUT flag. No explicit check on MCI_WAVE_OUTPUT is done since that
513 is the default.
514
515 The flags MCI_NOTIFY (and the callback parameter in lpParms) and MCI_WAIT
516 are ignored
517 */
518
519 DWORD dwRet;
520 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
521
522 FIXME("(%u, %08lX, %p); likely to fail\n", wDevID, dwParam, lpParms);
523
524 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
525
526 /* always close elements ? */
527 if (wmw->hFile != 0) {
528 mmioClose(wmw->hFile, 0);
529 wmw->hFile = 0;
530 }
531
532 dwRet = MMSYSERR_NOERROR; /* assume success */
533
534 if ((dwParam & MCI_WAVE_INPUT) && !wmw->fInput) {
535 dwRet = waveOutClose(wmw->hWave);
536 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
537 wmw->fInput = TRUE;
538 } else if (wmw->fInput) {
539 dwRet = waveInClose(wmw->hWave);
540 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
541 wmw->fInput = FALSE;
542 }
543 wmw->hWave = 0;
544 return (dwRet == MMSYSERR_NOERROR) ? 0 : MCIERR_INTERNAL;
545 }
546
547 /**************************************************************************
548 * WAVE_mciStop [internal]
549 */
550 static DWORD WAVE_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
551 {
552 DWORD dwRet = 0;
553 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
554
555 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
556
557 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
558
559 /* wait for playback thread (if any) to exit before processing further */
560 switch (wmw->dwStatus) {
561 case MCI_MODE_PAUSE:
562 case MCI_MODE_PLAY:
563 case MCI_MODE_RECORD:
564 {
565 int oldStat = wmw->dwStatus;
566 wmw->dwStatus = MCI_MODE_NOT_READY;
567 if (oldStat == MCI_MODE_PAUSE)
568 dwRet = (wmw->fInput) ? waveInReset(wmw->hWave) : waveOutReset(wmw->hWave);
569 }
570 while (wmw->dwStatus != MCI_MODE_STOP)
571 Sleep(10);
572 break;
573 }
574
575 wmw->dwPosition = 0;
576
577 /* sanity resets */
578 wmw->dwStatus = MCI_MODE_STOP;
579
580 if ((dwFlags & MCI_NOTIFY) && lpParms) {
581 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
582 wmw->openParms.wDeviceID, MCI_NOTIFY_SUCCESSFUL);
583 }
584
585 return dwRet;
586 }
587
588 /**************************************************************************
589 * WAVE_mciClose [internal]
590 */
591 static DWORD WAVE_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
592 {
593 DWORD dwRet = 0;
594 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
595
596 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
597
598 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
599
600 if (wmw->dwStatus != MCI_MODE_STOP) {
601 dwRet = WAVE_mciStop(wDevID, MCI_WAIT, lpParms);
602 }
603
604 wmw->nUseCount--;
605
606 if (wmw->nUseCount == 0) {
607 if (wmw->hFile != 0) {
608 mmioClose(wmw->hFile, 0);
609 wmw->hFile = 0;
610 }
611 }
612
613 /* That string got allocated in mciOpen because no filename was specified
614 * in MCI_OPEN_PARMS stucture. Cast-away const from string since it was
615 * allocated by mciOpen, *NOT* the application.
616 */
617 if (wmw->bTemporaryFile)
618 {
619 HeapFree(GetProcessHeap(), 0, (CHAR*) wmw->openParms.lpstrElementName);
620 wmw->openParms.lpstrElementName = NULL;
621 }
622
623 HeapFree(GetProcessHeap(), 0, wmw->lpWaveFormat);
624 wmw->lpWaveFormat = NULL;
625
626 if ((dwFlags & MCI_NOTIFY) && lpParms) {
627 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
628 wmw->openParms.wDeviceID,
629 (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
630 }
631
632 return 0;
633 }
634
635 /**************************************************************************
636 * WAVE_mciPlayCallback [internal]
637 */
638 static void CALLBACK WAVE_mciPlayCallback(HWAVEOUT hwo, UINT uMsg,
639 DWORD dwInstance,
640 DWORD dwParam1, DWORD dwParam2)
641 {
642 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)dwInstance;
643
644 switch (uMsg) {
645 case WOM_OPEN:
646 case WOM_CLOSE:
647 break;
648 case WOM_DONE:
649 InterlockedIncrement(&wmw->dwEventCount);
650 TRACE("Returning waveHdr=%lx\n", dwParam1);
651 SetEvent(wmw->hEvent);
652 break;
653 default:
654 ERR("Unknown uMsg=%d\n", uMsg);
655 }
656 }
657
658 static void WAVE_mciPlayWaitDone(WINE_MCIWAVE* wmw)
659 {
660 for (;;) {
661 ResetEvent(wmw->hEvent);
662 if (InterlockedDecrement(&wmw->dwEventCount) >= 0) {
663 break;
664 }
665 InterlockedIncrement(&wmw->dwEventCount);
666
667 WaitForSingleObject(wmw->hEvent, INFINITE);
668 }
669 }
670
671 /**************************************************************************
672 * WAVE_mciPlay [internal]
673 */
674 static DWORD WAVE_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
675 {
676 DWORD end;
677 LONG bufsize, count, left;
678 DWORD dwRet = 0;
679 LPWAVEHDR waveHdr = NULL;
680 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
681 int whidx;
682
683 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
684
685 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
686 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
687
688 /* FIXME : since there is no way to determine in which mode the device is
689 * open (recording/playback) automatically switch from a mode to another
690 */
691 wmw->fInput = FALSE;
692
693 if (wmw->fInput) {
694 WARN("cannot play on input device\n");
695 return MCIERR_NONAPPLICABLE_FUNCTION;
696 }
697
698 if (wmw->hFile == 0) {
699 WARN("Can't play: no file='%s' !\n", wmw->openParms.lpstrElementName);
700 return MCIERR_FILE_NOT_FOUND;
701 }
702
703 if (wmw->dwStatus == MCI_MODE_PAUSE) {
704 /* FIXME: parameters (start/end) in lpParams may not be used */
705 return WAVE_mciResume(wDevID, dwFlags, (LPMCI_GENERIC_PARMS)lpParms);
706 }
707
708 /** This function will be called again by a thread when async is used.
709 * We have to set MCI_MODE_PLAY before we do this so that the app can spin
710 * on MCI_STATUS, so we have to allow it here if we're not going to start this thread.
711 */
712 if ((wmw->dwStatus != MCI_MODE_STOP) && ((wmw->dwStatus != MCI_MODE_PLAY) && (dwFlags & MCI_WAIT))) {
713 return MCIERR_INTERNAL;
714 }
715
716 wmw->dwStatus = MCI_MODE_PLAY;
717
718 if (!(dwFlags & MCI_WAIT)) {
719 return MCI_SendCommandAsync(wmw->openParms.wDeviceID, MCI_PLAY, dwFlags,
720 (DWORD)lpParms, sizeof(MCI_PLAY_PARMS));
721 }
722
723 end = 0xFFFFFFFF;
724 if (lpParms && (dwFlags & MCI_FROM)) {
725 wmw->dwPosition = WAVE_ConvertTimeFormatToByte(wmw, lpParms->dwFrom);
726 }
727 if (lpParms && (dwFlags & MCI_TO)) {
728 end = WAVE_ConvertTimeFormatToByte(wmw, lpParms->dwTo);
729 }
730
731 TRACE("Playing from byte=%lu to byte=%lu\n", wmw->dwPosition, end);
732
733 if (end <= wmw->dwPosition)
734 return TRUE;
735
736
737 #define WAVE_ALIGN_ON_BLOCK(wmw,v) \
738 ((((v) + (wmw)->lpWaveFormat->nBlockAlign - 1) / (wmw)->lpWaveFormat->nBlockAlign) * (wmw)->lpWaveFormat->nBlockAlign)
739
740 wmw->dwPosition = WAVE_ALIGN_ON_BLOCK(wmw, wmw->dwPosition);
741 wmw->ckWaveData.cksize = WAVE_ALIGN_ON_BLOCK(wmw, wmw->ckWaveData.cksize);
742
743 if (dwRet == 0) {
744 if (wmw->lpWaveFormat) {
745 switch (wmw->lpWaveFormat->wFormatTag) {
746 case WAVE_FORMAT_PCM:
747 if (wmw->lpWaveFormat->nAvgBytesPerSec !=
748 wmw->lpWaveFormat->nSamplesPerSec * wmw->lpWaveFormat->nBlockAlign) {
749 WARN("Incorrect nAvgBytesPerSec (%ld), setting it to %ld\n",
750 wmw->lpWaveFormat->nAvgBytesPerSec,
751 wmw->lpWaveFormat->nSamplesPerSec *
752 wmw->lpWaveFormat->nBlockAlign);
753 wmw->lpWaveFormat->nAvgBytesPerSec =
754 wmw->lpWaveFormat->nSamplesPerSec *
755 wmw->lpWaveFormat->nBlockAlign;
756 }
757 break;
758 }
759 }
760 } else {
761 TRACE("can't retrieve wave format %ld\n", dwRet);
762 goto cleanUp;
763 }
764
765
766 /* go back to beginning of chunk plus the requested position */
767 /* FIXME: I'm not sure this is correct, notably because some data linked to
768 * the decompression state machine will not be correcly initialized.
769 * try it this way (other way would be to decompress from 0 up to dwPosition
770 * and to start sending to hWave when dwPosition is reached)
771 */
772 mmioSeek(wmw->hFile, wmw->ckWaveData.dwDataOffset + wmw->dwPosition, SEEK_SET); /* >= 0 */
773
774 /* By default the device will be opened for output, the MCI_CUE function is there to
775 * change from output to input and back
776 */
777 /* FIXME: how to choose between several output channels ? here mapper is forced */
778 dwRet = waveOutOpen((HWAVEOUT *)&wmw->hWave, WAVE_MAPPER, wmw->lpWaveFormat,
779 (DWORD)WAVE_mciPlayCallback, (DWORD)wmw, CALLBACK_FUNCTION);
780
781 if (dwRet != 0) {
782 TRACE("Can't open low level audio device %ld\n", dwRet);
783 dwRet = MCIERR_DEVICE_OPEN;
784 wmw->hWave = 0;
785 goto cleanUp;
786 }
787
788 /* make it so that 3 buffers per second are needed */
789 bufsize = WAVE_ALIGN_ON_BLOCK(wmw, wmw->lpWaveFormat->nAvgBytesPerSec / 3);
790
791 waveHdr = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(WAVEHDR) + 2 * bufsize);
792 waveHdr[0].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR);
793 waveHdr[1].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR) + bufsize;
794 waveHdr[0].dwUser = waveHdr[1].dwUser = 0L;
795 waveHdr[0].dwLoops = waveHdr[1].dwLoops = 0L;
796 waveHdr[0].dwFlags = waveHdr[1].dwFlags = 0L;
797 waveHdr[0].dwBufferLength = waveHdr[1].dwBufferLength = bufsize;
798 if (waveOutPrepareHeader(wmw->hWave, &waveHdr[0], sizeof(WAVEHDR)) ||
799 waveOutPrepareHeader(wmw->hWave, &waveHdr[1], sizeof(WAVEHDR))) {
800 dwRet = MCIERR_INTERNAL;
801 goto cleanUp;
802 }
803
804 whidx = 0;
805 left = min(wmw->ckWaveData.cksize, end - wmw->dwPosition);
806 wmw->hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
807 wmw->dwEventCount = 1L; /* for first buffer */
808
809 TRACE("Playing (normalized) from byte=%lu for %lu bytes\n", wmw->dwPosition, left);
810
811 /* FIXME: this doesn't work if wmw->dwPosition != 0 */
812 while (left > 0 && wmw->dwStatus != MCI_MODE_STOP && wmw->dwStatus != MCI_MODE_NOT_READY) {
813 count = mmioRead(wmw->hFile, waveHdr[whidx].lpData, min(bufsize, left));
814 TRACE("mmioRead bufsize=%ld count=%ld\n", bufsize, count);
815 if (count < 1)
816 break;
817 /* count is always <= bufsize, so this is correct regarding the
818 * waveOutPrepareHeader function
819 */
820 waveHdr[whidx].dwBufferLength = count;
821 waveHdr[whidx].dwFlags &= ~WHDR_DONE;
822 TRACE("before WODM_WRITE lpWaveHdr=%p dwBufferLength=%lu dwBytesRecorded=%lu\n",
823 &waveHdr[whidx], waveHdr[whidx].dwBufferLength,
824 waveHdr[whidx].dwBytesRecorded);
825 dwRet = waveOutWrite(wmw->hWave, &waveHdr[whidx], sizeof(WAVEHDR));
826 left -= count;
827 wmw->dwPosition += count;
828 TRACE("after WODM_WRITE dwPosition=%lu\n", wmw->dwPosition);
829
830 WAVE_mciPlayWaitDone(wmw);
831 whidx ^= 1;
832 }
833
834 WAVE_mciPlayWaitDone(wmw); /* to balance first buffer */
835
836 /* just to get rid of some race conditions between play, stop and pause */
837 waveOutReset(wmw->hWave);
838
839 waveOutUnprepareHeader(wmw->hWave, &waveHdr[0], sizeof(WAVEHDR));
840 waveOutUnprepareHeader(wmw->hWave, &waveHdr[1], sizeof(WAVEHDR));
841
842 dwRet = 0;
843
844 cleanUp:
845 HeapFree(GetProcessHeap(), 0, waveHdr);
846
847 if (wmw->hWave) {
848 waveOutClose(wmw->hWave);
849 wmw->hWave = 0;
850 }
851 CloseHandle(wmw->hEvent);
852
853 if (lpParms && (dwFlags & MCI_NOTIFY)) {
854 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
855 wmw->openParms.wDeviceID,
856 dwRet ? MCI_NOTIFY_FAILURE : MCI_NOTIFY_SUCCESSFUL);
857 }
858
859 wmw->dwStatus = MCI_MODE_STOP;
860
861 return dwRet;
862 }
863
864 /**************************************************************************
865 * WAVE_mciPlayCallback [internal]
866 */
867 static void CALLBACK WAVE_mciRecordCallback(HWAVEOUT hwo, UINT uMsg,
868 DWORD dwInstance,
869 DWORD dwParam1, DWORD dwParam2)
870 {
871 WINE_MCIWAVE* wmw = (WINE_MCIWAVE*)dwInstance;
872 LPWAVEHDR lpWaveHdr = NULL;
873 LONG count = 0;
874 switch (uMsg) {
875 case WIM_OPEN:
876 case WIM_CLOSE:
877 break;
878 case WIM_DATA:
879 lpWaveHdr = (LPWAVEHDR) dwParam1;
880
881 InterlockedIncrement(&wmw->dwEventCount);
882
883 count = mmioWrite(wmw->hFile, lpWaveHdr->lpData, lpWaveHdr->dwBytesRecorded);
884
885 lpWaveHdr->dwFlags &= ~WHDR_DONE;
886 wmw->dwPosition += count;
887 wmw->dwRemaining -= count;
888
889 if (wmw->dwStatus == MCI_MODE_RECORD)
890 {
891 /* Only queue up another buffer if we are recording. We could receive this
892 message also when waveInReset() is called, since it notifies on all wave
893 buffers that are outstanding. Queueing up more sometimes causes waveInClose
894 to fail. */
895 waveInAddBuffer(wmw->hWave, lpWaveHdr, sizeof(*lpWaveHdr));
896 TRACE("after mmioWrite dwPosition=%lu\n", wmw->dwPosition);
897 }
898
899 SetEvent(wmw->hEvent);
900 break;
901 default:
902 ERR("Unknown uMsg=%d\n", uMsg);
903 }
904 }
905
906 static void WAVE_mciRecordWaitDone(WINE_MCIWAVE* wmw)
907 {
908 for (;;) {
909 ResetEvent(wmw->hEvent);
910 if (InterlockedDecrement(&wmw->dwEventCount) >= 0) {
911 break;
912 }
913 InterlockedIncrement(&wmw->dwEventCount);
914
915 WaitForSingleObject(wmw->hEvent, INFINITE);
916 }
917 }
918
919 /**************************************************************************
920 * WAVE_mciRecord [internal]
921 */
922 static DWORD WAVE_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
923 {
924 DWORD end;
925 DWORD dwRet = 0;
926 LONG bufsize;
927 LPWAVEHDR waveHdr = NULL;
928 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
929
930
931 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
932
933 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
934 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
935
936 /* FIXME : since there is no way to determine in which mode the device is
937 * open (recording/playback) automatically switch from a mode to another
938 */
939 wmw->fInput = TRUE;
940
941 if (!wmw->fInput) {
942 WARN("cannot record on output device\n");
943 return MCIERR_NONAPPLICABLE_FUNCTION;
944 }
945
946 if (wmw->dwStatus == MCI_MODE_PAUSE) {
947 /* FIXME: parameters (start/end) in lpParams may not be used */
948 return WAVE_mciResume(wDevID, dwFlags, (LPMCI_GENERIC_PARMS)lpParms);
949 }
950
951 /** This function will be called again by a thread when async is used.
952 * We have to set MCI_MODE_PLAY before we do this so that the app can spin
953 * on MCI_STATUS, so we have to allow it here if we're not going to start this thread.
954 */
955 if ((wmw->dwStatus != MCI_MODE_STOP) && ((wmw->dwStatus != MCI_MODE_RECORD) && (dwFlags & MCI_WAIT))) {
956 return MCIERR_INTERNAL;
957 }
958
959 wmw->dwStatus = MCI_MODE_RECORD;
960
961 if (!(dwFlags & MCI_WAIT)) {
962 return MCI_SendCommandAsync(wmw->openParms.wDeviceID, MCI_RECORD, dwFlags,
963 (DWORD)lpParms, sizeof(MCI_RECORD_PARMS));
964 }
965
966 if (!wmw->lpWaveFormat)
967 {
968 /* new RIFF file */
969 dwRet = WAVE_mciCreateRIFFSkeleton(wmw);
970 } else
971 {
972 FIXME("Should descend into data chunk. Please report.\n");
973 }
974
975 end = 0xFFFFFFFF;
976 if (lpParms && (dwFlags & MCI_FROM)) {
977 wmw->dwPosition = WAVE_ConvertTimeFormatToByte(wmw, lpParms->dwFrom);
978 }
979
980 if (lpParms && (dwFlags & MCI_TO)) {
981 end = WAVE_ConvertTimeFormatToByte(wmw, lpParms->dwTo);
982 }
983
984 TRACE("Recording from byte=%lu to byte=%lu\n", wmw->dwPosition, end);
985
986 if (end <= wmw->dwPosition)
987 {
988 return TRUE;
989 }
990
991 #define WAVE_ALIGN_ON_BLOCK(wmw,v) \
992 ((((v) + (wmw)->lpWaveFormat->nBlockAlign - 1) / (wmw)->lpWaveFormat->nBlockAlign) * (wmw)->lpWaveFormat->nBlockAlign)
993
994 wmw->dwPosition = WAVE_ALIGN_ON_BLOCK(wmw, wmw->dwPosition);
995 wmw->ckWaveData.cksize = WAVE_ALIGN_ON_BLOCK(wmw, wmw->ckWaveData.cksize);
996
997 /* go back to beginning of chunk plus the requested position */
998 /* FIXME: I'm not sure this is correct, notably because some data linked to
999 * the decompression state machine will not be correcly initialized.
1000 * try it this way (other way would be to decompress from 0 up to dwPosition
1001 * and to start sending to hWave when dwPosition is reached)
1002 */
1003 mmioSeek(wmw->hFile, wmw->ckWaveData.dwDataOffset + wmw->dwPosition, SEEK_SET); /* >= 0 */
1004
1005 /* By default the device will be opened for output, the MCI_CUE function is there to
1006 * change from output to input and back
1007 */
1008 /* FIXME: how to choose between several output channels ? here mapper is forced */
1009 dwRet = waveInOpen((HWAVEIN*)&wmw->hWave, WAVE_MAPPER, wmw->lpWaveFormat,
1010 (DWORD)WAVE_mciRecordCallback, (DWORD)wmw, CALLBACK_FUNCTION);
1011
1012 if (dwRet != 0) {
1013 TRACE("Can't open low level audio device %ld\n", dwRet);
1014 dwRet = MCIERR_DEVICE_OPEN;
1015 wmw->hWave = 0;
1016 goto cleanUp;
1017 }
1018
1019 /* make it so that 3 buffers per second are needed */
1020 bufsize = WAVE_ALIGN_ON_BLOCK(wmw, wmw->lpWaveFormat->nAvgBytesPerSec / 3);
1021
1022 waveHdr = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(WAVEHDR) + 2 * bufsize);
1023 waveHdr[0].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR);
1024 waveHdr[1].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR) + bufsize;
1025 waveHdr[0].dwUser = waveHdr[1].dwUser = 0L;
1026 waveHdr[0].dwLoops = waveHdr[1].dwLoops = 0L;
1027 waveHdr[0].dwFlags = waveHdr[1].dwFlags = 0L;
1028 waveHdr[0].dwBufferLength = waveHdr[1].dwBufferLength = bufsize;
1029
1030 if (waveInPrepareHeader(wmw->hWave, &waveHdr[0], sizeof(WAVEHDR)) ||
1031 waveInPrepareHeader(wmw->hWave, &waveHdr[1], sizeof(WAVEHDR))) {
1032 dwRet = MCIERR_INTERNAL;
1033 goto cleanUp;
1034 }
1035
1036 if (waveInAddBuffer(wmw->hWave, &waveHdr[0], sizeof(WAVEHDR)) ||
1037 waveInAddBuffer(wmw->hWave, &waveHdr[1], sizeof(WAVEHDR))) {
1038 dwRet = MCIERR_INTERNAL;
1039 goto cleanUp;
1040 }
1041
1042 wmw->hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1043 wmw->dwEventCount = 1L; /* for first buffer */
1044
1045 wmw->dwRemaining = end - wmw->dwPosition;
1046
1047 TRACE("Recording (normalized) from byte=%lu for %lu bytes\n", wmw->dwPosition, wmw->dwRemaining);
1048
1049 dwRet = waveInStart(wmw->hWave);
1050
1051 while ( wmw->dwRemaining > 0 && wmw->dwStatus != MCI_MODE_STOP && wmw->dwStatus != MCI_MODE_NOT_READY) {
1052 WAVE_mciRecordWaitDone(wmw);
1053 }
1054
1055 /* needed so that the callback above won't add again the buffers returned by the reset */
1056 wmw->dwStatus = MCI_MODE_STOP;
1057
1058 waveInReset(wmw->hWave);
1059
1060 waveInUnprepareHeader(wmw->hWave, &waveHdr[0], sizeof(WAVEHDR));
1061 waveInUnprepareHeader(wmw->hWave, &waveHdr[1], sizeof(WAVEHDR));
1062
1063 dwRet = 0;
1064
1065 cleanUp:
1066 HeapFree(GetProcessHeap(), 0, waveHdr);
1067
1068 if (wmw->hWave) {
1069 waveInClose(wmw->hWave);
1070 wmw->hWave = 0;
1071 }
1072 CloseHandle(wmw->hEvent);
1073
1074 /* need to update the size of the data chunk */
1075 if (mmioAscend(wmw->hFile, &wmw->ckWaveData, 0) != MMSYSERR_NOERROR) {
1076 TRACE("failed on ascend\n");
1077 }
1078
1079 if (lpParms && (dwFlags & MCI_NOTIFY)) {
1080 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
1081 wmw->openParms.wDeviceID,
1082 dwRet ? MCI_NOTIFY_FAILURE : MCI_NOTIFY_SUCCESSFUL);
1083 }
1084
1085 wmw->dwStatus = MCI_MODE_STOP;
1086
1087 return dwRet;
1088
1089 }
1090
1091 /**************************************************************************
1092 * WAVE_mciPause [internal]
1093 */
1094 static DWORD WAVE_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1095 {
1096 DWORD dwRet;
1097 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1098
1099 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1100
1101 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1102 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
1103
1104 if (wmw->dwStatus == MCI_MODE_PLAY) {
1105 wmw->dwStatus = MCI_MODE_PAUSE;
1106 }
1107
1108 if (wmw->fInput) dwRet = waveInStop(wmw->hWave);
1109 else dwRet = waveOutPause(wmw->hWave);
1110
1111 return (dwRet == MMSYSERR_NOERROR) ? 0 : MCIERR_INTERNAL;
1112 }
1113
1114 /**************************************************************************
1115 * WAVE_mciResume [internal]
1116 */
1117 static DWORD WAVE_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1118 {
1119 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1120 DWORD dwRet = 0;
1121
1122 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1123
1124 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
1125
1126 if (wmw->dwStatus == MCI_MODE_PAUSE) {
1127 wmw->dwStatus = MCI_MODE_PLAY;
1128 }
1129
1130 if (wmw->fInput) dwRet = waveInStart(wmw->hWave);
1131 else dwRet = waveOutRestart(wmw->hWave);
1132 return (dwRet == MMSYSERR_NOERROR) ? 0 : MCIERR_INTERNAL;
1133 }
1134
1135 /**************************************************************************
1136 * WAVE_mciSeek [internal]
1137 */
1138 static DWORD WAVE_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
1139 {
1140 DWORD ret = 0;
1141 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1142
1143 TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1144
1145 if (lpParms == NULL) {
1146 ret = MCIERR_NULL_PARAMETER_BLOCK;
1147 } else if (wmw == NULL) {
1148 ret = MCIERR_INVALID_DEVICE_ID;
1149 } else {
1150 WAVE_mciStop(wDevID, MCI_WAIT, 0);
1151
1152 if (dwFlags & MCI_SEEK_TO_START) {
1153 wmw->dwPosition = 0;
1154 } else if (dwFlags & MCI_SEEK_TO_END) {
1155 wmw->dwPosition = wmw->ckWaveData.cksize;
1156 } else if (dwFlags & MCI_TO) {
1157 wmw->dwPosition = WAVE_ConvertTimeFormatToByte(wmw, lpParms->dwTo);
1158 } else {
1159 WARN("dwFlag doesn't tell where to seek to...\n");
1160 return MCIERR_MISSING_PARAMETER;
1161 }
1162
1163 TRACE("Seeking to position=%lu bytes\n", wmw->dwPosition);
1164
1165 if (dwFlags & MCI_NOTIFY) {
1166 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
1167 wmw->openParms.wDeviceID, MCI_NOTIFY_SUCCESSFUL);
1168 }
1169 }
1170 return ret;
1171 }
1172
1173 /**************************************************************************
1174 * WAVE_mciSet [internal]
1175 */
1176 static DWORD WAVE_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
1177 {
1178 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1179
1180 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1181
1182 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1183 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
1184
1185 if (dwFlags & MCI_SET_TIME_FORMAT) {
1186 switch (lpParms->dwTimeFormat) {
1187 case MCI_FORMAT_MILLISECONDS:
1188 TRACE("MCI_FORMAT_MILLISECONDS !\n");
1189 wmw->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
1190 break;
1191 case MCI_FORMAT_BYTES:
1192 TRACE("MCI_FORMAT_BYTES !\n");
1193 wmw->dwMciTimeFormat = MCI_FORMAT_BYTES;
1194 break;
1195 case MCI_FORMAT_SAMPLES:
1196 TRACE("MCI_FORMAT_SAMPLES !\n");
1197 wmw->dwMciTimeFormat = MCI_FORMAT_SAMPLES;
1198 break;
1199 default:
1200 WARN("Bad time format %lu!\n", lpParms->dwTimeFormat);
1201 return MCIERR_BAD_TIME_FORMAT;
1202 }
1203 }
1204 if (dwFlags & MCI_SET_VIDEO) {
1205 TRACE("No support for video !\n");
1206 return MCIERR_UNSUPPORTED_FUNCTION;
1207 }
1208 if (dwFlags & MCI_SET_DOOR_OPEN) {
1209 TRACE("No support for door open !\n");
1210 return MCIERR_UNSUPPORTED_FUNCTION;
1211 }
1212 if (dwFlags & MCI_SET_DOOR_CLOSED) {
1213 TRACE("No support for door close !\n");
1214 return MCIERR_UNSUPPORTED_FUNCTION;
1215 }
1216 if (dwFlags & MCI_SET_AUDIO) {
1217 if (dwFlags & MCI_SET_ON) {
1218 TRACE("MCI_SET_ON audio !\n");
1219 } else if (dwFlags & MCI_SET_OFF) {
1220 TRACE("MCI_SET_OFF audio !\n");
1221 } else {
1222 WARN("MCI_SET_AUDIO without SET_ON or SET_OFF\n");
1223 return MCIERR_BAD_INTEGER;
1224 }
1225
1226 if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
1227 TRACE("MCI_SET_AUDIO_ALL !\n");
1228 if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
1229 TRACE("MCI_SET_AUDIO_LEFT !\n");
1230 if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
1231 TRACE("MCI_SET_AUDIO_RIGHT !\n");
1232 }
1233 if (dwFlags & MCI_WAVE_INPUT)
1234 TRACE("MCI_WAVE_INPUT !\n");
1235 if (dwFlags & MCI_WAVE_OUTPUT)
1236 TRACE("MCI_WAVE_OUTPUT !\n");
1237 if (dwFlags & MCI_WAVE_SET_ANYINPUT)
1238 TRACE("MCI_WAVE_SET_ANYINPUT !\n");
1239 if (dwFlags & MCI_WAVE_SET_ANYOUTPUT)
1240 TRACE("MCI_WAVE_SET_ANYOUTPUT !\n");
1241 if (dwFlags & MCI_WAVE_SET_AVGBYTESPERSEC) {
1242 wmw->wfxRef.nAvgBytesPerSec = ((LPMCI_WAVE_SET_PARMS)lpParms)->nAvgBytesPerSec;
1243 TRACE("MCI_WAVE_SET_AVGBYTESPERSEC = %ld\n", wmw->wfxRef.nAvgBytesPerSec);
1244 }
1245 if (dwFlags & MCI_WAVE_SET_BITSPERSAMPLE) {
1246 wmw->wfxRef.wBitsPerSample = ((LPMCI_WAVE_SET_PARMS)lpParms)->wBitsPerSample;
1247 TRACE("MCI_WAVE_SET_BITSPERSAMPLE = %d\n", wmw->wfxRef.wBitsPerSample);
1248 }
1249 if (dwFlags & MCI_WAVE_SET_BLOCKALIGN) {
1250 wmw->wfxRef.nBlockAlign = ((LPMCI_WAVE_SET_PARMS)lpParms)->nBlockAlign;
1251 TRACE("MCI_WAVE_SET_BLOCKALIGN = %d\n", wmw->wfxRef.nBlockAlign);
1252 }
1253 if (dwFlags & MCI_WAVE_SET_CHANNELS) {
1254 wmw->wfxRef.nChannels = ((LPMCI_WAVE_SET_PARMS)lpParms)->nChannels;
1255 TRACE("MCI_WAVE_SET_CHANNELS = %d\n", wmw->wfxRef.nChannels);
1256 }
1257 if (dwFlags & MCI_WAVE_SET_FORMATTAG) {
1258 wmw->wfxRef.wFormatTag = ((LPMCI_WAVE_SET_PARMS)lpParms)->wFormatTag;
1259 TRACE("MCI_WAVE_SET_FORMATTAG = %d\n", wmw->wfxRef.wFormatTag);
1260 }
1261 if (dwFlags & MCI_WAVE_SET_SAMPLESPERSEC) {
1262 wmw->wfxRef.nSamplesPerSec = ((LPMCI_WAVE_SET_PARMS)lpParms)->nSamplesPerSec;
1263 TRACE("MCI_WAVE_SET_SAMPLESPERSEC = %ld\n", wmw->wfxRef.nSamplesPerSec);
1264 }
1265 return 0;
1266 }
1267
1268 /**************************************************************************
1269 * WAVE_mciSave [internal]
1270 */
1271 static DWORD WAVE_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_SAVE_PARMS lpParms)
1272 {
1273 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1274 DWORD ret = MCIERR_FILE_NOT_SAVED, tmpRet;
1275 WPARAM wparam = MCI_NOTIFY_FAILURE;
1276
1277 TRACE("%d, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1278 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1279 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
1280
1281 if (dwFlags & MCI_WAIT)
1282 {
1283 FIXME("MCI_WAIT not implemented\n");
1284 }
1285
1286 ret = mmioAscend(wmw->hFile, &wmw->ckWaveData, 0);
1287 ret = mmioAscend(wmw->hFile, &wmw->ckMainRIFF, 0);
1288
1289
1290 ret = mmioClose(wmw->hFile, 0);
1291
1292 /*
1293 If the destination file already exists, it has to be overwritten. (Behaviour
1294 verified in Windows (2000)). If it doesn't overwrite, it is breaking one of
1295 my applications. We are making use of mmioRename, which WILL NOT overwrite
1296 the destination file (which is what Windows does, also verified in Win2K)
1297 So, lets delete the destination file before calling mmioRename. If the
1298 destination file DOESN'T exist, the delete will fail silently. Let's also be
1299 careful not to lose our previous error code.
1300 */
1301 tmpRet = GetLastError();
1302 DeleteFileA (lpParms->lpfilename);
1303 SetLastError(tmpRet);
1304
1305 if (0 == mmioRenameA(wmw->openParms.lpstrElementName, lpParms->lpfilename, 0, 0 )) {
1306 ret = ERROR_SUCCESS;
1307 }
1308
1309 if (dwFlags & MCI_NOTIFY) {
1310 if (ret == ERROR_SUCCESS) wparam = MCI_NOTIFY_SUCCESSFUL;
1311
1312 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
1313 wmw->openParms.wDeviceID, wparam);
1314 }
1315
1316 return ret;
1317 }
1318
1319 /**************************************************************************
1320 * WAVE_mciStatus [internal]
1321 */
1322 static DWORD WAVE_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
1323 {
1324 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1325 DWORD ret = 0;
1326
1327 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1328 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1329 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
1330
1331 if (dwFlags & MCI_STATUS_ITEM) {
1332 switch (lpParms->dwItem) {
1333 case MCI_STATUS_CURRENT_TRACK:
1334 lpParms->dwReturn = 1;
1335 TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
1336 break;
1337 case MCI_STATUS_LENGTH:
1338 if (!wmw->hFile) {
1339 lpParms->dwReturn = 0;
1340 return MCIERR_UNSUPPORTED_FUNCTION;
1341 }
1342 /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
1343 lpParms->dwReturn = WAVE_ConvertByteToTimeFormat(wmw, wmw->ckWaveData.cksize, &ret);
1344 TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
1345 break;
1346 case MCI_STATUS_MODE:
1347 TRACE("MCI_STATUS_MODE => %u\n", wmw->dwStatus);
1348 lpParms->dwReturn = MAKEMCIRESOURCE(wmw->dwStatus, wmw->dwStatus);
1349 ret = MCI_RESOURCE_RETURNED;
1350 break;
1351 case MCI_STATUS_MEDIA_PRESENT:
1352 TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE!\n");
1353 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1354 ret = MCI_RESOURCE_RETURNED;
1355 break;
1356 case MCI_STATUS_NUMBER_OF_TRACKS:
1357 /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
1358 lpParms->dwReturn = 1;
1359 TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu!\n", lpParms->dwReturn);
1360 break;
1361 case MCI_STATUS_POSITION:
1362 if (!wmw->hFile) {
1363 lpParms->dwReturn = 0;
1364 return MCIERR_UNSUPPORTED_FUNCTION;
1365 }
1366 /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
1367 lpParms->dwReturn = WAVE_ConvertByteToTimeFormat(wmw,
1368 (dwFlags & MCI_STATUS_START) ? 0 : wmw->dwPosition,
1369 &ret);
1370 TRACE("MCI_STATUS_POSITION %s => %lu\n",
1371 (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
1372 break;
1373 case MCI_STATUS_READY:
1374 lpParms->dwReturn = (wmw->dwStatus == MCI_MODE_NOT_READY) ?
1375 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1376 TRACE("MCI_STATUS_READY => %u!\n", LOWORD(lpParms->dwReturn));
1377 ret = MCI_RESOURCE_RETURNED;
1378 break;
1379 case MCI_STATUS_TIME_FORMAT:
1380 lpParms->dwReturn = MAKEMCIRESOURCE(wmw->dwMciTimeFormat, wmw->dwMciTimeFormat);
1381 TRACE("MCI_STATUS_TIME_FORMAT => %lu\n", lpParms->dwReturn);
1382 ret = MCI_RESOURCE_RETURNED;
1383 break;
1384 case MCI_WAVE_INPUT:
1385 TRACE("MCI_WAVE_INPUT !\n");
1386 lpParms->dwReturn = 0;
1387 ret = MCIERR_WAVE_INPUTUNSPECIFIED;
1388 break;
1389 case MCI_WAVE_OUTPUT:
1390 TRACE("MCI_WAVE_OUTPUT !\n");
1391 {
1392 UINT id;
1393 if (waveOutGetID(wmw->hWave, &id) == MMSYSERR_NOERROR) {
1394 lpParms->dwReturn = id;
1395 } else {
1396 lpParms->dwReturn = 0;
1397 ret = MCIERR_WAVE_INPUTUNSPECIFIED;
1398 }
1399 }
1400 break;
1401 case MCI_WAVE_STATUS_AVGBYTESPERSEC:
1402 if (!wmw->hFile) {
1403 lpParms->dwReturn = 0;
1404 return MCIERR_UNSUPPORTED_FUNCTION;
1405 }
1406 lpParms->dwReturn = wmw->lpWaveFormat->nAvgBytesPerSec;
1407 TRACE("MCI_WAVE_STATUS_AVGBYTESPERSEC => %lu!\n", lpParms->dwReturn);
1408 break;
1409 case MCI_WAVE_STATUS_BITSPERSAMPLE:
1410 if (!wmw->hFile) {
1411 lpParms->dwReturn = 0;
1412 return MCIERR_UNSUPPORTED_FUNCTION;
1413 }
1414 lpParms->dwReturn = wmw->lpWaveFormat->wBitsPerSample;
1415 TRACE("MCI_WAVE_STATUS_BITSPERSAMPLE => %lu!\n", lpParms->dwReturn);
1416 break;
1417 case MCI_WAVE_STATUS_BLOCKALIGN:
1418 if (!wmw->hFile) {
1419 lpParms->dwReturn = 0;
1420 return MCIERR_UNSUPPORTED_FUNCTION;
1421 }
1422 lpParms->dwReturn = wmw->lpWaveFormat->nBlockAlign;
1423 TRACE("MCI_WAVE_STATUS_BLOCKALIGN => %lu!\n", lpParms->dwReturn);
1424 break;
1425 case MCI_WAVE_STATUS_CHANNELS:
1426 if (!wmw->hFile) {
1427 lpParms->dwReturn = 0;
1428 return MCIERR_UNSUPPORTED_FUNCTION;
1429 }
1430 lpParms->dwReturn = wmw->lpWaveFormat->nChannels;
1431 TRACE("MCI_WAVE_STATUS_CHANNELS => %lu!\n", lpParms->dwReturn);
1432 break;
1433 case MCI_WAVE_STATUS_FORMATTAG:
1434 if (!wmw->hFile) {
1435 lpParms->dwReturn = 0;
1436 return MCIERR_UNSUPPORTED_FUNCTION;
1437 }
1438 lpParms->dwReturn = wmw->lpWaveFormat->wFormatTag;
1439 TRACE("MCI_WAVE_FORMATTAG => %lu!\n", lpParms->dwReturn);
1440 break;
1441 case MCI_WAVE_STATUS_LEVEL:
1442 TRACE("MCI_WAVE_STATUS_LEVEL !\n");
1443 lpParms->dwReturn = 0xAAAA5555;
1444 break;
1445 case MCI_WAVE_STATUS_SAMPLESPERSEC:
1446 if (!wmw->hFile) {
1447 lpParms->dwReturn = 0;
1448 return MCIERR_UNSUPPORTED_FUNCTION;
1449 }
1450 lpParms->dwReturn = wmw->lpWaveFormat->nSamplesPerSec;
1451 TRACE("MCI_WAVE_STATUS_SAMPLESPERSEC => %lu!\n", lpParms->dwReturn);
1452 break;
1453 default:
1454 WARN("unknown command %08lX !\n", lpParms->dwItem);
1455 return MCIERR_UNRECOGNIZED_COMMAND;
1456 }
1457 }
1458 if (dwFlags & MCI_NOTIFY) {
1459 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
1460 wmw->openParms.wDeviceID, MCI_NOTIFY_SUCCESSFUL);
1461 }
1462 return ret;
1463 }
1464
1465 /**************************************************************************
1466 * WAVE_mciGetDevCaps [internal]
1467 */
1468 static DWORD WAVE_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
1469 LPMCI_GETDEVCAPS_PARMS lpParms)
1470 {
1471 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1472 DWORD ret = 0;
1473
1474 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1475
1476 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1477 if (wmw == NULL) return MCIERR_INVALID_DEVICE_ID;
1478
1479 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
1480 switch(lpParms->dwItem) {
1481 case MCI_GETDEVCAPS_DEVICE_TYPE:
1482 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_WAVEFORM_AUDIO, MCI_DEVTYPE_WAVEFORM_AUDIO);
1483 ret = MCI_RESOURCE_RETURNED;
1484 break;
1485 case MCI_GETDEVCAPS_HAS_AUDIO:
1486 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1487 ret = MCI_RESOURCE_RETURNED;
1488 break;
1489 case MCI_GETDEVCAPS_HAS_VIDEO:
1490 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1491 ret = MCI_RESOURCE_RETURNED;
1492 break;
1493 case MCI_GETDEVCAPS_USES_FILES:
1494 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1495 ret = MCI_RESOURCE_RETURNED;
1496 break;
1497 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
1498 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1499 ret = MCI_RESOURCE_RETURNED;
1500 break;
1501 case MCI_GETDEVCAPS_CAN_RECORD:
1502 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1503 ret = MCI_RESOURCE_RETURNED;
1504 break;
1505 case MCI_GETDEVCAPS_CAN_EJECT:
1506 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
1507 ret = MCI_RESOURCE_RETURNED;
1508 break;
1509 case MCI_GETDEVCAPS_CAN_PLAY:
1510 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1511 ret = MCI_RESOURCE_RETURNED;
1512 break;
1513 case MCI_GETDEVCAPS_CAN_SAVE:
1514 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
1515 ret = MCI_RESOURCE_RETURNED;
1516 break;
1517 case MCI_WAVE_GETDEVCAPS_INPUTS:
1518 lpParms->dwReturn = 1;
1519 break;
1520 case MCI_WAVE_GETDEVCAPS_OUTPUTS:
1521 lpParms->dwReturn = 1;
1522 break;
1523 default:
1524 FIXME("Unknown capability (%08lx) !\n", lpParms->dwItem);
1525 return MCIERR_UNRECOGNIZED_COMMAND;
1526 }
1527 } else {
1528 WARN("No GetDevCaps-Item !\n");
1529 return MCIERR_UNRECOGNIZED_COMMAND;
1530 }
1531 return ret;
1532 }
1533
1534 /**************************************************************************
1535 * WAVE_mciInfo [internal]
1536 */
1537 static DWORD WAVE_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMSA lpParms)
1538 {
1539 DWORD ret = 0;
1540 LPCSTR str = 0;
1541 WINE_MCIWAVE* wmw = WAVE_mciGetOpenDev(wDevID);
1542
1543 TRACE("(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
1544
1545 if (lpParms == NULL || lpParms->lpstrReturn == NULL) {
1546 ret = MCIERR_NULL_PARAMETER_BLOCK;
1547 } else if (wmw == NULL) {
1548 ret = MCIERR_INVALID_DEVICE_ID;
1549 } else {
1550 TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
1551
1552 switch (dwFlags & ~(MCI_WAIT|MCI_NOTIFY)) {
1553 case MCI_INFO_PRODUCT:
1554 str = "Wine's audio player";
1555 break;
1556 case MCI_INFO_FILE:
1557 str = wmw->openParms.lpstrElementName;
1558 break;
1559 case MCI_WAVE_INPUT:
1560 str = "Wine Wave In";
1561 break;
1562 case MCI_WAVE_OUTPUT:
1563 str = "Wine Wave Out";
1564 break;
1565 default:
1566 WARN("Don't know this info command (%lu)\n", dwFlags);
1567 ret = MCIERR_UNRECOGNIZED_COMMAND;
1568 }
1569 }
1570 if (str) {
1571 if (strlen(str) + 1 > lpParms->dwRetSize) {
1572 ret = MCIERR_PARAM_OVERFLOW;
1573 } else {
1574 lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize);
1575 }
1576 } else {
1577 lpParms->lpstrReturn[0] = 0;
1578 }
1579
1580 return ret;
1581 }
1582
1583 /**************************************************************************
1584 * DriverProc (MCIWAVE.@)
1585 */
1586 LONG CALLBACK MCIWAVE_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
1587 DWORD dwParam1, DWORD dwParam2)
1588 {
1589 TRACE("(%08lX, %p, %08lX, %08lX, %08lX)\n",
1590 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1591
1592 switch (wMsg) {
1593 case DRV_LOAD: return 1;
1594 case DRV_FREE: return 1;
1595 case DRV_OPEN: return WAVE_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
1596 case DRV_CLOSE: return WAVE_drvClose(dwDevID);
1597 case DRV_ENABLE: return 1;
1598 case DRV_DISABLE: return 1;
1599 case DRV_QUERYCONFIGURE: return 1;
1600 case DRV_CONFIGURE: MessageBoxA(0, "Sample MultiMedia Driver !", "OSS Driver", MB_OK); return 1;
1601 case DRV_INSTALL: return DRVCNF_RESTART;
1602 case DRV_REMOVE: return DRVCNF_RESTART;
1603 }
1604
1605 if (dwDevID == 0xFFFFFFFF) return MCIERR_UNSUPPORTED_FUNCTION;
1606
1607 switch (wMsg) {
1608 case MCI_OPEN_DRIVER: return WAVE_mciOpen (dwDevID, dwParam1, (LPMCI_WAVE_OPEN_PARMSA) dwParam2);
1609 case MCI_CLOSE_DRIVER: return WAVE_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1610 case MCI_CUE: return WAVE_mciCue (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1611 case MCI_PLAY: return WAVE_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1612 case MCI_RECORD: return WAVE_mciRecord (dwDevID, dwParam1, (LPMCI_RECORD_PARMS) dwParam2);
1613 case MCI_STOP: return WAVE_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1614 case MCI_SET: return WAVE_mciSet (dwDevID, dwParam1, (LPMCI_SET_PARMS) dwParam2);
1615 case MCI_PAUSE: return WAVE_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1616 case MCI_RESUME: return WAVE_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1617 case MCI_STATUS: return WAVE_mciStatus (dwDevID, dwParam1, (LPMCI_STATUS_PARMS) dwParam2);
1618 case MCI_GETDEVCAPS: return WAVE_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1619 case MCI_INFO: return WAVE_mciInfo (dwDevID, dwParam1, (LPMCI_INFO_PARMSA) dwParam2);
1620 case MCI_SEEK: return WAVE_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1621 case MCI_SAVE: return WAVE_mciSave (dwDevID, dwParam1, (LPMCI_SAVE_PARMS) dwParam2);
1622 /* commands that should be supported */
1623 case MCI_LOAD:
1624 case MCI_FREEZE:
1625 case MCI_PUT:
1626 case MCI_REALIZE:
1627 case MCI_UNFREEZE:
1628 case MCI_UPDATE:
1629 case MCI_WHERE:
1630 case MCI_STEP:
1631 case MCI_SPIN:
1632 case MCI_ESCAPE:
1633 case MCI_COPY:
1634 case MCI_CUT:
1635 case MCI_DELETE:
1636 case MCI_PASTE:
1637 FIXME("Unsupported yet command [%lu]\n", wMsg);
1638 break;
1639 case MCI_WINDOW:
1640 TRACE("Unsupported command [%lu]\n", wMsg);
1641 break;
1642 /* option which can be silenced */
1643 case MCI_CONFIGURE:
1644 return 0;
1645 case MCI_OPEN:
1646 case MCI_CLOSE:
1647 ERR("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1648 break;
1649 default:
1650 FIXME("is probably wrong msg [%lu]\n", wMsg);
1651 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1652 }
1653 return MCIERR_UNRECOGNIZED_COMMAND;
1654 }
useful hacks and other patches not (yet) suitable for mainline