?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 961215
[wine/gsoc-2012-control.git] / multimedia / audio.c
blobb71b1d2874eab70539b259657fcd9339ebfe57cb
1 /*
2 * Sample Wine Driver for Linux
3 *
4 * Copyright 1994 Martin Ayotte
5 */
6
7 #ifndef WINELIB
8 #define BUILTIN_MMSYSTEM
9 #endif
10
11 #ifdef BUILTIN_MMSYSTEM
12
13 #define EMULATE_SB16
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <unistd.h>
18 #include <fcntl.h>
19 #include <sys/ioctl.h>
20 #include "windows.h"
21 #include "user.h"
22 #include "driver.h"
23 #include "mmsystem.h"
24 #include "ldt.h"
25
26 #ifdef linux
27 #include <linux/soundcard.h>
28 #elif __FreeBSD__
29 #include <machine/soundcard.h>
30 #endif
31
32 #include "stddebug.h"
33 #include "debug.h"
34
35 #if defined(linux) || defined(__FreeBSD__)
36 #define SOUND_DEV "/dev/dsp"
37
38 #ifdef SOUND_VERSION
39 #define IOCTL(a,b,c) ((-1==ioctl(a,b,&c))&&(perror("ioctl:"#b":"#c),0))
40 #else
41 #define IOCTL(a,b,c) (c = ioctl(a,b,c) )
42 #endif
43
44 #define MAX_WAVOUTDRV 2
45 #define MAX_WAVINDRV 2
46 #define MAX_MCIWAVDRV 2
47
48 typedef struct {
49 int unixdev;
50 int state;
51 DWORD bufsize;
52 WAVEOPENDESC waveDesc;
53 WORD wFlags;
54 PCMWAVEFORMAT Format;
55 LPWAVEHDR lpQueueHdr;
56 DWORD dwTotalPlayed;
57 } LINUX_WAVEOUT;
58
59 typedef struct {
60 int unixdev;
61 int state;
62 DWORD bufsize; /* Linux '/dev/dsp' give us that size */
63 WAVEOPENDESC waveDesc;
64 WORD wFlags;
65 PCMWAVEFORMAT Format;
66 LPWAVEHDR lpQueueHdr;
67 DWORD dwTotalRecorded;
68 } LINUX_WAVEIN;
69
70 typedef struct {
71 int nUseCount; /* Incremented for each shared open */
72 BOOL fShareable; /* TRUE if first open was shareable */
73 WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
74 HANDLE16 hCallback; /* Callback handle for pending notification */
75 HMMIO16 hFile; /* mmio file handle open as Element */
76 MCI_WAVE_OPEN_PARMS openParms;
77 PCMWAVEFORMAT WaveFormat;
78 WAVEHDR WaveHdr;
79 } LINUX_MCIWAVE;
80
81 static LINUX_WAVEOUT WOutDev[MAX_WAVOUTDRV];
82 static LINUX_WAVEIN WInDev[MAX_WAVOUTDRV];
83 static LINUX_MCIWAVE MCIWavDev[MAX_MCIWAVDRV];
84
85
86 /**************************************************************************
87 * WAVE_NotifyClient [internal]
88 */
89 static DWORD WAVE_NotifyClient(UINT wDevID, WORD wMsg,
90 DWORD dwParam1, DWORD dwParam2)
91 {
92 if (WInDev[wDevID].wFlags != DCB_NULL && !DriverCallback(
93 WInDev[wDevID].waveDesc.dwCallBack, WInDev[wDevID].wFlags,
94 WInDev[wDevID].waveDesc.hWave, wMsg,
95 WInDev[wDevID].waveDesc.dwInstance, dwParam1, dwParam2)) {
96 dprintf_mciwave(stddeb,"WAVE_NotifyClient // can't notify client !\n");
97 return MMSYSERR_NOERROR;
98 }
99 return 0;
100 }
101
102
103 /**************************************************************************
104 * WAVE_mciOpen */
105 static DWORD WAVE_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lpParms)
106 {
107 HLOCAL16 hFormat;
108 LPPCMWAVEFORMAT lpWaveFormat;
109 HLOCAL16 hDesc;
110 LPWAVEOPENDESC lpDesc;
111 LPSTR lpstrElementName;
112 DWORD dwRet;
113 char str[128];
114
115 dprintf_mciwave(stddeb,"WAVE_mciOpen(%04X, %08lX, %p)\n",
116 wDevID, dwFlags, lpParms);
117 if (lpParms == NULL) return MCIERR_INTERNAL;
118 dprintf_mciwave(stddeb,"WAVE_mciOpen // wDevID=%04X\n", wDevID);
119 if (MCIWavDev[wDevID].nUseCount > 0) {
120 /* The driver already open on this channel */
121 /* If the driver was opened shareable before and this open specifies */
122 /* shareable then increment the use count */
123 if (MCIWavDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
124 ++MCIWavDev[wDevID].nUseCount;
125 else
126 return MCIERR_MUST_USE_SHAREABLE;
127 }
128 else {
129 MCIWavDev[wDevID].nUseCount = 1;
130 MCIWavDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
131 }
132 lpParms->wDeviceID = wDevID;
133 dprintf_mciwave(stddeb,"WAVE_mciOpen // wDevID=%04X\n", wDevID);
134 dprintf_mciwave(stddeb,"WAVE_mciOpen // before OPEN_ELEMENT\n");
135 if (dwFlags & MCI_OPEN_ELEMENT) {
136 lpstrElementName = (LPSTR)PTR_SEG_TO_LIN(lpParms->lpstrElementName);
137 dprintf_mciwave(stddeb,"WAVE_mciOpen // MCI_OPEN_ELEMENT '%s' !\n",
138 lpstrElementName);
139 if (strlen(lpstrElementName) > 0) {
140 strcpy(str, lpstrElementName);
141 AnsiUpper(str);
142 MCIWavDev[wDevID].hFile = mmioOpen(str, NULL,
143 MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_EXCLUSIVE);
144 if (MCIWavDev[wDevID].hFile == 0) {
145 dprintf_mciwave(stddeb,"WAVE_mciOpen // can't find file='%s' !\n", str);
146 return MCIERR_FILE_NOT_FOUND;
147 }
148 }
149 else
150 MCIWavDev[wDevID].hFile = 0;
151 }
152 dprintf_mciwave(stddeb,"WAVE_mciOpen // hFile=%u\n", MCIWavDev[wDevID].hFile);
153 memcpy(&MCIWavDev[wDevID].openParms, lpParms, sizeof(MCI_WAVE_OPEN_PARMS));
154 MCIWavDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
155 lpWaveFormat = &MCIWavDev[wDevID].WaveFormat;
156 hDesc = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
157 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hDesc);
158 lpDesc->hWave = 0;
159 /*
160 lpWaveFormat->wf.wFormatTag = WAVE_FORMAT_PCM;
161 lpWaveFormat->wBitsPerSample = 8;
162 lpWaveFormat->wf.nChannels = 1;
163 lpWaveFormat->wf.nSamplesPerSec = 11025;
164 lpWaveFormat->wf.nAvgBytesPerSec = 11025;
165 lpWaveFormat->wf.nBlockAlign = 1;
166 */
167 if (MCIWavDev[wDevID].hFile != 0) {
168 MMCKINFO mmckInfo;
169 MMCKINFO ckMainRIFF;
170 if (mmioDescend(MCIWavDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0) {
171 return MCIERR_INTERNAL;
172 }
173 dprintf_mciwave(stddeb,
174 "WAVE_mciOpen // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
175 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
176 ckMainRIFF.cksize);
177 if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
178 (ckMainRIFF.fccType != mmioFOURCC('W', 'A', 'V', 'E'))) {
179 return MCIERR_INTERNAL;
180 }
181 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
182 if (mmioDescend(MCIWavDev[wDevID].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0) {
183 return MCIERR_INTERNAL;
184 }
185 dprintf_mciwave(stddeb,
186 "WAVE_mciOpen // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
187 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType,
188 mmckInfo.cksize);
189 if (mmioRead(MCIWavDev[wDevID].hFile, (HPSTR) lpWaveFormat,
190 (long) sizeof(PCMWAVEFORMAT)) != (long) sizeof(PCMWAVEFORMAT)) {
191 return MCIERR_INTERNAL;
192 }
193 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
194 if (mmioDescend(MCIWavDev[wDevID].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0) {
195 return MCIERR_INTERNAL;
196 }
197 dprintf_mciwave(stddeb,
198 "WAVE_mciOpen // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
199 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType,
200 mmckInfo.cksize);
201 dprintf_mciwave(stddeb,
202 "WAVE_mciOpen // nChannels=%d nSamplesPerSec=%ld\n",
203 lpWaveFormat->wf.nChannels, lpWaveFormat->wf.nSamplesPerSec);
204 lpWaveFormat->wBitsPerSample = 0;
205 }
206 lpWaveFormat->wf.nAvgBytesPerSec =
207 lpWaveFormat->wf.nSamplesPerSec * lpWaveFormat->wf.nBlockAlign;
208 hFormat = USER_HEAP_ALLOC(sizeof(PCMWAVEFORMAT));
209 lpDesc->lpFormat = (LPWAVEFORMAT) USER_HEAP_LIN_ADDR(hFormat);
210 memcpy(lpDesc->lpFormat, lpWaveFormat, sizeof(PCMWAVEFORMAT));
211 lpDesc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hDesc);
212 dwRet = wodMessage(0, WODM_OPEN, 0, (DWORD)lpDesc, CALLBACK_NULL);
213 dwRet = widMessage(0, WIDM_OPEN, 0, (DWORD)lpDesc, CALLBACK_NULL);
214 USER_HEAP_FREE(hFormat);
215 USER_HEAP_FREE(hDesc);
216 return 0;
217 }
218
219 /**************************************************************************
220 * WAVE_mciClose [internal]
221 */
222 static DWORD WAVE_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
223 {
224 DWORD dwRet;
225 dprintf_mciwave(stddeb,
226 "WAVE_mciClose(%u, %08lX, %p);\n", wDevID, dwParam, lpParms);
227 MCIWavDev[wDevID].nUseCount--;
228 if (MCIWavDev[wDevID].nUseCount == 0) {
229 if (MCIWavDev[wDevID].hFile != 0) {
230 mmioClose(MCIWavDev[wDevID].hFile, 0);
231 MCIWavDev[wDevID].hFile = 0;
232 }
233 dwRet = wodMessage(0, WODM_CLOSE, 0, 0L, 0L);
234 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
235 dwRet = widMessage(0, WIDM_CLOSE, 0, 0L, 0L);
236 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
237 }
238 return 0;
239 }
240
241
242 /**************************************************************************
243 * WAVE_mciPlay [internal]
244 */
245 static DWORD WAVE_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
246 {
247 int start, end;
248 LONG bufsize, count;
249 HGLOBAL16 hData;
250 HLOCAL16 hWaveHdr;
251 LPWAVEHDR lpWaveHdr;
252 LPWAVEHDR lp16WaveHdr;
253 DWORD dwRet;
254 dprintf_mciwave(stddeb,
255 "WAVE_mciPlay(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
256 if (MCIWavDev[wDevID].hFile == 0) {
257 dprintf_mciwave(stddeb,"WAVE_mciPlay // can't find file='%s' !\n",
258 MCIWavDev[wDevID].openParms.lpstrElementName);
259 return MCIERR_FILE_NOT_FOUND;
260 }
261 start = 1; end = 99999;
262 if (dwFlags & MCI_FROM) {
263 start = lpParms->dwFrom;
264 dprintf_mciwave(stddeb,
265 "WAVE_mciPlay // MCI_FROM=%d \n", start);
266 }
267 if (dwFlags & MCI_TO) {
268 end = lpParms->dwTo;
269 dprintf_mciwave(stddeb,"WAVE_mciPlay // MCI_TO=%d \n", end);
270 }
271 #if 0
272 if (dwFlags & MCI_NOTIFY) {
273 dprintf_mciwave(stddeb,
274 "WAVE_mciPlay // MCI_NOTIFY %08lX !\n", lpParms->dwCallback);
275 switch(fork()) {
276 case -1:
277 dprintf_mciwave(stddeb,
278 "WAVE_mciPlay // Can't 'fork' process !\n");
279 break;
280 case 0:
281 break;
282 default:
283 dprintf_mciwave(stddeb,"WAVE_mciPlay // process started ! return to caller...\n");
284 return 0;
285 }
286 }
287 #endif
288 bufsize = 64000;
289 lpWaveHdr = &MCIWavDev[wDevID].WaveHdr;
290 hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
291 lpWaveHdr->lpData = (LPSTR) WIN16_GlobalLock16(hData);
292 lpWaveHdr->dwUser = 0L;
293 lpWaveHdr->dwFlags = 0L;
294 lpWaveHdr->dwLoops = 0L;
295 hWaveHdr = USER_HEAP_ALLOC(sizeof(WAVEHDR));
296 lp16WaveHdr = (LPWAVEHDR) USER_HEAP_SEG_ADDR(hWaveHdr);
297 memcpy(PTR_SEG_TO_LIN(lp16WaveHdr), lpWaveHdr, sizeof(WAVEHDR));
298 lpWaveHdr = PTR_SEG_TO_LIN(lp16WaveHdr);
299 dwRet = wodMessage(0, WODM_PREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR));
300 while(TRUE) {
301 count = mmioRead(MCIWavDev[wDevID].hFile,
302 PTR_SEG_TO_LIN(lpWaveHdr->lpData), bufsize);
303 dprintf_mciwave(stddeb,"WAVE_mciPlay // mmioRead bufsize=%ld count=%ld\n", bufsize, count);
304 if (count < 1) break;
305 lpWaveHdr->dwBufferLength = count;
306 /* lpWaveHdr->dwBytesRecorded = count; */
307 dprintf_mciwave(stddeb,"WAVE_mciPlay // before WODM_WRITE lpWaveHdr=%p dwBufferLength=%lu dwBytesRecorded=%lu\n",
308 lpWaveHdr, lpWaveHdr->dwBufferLength, lpWaveHdr->dwBytesRecorded);
309 dwRet = wodMessage(0, WODM_WRITE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR));
310 }
311 dwRet = wodMessage(0, WODM_UNPREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR));
312 if (lpWaveHdr->lpData != NULL) {
313 GlobalUnlock16(hData);
314 GlobalFree16(hData);
315 lpWaveHdr->lpData = NULL;
316 }
317 USER_HEAP_FREE(hWaveHdr);
318 if (dwFlags & MCI_NOTIFY) {
319 dprintf_mciwave(stddeb,"WAVE_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
320 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
321 MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
322 }
323 return 0;
324 }
325
326
327 /**************************************************************************
328 * WAVE_mciRecord [internal]
329 */
330 static DWORD WAVE_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
331 {
332 int start, end;
333 LONG bufsize;
334 HGLOBAL16 hData;
335 HLOCAL16 hWaveHdr;
336 LPWAVEHDR lpWaveHdr;
337 LPWAVEHDR lp16WaveHdr;
338 DWORD dwRet;
339
340 dprintf_mciwave(stddeb,
341 "WAVE_mciRecord(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
342 if (MCIWavDev[wDevID].hFile == 0) {
343 dprintf_mciwave(stddeb,"WAVE_mciRecord // can't find file='%s' !\n",
344 MCIWavDev[wDevID].openParms.lpstrElementName);
345 return MCIERR_FILE_NOT_FOUND;
346 }
347 start = 1; end = 99999;
348 if (dwFlags & MCI_FROM) {
349 start = lpParms->dwFrom;
350 dprintf_mciwave(stddeb,
351 "WAVE_mciRecord // MCI_FROM=%d \n", start);
352 }
353 if (dwFlags & MCI_TO) {
354 end = lpParms->dwTo;
355 dprintf_mciwave(stddeb,"WAVE_mciRecord // MCI_TO=%d \n", end);
356 }
357 bufsize = 64000;
358 lpWaveHdr = &MCIWavDev[wDevID].WaveHdr;
359 hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
360 lpWaveHdr->lpData = (LPSTR) WIN16_GlobalLock16(hData);
361 lpWaveHdr->dwBufferLength = bufsize;
362 lpWaveHdr->dwUser = 0L;
363 lpWaveHdr->dwFlags = 0L;
364 lpWaveHdr->dwLoops = 0L;
365 hWaveHdr = USER_HEAP_ALLOC(sizeof(WAVEHDR));
366 lp16WaveHdr = (LPWAVEHDR) USER_HEAP_SEG_ADDR(hWaveHdr);
367 memcpy(PTR_SEG_TO_LIN(lp16WaveHdr), lpWaveHdr, sizeof(WAVEHDR));
368 lpWaveHdr = PTR_SEG_TO_LIN(lp16WaveHdr);
369 dwRet = widMessage(0, WIDM_PREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR));
370 dprintf_mciwave(stddeb,"WAVE_mciRecord // after WIDM_PREPARE \n");
371 while(TRUE) {
372 lpWaveHdr->dwBytesRecorded = 0;
373 dwRet = widMessage(0, WIDM_START, 0, 0L, 0L);
374 dprintf_mciwave(stddeb,
375 "WAVE_mciRecord // after WIDM_START lpWaveHdr=%p dwBytesRecorded=%lu\n",
376 lpWaveHdr, lpWaveHdr->dwBytesRecorded);
377 if (lpWaveHdr->dwBytesRecorded == 0) break;
378 }
379 dprintf_mciwave(stddeb,"WAVE_mciRecord // before WIDM_UNPREPARE \n");
380 dwRet = widMessage(0, WIDM_UNPREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR));
381 dprintf_mciwave(stddeb,"WAVE_mciRecord // after WIDM_UNPREPARE \n");
382 if (lpWaveHdr->lpData != NULL) {
383 GlobalUnlock16(hData);
384 GlobalFree16(hData);
385 lpWaveHdr->lpData = NULL;
386 }
387 USER_HEAP_FREE(hWaveHdr);
388 if (dwFlags & MCI_NOTIFY) {
389 dprintf_mciwave(stddeb,"WAVE_mciRecord // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
390 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
391 MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
392 }
393 return 0;
394 }
395
396
397 /**************************************************************************
398 * WAVE_mciStop [internal]
399 */
400 static DWORD WAVE_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
401 {
402 dprintf_mciwave(stddeb,
403 "WAVE_mciStop(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
404 if (lpParms == NULL) return MCIERR_INTERNAL;
405 return 0;
406 }
407
408
409 /**************************************************************************
410 * WAVE_mciPause [internal]
411 */
412 static DWORD WAVE_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
413 {
414 dprintf_mciwave(stddeb,
415 "WAVE_mciPause(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
416 if (lpParms == NULL) return MCIERR_INTERNAL;
417 return 0;
418 }
419
420
421 /**************************************************************************
422 * WAVE_mciResume [internal]
423 */
424 static DWORD WAVE_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
425 {
426 dprintf_mciwave(stddeb,
427 "WAVE_mciResume(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
428 if (lpParms == NULL) return MCIERR_INTERNAL;
429 return 0;
430 }
431
432
433 /**************************************************************************
434 * WAVE_mciSet [internal]
435 */
436 static DWORD WAVE_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
437 {
438 dprintf_mciwave(stddeb,
439 "WAVE_mciSet(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
440 if (lpParms == NULL) return MCIERR_INTERNAL;
441 dprintf_mciwave(stddeb,
442 "WAVE_mciSet // dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
443 dprintf_mciwave(stddeb,
444 "WAVE_mciSet // dwAudio=%08lX\n", lpParms->dwAudio);
445 if (dwFlags & MCI_SET_TIME_FORMAT) {
446 switch (lpParms->dwTimeFormat) {
447 case MCI_FORMAT_MILLISECONDS:
448 dprintf_mciwave(stddeb, "WAVE_mciSet // MCI_FORMAT_MILLISECONDS !\n");
449 break;
450 case MCI_FORMAT_BYTES:
451 dprintf_mciwave(stddeb, "WAVE_mciSet // MCI_FORMAT_BYTES !\n");
452 break;
453 case MCI_FORMAT_SAMPLES:
454 dprintf_mciwave(stddeb, "WAVE_mciSet // MCI_FORMAT_SAMPLES !\n");
455 break;
456 default:
457 dprintf_mciwave(stddeb, "WAVE_mciSet // bad time format !\n");
458 return MCIERR_BAD_TIME_FORMAT;
459 }
460 }
461 if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
462 if (dwFlags & MCI_SET_DOOR_OPEN) return MCIERR_UNSUPPORTED_FUNCTION;
463 if (dwFlags & MCI_SET_DOOR_CLOSED) return MCIERR_UNSUPPORTED_FUNCTION;
464 if (dwFlags & MCI_SET_AUDIO)
465 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_SET_AUDIO !\n");
466 if (dwFlags && MCI_SET_ON) {
467 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_SET_ON !\n");
468 if (dwFlags && MCI_SET_AUDIO_LEFT)
469 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_SET_AUDIO_LEFT !\n");
470 if (dwFlags && MCI_SET_AUDIO_RIGHT)
471 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_SET_AUDIO_RIGHT !\n");
472 }
473 if (dwFlags & MCI_SET_OFF)
474 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_SET_OFF !\n");
475 if (dwFlags & MCI_WAVE_INPUT)
476 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_WAVE_INPUT !\n");
477 if (dwFlags & MCI_WAVE_OUTPUT)
478 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_WAVE_OUTPUT !\n");
479 if (dwFlags & MCI_WAVE_SET_ANYINPUT)
480 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_WAVE_SET_ANYINPUT !\n");
481 if (dwFlags & MCI_WAVE_SET_ANYOUTPUT)
482 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_WAVE_SET_ANYOUTPUT !\n");
483 if (dwFlags & MCI_WAVE_SET_AVGBYTESPERSEC)
484 dprintf_mciwave(stddeb,
485 "WAVE_mciSet // MCI_WAVE_SET_AVGBYTESPERSEC !\n");
486 if (dwFlags & MCI_WAVE_SET_BITSPERSAMPLE)
487 dprintf_mciwave(stddeb,
488 "WAVE_mciSet // MCI_WAVE_SET_BITSPERSAMPLE !\n");
489 if (dwFlags & MCI_WAVE_SET_BLOCKALIGN)
490 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_WAVE_SET_BLOCKALIGN !\n");
491 if (dwFlags & MCI_WAVE_SET_CHANNELS)
492 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_WAVE_SET_CHANNELS !\n");
493 if (dwFlags & MCI_WAVE_SET_FORMATTAG)
494 dprintf_mciwave(stddeb,"WAVE_mciSet // MCI_WAVE_SET_FORMATTAG !\n");
495 if (dwFlags & MCI_WAVE_SET_SAMPLESPERSEC)
496 dprintf_mciwave(stddeb,
497 "WAVE_mciSet // MCI_WAVE_SET_SAMPLESPERSEC !\n");
498 return 0;
499 }
500
501
502 /**************************************************************************
503 * WAVE_mciStatus [internal]
504 */
505 static DWORD WAVE_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
506 {
507 dprintf_mciwave(stddeb,
508 "WAVE_mciStatus(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
509 if (lpParms == NULL) return MCIERR_INTERNAL;
510 if (dwFlags & MCI_STATUS_ITEM) {
511 switch(lpParms->dwItem) {
512 case MCI_STATUS_CURRENT_TRACK:
513 lpParms->dwReturn = 1;
514 break;
515 case MCI_STATUS_LENGTH:
516 lpParms->dwReturn = 5555;
517 if (dwFlags & MCI_TRACK) {
518 lpParms->dwTrack = 1;
519 lpParms->dwReturn = 2222;
520 }
521 break;
522 case MCI_STATUS_MODE:
523 lpParms->dwReturn = MCI_MODE_STOP;
524 break;
525 case MCI_STATUS_MEDIA_PRESENT:
526 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
527 lpParms->dwReturn = TRUE;
528 break;
529 case MCI_STATUS_NUMBER_OF_TRACKS:
530 lpParms->dwReturn = 1;
531 break;
532 case MCI_STATUS_POSITION:
533 lpParms->dwReturn = 3333;
534 if (dwFlags & MCI_STATUS_START) {
535 lpParms->dwItem = 1;
536 }
537 if (dwFlags & MCI_TRACK) {
538 lpParms->dwTrack = 1;
539 lpParms->dwReturn = 777;
540 }
541 break;
542 case MCI_STATUS_READY:
543 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_STATUS_READY !\n");
544 lpParms->dwReturn = TRUE;
545 break;
546 case MCI_STATUS_TIME_FORMAT:
547 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
548 lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
549 break;
550 case MCI_WAVE_INPUT:
551 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_INPUT !\n");
552 lpParms->dwReturn = 0;
553 break;
554 case MCI_WAVE_OUTPUT:
555 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_OUTPUT !\n");
556 lpParms->dwReturn = 0;
557 break;
558 case MCI_WAVE_STATUS_AVGBYTESPERSEC:
559 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_STATUS_AVGBYTESPERSEC !\n");
560 lpParms->dwReturn = 22050;
561 break;
562 case MCI_WAVE_STATUS_BITSPERSAMPLE:
563 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_STATUS_BITSPERSAMPLE !\n");
564 lpParms->dwReturn = 8;
565 break;
566 case MCI_WAVE_STATUS_BLOCKALIGN:
567 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_STATUS_BLOCKALIGN !\n");
568 lpParms->dwReturn = 1;
569 break;
570 case MCI_WAVE_STATUS_CHANNELS:
571 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_STATUS_CHANNELS !\n");
572 lpParms->dwReturn = 1;
573 break;
574 case MCI_WAVE_STATUS_FORMATTAG:
575 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_FORMATTAG !\n");
576 lpParms->dwReturn = WAVE_FORMAT_PCM;
577 break;
578 case MCI_WAVE_STATUS_LEVEL:
579 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_STATUS_LEVEL !\n");
580 lpParms->dwReturn = 0xAAAA5555;
581 break;
582 case MCI_WAVE_STATUS_SAMPLESPERSEC:
583 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_WAVE_STATUS_SAMPLESPERSEC !\n");
584 lpParms->dwReturn = 22050;
585 break;
586 default:
587 dprintf_mciwave(stddeb,"WAVE_mciStatus // unknown command %08lX !\n", lpParms->dwItem);
588 return MCIERR_UNRECOGNIZED_COMMAND;
589 }
590 }
591 if (dwFlags & MCI_NOTIFY) {
592 dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
593 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
594 MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
595 }
596 return 0;
597 }
598
599 /**************************************************************************
600 * WAVE_mciGetDevCaps [internal]
601 */
602 static DWORD WAVE_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
603 LPMCI_GETDEVCAPS_PARMS lpParms)
604 {
605 dprintf_mciwave(stddeb,
606 "WAVE_mciGetDevCaps(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
607 if (lpParms == NULL) return MCIERR_INTERNAL;
608 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
609 switch(lpParms->dwItem) {
610 case MCI_GETDEVCAPS_CAN_RECORD:
611 lpParms->dwReturn = TRUE;
612 break;
613 case MCI_GETDEVCAPS_HAS_AUDIO:
614 lpParms->dwReturn = TRUE;
615 break;
616 case MCI_GETDEVCAPS_HAS_VIDEO:
617 lpParms->dwReturn = FALSE;
618 break;
619 case MCI_GETDEVCAPS_DEVICE_TYPE:
620 lpParms->dwReturn = MCI_DEVTYPE_WAVEFORM_AUDIO;
621 break;
622 case MCI_GETDEVCAPS_USES_FILES:
623 lpParms->dwReturn = TRUE;
624 break;
625 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
626 lpParms->dwReturn = TRUE;
627 break;
628 case MCI_GETDEVCAPS_CAN_EJECT:
629 lpParms->dwReturn = FALSE;
630 break;
631 case MCI_GETDEVCAPS_CAN_PLAY:
632 lpParms->dwReturn = TRUE;
633 break;
634 case MCI_GETDEVCAPS_CAN_SAVE:
635 lpParms->dwReturn = TRUE;
636 break;
637 case MCI_WAVE_GETDEVCAPS_INPUTS:
638 lpParms->dwReturn = 1;
639 break;
640 case MCI_WAVE_GETDEVCAPS_OUTPUTS:
641 lpParms->dwReturn = 1;
642 break;
643 default:
644 return MCIERR_UNRECOGNIZED_COMMAND;
645 }
646 }
647 return 0;
648 }
649
650 /**************************************************************************
651 * WAVE_mciInfo [internal]
652 */
653 static DWORD WAVE_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms)
654 {
655 dprintf_mciwave(stddeb,
656 "WAVE_mciInfo(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
657 if (lpParms == NULL) return MCIERR_INTERNAL;
658 lpParms->lpstrReturn = NULL;
659 switch(dwFlags) {
660 case MCI_INFO_PRODUCT:
661 lpParms->lpstrReturn = "Linux Sound System 0.5";
662 break;
663 case MCI_INFO_FILE:
664 lpParms->lpstrReturn =
665 (LPSTR)MCIWavDev[wDevID].openParms.lpstrElementName;
666 break;
667 case MCI_WAVE_INPUT:
668 lpParms->lpstrReturn = "Linux Sound System 0.5";
669 break;
670 case MCI_WAVE_OUTPUT:
671 lpParms->lpstrReturn = "Linux Sound System 0.5";
672 break;
673 default:
674 return MCIERR_UNRECOGNIZED_COMMAND;
675 }
676 if (lpParms->lpstrReturn != NULL)
677 lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
678 else
679 lpParms->dwRetSize = 0;
680 return 0;
681 }
682
683
684 /*-----------------------------------------------------------------------*/
685
686
687 /**************************************************************************
688 * wodGetDevCaps [internal]
689 */
690 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPS lpCaps, DWORD dwSize)
691 {
692 int audio;
693 int smplrate;
694 int samplesize = 16;
695 int dsp_stereo = 1;
696 int bytespersmpl;
697 dprintf_mciwave(stddeb,
698 "wodGetDevCaps(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
699 if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
700 audio = open (SOUND_DEV, O_WRONLY, 0);
701 if (audio == -1) return MMSYSERR_NOTENABLED;
702 #ifdef EMULATE_SB16
703 lpCaps->wMid = 0x0002;
704 lpCaps->wPid = 0x0104;
705 strcpy(lpCaps->szPname, "SB16 Wave Out");
706 #else
707 lpCaps->wMid = 0x00FF; /* Manufac ID */
708 lpCaps->wPid = 0x0001; /* Product ID */
709 strcpy(lpCaps->szPname, "Linux WAVOUT Driver");
710 #endif
711 lpCaps->dwFormats = 0x00000000;
712 lpCaps->dwSupport = WAVECAPS_VOLUME;
713 lpCaps->wChannels = (IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo) != 0) ? 1 : 2;
714 if (lpCaps->wChannels > 1) lpCaps->dwSupport |= WAVECAPS_LRVOLUME;
715 bytespersmpl = (IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize) != 0) ? 1 : 2;
716 smplrate = 44100;
717 if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
718 lpCaps->dwFormats |= WAVE_FORMAT_4M08;
719 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_4S08;
720 if (bytespersmpl > 1) {
721 lpCaps->dwFormats |= WAVE_FORMAT_4M16;
722 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_4S16;
723 }
724 }
725 smplrate = 22050;
726 if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
727 lpCaps->dwFormats |= WAVE_FORMAT_2M08;
728 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_2S08;
729 if (bytespersmpl > 1) {
730 lpCaps->dwFormats |= WAVE_FORMAT_2M16;
731 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_2S16;
732 }
733 }
734 smplrate = 11025;
735 if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
736 lpCaps->dwFormats |= WAVE_FORMAT_1M08;
737 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_1S08;
738 if (bytespersmpl > 1) {
739 lpCaps->dwFormats |= WAVE_FORMAT_1M16;
740 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_1S16;
741 }
742 }
743 close(audio);
744 dprintf_mciwave(stddeb,
745 "wodGetDevCaps // dwFormats = %08lX\n", lpCaps->dwFormats);
746 return MMSYSERR_NOERROR;
747 }
748
749
750 /**************************************************************************
751 * wodOpen [internal]
752 */
753 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
754 {
755 int audio;
756 int abuf_size;
757 int smplrate;
758 int samplesize;
759 int dsp_stereo;
760 LPWAVEFORMAT lpFormat;
761
762 dprintf_mciwave(stddeb,
763 "wodOpen(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
764 if (lpDesc == NULL) {
765 dprintf_mciwave(stddeb,"Linux 'wodOpen' // Invalid Parameter !\n");
766 return MMSYSERR_INVALPARAM;
767 }
768 if (wDevID >= MAX_WAVOUTDRV) {
769 dprintf_mciwave(stddeb,"Linux 'wodOpen' // MAX_WAVOUTDRV reached !\n");
770 return MMSYSERR_ALLOCATED;
771 }
772 WOutDev[wDevID].unixdev = 0;
773 audio = open (SOUND_DEV, O_WRONLY, 0);
774 if (audio == -1) {
775 dprintf_mciwave(stddeb,"Linux 'wodOpen' // can't open !\n");
776 return MMSYSERR_NOTENABLED;
777 }
778 IOCTL(audio, SNDCTL_DSP_GETBLKSIZE, abuf_size);
779 if (abuf_size < 1024 || abuf_size > 65536) {
780 if (abuf_size == -1)
781 dprintf_mciwave(stddeb,"Linux 'wodOpen' // IOCTL can't 'SNDCTL_DSP_GETBLKSIZE' !\n");
782 else
783 dprintf_mciwave(stddeb,"Linux 'wodOpen' // SNDCTL_DSP_GETBLKSIZE Invalid bufsize !\n");
784 return MMSYSERR_NOTENABLED;
785 }
786 WOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
787 switch(WOutDev[wDevID].wFlags) {
788 case DCB_NULL:
789 dprintf_mciwave(stddeb, "Linux 'wodOpen' // CALLBACK_NULL !\n");
790 break;
791 case DCB_WINDOW:
792 dprintf_mciwave(stddeb, "Linux 'wodOpen' // CALLBACK_WINDOW !\n");
793 break;
794 case DCB_TASK:
795 dprintf_mciwave(stddeb, "Linux 'wodOpen' // CALLBACK_TASK !\n");
796 break;
797 case DCB_FUNCTION:
798 dprintf_mciwave(stddeb, "Linux 'wodOpen' // CALLBACK_FUNCTION !\n");
799 break;
800 }
801 WOutDev[wDevID].lpQueueHdr = NULL;
802 WOutDev[wDevID].unixdev = audio;
803 WOutDev[wDevID].dwTotalPlayed = 0;
804 WOutDev[wDevID].bufsize = abuf_size;
805 memcpy(&WOutDev[wDevID].waveDesc, lpDesc, sizeof(WAVEOPENDESC));
806 /* lpFormat = (LPWAVEFORMAT) PTR_SEG_TO_LIN(lpDesc->lpFormat); */
807 lpFormat = lpDesc->lpFormat;
808 if (lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
809 dprintf_mciwave(stddeb,"Linux 'wodOpen' // Bad format %04X !\n",
810 lpFormat->wFormatTag);
811 dprintf_mciwave(stddeb,"Linux 'wodOpen' // Bad nChannels %d !\n",
812 lpFormat->nChannels);
813 dprintf_mciwave(stddeb,"Linux 'wodOpen' // Bad nSamplesPerSec %ld !\n",
814 lpFormat->nSamplesPerSec);
815 return WAVERR_BADFORMAT;
816 }
817 memcpy(&WOutDev[wDevID].Format, lpFormat, sizeof(PCMWAVEFORMAT));
818 if (WOutDev[wDevID].Format.wf.nChannels == 0) return WAVERR_BADFORMAT;
819 if (WOutDev[wDevID].Format.wf.nSamplesPerSec == 0) return WAVERR_BADFORMAT;
820 dprintf_mciwave(stddeb,"Linux 'wodOpen' // wBitsPerSample=%u !\n",
821 WOutDev[wDevID].Format.wBitsPerSample);
822 if (WOutDev[wDevID].Format.wBitsPerSample == 0) {
823 WOutDev[wDevID].Format.wBitsPerSample = 8 *
824 (WOutDev[wDevID].Format.wf.nAvgBytesPerSec /
825 WOutDev[wDevID].Format.wf.nSamplesPerSec) /
826 WOutDev[wDevID].Format.wf.nChannels;
827 }
828 samplesize = WOutDev[wDevID].Format.wBitsPerSample;
829 smplrate = WOutDev[wDevID].Format.wf.nSamplesPerSec;
830 dsp_stereo = (WOutDev[wDevID].Format.wf.nChannels > 1) ? TRUE : FALSE;
831 IOCTL(audio, SNDCTL_DSP_SPEED, smplrate);
832 IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize);
833 IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo);
834 dprintf_mciwave(stddeb,"Linux 'wodOpen' // wBitsPerSample=%u !\n",
835 WOutDev[wDevID].Format.wBitsPerSample);
836 dprintf_mciwave(stddeb,"Linux 'wodOpen' // nAvgBytesPerSec=%lu !\n",
837 WOutDev[wDevID].Format.wf.nAvgBytesPerSec);
838 dprintf_mciwave(stddeb,"Linux 'wodOpen' // nSamplesPerSec=%lu !\n",
839 WOutDev[wDevID].Format.wf.nSamplesPerSec);
840 dprintf_mciwave(stddeb,"Linux 'wodOpen' // nChannels=%u !\n",
841 WOutDev[wDevID].Format.wf.nChannels);
842 if (WAVE_NotifyClient(wDevID, WOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
843 dprintf_mciwave(stddeb,"Linux 'wodOpen' // can't notify client !\n");
844 return MMSYSERR_INVALPARAM;
845 }
846 return MMSYSERR_NOERROR;
847 }
848
849 /**************************************************************************
850 * wodClose [internal]
851 */
852 static DWORD wodClose(WORD wDevID)
853 {
854 dprintf_mciwave(stddeb,"wodClose(%u);\n", wDevID);
855 if (WOutDev[wDevID].unixdev == 0) {
856 dprintf_mciwave(stddeb,"Linux 'wodClose' // can't close !\n");
857 return MMSYSERR_NOTENABLED;
858 }
859 close(WOutDev[wDevID].unixdev);
860 WOutDev[wDevID].unixdev = 0;
861 WOutDev[wDevID].bufsize = 0;
862 WOutDev[wDevID].lpQueueHdr = NULL;
863 if (WAVE_NotifyClient(wDevID, WOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
864 dprintf_mciwave(stddeb,"Linux 'wodClose' // can't notify client !\n");
865 return MMSYSERR_INVALPARAM;
866 }
867 return MMSYSERR_NOERROR;
868 }
869
870 /**************************************************************************
871 * wodWrite [internal]
872 */
873 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
874 {
875 int count;
876 LPSTR lpData;
877 dprintf_mciwave(stddeb,"wodWrite(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
878 if (WOutDev[wDevID].unixdev == 0) {
879 dprintf_mciwave(stddeb,"Linux 'wodWrite' // can't play !\n");
880 return MMSYSERR_NOTENABLED;
881 }
882 if (lpWaveHdr->lpData == NULL) return WAVERR_UNPREPARED;
883 if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) return WAVERR_UNPREPARED;
884 if (lpWaveHdr->dwFlags & WHDR_INQUEUE) return WAVERR_STILLPLAYING;
885 lpWaveHdr->dwFlags &= ~WHDR_DONE;
886 lpWaveHdr->dwFlags |= WHDR_INQUEUE;
887 dprintf_mciwave(stddeb,
888 "wodWrite() // dwBufferLength %lu !\n", lpWaveHdr->dwBufferLength);
889 dprintf_mciwave(stddeb,
890 "wodWrite() // WOutDev[%u].unixdev %u !\n", wDevID, WOutDev[wDevID].unixdev);
891 lpData = PTR_SEG_TO_LIN(lpWaveHdr->lpData);
892 count = write (WOutDev[wDevID].unixdev, lpData, lpWaveHdr->dwBufferLength);
893 dprintf_mciwave(stddeb,
894 "wodWrite() // write returned count %u !\n", count);
895 if (count != lpWaveHdr->dwBufferLength) {
896 dprintf_mciwave(stddeb,"Linux 'wodWrite' // error writting !\n");
897 return MMSYSERR_NOTENABLED;
898 }
899 WOutDev[wDevID].dwTotalPlayed += count;
900 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
901 lpWaveHdr->dwFlags |= WHDR_DONE;
902 if (WAVE_NotifyClient(wDevID, WOM_DONE, 0L, 0L) != MMSYSERR_NOERROR) {
903 dprintf_mciwave(stddeb,"Linux 'wodWrite' // can't notify client !\n");
904 return MMSYSERR_INVALPARAM;
905 }
906 return MMSYSERR_NOERROR;
907 }
908
909 /**************************************************************************
910 * wodPrepare [internal]
911 */
912 static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
913 {
914 dprintf_mciwave(stddeb,
915 "wodPrepare(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
916 if (WOutDev[wDevID].unixdev == 0) {
917 dprintf_mciwave(stddeb,"Linux 'wodPrepare' // can't prepare !\n");
918 return MMSYSERR_NOTENABLED;
919 }
920 /* the COOL waveeditor feels much better without this check...
921 * someone please have a look at available documentation
922 if (WOutDev[wDevID].lpQueueHdr != NULL) {
923 dprintf_mciwave(stddeb,"Linux 'wodPrepare' // already prepare !\n");
924 return MMSYSERR_NOTENABLED;
925 }
926 */
927 WOutDev[wDevID].dwTotalPlayed = 0;
928 WOutDev[wDevID].lpQueueHdr = lpWaveHdr;
929 if (lpWaveHdr->dwFlags & WHDR_INQUEUE) return WAVERR_STILLPLAYING;
930 lpWaveHdr->dwFlags |= WHDR_PREPARED;
931 lpWaveHdr->dwFlags &= ~WHDR_DONE;
932 return MMSYSERR_NOERROR;
933 }
934
935 /**************************************************************************
936 * wodUnprepare [internal]
937 */
938 static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
939 {
940 dprintf_mciwave(stddeb,
941 "wodUnprepare(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
942 if (WOutDev[wDevID].unixdev == 0) {
943 dprintf_mciwave(stddeb,"Linux 'wodUnprepare' // can't unprepare !\n");
944 return MMSYSERR_NOTENABLED;
945 }
946 return MMSYSERR_NOERROR;
947 }
948
949 /**************************************************************************
950 * wodRestart [internal]
951 */
952 static DWORD wodRestart(WORD wDevID)
953 {
954 dprintf_mciwave(stddeb,"wodRestart(%u);\n", wDevID);
955 if (WOutDev[wDevID].unixdev == 0) {
956 dprintf_mciwave(stddeb,"Linux 'wodRestart' // can't restart !\n");
957 return MMSYSERR_NOTENABLED;
958 }
959 return MMSYSERR_NOERROR;
960 }
961
962 /**************************************************************************
963 * wodReset [internal]
964 */
965 static DWORD wodReset(WORD wDevID)
966 {
967 dprintf_mciwave(stddeb,"wodReset(%u);\n", wDevID);
968 if (WOutDev[wDevID].unixdev == 0) {
969 dprintf_mciwave(stddeb,"Linux 'wodReset' // can't reset !\n");
970 return MMSYSERR_NOTENABLED;
971 }
972 return MMSYSERR_NOERROR;
973 }
974
975
976 /**************************************************************************
977 * wodGetPosition [internal]
978 */
979 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
980 {
981 int time;
982 dprintf_mciwave(stddeb,"wodGetPosition(%u, %p, %lu);\n", wDevID, lpTime, uSize);
983 if (WOutDev[wDevID].unixdev == 0) {
984 dprintf_mciwave(stddeb,"Linux 'wodGetPosition' // can't get pos !\n");
985 return MMSYSERR_NOTENABLED;
986 }
987 if (lpTime == NULL) return MMSYSERR_INVALPARAM;
988 switch(lpTime->wType) {
989 case TIME_BYTES:
990 lpTime->u.cb = WOutDev[wDevID].dwTotalPlayed;
991 dprintf_mciwave(stddeb,"wodGetPosition // TIME_BYTES=%lu\n", lpTime->u.cb);
992 break;
993 case TIME_SAMPLES:
994 dprintf_mciwave(stddeb,"wodGetPosition // dwTotalPlayed=%lu\n",
995 WOutDev[wDevID].dwTotalPlayed);
996 dprintf_mciwave(stddeb,"wodGetPosition // wBitsPerSample=%u\n",
997 WOutDev[wDevID].Format.wBitsPerSample);
998 lpTime->u.sample = WOutDev[wDevID].dwTotalPlayed * 8 /
999 WOutDev[wDevID].Format.wBitsPerSample;
1000 dprintf_mciwave(stddeb,"wodGetPosition // TIME_SAMPLES=%lu\n", lpTime->u.sample);
1001 break;
1002 case TIME_SMPTE:
1003 time = WOutDev[wDevID].dwTotalPlayed /
1004 (WOutDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
1005 lpTime->u.smpte.hour = time / 108000;
1006 time -= lpTime->u.smpte.hour * 108000;
1007 lpTime->u.smpte.min = time / 1800;
1008 time -= lpTime->u.smpte.min * 1800;
1009 lpTime->u.smpte.sec = time / 30;
1010 time -= lpTime->u.smpte.sec * 30;
1011 lpTime->u.smpte.frame = time;
1012 lpTime->u.smpte.fps = 30;
1013 dprintf_mciwave(stddeb,
1014 "wodGetPosition // TIME_SMPTE=%02u:%02u:%02u:%02u\n",
1015 lpTime->u.smpte.hour, lpTime->u.smpte.min,
1016 lpTime->u.smpte.sec, lpTime->u.smpte.frame);
1017 break;
1018 default:
1019 dprintf_mciwave(stddeb,"wodGetPosition() format not supported ! use TIME_MS !\n");
1020 lpTime->wType = TIME_MS;
1021 case TIME_MS:
1022 lpTime->u.ms = WOutDev[wDevID].dwTotalPlayed /
1023 (WOutDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
1024 dprintf_mciwave(stddeb,"wodGetPosition // TIME_MS=%lu\n", lpTime->u.ms);
1025 break;
1026 }
1027 return MMSYSERR_NOERROR;
1028 }
1029
1030 /**************************************************************************
1031 * wodGetVolume [internal]
1032 */
1033 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1034 {
1035 int mixer;
1036 int volume, left, right;
1037 dprintf_mciwave(stddeb,"wodGetVolume(%u, %p);\n", wDevID, lpdwVol);
1038 if (lpdwVol == NULL) return MMSYSERR_NOTENABLED;
1039 if ((mixer = open("/dev/mixer", O_RDONLY)) < 0) {
1040 dprintf_mciwave(stddeb, "Linux 'wodGetVolume' // mixer device not available !\n");
1041 return MMSYSERR_NOTENABLED;
1042 }
1043 if (ioctl(mixer, SOUND_MIXER_READ_PCM, &volume) == -1) {
1044 dprintf_mciwave(stddeb,"Linux 'wodGetVolume' // unable read mixer !\n");
1045 return MMSYSERR_NOTENABLED;
1046 }
1047 close(mixer);
1048 left = volume & 0x7F;
1049 right = (volume >> 8) & 0x7F;
1050 printf("Linux 'AUX_GetVolume' // left=%d right=%d !\n", left, right);
1051 *lpdwVol = MAKELONG(left << 9, right << 9);
1052 return MMSYSERR_NOERROR;
1053 }
1054
1055
1056 /**************************************************************************
1057 * wodSetVolume [internal]
1058 */
1059 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1060 {
1061 int mixer;
1062 int volume;
1063 dprintf_mciwave(stddeb,"wodSetVolume(%u, %08lX);\n", wDevID, dwParam);
1064 volume = (LOWORD(dwParam) >> 9 & 0x7F) +
1065 ((HIWORD(dwParam) >> 9 & 0x7F) << 8);
1066 if ((mixer = open("/dev/mixer", O_WRONLY)) < 0) {
1067 dprintf_mciwave(stddeb, "Linux 'wodSetVolume' // mixer device not available !\n");
1068 return MMSYSERR_NOTENABLED;
1069 }
1070 if (ioctl(mixer, SOUND_MIXER_WRITE_PCM, &volume) == -1) {
1071 dprintf_mciwave(stddeb,"Linux 'wodSetVolume' // unable set mixer !\n");
1072 return MMSYSERR_NOTENABLED;
1073 }
1074 close(mixer);
1075 return MMSYSERR_NOERROR;
1076 }
1077
1078 #endif /* linux || __FreeBSD__*/
1079
1080 /**************************************************************************
1081 * wodMessage [sample driver]
1082 */
1083 DWORD wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1084 DWORD dwParam1, DWORD dwParam2)
1085 {
1086 dprintf_mciwave(stddeb,"wodMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
1087 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1088 #if defined(linux) || defined(__FreeBSD__)
1089 switch(wMsg) {
1090 case WODM_OPEN:
1091 return wodOpen(wDevID, (LPWAVEOPENDESC)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1092 case WODM_CLOSE:
1093 return wodClose(wDevID);
1094 case WODM_WRITE:
1095 return wodWrite(wDevID, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1096 case WODM_PAUSE:
1097 return 0L;
1098 case WODM_GETPOS:
1099 return wodGetPosition(wDevID, (LPMMTIME)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1100 case WODM_BREAKLOOP:
1101 return 0L;
1102 case WODM_PREPARE:
1103 return wodPrepare(wDevID, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1104 case WODM_UNPREPARE:
1105 return wodUnprepare(wDevID, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1106 case WODM_GETDEVCAPS:
1107 return wodGetDevCaps(wDevID, (LPWAVEOUTCAPS)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1108 case WODM_GETNUMDEVS:
1109 return 1L;
1110 case WODM_GETPITCH:
1111 return 0L;
1112 case WODM_SETPITCH:
1113 return 0L;
1114 case WODM_GETPLAYBACKRATE:
1115 return 0L;
1116 case WODM_SETPLAYBACKRATE:
1117 return 0L;
1118 case WODM_GETVOLUME:
1119 return wodGetVolume(wDevID, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
1120 case WODM_SETVOLUME:
1121 return wodSetVolume(wDevID, dwParam1);
1122 case WODM_RESTART:
1123 return wodRestart(wDevID);
1124 case WODM_RESET:
1125 return wodReset(wDevID);
1126 default:
1127 dprintf_mciwave(stddeb,"wodMessage // unknown message !\n");
1128 }
1129 return MMSYSERR_NOTSUPPORTED;
1130 #else
1131 return MMSYSERR_NOTENABLED;
1132 #endif
1133 }
1134
1135
1136 /*-----------------------------------------------------------------------*/
1137
1138 #if defined(linux) || defined(__FreeBSD__)
1139
1140 /**************************************************************************
1141 * widGetDevCaps [internal]
1142 */
1143 static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPS lpCaps, DWORD dwSize)
1144 {
1145 int audio;
1146 int smplrate;
1147 int samplesize = 16;
1148 int dsp_stereo = 1;
1149 int bytespersmpl;
1150 dprintf_mciwave(stddeb,
1151 "widGetDevCaps(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
1152 if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1153 audio = open (SOUND_DEV, O_RDONLY, 0);
1154 if (audio == -1) return MMSYSERR_NOTENABLED;
1155 #ifdef EMULATE_SB16
1156 lpCaps->wMid = 0x0002;
1157 lpCaps->wPid = 0x0004;
1158 strcpy(lpCaps->szPname, "SB16 Wave Out");
1159 #else
1160 lpCaps->wMid = 0x00FF; /* Manufac ID */
1161 lpCaps->wPid = 0x0001; /* Product ID */
1162 strcpy(lpCaps->szPname, "Linux WAVIN Driver");
1163 #endif
1164 lpCaps->dwFormats = 0x00000000;
1165 lpCaps->wChannels = (IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo) != 0) ? 1 : 2;
1166 bytespersmpl = (IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize) != 0) ? 1 : 2;
1167 smplrate = 44100;
1168 if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
1169 lpCaps->dwFormats |= WAVE_FORMAT_4M08;
1170 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_4S08;
1171 if (bytespersmpl > 1) {
1172 lpCaps->dwFormats |= WAVE_FORMAT_4M16;
1173 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_4S16;
1174 }
1175 }
1176 smplrate = 22050;
1177 if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
1178 lpCaps->dwFormats |= WAVE_FORMAT_2M08;
1179 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_2S08;
1180 if (bytespersmpl > 1) {
1181 lpCaps->dwFormats |= WAVE_FORMAT_2M16;
1182 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_2S16;
1183 }
1184 }
1185 smplrate = 11025;
1186 if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
1187 lpCaps->dwFormats |= WAVE_FORMAT_1M08;
1188 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_1S08;
1189 if (bytespersmpl > 1) {
1190 lpCaps->dwFormats |= WAVE_FORMAT_1M16;
1191 if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_1S16;
1192 }
1193 }
1194 close(audio);
1195 dprintf_mciwave(stddeb,
1196 "widGetDevCaps // dwFormats = %08lX\n", lpCaps->dwFormats);
1197 return MMSYSERR_NOERROR;
1198 }
1199
1200
1201 /**************************************************************************
1202 * widOpen [internal]
1203 */
1204 static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1205 {
1206 int audio;
1207 int abuf_size;
1208 int smplrate;
1209 int samplesize;
1210 int dsp_stereo;
1211 LPWAVEFORMAT lpFormat;
1212 dprintf_mciwave(stddeb, "widOpen(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
1213 if (lpDesc == NULL) {
1214 dprintf_mciwave(stddeb,"Linux 'widOpen' // Invalid Parameter !\n");
1215 return MMSYSERR_INVALPARAM;
1216 }
1217 if (wDevID >= MAX_WAVINDRV) {
1218 dprintf_mciwave(stddeb,"Linux 'widOpen' // MAX_WAVINDRV reached !\n");
1219 return MMSYSERR_ALLOCATED;
1220 }
1221 WInDev[wDevID].unixdev = 0;
1222 audio = open (SOUND_DEV, O_RDONLY, 0);
1223 if (audio == -1) {
1224 dprintf_mciwave(stddeb,"Linux 'widOpen' // can't open !\n");
1225 return MMSYSERR_NOTENABLED;
1226 }
1227 IOCTL(audio, SNDCTL_DSP_GETBLKSIZE, abuf_size);
1228 if (abuf_size < 1024 || abuf_size > 65536) {
1229 if (abuf_size == -1)
1230 dprintf_mciwave(stddeb,"Linux 'widOpen' // IOCTL can't 'SNDCTL_DSP_GETBLKSIZE' !\n");
1231 else
1232 dprintf_mciwave(stddeb,"Linux 'widOpen' // SNDCTL_DSP_GETBLKSIZE Invalid bufsize !\n");
1233 return MMSYSERR_NOTENABLED;
1234 }
1235 WInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1236 switch(WInDev[wDevID].wFlags) {
1237 case DCB_NULL:
1238 dprintf_mciwave(stddeb, "Linux 'widOpen' // CALLBACK_NULL !\n");
1239 break;
1240 case DCB_WINDOW:
1241 dprintf_mciwave(stddeb, "Linux 'widOpen' // CALLBACK_WINDOW !\n");
1242 break;
1243 case DCB_TASK:
1244 dprintf_mciwave(stddeb, "Linux 'widOpen' // CALLBACK_TASK !\n");
1245 break;
1246 case DCB_FUNCTION:
1247 dprintf_mciwave(stddeb, "Linux 'widOpen' // CALLBACK_FUNCTION !\n");
1248 break;
1249 }
1250 WInDev[wDevID].lpQueueHdr = NULL;
1251 WInDev[wDevID].unixdev = audio;
1252 WInDev[wDevID].bufsize = abuf_size;
1253 WInDev[wDevID].dwTotalRecorded = 0;
1254 memcpy(&WInDev[wDevID].waveDesc, lpDesc, sizeof(WAVEOPENDESC));
1255 lpFormat = lpDesc->lpFormat;
1256 if (lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
1257 dprintf_mciwave(stddeb,"Linux 'widOpen' // Bad format %04X !\n",
1258 lpFormat->wFormatTag);
1259 return WAVERR_BADFORMAT;
1260 }
1261 memcpy(&WInDev[wDevID].Format, lpFormat, sizeof(PCMWAVEFORMAT));
1262 WInDev[wDevID].Format.wBitsPerSample = 8; /* <-------------- */
1263 if (WInDev[wDevID].Format.wf.nChannels == 0) return WAVERR_BADFORMAT;
1264 if (WInDev[wDevID].Format.wf.nSamplesPerSec == 0) return WAVERR_BADFORMAT;
1265 if (WInDev[wDevID].Format.wBitsPerSample == 0) {
1266 WInDev[wDevID].Format.wBitsPerSample = 8 *
1267 (WInDev[wDevID].Format.wf.nAvgBytesPerSec /
1268 WInDev[wDevID].Format.wf.nSamplesPerSec) /
1269 WInDev[wDevID].Format.wf.nChannels;
1270 }
1271 samplesize = WInDev[wDevID].Format.wBitsPerSample;
1272 smplrate = WInDev[wDevID].Format.wf.nSamplesPerSec;
1273 dsp_stereo = (WInDev[wDevID].Format.wf.nChannels > 1) ? TRUE : FALSE;
1274 IOCTL(audio, SNDCTL_DSP_SPEED, smplrate);
1275 IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize);
1276 IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo);
1277 dprintf_mciwave(stddeb,"Linux 'widOpen' // wBitsPerSample=%u !\n",
1278 WInDev[wDevID].Format.wBitsPerSample);
1279 dprintf_mciwave(stddeb,"Linux 'widOpen' // nSamplesPerSec=%lu !\n",
1280 WInDev[wDevID].Format.wf.nSamplesPerSec);
1281 dprintf_mciwave(stddeb,"Linux 'widOpen' // nChannels=%u !\n",
1282 WInDev[wDevID].Format.wf.nChannels);
1283 dprintf_mciwave(stddeb,"Linux 'widOpen' // nAvgBytesPerSec=%lu\n",
1284 WInDev[wDevID].Format.wf.nAvgBytesPerSec);
1285 if (WAVE_NotifyClient(wDevID, WIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
1286 dprintf_mciwave(stddeb,"Linux 'widOpen' // can't notify client !\n");
1287 return MMSYSERR_INVALPARAM;
1288 }
1289 return MMSYSERR_NOERROR;
1290 }
1291
1292 /**************************************************************************
1293 * widClose [internal]
1294 */
1295 static DWORD widClose(WORD wDevID)
1296 {
1297 dprintf_mciwave(stddeb,"widClose(%u);\n", wDevID);
1298 if (WInDev[wDevID].unixdev == 0) {
1299 dprintf_mciwave(stddeb,"Linux 'widClose' // can't close !\n");
1300 return MMSYSERR_NOTENABLED;
1301 }
1302 close(WInDev[wDevID].unixdev);
1303 WInDev[wDevID].unixdev = 0;
1304 WInDev[wDevID].bufsize = 0;
1305 if (WAVE_NotifyClient(wDevID, WIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
1306 dprintf_mciwave(stddeb,"Linux 'widClose' // can't notify client !\n");
1307 return MMSYSERR_INVALPARAM;
1308 }
1309 return MMSYSERR_NOERROR;
1310 }
1311
1312 /**************************************************************************
1313 * widAddBuffer [internal]
1314 */
1315 static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1316 {
1317 int count = 1;
1318 LPWAVEHDR lpWIHdr;
1319 dprintf_mciwave(stddeb,
1320 "widAddBuffer(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1321 if (WInDev[wDevID].unixdev == 0) {
1322 dprintf_mciwave(stddeb,"Linux 'widAddBuffer' // can't do it !\n");
1323 return MMSYSERR_NOTENABLED;
1324 }
1325 if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) {
1326 dprintf_mciwave(stddeb, "Linux 'widAddBuffer' // never been prepared !\n");
1327 return WAVERR_UNPREPARED;
1328 }
1329 if (lpWaveHdr->dwFlags & WHDR_INQUEUE) {
1330 dprintf_mciwave(stddeb, "Linux 'widAddBuffer' // header already in use !\n");
1331 return WAVERR_STILLPLAYING;
1332 }
1333 lpWaveHdr->dwFlags |= WHDR_PREPARED;
1334 lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1335 lpWaveHdr->dwFlags &= ~WHDR_DONE;
1336 lpWaveHdr->dwBytesRecorded = 0;
1337 if (WInDev[wDevID].lpQueueHdr == NULL) {
1338 /* begin the queue with a first header ... */
1339 WInDev[wDevID].lpQueueHdr = lpWaveHdr;
1340 WInDev[wDevID].dwTotalRecorded = 0;
1341 }
1342 else {
1343 /* added to the queue, except if it's the one just prepared ... */
1344 lpWIHdr = WInDev[wDevID].lpQueueHdr;
1345 while (lpWIHdr->lpNext != NULL) {
1346 lpWIHdr = lpWIHdr->lpNext;
1347 count++;
1348 }
1349 lpWIHdr->lpNext = lpWaveHdr;
1350 count++;
1351 }
1352 dprintf_mciwave(stddeb,
1353 "widAddBuffer // buffer added ! (now %u in queue)\n", count);
1354 return MMSYSERR_NOERROR;
1355 }
1356
1357 /**************************************************************************
1358 * widPrepare [internal]
1359 */
1360 static DWORD widPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1361 {
1362 dprintf_mciwave(stddeb,
1363 "widPrepare(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1364 if (WInDev[wDevID].unixdev == 0) {
1365 dprintf_mciwave(stddeb,"Linux 'widPrepare' // can't prepare !\n");
1366 return MMSYSERR_NOTENABLED;
1367 }
1368 if (WInDev[wDevID].lpQueueHdr != NULL) {
1369 dprintf_mciwave(stddeb,"Linux 'widPrepare' // already prepare !\n");
1370 return WAVERR_BADFORMAT;
1371 }
1372 if (lpWaveHdr->dwFlags & WHDR_INQUEUE) return WAVERR_STILLPLAYING;
1373 lpWaveHdr->dwFlags |= WHDR_PREPARED;
1374 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1375 lpWaveHdr->dwFlags &= ~WHDR_DONE;
1376 lpWaveHdr->dwBytesRecorded = 0;
1377 dprintf_mciwave(stddeb,"Linux 'widPrepare' // header prepared !\n");
1378 return MMSYSERR_NOERROR;
1379 }
1380
1381 /**************************************************************************
1382 * widUnprepare [internal]
1383 */
1384 static DWORD widUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1385 {
1386 dprintf_mciwave(stddeb,
1387 "widUnprepare(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
1388 if (WInDev[wDevID].unixdev == 0) {
1389 dprintf_mciwave(stddeb,"Linux 'widUnprepare' // can't unprepare !\n");
1390 return MMSYSERR_NOTENABLED;
1391 }
1392 lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
1393 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1394 lpWaveHdr->dwFlags |= WHDR_DONE;
1395 WInDev[wDevID].lpQueueHdr = NULL;
1396 dprintf_mciwave(stddeb,
1397 "Linux 'widUnprepare' // all headers unprepared !\n");
1398 return MMSYSERR_NOERROR;
1399 }
1400
1401 /**************************************************************************
1402 * widStart [internal]
1403 */
1404 static DWORD widStart(WORD wDevID)
1405 {
1406 int count = 1;
1407 LPWAVEHDR lpWIHdr;
1408 dprintf_mciwave(stddeb,"widStart(%u);\n", wDevID);
1409 if (WInDev[wDevID].unixdev == 0) {
1410 dprintf_mciwave(stddeb, "Linux 'widStart' // can't start recording !\n");
1411 return MMSYSERR_NOTENABLED;
1412 }
1413 if (WInDev[wDevID].lpQueueHdr == NULL ||
1414 WInDev[wDevID].lpQueueHdr->lpData == NULL) {
1415 dprintf_mciwave(stddeb,"Linux 'widStart' // never been prepared !\n");
1416 return WAVERR_UNPREPARED;
1417 }
1418 lpWIHdr = WInDev[wDevID].lpQueueHdr;
1419 while(lpWIHdr != NULL) {
1420 lpWIHdr->dwBufferLength &= 0xFFFF;
1421 dprintf_mciwave(stddeb,
1422 "widStart // recording buf#%u=%p size=%lu \n",
1423 count, lpWIHdr->lpData, lpWIHdr->dwBufferLength);
1424 fflush(stddeb);
1425 read (WInDev[wDevID].unixdev,
1426 PTR_SEG_TO_LIN(lpWIHdr->lpData),
1427 lpWIHdr->dwBufferLength);
1428 lpWIHdr->dwBytesRecorded = lpWIHdr->dwBufferLength;
1429 WInDev[wDevID].dwTotalRecorded += lpWIHdr->dwBytesRecorded;
1430 lpWIHdr->dwFlags &= ~WHDR_INQUEUE;
1431 lpWIHdr->dwFlags |= WHDR_DONE;
1432 if (WAVE_NotifyClient(wDevID, WIM_DATA, (DWORD)lpWIHdr, 0L) !=
1433 MMSYSERR_NOERROR) {
1434 dprintf_mciwave(stddeb, "Linux 'widStart' // can't notify client !\n");
1435 return MMSYSERR_INVALPARAM;
1436 }
1437 lpWIHdr = lpWIHdr->lpNext;
1438 count++;
1439 }
1440 dprintf_mciwave(stddeb,"widStart // end of recording !\n");
1441 fflush(stdout);
1442 return MMSYSERR_NOERROR;
1443 }
1444
1445 /**************************************************************************
1446 * widStop [internal]
1447 */
1448 static DWORD widStop(WORD wDevID)
1449 {
1450 dprintf_mciwave(stddeb,"widStop(%u);\n", wDevID);
1451 if (WInDev[wDevID].unixdev == 0) {
1452 dprintf_mciwave(stddeb,"Linux 'widStop' // can't stop !\n");
1453 return MMSYSERR_NOTENABLED;
1454 }
1455 return MMSYSERR_NOERROR;
1456 }
1457
1458 /**************************************************************************
1459 * widReset [internal]
1460 */
1461 static DWORD widReset(WORD wDevID)
1462 {
1463 dprintf_mciwave(stddeb,"widReset(%u);\n", wDevID);
1464 if (WInDev[wDevID].unixdev == 0) {
1465 dprintf_mciwave(stddeb,"Linux 'widReset' // can't reset !\n");
1466 return MMSYSERR_NOTENABLED;
1467 }
1468 return MMSYSERR_NOERROR;
1469 }
1470
1471 /**************************************************************************
1472 * widGetPosition [internal]
1473 */
1474 static DWORD widGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1475 {
1476 int time;
1477
1478 dprintf_mciwave(stddeb,
1479 "widGetPosition(%u, %p, %lu);\n", wDevID, lpTime, uSize);
1480 if (WInDev[wDevID].unixdev == 0) {
1481 dprintf_mciwave(stddeb,"Linux 'widGetPosition' // can't get pos !\n");
1482 return MMSYSERR_NOTENABLED;
1483 }
1484 if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1485 dprintf_mciwave(stddeb,"widGetPosition // wType=%04X !\n",
1486 lpTime->wType);
1487 dprintf_mciwave(stddeb,"widGetPosition // wBitsPerSample=%u\n",
1488 WInDev[wDevID].Format.wBitsPerSample);
1489 dprintf_mciwave(stddeb,"widGetPosition // nSamplesPerSec=%lu\n",
1490 WInDev[wDevID].Format.wf.nSamplesPerSec);
1491 dprintf_mciwave(stddeb,"widGetPosition // nChannels=%u\n",
1492 WInDev[wDevID].Format.wf.nChannels);
1493 dprintf_mciwave(stddeb,"widGetPosition // nAvgBytesPerSec=%lu\n",
1494 WInDev[wDevID].Format.wf.nAvgBytesPerSec);
1495 fflush(stddeb);
1496 switch(lpTime->wType) {
1497 case TIME_BYTES:
1498 lpTime->u.cb = WInDev[wDevID].dwTotalRecorded;
1499 dprintf_mciwave(stddeb,
1500 "widGetPosition // TIME_BYTES=%lu\n", lpTime->u.cb);
1501 break;
1502 case TIME_SAMPLES:
1503 lpTime->u.sample = WInDev[wDevID].dwTotalRecorded * 8 /
1504 WInDev[wDevID].Format.wBitsPerSample;
1505 dprintf_mciwave(stddeb,
1506 "widGetPosition // TIME_SAMPLES=%lu\n",
1507 lpTime->u.sample);
1508 break;
1509 case TIME_SMPTE:
1510 time = WInDev[wDevID].dwTotalRecorded /
1511 (WInDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
1512 lpTime->u.smpte.hour = time / 108000;
1513 time -= lpTime->u.smpte.hour * 108000;
1514 lpTime->u.smpte.min = time / 1800;
1515 time -= lpTime->u.smpte.min * 1800;
1516 lpTime->u.smpte.sec = time / 30;
1517 time -= lpTime->u.smpte.sec * 30;
1518 lpTime->u.smpte.frame = time;
1519 lpTime->u.smpte.fps = 30;
1520 dprintf_mciwave(stddeb,"widGetPosition // TIME_SMPTE=%02u:%02u:%02u:%02u\n",
1521 lpTime->u.smpte.hour, lpTime->u.smpte.min,
1522 lpTime->u.smpte.sec, lpTime->u.smpte.frame);
1523 break;
1524 default:
1525 dprintf_mciwave(stddeb,"widGetPosition() format not supported ! use TIME_MS !\n");
1526 lpTime->wType = TIME_MS;
1527 case TIME_MS:
1528 lpTime->u.ms = WInDev[wDevID].dwTotalRecorded /
1529 (WInDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
1530 dprintf_mciwave(stddeb,
1531 "widGetPosition // TIME_MS=%lu\n", lpTime->u.ms);
1532 break;
1533 }
1534 return MMSYSERR_NOERROR;
1535 }
1536
1537 #endif /* linux || __FreeBSD__ */
1538
1539 /**************************************************************************
1540 * widMessage [sample driver]
1541 */
1542 DWORD widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1543 DWORD dwParam1, DWORD dwParam2)
1544 {
1545 dprintf_mciwave(stddeb,"widMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
1546 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1547 #if defined(linux) || defined(__FreeBSD__)
1548 switch(wMsg) {
1549 case WIDM_OPEN:
1550 return widOpen(wDevID, (LPWAVEOPENDESC)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1551 case WIDM_CLOSE:
1552 return widClose(wDevID);
1553 case WIDM_ADDBUFFER:
1554 return widAddBuffer(wDevID, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1555 case WIDM_PREPARE:
1556 return widPrepare(wDevID, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1557 case WIDM_UNPREPARE:
1558 return widUnprepare(wDevID, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1559 case WIDM_GETDEVCAPS:
1560 return widGetDevCaps(wDevID, (LPWAVEINCAPS)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1561 case WIDM_GETNUMDEVS:
1562 return 1;
1563 case WIDM_GETPOS:
1564 return widGetPosition(wDevID, (LPMMTIME)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1565 case WIDM_RESET:
1566 return widReset(wDevID);
1567 case WIDM_START:
1568 return widStart(wDevID);
1569 case WIDM_STOP:
1570 return widStop(wDevID);
1571 default:
1572 dprintf_mciwave(stddeb,"widMessage // unknown message !\n");
1573 }
1574 return MMSYSERR_NOTSUPPORTED;
1575 #else
1576 return MMSYSERR_NOTENABLED;
1577 #endif
1578 }
1579
1580
1581 /**************************************************************************
1582 * AUDIO_DriverProc [sample driver]
1583 */
1584 LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
1585 DWORD dwParam1, DWORD dwParam2)
1586 {
1587 #if defined(linux) || defined(__FreeBSD__)
1588 dprintf_mciwave(stddeb,"WAVE_DriverProc(%08lX, %04X, %04X, %08lX, %08lX)\n",
1589 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1590 switch(wMsg) {
1591 case DRV_LOAD:
1592 return 1;
1593 case DRV_FREE:
1594 return 1;
1595 case DRV_OPEN:
1596 return 1;
1597 case DRV_CLOSE:
1598 return 1;
1599 case DRV_ENABLE:
1600 return 1;
1601 case DRV_DISABLE:
1602 return 1;
1603 case DRV_QUERYCONFIGURE:
1604 return 1;
1605 case DRV_CONFIGURE:
1606 MessageBox16((HWND)NULL, "Sample MultiMedia Linux Driver !",
1607 "MMLinux Driver", MB_OK);
1608 return 1;
1609 case DRV_INSTALL:
1610 return DRVCNF_RESTART;
1611 case DRV_REMOVE:
1612 return DRVCNF_RESTART;
1613 case MCI_OPEN_DRIVER:
1614 case MCI_OPEN:
1615 return WAVE_mciOpen(dwDevID, dwParam1, (LPMCI_WAVE_OPEN_PARMS)PTR_SEG_TO_LIN(dwParam2));
1616 case MCI_CLOSE_DRIVER:
1617 case MCI_CLOSE:
1618 return WAVE_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
1619 case MCI_PLAY:
1620 return WAVE_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
1621 case MCI_RECORD:
1622 return WAVE_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)PTR_SEG_TO_LIN(dwParam2));
1623 case MCI_STOP:
1624 return WAVE_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
1625 case MCI_SET:
1626 return WAVE_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
1627 case MCI_PAUSE:
1628 return WAVE_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
1629 case MCI_RESUME:
1630 return WAVE_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
1631 case MCI_STATUS:
1632 return WAVE_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
1633 case MCI_GETDEVCAPS:
1634 return WAVE_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
1635 case MCI_INFO:
1636 return WAVE_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS)PTR_SEG_TO_LIN(dwParam2));
1637 default:
1638 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1639 }
1640 #else
1641 return MMSYSERR_NOTENABLED;
1642 #endif
1643 }
1644
1645
1646 #endif /* #ifdef BUILTIN_MMSYSTEM */
GSOC 2012 project to enhance the control panel