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