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