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