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