2 * Sample Wine Driver for Open Sound System (featured in Linux and FreeBSD)
4 * Copyright 1994 Martin Ayotte
5 * 1999 Eric Pouech (async playing in waveOut/waveIn)
6 * 2000 Eric Pouech (loops in waveOut)
7 * 2002 Eric Pouech (full duplex)
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.
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.
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
25 * pause in waveOut does not work correctly in loop mode
26 * Direct Sound Capture driver does not work (not complete yet)
29 /* an exact wodGetPosition is usually not worth the extra context switches,
30 * as we're going to have near fragment accuracy anyway */
31 #define EXACT_WODPOSITION
32 #define EXACT_WIDPOSITION
35 #include "wine/port.h"
46 #ifdef HAVE_SYS_IOCTL_H
47 # include <sys/ioctl.h>
49 #ifdef HAVE_SYS_MMAN_H
50 # include <sys/mman.h>
55 #ifdef HAVE_SYS_POLL_H
56 # include <sys/poll.h>
74 #include "wine/debug.h"
78 WINE_DEFAULT_DEBUG_CHANNEL(wave
);
80 /* Allow 1% deviation for sample rates (some ES137x cards) */
81 #define NEAR_MATCH(rate1,rate2) (((100*((int)(rate1)-(int)(rate2)))/(rate1))==0)
85 WINE_WAVEOUT WOutDev
[MAX_WAVEDRV
];
86 WINE_WAVEIN WInDev
[MAX_WAVEDRV
];
90 /* state diagram for waveOut writing:
92 * +---------+-------------+---------------+---------------------------------+
93 * | state | function | event | new state |
94 * +---------+-------------+---------------+---------------------------------+
95 * | | open() | | STOPPED |
96 * | PAUSED | write() | | PAUSED |
97 * | STOPPED | write() | <thrd create> | PLAYING |
98 * | PLAYING | write() | HEADER | PLAYING |
99 * | (other) | write() | <error> | |
100 * | (any) | pause() | PAUSING | PAUSED |
101 * | PAUSED | restart() | RESTARTING | PLAYING (if no thrd => STOPPED) |
102 * | (any) | reset() | RESETTING | STOPPED |
103 * | (any) | close() | CLOSING | CLOSED |
104 * +---------+-------------+---------------+---------------------------------+
107 /* These strings used only for tracing */
108 static const char * getCmdString(enum win_wm_message msg
)
110 #define MSG_TO_STR(x) case x: return #x
112 MSG_TO_STR(WINE_WM_PAUSING
);
113 MSG_TO_STR(WINE_WM_RESTARTING
);
114 MSG_TO_STR(WINE_WM_RESETTING
);
115 MSG_TO_STR(WINE_WM_HEADER
);
116 MSG_TO_STR(WINE_WM_UPDATE
);
117 MSG_TO_STR(WINE_WM_BREAKLOOP
);
118 MSG_TO_STR(WINE_WM_CLOSING
);
119 MSG_TO_STR(WINE_WM_STARTING
);
120 MSG_TO_STR(WINE_WM_STOPPING
);
123 return wine_dbg_sprintf("UNKNOWN(0x%08x)", msg
);
126 int getEnables(OSS_DEVICE
*ossdev
)
128 return ( (ossdev
->bOutputEnabled
? PCM_ENABLE_OUTPUT
: 0) |
129 (ossdev
->bInputEnabled
? PCM_ENABLE_INPUT
: 0) );
132 static const char * getMessage(UINT msg
)
134 #define MSG_TO_STR(x) case x: return #x
136 MSG_TO_STR(DRVM_INIT
);
137 MSG_TO_STR(DRVM_EXIT
);
138 MSG_TO_STR(DRVM_ENABLE
);
139 MSG_TO_STR(DRVM_DISABLE
);
140 MSG_TO_STR(WIDM_OPEN
);
141 MSG_TO_STR(WIDM_CLOSE
);
142 MSG_TO_STR(WIDM_ADDBUFFER
);
143 MSG_TO_STR(WIDM_PREPARE
);
144 MSG_TO_STR(WIDM_UNPREPARE
);
145 MSG_TO_STR(WIDM_GETDEVCAPS
);
146 MSG_TO_STR(WIDM_GETNUMDEVS
);
147 MSG_TO_STR(WIDM_GETPOS
);
148 MSG_TO_STR(WIDM_RESET
);
149 MSG_TO_STR(WIDM_START
);
150 MSG_TO_STR(WIDM_STOP
);
151 MSG_TO_STR(WODM_OPEN
);
152 MSG_TO_STR(WODM_CLOSE
);
153 MSG_TO_STR(WODM_WRITE
);
154 MSG_TO_STR(WODM_PAUSE
);
155 MSG_TO_STR(WODM_GETPOS
);
156 MSG_TO_STR(WODM_BREAKLOOP
);
157 MSG_TO_STR(WODM_PREPARE
);
158 MSG_TO_STR(WODM_UNPREPARE
);
159 MSG_TO_STR(WODM_GETDEVCAPS
);
160 MSG_TO_STR(WODM_GETNUMDEVS
);
161 MSG_TO_STR(WODM_GETPITCH
);
162 MSG_TO_STR(WODM_SETPITCH
);
163 MSG_TO_STR(WODM_GETPLAYBACKRATE
);
164 MSG_TO_STR(WODM_SETPLAYBACKRATE
);
165 MSG_TO_STR(WODM_GETVOLUME
);
166 MSG_TO_STR(WODM_SETVOLUME
);
167 MSG_TO_STR(WODM_RESTART
);
168 MSG_TO_STR(WODM_RESET
);
169 MSG_TO_STR(DRV_QUERYDEVICEINTERFACESIZE
);
170 MSG_TO_STR(DRV_QUERYDEVICEINTERFACE
);
171 MSG_TO_STR(DRV_QUERYDSOUNDIFACE
);
172 MSG_TO_STR(DRV_QUERYDSOUNDDESC
);
175 return wine_dbg_sprintf("UNKNOWN(0x%04x)", msg
);
178 static DWORD
wodDevInterfaceSize(UINT wDevID
, LPDWORD dwParam1
)
180 TRACE("(%u, %p)\n", wDevID
, dwParam1
);
182 *dwParam1
= MultiByteToWideChar(CP_UNIXCP
, 0, WOutDev
[wDevID
].ossdev
.interface_name
, -1,
183 NULL
, 0 ) * sizeof(WCHAR
);
184 return MMSYSERR_NOERROR
;
187 static DWORD
wodDevInterface(UINT wDevID
, PWCHAR dwParam1
, DWORD dwParam2
)
189 if (dwParam2
>= MultiByteToWideChar(CP_UNIXCP
, 0, WOutDev
[wDevID
].ossdev
.interface_name
, -1,
190 NULL
, 0 ) * sizeof(WCHAR
))
192 MultiByteToWideChar(CP_UNIXCP
, 0, WOutDev
[wDevID
].ossdev
.interface_name
, -1,
193 dwParam1
, dwParam2
/ sizeof(WCHAR
));
194 return MMSYSERR_NOERROR
;
197 return MMSYSERR_INVALPARAM
;
200 static DWORD
widDevInterfaceSize(UINT wDevID
, LPDWORD dwParam1
)
202 TRACE("(%u, %p)\n", wDevID
, dwParam1
);
204 *dwParam1
= MultiByteToWideChar(CP_UNIXCP
, 0, WInDev
[wDevID
].ossdev
.interface_name
, -1,
205 NULL
, 0 ) * sizeof(WCHAR
);
206 return MMSYSERR_NOERROR
;
209 static DWORD
widDevInterface(UINT wDevID
, PWCHAR dwParam1
, DWORD dwParam2
)
211 if (dwParam2
>= MultiByteToWideChar(CP_UNIXCP
, 0, WInDev
[wDevID
].ossdev
.interface_name
, -1,
212 NULL
, 0 ) * sizeof(WCHAR
))
214 MultiByteToWideChar(CP_UNIXCP
, 0, WInDev
[wDevID
].ossdev
.interface_name
, -1,
215 dwParam1
, dwParam2
/ sizeof(WCHAR
));
216 return MMSYSERR_NOERROR
;
219 return MMSYSERR_INVALPARAM
;
222 static DWORD
bytes_to_mmtime(LPMMTIME lpTime
, DWORD position
,
223 WAVEFORMATPCMEX
* format
)
225 TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%u nChannels=%u nAvgBytesPerSec=%u\n",
226 lpTime
->wType
, format
->Format
.wBitsPerSample
, format
->Format
.nSamplesPerSec
,
227 format
->Format
.nChannels
, format
->Format
.nAvgBytesPerSec
);
228 TRACE("Position in bytes=%u\n", position
);
230 switch (lpTime
->wType
) {
232 lpTime
->u
.sample
= position
/ (format
->Format
.wBitsPerSample
/ 8 * format
->Format
.nChannels
);
233 TRACE("TIME_SAMPLES=%u\n", lpTime
->u
.sample
);
236 lpTime
->u
.ms
= 1000.0 * position
/ (format
->Format
.wBitsPerSample
/ 8 * format
->Format
.nChannels
* format
->Format
.nSamplesPerSec
);
237 TRACE("TIME_MS=%u\n", lpTime
->u
.ms
);
240 lpTime
->u
.smpte
.fps
= 30;
241 position
= position
/ (format
->Format
.wBitsPerSample
/ 8 * format
->Format
.nChannels
);
242 position
+= (format
->Format
.nSamplesPerSec
/ lpTime
->u
.smpte
.fps
) - 1; /* round up */
243 lpTime
->u
.smpte
.sec
= position
/ format
->Format
.nSamplesPerSec
;
244 position
-= lpTime
->u
.smpte
.sec
* format
->Format
.nSamplesPerSec
;
245 lpTime
->u
.smpte
.min
= lpTime
->u
.smpte
.sec
/ 60;
246 lpTime
->u
.smpte
.sec
-= 60 * lpTime
->u
.smpte
.min
;
247 lpTime
->u
.smpte
.hour
= lpTime
->u
.smpte
.min
/ 60;
248 lpTime
->u
.smpte
.min
-= 60 * lpTime
->u
.smpte
.hour
;
249 lpTime
->u
.smpte
.fps
= 30;
250 lpTime
->u
.smpte
.frame
= position
* lpTime
->u
.smpte
.fps
/ format
->Format
.nSamplesPerSec
;
251 TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
252 lpTime
->u
.smpte
.hour
, lpTime
->u
.smpte
.min
,
253 lpTime
->u
.smpte
.sec
, lpTime
->u
.smpte
.frame
);
256 WARN("Format %d not supported, using TIME_BYTES !\n", lpTime
->wType
);
257 lpTime
->wType
= TIME_BYTES
;
260 lpTime
->u
.cb
= position
;
261 TRACE("TIME_BYTES=%u\n", lpTime
->u
.cb
);
264 return MMSYSERR_NOERROR
;
267 static BOOL
supportedFormat(LPWAVEFORMATEX wf
)
271 if (wf
->nSamplesPerSec
<DSBFREQUENCY_MIN
||wf
->nSamplesPerSec
>DSBFREQUENCY_MAX
)
274 if (wf
->wFormatTag
== WAVE_FORMAT_PCM
) {
275 if (wf
->nChannels
>= 1 && wf
->nChannels
<= MAX_CHANNELS
) {
276 if (wf
->wBitsPerSample
==8||wf
->wBitsPerSample
==16)
279 } else if (wf
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
) {
280 WAVEFORMATEXTENSIBLE
* wfex
= (WAVEFORMATEXTENSIBLE
*)wf
;
282 if (wf
->cbSize
== 22 && IsEqualGUID(&wfex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
)) {
283 if (wf
->nChannels
>=1 && wf
->nChannels
<= MAX_CHANNELS
) {
284 if (wf
->wBitsPerSample
==wfex
->Samples
.wValidBitsPerSample
) {
285 if (wf
->wBitsPerSample
==8||wf
->wBitsPerSample
==16)
288 WARN("wBitsPerSample != wValidBitsPerSample not supported yet\n");
291 WARN("only KSDATAFORMAT_SUBTYPE_PCM supported\n");
293 WARN("only WAVE_FORMAT_PCM and WAVE_FORMAT_EXTENSIBLE supported\n");
298 void copy_format(LPWAVEFORMATEX wf1
, LPWAVEFORMATPCMEX wf2
)
300 ZeroMemory(wf2
, sizeof(*wf2
));
301 if (wf1
->wFormatTag
== WAVE_FORMAT_PCM
)
302 memcpy(wf2
, wf1
, sizeof(PCMWAVEFORMAT
));
303 else if (wf1
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
)
304 memcpy(wf2
, wf1
, sizeof(WAVEFORMATPCMEX
));
306 memcpy(wf2
, wf1
, sizeof(WAVEFORMATEX
) + wf1
->cbSize
);
309 /*======================================================================*
310 * Low level WAVE implementation *
311 *======================================================================*/
313 /******************************************************************
316 * Low level device opening (from values stored in ossdev)
318 static DWORD
OSS_RawOpenDevice(OSS_DEVICE
* ossdev
, int strict_format
)
321 TRACE("(%p,%d)\n",ossdev
,strict_format
);
323 TRACE("open_access=%s\n",
324 ossdev
->open_access
== O_RDONLY
? "O_RDONLY" :
325 ossdev
->open_access
== O_WRONLY
? "O_WRONLY" :
326 ossdev
->open_access
== O_RDWR
? "O_RDWR" : "Unknown");
328 if ((fd
= open(ossdev
->dev_name
, ossdev
->open_access
|O_NDELAY
, 0)) == -1)
330 WARN("Couldn't open %s (%s)\n", ossdev
->dev_name
, strerror(errno
));
331 return (errno
== EBUSY
) ? MMSYSERR_ALLOCATED
: MMSYSERR_ERROR
;
333 fcntl(fd
, F_SETFD
, 1); /* set close on exec flag */
334 /* turn full duplex on if it has been requested */
335 if (ossdev
->open_access
== O_RDWR
&& ossdev
->full_duplex
) {
336 rc
= ioctl(fd
, SNDCTL_DSP_SETDUPLEX
, 0);
337 /* on *BSD, as full duplex is always enabled by default, this ioctl
338 * will fail with EINVAL
339 * so, we don't consider EINVAL an error here
341 if (rc
!= 0 && errno
!= EINVAL
) {
342 WARN("ioctl(%s, SNDCTL_DSP_SETDUPLEX) failed (%s)\n", ossdev
->dev_name
, strerror(errno
));
347 if (ossdev
->audio_fragment
) {
348 rc
= ioctl(fd
, SNDCTL_DSP_SETFRAGMENT
, &ossdev
->audio_fragment
);
350 ERR("ioctl(%s, SNDCTL_DSP_SETFRAGMENT) failed (%s)\n", ossdev
->dev_name
, strerror(errno
));
355 /* First size and channels then samplerate */
356 if (ossdev
->format
>=0)
358 val
= ossdev
->format
;
359 rc
= ioctl(fd
, SNDCTL_DSP_SETFMT
, &ossdev
->format
);
360 if (rc
!= 0 || val
!= ossdev
->format
) {
361 TRACE("Can't set format to %d (returned %d)\n", val
, ossdev
->format
);
366 if (ossdev
->channels
>=0)
368 val
= ossdev
->channels
;
369 rc
= ioctl(fd
, SNDCTL_DSP_CHANNELS
, &ossdev
->channels
);
370 if (rc
!= 0 || val
!= ossdev
->channels
) {
371 TRACE("Can't set channels to %u (returned %d)\n", val
, ossdev
->channels
);
376 if (ossdev
->sample_rate
>=0)
378 val
= ossdev
->sample_rate
;
379 rc
= ioctl(fd
, SNDCTL_DSP_SPEED
, &ossdev
->sample_rate
);
380 if (rc
!= 0 || !NEAR_MATCH(val
, ossdev
->sample_rate
)) {
381 TRACE("Can't set sample_rate to %u (returned %d)\n", val
, ossdev
->sample_rate
);
388 ossdev
->bOutputEnabled
= TRUE
; /* OSS enables by default */
389 ossdev
->bInputEnabled
= TRUE
; /* OSS enables by default */
390 if (ossdev
->open_access
== O_RDONLY
)
391 ossdev
->bOutputEnabled
= FALSE
;
392 if (ossdev
->open_access
== O_WRONLY
)
393 ossdev
->bInputEnabled
= FALSE
;
395 if (ossdev
->bTriggerSupport
) {
397 trigger
= getEnables(ossdev
);
398 /* If we do not have full duplex, but they opened RDWR
399 ** (as you have to in order for an mmap to succeed)
400 ** then we start out with input off
402 if (ossdev
->open_access
== O_RDWR
&& !ossdev
->full_duplex
&&
403 ossdev
->bInputEnabled
&& ossdev
->bOutputEnabled
) {
404 ossdev
->bInputEnabled
= FALSE
;
405 trigger
&= ~PCM_ENABLE_INPUT
;
406 ioctl(fd
, SNDCTL_DSP_SETTRIGGER
, &trigger
);
410 return MMSYSERR_NOERROR
;
414 return WAVERR_BADFORMAT
;
417 return MMSYSERR_ERROR
;
420 /******************************************************************
423 * since OSS has poor capabilities in full duplex, we try here to let a program
424 * open the device for both waveout and wavein streams...
425 * this is hackish, but it's the way OSS interface is done...
427 DWORD
OSS_OpenDevice(OSS_DEVICE
* ossdev
, unsigned req_access
,
428 int* frag
, int strict_format
,
429 int sample_rate
, int channels
, int fmt
)
433 TRACE("(%p,%u,%p,%d,%d,%d,%x)\n",ossdev
,req_access
,frag
,strict_format
,sample_rate
,channels
,fmt
);
435 if (ossdev
->full_duplex
&& (req_access
== O_RDONLY
|| req_access
== O_WRONLY
))
437 TRACE("Opening RDWR because full_duplex=%d and req_access=%d\n",
438 ossdev
->full_duplex
,req_access
);
439 open_access
= O_RDWR
;
443 open_access
=req_access
;
446 /* FIXME: this should be protected, and it also contains a race with OSS_CloseDevice */
447 if (ossdev
->open_count
== 0)
449 if (access(ossdev
->dev_name
, 0) != 0) return MMSYSERR_NODRIVER
;
451 ossdev
->audio_fragment
= (frag
) ? *frag
: 0;
452 ossdev
->sample_rate
= sample_rate
;
453 ossdev
->channels
= channels
;
454 ossdev
->format
= fmt
;
455 ossdev
->open_access
= open_access
;
456 ossdev
->owner_tid
= GetCurrentThreadId();
458 if ((ret
= OSS_RawOpenDevice(ossdev
,strict_format
)) != MMSYSERR_NOERROR
) return ret
;
459 if (ossdev
->full_duplex
&& ossdev
->bTriggerSupport
&&
460 (req_access
== O_RDONLY
|| req_access
== O_WRONLY
))
463 if (req_access
== O_WRONLY
)
464 ossdev
->bInputEnabled
=0;
466 ossdev
->bOutputEnabled
=0;
467 enable
= getEnables(ossdev
);
468 TRACE("Calling SNDCTL_DSP_SETTRIGGER with %x\n",enable
);
469 if (ioctl(ossdev
->fd
, SNDCTL_DSP_SETTRIGGER
, &enable
) < 0)
470 ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER, %d) failed (%s)\n",ossdev
->dev_name
, enable
, strerror(errno
));
475 /* check we really open with the same parameters */
476 if (ossdev
->open_access
!= open_access
)
478 ERR("FullDuplex: Mismatch in access. Your sound device is not full duplex capable.\n");
479 return WAVERR_BADFORMAT
;
482 /* check if the audio parameters are the same */
483 if (ossdev
->sample_rate
!= sample_rate
||
484 ossdev
->channels
!= channels
||
485 ossdev
->format
!= fmt
)
487 /* This is not a fatal error because MSACM might do the remapping */
488 WARN("FullDuplex: mismatch in PCM parameters for input and output\n"
489 "OSS doesn't allow us different parameters\n"
490 "audio_frag(%x/%x) sample_rate(%d/%d) channels(%d/%d) fmt(%d/%d)\n",
491 ossdev
->audio_fragment
, frag
? *frag
: 0,
492 ossdev
->sample_rate
, sample_rate
,
493 ossdev
->channels
, channels
,
494 ossdev
->format
, fmt
);
495 return WAVERR_BADFORMAT
;
497 /* check if the fragment sizes are the same */
498 if (ossdev
->audio_fragment
!= (frag
? *frag
: 0) )
500 ERR("FullDuplex: Playback and Capture hardware acceleration levels are different.\n"
501 "Please run winecfg, open \"Audio\" page and set\n"
502 "\"Hardware Acceleration\" to \"Emulation\".\n");
503 return WAVERR_BADFORMAT
;
505 if (GetCurrentThreadId() != ossdev
->owner_tid
)
507 WARN("Another thread is trying to access audio...\n");
508 return MMSYSERR_ERROR
;
510 if (ossdev
->full_duplex
&& ossdev
->bTriggerSupport
&&
511 (req_access
== O_RDONLY
|| req_access
== O_WRONLY
))
514 if (req_access
== O_WRONLY
)
515 ossdev
->bOutputEnabled
=1;
517 ossdev
->bInputEnabled
=1;
518 enable
= getEnables(ossdev
);
519 TRACE("Calling SNDCTL_DSP_SETTRIGGER with %x\n",enable
);
520 if (ioctl(ossdev
->fd
, SNDCTL_DSP_SETTRIGGER
, &enable
) < 0)
521 ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER, %d) failed (%s)\n",ossdev
->dev_name
, enable
, strerror(errno
));
525 ossdev
->open_count
++;
527 return MMSYSERR_NOERROR
;
530 /******************************************************************
535 void OSS_CloseDevice(OSS_DEVICE
* ossdev
)
537 TRACE("(%p)\n",ossdev
);
538 if (ossdev
->open_count
>0) {
539 ossdev
->open_count
--;
541 WARN("OSS_CloseDevice called too many times\n");
543 if (ossdev
->open_count
== 0)
545 fcntl(ossdev
->fd
, F_SETFL
, fcntl(ossdev
->fd
, F_GETFL
) & ~O_NDELAY
);
546 /* reset the device before we close it in case it is in a bad state */
547 ioctl(ossdev
->fd
, SNDCTL_DSP_RESET
, 0);
548 if (close(ossdev
->fd
) != 0) FIXME("Cannot close %d: %s\n", ossdev
->fd
, strerror(errno
));
552 /******************************************************************
555 * Resets the device. OSS Commercial requires the device to be closed
556 * after a SNDCTL_DSP_RESET ioctl call... this function implements
558 * FIXME: This causes problems when doing full duplex so we really
559 * only reset when not doing full duplex. We need to do this better
562 static DWORD
OSS_ResetDevice(OSS_DEVICE
* ossdev
)
564 DWORD ret
= MMSYSERR_NOERROR
;
565 int old_fd
= ossdev
->fd
;
566 TRACE("(%p)\n", ossdev
);
568 if (ossdev
->open_count
== 1) {
569 if (ioctl(ossdev
->fd
, SNDCTL_DSP_RESET
, NULL
) == -1)
571 perror("ioctl SNDCTL_DSP_RESET");
575 ret
= OSS_RawOpenDevice(ossdev
, 1);
576 TRACE("Changing fd from %d to %d\n", old_fd
, ossdev
->fd
);
578 WARN("Not resetting device because it is in full duplex mode!\n");
583 static const int win_std_oss_fmts
[2]={AFMT_U8
,AFMT_S16_LE
};
584 static const int win_std_rates
[5]={96000,48000,44100,22050,11025};
585 static const int win_std_formats
[2][2][5]=
586 {{{WAVE_FORMAT_96M08
, WAVE_FORMAT_48M08
, WAVE_FORMAT_4M08
,
587 WAVE_FORMAT_2M08
, WAVE_FORMAT_1M08
},
588 {WAVE_FORMAT_96S08
, WAVE_FORMAT_48S08
, WAVE_FORMAT_4S08
,
589 WAVE_FORMAT_2S08
, WAVE_FORMAT_1S08
}},
590 {{WAVE_FORMAT_96M16
, WAVE_FORMAT_48M16
, WAVE_FORMAT_4M16
,
591 WAVE_FORMAT_2M16
, WAVE_FORMAT_1M16
},
592 {WAVE_FORMAT_96S16
, WAVE_FORMAT_48S16
, WAVE_FORMAT_4S16
,
593 WAVE_FORMAT_2S16
, WAVE_FORMAT_1S16
}},
596 static void OSS_Info(int fd
)
598 /* Note that this only reports the formats supported by the hardware.
599 * The driver may support other formats and do the conversions in
600 * software which is why we don't use this value
602 int oss_mask
, oss_caps
;
603 if (ioctl(fd
, SNDCTL_DSP_GETFMTS
, &oss_mask
) >= 0) {
604 TRACE("Formats=%08x ( ", oss_mask
);
605 if (oss_mask
& AFMT_MU_LAW
) TRACE("AFMT_MU_LAW ");
606 if (oss_mask
& AFMT_A_LAW
) TRACE("AFMT_A_LAW ");
607 if (oss_mask
& AFMT_IMA_ADPCM
) TRACE("AFMT_IMA_ADPCM ");
608 if (oss_mask
& AFMT_U8
) TRACE("AFMT_U8 ");
609 if (oss_mask
& AFMT_S16_LE
) TRACE("AFMT_S16_LE ");
610 if (oss_mask
& AFMT_S16_BE
) TRACE("AFMT_S16_BE ");
611 if (oss_mask
& AFMT_S8
) TRACE("AFMT_S8 ");
612 if (oss_mask
& AFMT_U16_LE
) TRACE("AFMT_U16_LE ");
613 if (oss_mask
& AFMT_U16_BE
) TRACE("AFMT_U16_BE ");
614 if (oss_mask
& AFMT_MPEG
) TRACE("AFMT_MPEG ");
616 if (oss_mask
& AFMT_AC3
) TRACE("AFMT_AC3 ");
619 if (oss_mask
& AFMT_VORBIS
) TRACE("AFMT_VORBIS ");
622 if (oss_mask
& AFMT_S32_LE
) TRACE("AFMT_S32_LE ");
625 if (oss_mask
& AFMT_S32_BE
) TRACE("AFMT_S32_BE ");
628 if (oss_mask
& AFMT_FLOAT
) TRACE("AFMT_FLOAT ");
631 if (oss_mask
& AFMT_S24_LE
) TRACE("AFMT_S24_LE ");
634 if (oss_mask
& AFMT_S24_BE
) TRACE("AFMT_S24_BE ");
636 #ifdef AFMT_SPDIF_RAW
637 if (oss_mask
& AFMT_SPDIF_RAW
) TRACE("AFMT_SPDIF_RAW ");
641 if (ioctl(fd
, SNDCTL_DSP_GETCAPS
, &oss_caps
) >= 0) {
642 TRACE("Caps=%08x\n",oss_caps
);
643 TRACE("\tRevision: %d\n", oss_caps
&DSP_CAP_REVISION
);
644 TRACE("\tDuplex: %s\n", oss_caps
& DSP_CAP_DUPLEX
? "true" : "false");
645 TRACE("\tRealtime: %s\n", oss_caps
& DSP_CAP_REALTIME
? "true" : "false");
646 TRACE("\tBatch: %s\n", oss_caps
& DSP_CAP_BATCH
? "true" : "false");
647 TRACE("\tCoproc: %s\n", oss_caps
& DSP_CAP_COPROC
? "true" : "false");
648 TRACE("\tTrigger: %s\n", oss_caps
& DSP_CAP_TRIGGER
? "true" : "false");
649 TRACE("\tMmap: %s\n", oss_caps
& DSP_CAP_MMAP
? "true" : "false");
651 TRACE("\tMulti: %s\n", oss_caps
& DSP_CAP_MULTI
? "true" : "false");
654 TRACE("\tBind: %s\n", oss_caps
& DSP_CAP_BIND
? "true" : "false");
657 TRACE("\tInput: %s\n", oss_caps
& DSP_CAP_INPUT
? "true" : "false");
659 #ifdef DSP_CAP_OUTPUT
660 TRACE("\tOutput: %s\n", oss_caps
& DSP_CAP_OUTPUT
? "true" : "false");
662 #ifdef DSP_CAP_VIRTUAL
663 TRACE("\tVirtual: %s\n", oss_caps
& DSP_CAP_VIRTUAL
? "true" : "false");
665 #ifdef DSP_CAP_ANALOGOUT
666 TRACE("\tAnalog Out: %s\n", oss_caps
& DSP_CAP_ANALOGOUT
? "true" : "false");
668 #ifdef DSP_CAP_ANALOGIN
669 TRACE("\tAnalog In: %s\n", oss_caps
& DSP_CAP_ANALOGIN
? "true" : "false");
671 #ifdef DSP_CAP_DIGITALOUT
672 TRACE("\tDigital Out: %s\n", oss_caps
& DSP_CAP_DIGITALOUT
? "true" : "false");
674 #ifdef DSP_CAP_DIGITALIN
675 TRACE("\tDigital In: %s\n", oss_caps
& DSP_CAP_DIGITALIN
? "true" : "false");
677 #ifdef DSP_CAP_ADMASK
678 TRACE("\tA/D Mask: %s\n", oss_caps
& DSP_CAP_ADMASK
? "true" : "false");
680 #ifdef DSP_CAP_SHADOW
681 TRACE("\tShadow: %s\n", oss_caps
& DSP_CAP_SHADOW
? "true" : "false");
684 TRACE("\tChannel Mask: %x\n", oss_caps
& DSP_CH_MASK
);
687 TRACE("\tSlave: %s\n", oss_caps
& DSP_CAP_SLAVE
? "true" : "false");
692 /******************************************************************
697 static BOOL
OSS_WaveOutInit(OSS_DEVICE
* ossdev
)
702 BOOL has_mixer
= FALSE
;
703 TRACE("(%p) %s\n", ossdev
, ossdev
->dev_name
);
705 if (OSS_OpenDevice(ossdev
, O_WRONLY
, NULL
, 0,-1,-1,-1) != 0)
708 ioctl(ossdev
->fd
, SNDCTL_DSP_RESET
, 0);
710 #if defined(SNDCTL_MIXERINFO)
713 if ((mixer
= open(ossdev
->mixer_name
, O_RDONLY
|O_NDELAY
)) >= 0) {
716 if (ioctl(mixer
, SNDCTL_MIXERINFO
, &info
) >= 0) {
717 lstrcpynA(ossdev
->ds_desc
.szDesc
, info
.name
, sizeof(info
.name
));
718 strcpy(ossdev
->ds_desc
.szDrvname
, "wineoss.drv");
719 MultiByteToWideChar(CP_UNIXCP
, 0, info
.name
, sizeof(info
.name
),
720 ossdev
->out_caps
.szPname
,
721 sizeof(ossdev
->out_caps
.szPname
) / sizeof(WCHAR
));
722 TRACE("%s: %s\n", ossdev
->mixer_name
, ossdev
->ds_desc
.szDesc
);
725 WARN("%s: cannot read SNDCTL_MIXERINFO!\n", ossdev
->mixer_name
);
729 WARN("open(%s) failed (%s)\n", ossdev
->mixer_name
, strerror(errno
));
732 #elif defined(SOUND_MIXER_INFO)
735 if ((mixer
= open(ossdev
->mixer_name
, O_RDONLY
|O_NDELAY
)) >= 0) {
737 if (ioctl(mixer
, SOUND_MIXER_INFO
, &info
) >= 0) {
738 lstrcpynA(ossdev
->ds_desc
.szDesc
, info
.name
, sizeof(info
.name
));
739 strcpy(ossdev
->ds_desc
.szDrvname
, "wineoss.drv");
740 MultiByteToWideChar(CP_UNIXCP
, 0, info
.name
, sizeof(info
.name
),
741 ossdev
->out_caps
.szPname
,
742 sizeof(ossdev
->out_caps
.szPname
) / sizeof(WCHAR
));
743 TRACE("%s: %s\n", ossdev
->mixer_name
, ossdev
->ds_desc
.szDesc
);
746 /* FreeBSD up to at least 5.2 provides this ioctl, but does not
747 * implement it properly, and there are probably similar issues
748 * on other platforms, so we warn but try to go ahead.
750 WARN("%s: cannot read SOUND_MIXER_INFO!\n", ossdev
->mixer_name
);
754 WARN("open(%s) failed (%s)\n", ossdev
->mixer_name
, strerror(errno
));
757 #endif /* SOUND_MIXER_INFO */
759 if (WINE_TRACE_ON(wave
))
760 OSS_Info(ossdev
->fd
);
762 ossdev
->out_caps
.wMid
= 0x00FF; /* Manufac ID */
763 ossdev
->out_caps
.wPid
= 0x0001; /* Product ID */
765 ossdev
->out_caps
.vDriverVersion
= 0x0100;
766 ossdev
->out_caps
.wChannels
= 1;
767 ossdev
->out_caps
.dwFormats
= 0x00000000;
768 ossdev
->out_caps
.wReserved1
= 0;
769 ossdev
->out_caps
.dwSupport
= has_mixer
? WAVECAPS_VOLUME
: 0;
771 /* direct sound caps */
772 ossdev
->ds_caps
.dwFlags
= DSCAPS_CERTIFIED
;
773 ossdev
->ds_caps
.dwFlags
|= DSCAPS_SECONDARY8BIT
;
774 ossdev
->ds_caps
.dwFlags
|= DSCAPS_SECONDARY16BIT
;
775 ossdev
->ds_caps
.dwFlags
|= DSCAPS_SECONDARYMONO
;
776 ossdev
->ds_caps
.dwFlags
|= DSCAPS_SECONDARYSTEREO
;
777 ossdev
->ds_caps
.dwFlags
|= DSCAPS_CONTINUOUSRATE
;
779 ossdev
->ds_caps
.dwPrimaryBuffers
= 1;
780 ossdev
->ds_caps
.dwMinSecondarySampleRate
= DSBFREQUENCY_MIN
;
781 ossdev
->ds_caps
.dwMaxSecondarySampleRate
= DSBFREQUENCY_MAX
;
783 /* We must first set the format and the stereo mode as some sound cards
784 * may support 44kHz mono but not 44kHz stereo. Also we must
785 * systematically check the return value of these ioctls as they will
786 * always succeed (see OSS Linux) but will modify the parameter to match
787 * whatever they support. The OSS specs also say we must first set the
788 * sample size, then the stereo and then the sample rate.
791 arg
=win_std_oss_fmts
[f
];
792 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_SAMPLESIZE
, &arg
);
793 if (rc
!=0 || arg
!=win_std_oss_fmts
[f
]) {
794 TRACE("DSP_SAMPLESIZE: rc=%d returned %d for %d\n",
795 rc
,arg
,win_std_oss_fmts
[f
]);
799 ossdev
->ds_caps
.dwFlags
|= DSCAPS_PRIMARY8BIT
;
801 ossdev
->ds_caps
.dwFlags
|= DSCAPS_PRIMARY16BIT
;
803 for (c
= 1; c
<= MAX_CHANNELS
; c
++) {
805 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_CHANNELS
, &arg
);
807 if (rc
!=0 || arg
!=c
) {
808 TRACE("DSP_CHANNELS: rc=%d returned %d for %d\n",rc
,arg
,c
);
812 ossdev
->ds_caps
.dwFlags
|= DSCAPS_PRIMARYMONO
;
814 ossdev
->out_caps
.wChannels
= 2;
816 ossdev
->out_caps
.dwSupport
|=WAVECAPS_LRVOLUME
;
817 ossdev
->ds_caps
.dwFlags
|= DSCAPS_PRIMARYSTEREO
;
819 ossdev
->out_caps
.wChannels
= c
;
821 for (r
=0;r
<sizeof(win_std_rates
)/sizeof(*win_std_rates
);r
++) {
822 arg
=win_std_rates
[r
];
823 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_SPEED
, &arg
);
824 TRACE("DSP_SPEED: rc=%d returned %d for %dx%dx%d\n",
825 rc
,arg
,win_std_rates
[r
],win_std_oss_fmts
[f
],c
);
826 if (rc
==0 && arg
!=0 && NEAR_MATCH(arg
,win_std_rates
[r
]) && c
< 3)
827 ossdev
->out_caps
.dwFormats
|=win_std_formats
[f
][c
-1][r
];
832 if (ioctl(ossdev
->fd
, SNDCTL_DSP_GETCAPS
, &arg
) == 0) {
833 if (arg
& DSP_CAP_TRIGGER
)
834 ossdev
->bTriggerSupport
= TRUE
;
835 if ((arg
& DSP_CAP_REALTIME
) && !(arg
& DSP_CAP_BATCH
)) {
836 ossdev
->out_caps
.dwSupport
|= WAVECAPS_SAMPLEACCURATE
;
838 /* well, might as well use the DirectSound cap flag for something */
839 if ((arg
& DSP_CAP_TRIGGER
) && (arg
& DSP_CAP_MMAP
) &&
840 !(arg
& DSP_CAP_BATCH
)) {
841 ossdev
->out_caps
.dwSupport
|= WAVECAPS_DIRECTSOUND
;
843 ossdev
->ds_caps
.dwFlags
|= DSCAPS_EMULDRIVER
;
845 #ifdef DSP_CAP_MULTI /* not every oss has this */
846 /* check for hardware secondary buffer support (multi open) */
847 if ((arg
& DSP_CAP_MULTI
) &&
848 (ossdev
->out_caps
.dwSupport
& WAVECAPS_DIRECTSOUND
)) {
849 TRACE("hardware secondary buffer support available\n");
851 ossdev
->ds_caps
.dwMaxHwMixingAllBuffers
= 16;
852 ossdev
->ds_caps
.dwMaxHwMixingStaticBuffers
= 0;
853 ossdev
->ds_caps
.dwMaxHwMixingStreamingBuffers
= 16;
855 ossdev
->ds_caps
.dwFreeHwMixingAllBuffers
= 16;
856 ossdev
->ds_caps
.dwFreeHwMixingStaticBuffers
= 0;
857 ossdev
->ds_caps
.dwFreeHwMixingStreamingBuffers
= 16;
861 OSS_CloseDevice(ossdev
);
862 TRACE("out wChannels = %d, dwFormats = %08X, dwSupport = %08X\n",
863 ossdev
->out_caps
.wChannels
, ossdev
->out_caps
.dwFormats
,
864 ossdev
->out_caps
.dwSupport
);
868 /******************************************************************
873 static BOOL
OSS_WaveInInit(OSS_DEVICE
* ossdev
)
878 TRACE("(%p) %s\n", ossdev
, ossdev
->dev_name
);
880 if (OSS_OpenDevice(ossdev
, O_RDONLY
, NULL
, 0,-1,-1,-1) != 0)
883 ioctl(ossdev
->fd
, SNDCTL_DSP_RESET
, 0);
885 #if defined(SNDCTL_MIXERINFO)
888 if ((mixer
= open(ossdev
->mixer_name
, O_RDONLY
|O_NDELAY
)) >= 0) {
891 if (ioctl(mixer
, SNDCTL_MIXERINFO
, &info
) >= 0) {
892 MultiByteToWideChar(CP_UNIXCP
, 0, info
.name
, -1,
893 ossdev
->in_caps
.szPname
,
894 sizeof(ossdev
->in_caps
.szPname
) / sizeof(WCHAR
));
895 TRACE("%s: %s\n", ossdev
->mixer_name
, ossdev
->ds_desc
.szDesc
);
897 WARN("%s: cannot read SNDCTL_MIXERINFO!\n", ossdev
->mixer_name
);
901 WARN("open(%s) failed (%s)\n", ossdev
->mixer_name
, strerror(errno
));
904 #elif defined(SOUND_MIXER_INFO)
907 if ((mixer
= open(ossdev
->mixer_name
, O_RDONLY
|O_NDELAY
)) >= 0) {
909 if (ioctl(mixer
, SOUND_MIXER_INFO
, &info
) >= 0) {
910 MultiByteToWideChar(CP_UNIXCP
, 0, info
.name
, -1,
911 ossdev
->in_caps
.szPname
,
912 sizeof(ossdev
->in_caps
.szPname
) / sizeof(WCHAR
));
913 TRACE("%s: %s\n", ossdev
->mixer_name
, ossdev
->ds_desc
.szDesc
);
915 /* FreeBSD up to at least 5.2 provides this ioctl, but does not
916 * implement it properly, and there are probably similar issues
917 * on other platforms, so we warn but try to go ahead.
919 WARN("%s: cannot read SOUND_MIXER_INFO!\n", ossdev
->mixer_name
);
923 WARN("open(%s) failed (%s)\n", ossdev
->mixer_name
, strerror(errno
));
926 #endif /* SOUND_MIXER_INFO */
928 if (WINE_TRACE_ON(wave
))
929 OSS_Info(ossdev
->fd
);
931 ossdev
->in_caps
.wMid
= 0x00FF; /* Manufac ID */
932 ossdev
->in_caps
.wPid
= 0x0001; /* Product ID */
934 ossdev
->in_caps
.dwFormats
= 0x00000000;
935 ossdev
->in_caps
.wChannels
= 1;
936 ossdev
->in_caps
.wReserved1
= 0;
938 /* direct sound caps */
939 ossdev
->dsc_caps
.dwSize
= sizeof(ossdev
->dsc_caps
);
940 ossdev
->dsc_caps
.dwFlags
= 0;
941 ossdev
->dsc_caps
.dwFormats
= 0x00000000;
942 ossdev
->dsc_caps
.dwChannels
= 1;
944 /* See the comment in OSS_WaveOutInit for the loop order */
946 arg
=win_std_oss_fmts
[f
];
947 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_SAMPLESIZE
, &arg
);
948 if (rc
!=0 || arg
!=win_std_oss_fmts
[f
]) {
949 TRACE("DSP_SAMPLESIZE: rc=%d returned 0x%x for 0x%x\n",
950 rc
,arg
,win_std_oss_fmts
[f
]);
954 for (c
= 1; c
<= MAX_CHANNELS
; c
++) {
956 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_CHANNELS
, &arg
);
958 if (rc
!=0 || arg
!=c
) {
959 TRACE("DSP_CHANNELS: rc=%d returned %d for %d\n",rc
,arg
,c
);
963 ossdev
->in_caps
.wChannels
= c
;
964 ossdev
->dsc_caps
.dwChannels
= c
;
967 for (r
=0;r
<sizeof(win_std_rates
)/sizeof(*win_std_rates
);r
++) {
968 arg
=win_std_rates
[r
];
969 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_SPEED
, &arg
);
970 TRACE("DSP_SPEED: rc=%d returned %d for %dx%dx%d\n",rc
,arg
,win_std_rates
[r
],win_std_oss_fmts
[f
],c
);
971 if (rc
==0 && NEAR_MATCH(arg
,win_std_rates
[r
]) && c
< 3)
972 ossdev
->in_caps
.dwFormats
|=win_std_formats
[f
][c
-1][r
];
973 ossdev
->dsc_caps
.dwFormats
|=win_std_formats
[f
][c
-1][r
];
978 if (ioctl(ossdev
->fd
, SNDCTL_DSP_GETCAPS
, &arg
) == 0) {
979 if (arg
& DSP_CAP_TRIGGER
)
980 ossdev
->bTriggerSupport
= TRUE
;
981 if ((arg
& DSP_CAP_TRIGGER
) && (arg
& DSP_CAP_MMAP
) &&
982 !(arg
& DSP_CAP_BATCH
)) {
983 /* FIXME: enable the next statement if you want to work on the driver */
985 ossdev
->in_caps_support
|= WAVECAPS_DIRECTSOUND
;
988 if ((arg
& DSP_CAP_REALTIME
) && !(arg
& DSP_CAP_BATCH
))
989 ossdev
->in_caps_support
|= WAVECAPS_SAMPLEACCURATE
;
991 OSS_CloseDevice(ossdev
);
992 TRACE("in wChannels = %d, dwFormats = %08X, in_caps_support = %08X\n",
993 ossdev
->in_caps
.wChannels
, ossdev
->in_caps
.dwFormats
, ossdev
->in_caps_support
);
997 /******************************************************************
998 * OSS_WaveFullDuplexInit
1002 static void OSS_WaveFullDuplexInit(OSS_DEVICE
* ossdev
)
1008 BOOL has_mixer
= FALSE
;
1009 TRACE("(%p) %s\n", ossdev
, ossdev
->dev_name
);
1011 /* The OSS documentation says we must call SNDCTL_SETDUPLEX
1012 * *before* checking for SNDCTL_DSP_GETCAPS otherwise we may
1013 * get the wrong result. This ioctl must even be done before
1014 * setting the fragment size so that only OSS_RawOpenDevice is
1015 * in a position to do it. So we set full_duplex speculatively
1016 * and adjust right after.
1018 ossdev
->full_duplex
=1;
1019 rc
=OSS_OpenDevice(ossdev
, O_RDWR
, NULL
, 0,-1,-1,-1);
1020 ossdev
->full_duplex
=0;
1024 ioctl(ossdev
->fd
, SNDCTL_DSP_RESET
, 0);
1026 #if defined(SNDCTL_MIXERINFO)
1029 if ((mixer
= open(ossdev
->mixer_name
, O_RDWR
|O_NDELAY
)) >= 0) {
1032 if (ioctl(mixer
, SNDCTL_MIXERINFO
, &info
) >= 0) {
1035 WARN("%s: cannot read SNDCTL_MIXERINFO!\n", ossdev
->mixer_name
);
1039 WARN("open(%s) failed (%s)\n", ossdev
->mixer_name
, strerror(errno
));
1042 #elif defined(SOUND_MIXER_INFO)
1045 if ((mixer
= open(ossdev
->mixer_name
, O_RDWR
|O_NDELAY
)) >= 0) {
1047 if (ioctl(mixer
, SOUND_MIXER_INFO
, &info
) >= 0) {
1050 /* FreeBSD up to at least 5.2 provides this ioctl, but does not
1051 * implement it properly, and there are probably similar issues
1052 * on other platforms, so we warn but try to go ahead.
1054 WARN("%s: cannot read SOUND_MIXER_INFO!\n", ossdev
->mixer_name
);
1058 WARN("open(%s) failed (%s)\n", ossdev
->mixer_name
, strerror(errno
));
1061 #endif /* SOUND_MIXER_INFO */
1063 TRACE("%s\n", ossdev
->ds_desc
.szDesc
);
1065 if (ioctl(ossdev
->fd
, SNDCTL_DSP_GETCAPS
, &caps
) == 0)
1066 ossdev
->full_duplex
= (caps
& DSP_CAP_DUPLEX
);
1068 ossdev
->duplex_out_caps
= ossdev
->out_caps
;
1070 ossdev
->duplex_out_caps
.wChannels
= 1;
1071 ossdev
->duplex_out_caps
.dwFormats
= 0x00000000;
1072 ossdev
->duplex_out_caps
.dwSupport
= has_mixer
? WAVECAPS_VOLUME
: 0;
1074 if (WINE_TRACE_ON(wave
))
1075 OSS_Info(ossdev
->fd
);
1077 /* See the comment in OSS_WaveOutInit for the loop order */
1079 arg
=win_std_oss_fmts
[f
];
1080 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_SAMPLESIZE
, &arg
);
1081 if (rc
!=0 || arg
!=win_std_oss_fmts
[f
]) {
1082 TRACE("DSP_SAMPLESIZE: rc=%d returned 0x%x for 0x%x\n",
1083 rc
,arg
,win_std_oss_fmts
[f
]);
1087 for (c
= 1; c
<= MAX_CHANNELS
; c
++) {
1089 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_CHANNELS
, &arg
);
1090 if( rc
== -1) break;
1091 if (rc
!=0 || arg
!=c
) {
1092 TRACE("DSP_CHANNELS: rc=%d returned %d for %d\n",rc
,arg
,c
);
1096 ossdev
->ds_caps
.dwFlags
|= DSCAPS_PRIMARYMONO
;
1097 } else if (c
== 2) {
1098 ossdev
->duplex_out_caps
.wChannels
= 2;
1100 ossdev
->duplex_out_caps
.dwSupport
|=WAVECAPS_LRVOLUME
;
1101 ossdev
->ds_caps
.dwFlags
|= DSCAPS_PRIMARYSTEREO
;
1103 ossdev
->duplex_out_caps
.wChannels
= c
;
1105 for (r
=0;r
<sizeof(win_std_rates
)/sizeof(*win_std_rates
);r
++) {
1106 arg
=win_std_rates
[r
];
1107 rc
=ioctl(ossdev
->fd
, SNDCTL_DSP_SPEED
, &arg
);
1108 TRACE("DSP_SPEED: rc=%d returned %d for %dx%dx%d\n",
1109 rc
,arg
,win_std_rates
[r
],win_std_oss_fmts
[f
],c
);
1110 if (rc
==0 && arg
!=0 && NEAR_MATCH(arg
,win_std_rates
[r
]) && c
< 3)
1111 ossdev
->duplex_out_caps
.dwFormats
|=win_std_formats
[f
][c
-1][r
];
1116 if (ioctl(ossdev
->fd
, SNDCTL_DSP_GETCAPS
, &arg
) == 0) {
1117 if ((arg
& DSP_CAP_REALTIME
) && !(arg
& DSP_CAP_BATCH
)) {
1118 ossdev
->duplex_out_caps
.dwSupport
|= WAVECAPS_SAMPLEACCURATE
;
1120 /* well, might as well use the DirectSound cap flag for something */
1121 if ((arg
& DSP_CAP_TRIGGER
) && (arg
& DSP_CAP_MMAP
) &&
1122 !(arg
& DSP_CAP_BATCH
)) {
1123 ossdev
->duplex_out_caps
.dwSupport
|= WAVECAPS_DIRECTSOUND
;
1126 OSS_CloseDevice(ossdev
);
1127 TRACE("duplex wChannels = %d, dwFormats = %08X, dwSupport = %08X\n",
1128 ossdev
->duplex_out_caps
.wChannels
,
1129 ossdev
->duplex_out_caps
.dwFormats
,
1130 ossdev
->duplex_out_caps
.dwSupport
);
1133 static char* StrDup(const char* str
, const char* def
)
1138 dst
=HeapAlloc(GetProcessHeap(),0,strlen(str
)+1);
1143 static int WAVE_loadcount
;
1145 /******************************************************************
1148 * Initialize internal structures from OSS information
1150 static LRESULT
OSS_WaveInit(void)
1155 /* FIXME: Remove unneeded members of WOutDev and WInDev */
1156 TRACE("(%i)\n", WAVE_loadcount
);
1157 if (WAVE_loadcount
++)
1160 str
=getenv("AUDIODEV");
1163 WOutDev
[0].ossdev
.dev_name
= WInDev
[0].ossdev
.dev_name
= StrDup(str
,"");
1164 WOutDev
[0].ossdev
.mixer_name
= WInDev
[0].ossdev
.mixer_name
= StrDup(getenv("MIXERDEV"),"/dev/mixer");
1165 for (i
= 1; i
< MAX_WAVEDRV
; ++i
)
1167 WOutDev
[i
].ossdev
.dev_name
= WInDev
[i
].ossdev
.dev_name
= StrDup("",NULL
);
1168 WOutDev
[i
].ossdev
.mixer_name
= WInDev
[i
].ossdev
.mixer_name
= StrDup("",NULL
);
1173 WOutDev
[0].ossdev
.dev_name
= WInDev
[0].ossdev
.dev_name
= StrDup("/dev/dsp",NULL
);
1174 WOutDev
[0].ossdev
.mixer_name
= WInDev
[0].ossdev
.mixer_name
= StrDup("/dev/mixer",NULL
);
1175 for (i
= 1; i
< MAX_WAVEDRV
; ++i
)
1177 WOutDev
[i
].ossdev
.dev_name
= WInDev
[i
].ossdev
.dev_name
= HeapAlloc(GetProcessHeap(),0,11);
1178 sprintf(WOutDev
[i
].ossdev
.dev_name
, "/dev/dsp%u", i
);
1179 WOutDev
[i
].ossdev
.mixer_name
= WInDev
[i
].ossdev
.mixer_name
= HeapAlloc(GetProcessHeap(),0,13);
1180 sprintf(WOutDev
[i
].ossdev
.mixer_name
, "/dev/mixer%u", i
);
1184 for (i
= 0; i
< MAX_WAVEDRV
; ++i
)
1186 WOutDev
[i
].ossdev
.interface_name
= WInDev
[i
].ossdev
.interface_name
=
1187 HeapAlloc(GetProcessHeap(),0,9+strlen(WOutDev
[i
].ossdev
.dev_name
)+1);
1188 sprintf(WOutDev
[i
].ossdev
.interface_name
, "wineoss: %s", WOutDev
[i
].ossdev
.dev_name
);
1191 /* start with output devices */
1192 for (i
= 0; i
< MAX_WAVEDRV
; ++i
)
1194 if (*WOutDev
[i
].ossdev
.dev_name
== '\0' || OSS_WaveOutInit(&WOutDev
[i
].ossdev
))
1196 WOutDev
[numOutDev
].state
= WINE_WS_CLOSED
;
1197 WOutDev
[numOutDev
].volume
= 0xffffffff;
1202 /* then do input devices */
1203 for (i
= 0; i
< MAX_WAVEDRV
; ++i
)
1205 if (*WInDev
[i
].ossdev
.dev_name
=='\0' || OSS_WaveInInit(&WInDev
[i
].ossdev
))
1207 WInDev
[numInDev
].state
= WINE_WS_CLOSED
;
1212 /* finish with the full duplex bits */
1213 for (i
= 0; i
< MAX_WAVEDRV
; i
++)
1214 if (*WOutDev
[i
].ossdev
.dev_name
!='\0')
1215 OSS_WaveFullDuplexInit(&WOutDev
[i
].ossdev
);
1217 TRACE("%d wave out devices\n", numOutDev
);
1218 for (i
= 0; i
< numOutDev
; i
++) {
1219 TRACE("%u: %s, %s, %s\n", i
, WOutDev
[i
].ossdev
.dev_name
,
1220 WOutDev
[i
].ossdev
.mixer_name
, WOutDev
[i
].ossdev
.interface_name
);
1223 TRACE("%d wave in devices\n", numInDev
);
1224 for (i
= 0; i
< numInDev
; i
++) {
1225 TRACE("%u: %s, %s, %s\n", i
, WInDev
[i
].ossdev
.dev_name
,
1226 WInDev
[i
].ossdev
.mixer_name
, WInDev
[i
].ossdev
.interface_name
);
1232 /******************************************************************
1235 * Delete/clear internal structures of OSS information
1237 static LRESULT
OSS_WaveExit(void)
1240 TRACE("(%i)\n", WAVE_loadcount
);
1241 if (--WAVE_loadcount
)
1244 for (i
= 0; i
< MAX_WAVEDRV
; ++i
)
1246 HeapFree(GetProcessHeap(), 0, WOutDev
[i
].ossdev
.dev_name
);
1247 HeapFree(GetProcessHeap(), 0, WOutDev
[i
].ossdev
.mixer_name
);
1248 HeapFree(GetProcessHeap(), 0, WOutDev
[i
].ossdev
.interface_name
);
1251 ZeroMemory(WOutDev
, sizeof(WOutDev
));
1252 ZeroMemory(WInDev
, sizeof(WInDev
));
1260 /******************************************************************
1261 * OSS_InitRingMessage
1263 * Initialize the ring of messages for passing between driver's caller and playback/record
1266 static int OSS_InitRingMessage(OSS_MSG_RING
* omr
)
1269 omr
->msg_tosave
= 0;
1270 #ifdef USE_PIPE_SYNC
1271 if (pipe(omr
->msg_pipe
) < 0) {
1272 omr
->msg_pipe
[0] = -1;
1273 omr
->msg_pipe
[1] = -1;
1274 ERR("could not create pipe, error=%s\n", strerror(errno
));
1277 omr
->msg_event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1279 omr
->ring_buffer_size
= OSS_RING_BUFFER_INCREMENT
;
1280 omr
->messages
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,omr
->ring_buffer_size
* sizeof(OSS_MSG
));
1281 InitializeCriticalSection(&omr
->msg_crst
);
1282 omr
->msg_crst
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": OSS_MSG_RING.msg_crst");
1286 /******************************************************************
1287 * OSS_DestroyRingMessage
1290 static int OSS_DestroyRingMessage(OSS_MSG_RING
* omr
)
1292 #ifdef USE_PIPE_SYNC
1293 close(omr
->msg_pipe
[0]);
1294 close(omr
->msg_pipe
[1]);
1296 CloseHandle(omr
->msg_event
);
1298 HeapFree(GetProcessHeap(),0,omr
->messages
);
1299 omr
->msg_crst
.DebugInfo
->Spare
[0] = 0;
1300 DeleteCriticalSection(&omr
->msg_crst
);
1304 /******************************************************************
1305 * OSS_AddRingMessage
1307 * Inserts a new message into the ring (should be called from DriverProc derived routines)
1309 static int OSS_AddRingMessage(OSS_MSG_RING
* omr
, enum win_wm_message msg
, DWORD param
, BOOL wait
)
1311 HANDLE hEvent
= INVALID_HANDLE_VALUE
;
1313 EnterCriticalSection(&omr
->msg_crst
);
1314 if ((omr
->msg_toget
== ((omr
->msg_tosave
+ 1) % omr
->ring_buffer_size
)))
1316 int old_ring_buffer_size
= omr
->ring_buffer_size
;
1317 omr
->ring_buffer_size
+= OSS_RING_BUFFER_INCREMENT
;
1318 TRACE("omr->ring_buffer_size=%d\n",omr
->ring_buffer_size
);
1319 omr
->messages
= HeapReAlloc(GetProcessHeap(),0,omr
->messages
, omr
->ring_buffer_size
* sizeof(OSS_MSG
));
1320 /* Now we need to rearrange the ring buffer so that the new
1321 buffers just allocated are in between omr->msg_tosave and
1324 if (omr
->msg_tosave
< omr
->msg_toget
)
1326 memmove(&(omr
->messages
[omr
->msg_toget
+ OSS_RING_BUFFER_INCREMENT
]),
1327 &(omr
->messages
[omr
->msg_toget
]),
1328 sizeof(OSS_MSG
)*(old_ring_buffer_size
- omr
->msg_toget
)
1330 omr
->msg_toget
+= OSS_RING_BUFFER_INCREMENT
;
1335 hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1336 if (hEvent
== INVALID_HANDLE_VALUE
)
1338 ERR("can't create event !?\n");
1339 LeaveCriticalSection(&omr
->msg_crst
);
1342 if (omr
->msg_toget
!= omr
->msg_tosave
&& omr
->messages
[omr
->msg_toget
].msg
!= WINE_WM_HEADER
)
1343 FIXME("two fast messages in the queue!!!! toget = %d(%s), tosave=%d(%s)\n",
1344 omr
->msg_toget
,getCmdString(omr
->messages
[omr
->msg_toget
].msg
),
1345 omr
->msg_tosave
,getCmdString(omr
->messages
[omr
->msg_tosave
].msg
));
1347 /* fast messages have to be added at the start of the queue */
1348 omr
->msg_toget
= (omr
->msg_toget
+ omr
->ring_buffer_size
- 1) % omr
->ring_buffer_size
;
1349 omr
->messages
[omr
->msg_toget
].msg
= msg
;
1350 omr
->messages
[omr
->msg_toget
].param
= param
;
1351 omr
->messages
[omr
->msg_toget
].hEvent
= hEvent
;
1355 omr
->messages
[omr
->msg_tosave
].msg
= msg
;
1356 omr
->messages
[omr
->msg_tosave
].param
= param
;
1357 omr
->messages
[omr
->msg_tosave
].hEvent
= INVALID_HANDLE_VALUE
;
1358 omr
->msg_tosave
= (omr
->msg_tosave
+ 1) % omr
->ring_buffer_size
;
1360 LeaveCriticalSection(&omr
->msg_crst
);
1361 /* signal a new message */
1365 /* wait for playback/record thread to have processed the message */
1366 WaitForSingleObject(hEvent
, INFINITE
);
1367 CloseHandle(hEvent
);
1372 /******************************************************************
1373 * OSS_RetrieveRingMessage
1375 * Get a message from the ring. Should be called by the playback/record thread.
1377 static int OSS_RetrieveRingMessage(OSS_MSG_RING
* omr
,
1378 enum win_wm_message
*msg
, DWORD_PTR
*param
, HANDLE
*hEvent
)
1380 EnterCriticalSection(&omr
->msg_crst
);
1382 if (omr
->msg_toget
== omr
->msg_tosave
) /* buffer empty ? */
1384 LeaveCriticalSection(&omr
->msg_crst
);
1388 *msg
= omr
->messages
[omr
->msg_toget
].msg
;
1389 omr
->messages
[omr
->msg_toget
].msg
= 0;
1390 *param
= omr
->messages
[omr
->msg_toget
].param
;
1391 *hEvent
= omr
->messages
[omr
->msg_toget
].hEvent
;
1392 omr
->msg_toget
= (omr
->msg_toget
+ 1) % omr
->ring_buffer_size
;
1394 LeaveCriticalSection(&omr
->msg_crst
);
1398 /******************************************************************
1399 * OSS_PeekRingMessage
1401 * Peek at a message from the ring but do not remove it.
1402 * Should be called by the playback/record thread.
1404 static int OSS_PeekRingMessage(OSS_MSG_RING
* omr
,
1405 enum win_wm_message
*msg
,
1406 DWORD_PTR
*param
, HANDLE
*hEvent
)
1408 EnterCriticalSection(&omr
->msg_crst
);
1410 if (omr
->msg_toget
== omr
->msg_tosave
) /* buffer empty ? */
1412 LeaveCriticalSection(&omr
->msg_crst
);
1416 *msg
= omr
->messages
[omr
->msg_toget
].msg
;
1417 *param
= omr
->messages
[omr
->msg_toget
].param
;
1418 *hEvent
= omr
->messages
[omr
->msg_toget
].hEvent
;
1419 LeaveCriticalSection(&omr
->msg_crst
);
1423 /*======================================================================*
1424 * Low level WAVE OUT implementation *
1425 *======================================================================*/
1427 /**************************************************************************
1428 * wodNotifyClient [internal]
1430 static void wodNotifyClient(WINE_WAVEOUT
* wwo
, WORD wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
1432 TRACE("wMsg = 0x%04x (%s) dwParm1 = %04lx dwParam2 = %04lx\n", wMsg
,
1433 wMsg
== WOM_OPEN
? "WOM_OPEN" : wMsg
== WOM_CLOSE
? "WOM_CLOSE" :
1434 wMsg
== WOM_DONE
? "WOM_DONE" : "Unknown", dwParam1
, dwParam2
);
1440 if (wwo
->wFlags
!= DCB_NULL
&&
1441 !DriverCallback(wwo
->waveDesc
.dwCallback
, wwo
->wFlags
,
1442 (HDRVR
)wwo
->waveDesc
.hWave
, wMsg
,
1443 wwo
->waveDesc
.dwInstance
, dwParam1
, dwParam2
)) {
1444 WARN("can't notify client !\n");
1448 FIXME("Unknown callback message %u\n", wMsg
);
1452 /**************************************************************************
1453 * wodUpdatePlayedTotal [internal]
1456 static BOOL
wodUpdatePlayedTotal(WINE_WAVEOUT
* wwo
, audio_buf_info
* info
)
1458 audio_buf_info dspspace
;
1460 if (!info
) info
= &dspspace
;
1462 if (ioctl(wwo
->ossdev
.fd
, SNDCTL_DSP_GETOSPACE
, info
) < 0) {
1463 ERR("ioctl(%s, SNDCTL_DSP_GETOSPACE) failed (%s)\n", wwo
->ossdev
.dev_name
, strerror(errno
));
1467 /* GETOSPACE is not always accurate when we're down to the last fragment or two;
1468 ** we try to accommodate that here by assuming that the dsp is empty by looking
1469 ** at the clock rather than the result of GETOSPACE */
1470 notplayed
= wwo
->dwBufferSize
- info
->bytes
;
1471 if (notplayed
> 0 && notplayed
< (info
->fragsize
* 2))
1473 if (wwo
->dwProjectedFinishTime
&& GetTickCount() >= wwo
->dwProjectedFinishTime
)
1475 TRACE("Adjusting for a presumed OSS bug and assuming all data has been played.\n");
1476 wwo
->dwPlayedTotal
= wwo
->dwWrittenTotal
;
1480 /* Some OSS drivers will clean up nicely if given a POST, so give 'em the chance... */
1481 ioctl(wwo
->ossdev
.fd
, SNDCTL_DSP_POST
, 0);
1484 wwo
->dwPlayedTotal
= wwo
->dwWrittenTotal
- notplayed
;
1488 /**************************************************************************
1489 * wodPlayer_BeginWaveHdr [internal]
1491 * Makes the specified lpWaveHdr the currently playing wave header.
1492 * If the specified wave header is a begin loop and we're not already in
1493 * a loop, setup the loop.
1495 static void wodPlayer_BeginWaveHdr(WINE_WAVEOUT
* wwo
, LPWAVEHDR lpWaveHdr
)
1497 wwo
->lpPlayPtr
= lpWaveHdr
;
1499 if (!lpWaveHdr
) return;
1501 if (lpWaveHdr
->dwFlags
& WHDR_BEGINLOOP
) {
1502 if (wwo
->lpLoopPtr
) {
1503 WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr
);
1505 TRACE("Starting loop (%dx) with %p\n", lpWaveHdr
->dwLoops
, lpWaveHdr
);
1506 wwo
->lpLoopPtr
= lpWaveHdr
;
1507 /* Windows does not touch WAVEHDR.dwLoops,
1508 * so we need to make an internal copy */
1509 wwo
->dwLoops
= lpWaveHdr
->dwLoops
;
1512 wwo
->dwPartialOffset
= 0;
1515 /**************************************************************************
1516 * wodPlayer_PlayPtrNext [internal]
1518 * Advance the play pointer to the next waveheader, looping if required.
1520 static LPWAVEHDR
wodPlayer_PlayPtrNext(WINE_WAVEOUT
* wwo
)
1522 LPWAVEHDR lpWaveHdr
= wwo
->lpPlayPtr
;
1524 wwo
->dwPartialOffset
= 0;
1525 if ((lpWaveHdr
->dwFlags
& WHDR_ENDLOOP
) && wwo
->lpLoopPtr
) {
1526 /* We're at the end of a loop, loop if required */
1527 if (--wwo
->dwLoops
> 0) {
1528 wwo
->lpPlayPtr
= wwo
->lpLoopPtr
;
1530 /* Handle overlapping loops correctly */
1531 if (wwo
->lpLoopPtr
!= lpWaveHdr
&& (lpWaveHdr
->dwFlags
& WHDR_BEGINLOOP
)) {
1532 FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
1533 /* shall we consider the END flag for the closing loop or for
1534 * the opening one or for both ???
1535 * code assumes for closing loop only
1538 lpWaveHdr
= lpWaveHdr
->lpNext
;
1540 wwo
->lpLoopPtr
= NULL
;
1541 wodPlayer_BeginWaveHdr(wwo
, lpWaveHdr
);
1544 /* We're not in a loop. Advance to the next wave header */
1545 wodPlayer_BeginWaveHdr(wwo
, lpWaveHdr
= lpWaveHdr
->lpNext
);
1551 /**************************************************************************
1552 * wodPlayer_TicksTillEmpty [internal]
1553 * Returns the number of ticks until we think the DSP should be empty
1555 static DWORD
wodPlayer_TicksTillEmpty(const WINE_WAVEOUT
*wwo
)
1557 return ((wwo
->dwWrittenTotal
- wwo
->dwPlayedTotal
) * 1000)
1558 / wwo
->waveFormat
.Format
.nAvgBytesPerSec
;
1561 /**************************************************************************
1562 * wodPlayer_DSPWait [internal]
1563 * Returns the number of milliseconds to wait for the DSP buffer to write
1566 static DWORD
wodPlayer_DSPWait(const WINE_WAVEOUT
*wwo
)
1568 /* time for one fragment to be played */
1569 return wwo
->dwFragmentSize
* 1000 / wwo
->waveFormat
.Format
.nAvgBytesPerSec
;
1572 /**************************************************************************
1573 * wodPlayer_NotifyWait [internal]
1574 * Returns the number of milliseconds to wait before attempting to notify
1575 * completion of the specified wavehdr.
1576 * This is based on the number of bytes remaining to be written in the
1579 static DWORD
wodPlayer_NotifyWait(const WINE_WAVEOUT
* wwo
, LPWAVEHDR lpWaveHdr
)
1583 if (lpWaveHdr
->reserved
< wwo
->dwPlayedTotal
) {
1586 dwMillis
= (lpWaveHdr
->reserved
- wwo
->dwPlayedTotal
) * 1000 / wwo
->waveFormat
.Format
.nAvgBytesPerSec
;
1587 if (!dwMillis
) dwMillis
= 1;
1594 /**************************************************************************
1595 * wodPlayer_WriteMaxFrags [internal]
1596 * Writes the maximum number of bytes possible to the DSP and returns
1597 * TRUE iff the current playPtr has been fully played
1599 static BOOL
wodPlayer_WriteMaxFrags(WINE_WAVEOUT
* wwo
, DWORD
* bytes
)
1601 DWORD dwLength
= wwo
->lpPlayPtr
->dwBufferLength
- wwo
->dwPartialOffset
;
1602 DWORD toWrite
= min(dwLength
, *bytes
);
1606 TRACE("Writing wavehdr %p.%u[%u]/%u\n",
1607 wwo
->lpPlayPtr
, wwo
->dwPartialOffset
, wwo
->lpPlayPtr
->dwBufferLength
, toWrite
);
1611 written
= write(wwo
->ossdev
.fd
, wwo
->lpPlayPtr
->lpData
+ wwo
->dwPartialOffset
, toWrite
);
1613 TRACE("write(%s, %p, %d) failed (%s) returned %d\n", wwo
->ossdev
.dev_name
,
1614 wwo
->lpPlayPtr
->lpData
+ wwo
->dwPartialOffset
, toWrite
, strerror(errno
), written
);
1621 if (written
>= dwLength
) {
1622 /* If we wrote all current wavehdr, skip to the next one */
1623 wodPlayer_PlayPtrNext(wwo
);
1626 /* Remove the amount written */
1627 wwo
->dwPartialOffset
+= written
;
1630 wwo
->dwWrittenTotal
+= written
;
1631 TRACE("dwWrittenTotal=%u\n", wwo
->dwWrittenTotal
);
1636 /**************************************************************************
1637 * wodPlayer_NotifyCompletions [internal]
1639 * Notifies and remove from queue all wavehdrs which have been played to
1640 * the speaker (ie. they have cleared the OSS buffer). If force is true,
1641 * we notify all wavehdrs and remove them all from the queue even if they
1642 * are unplayed or part of a loop.
1644 static DWORD
wodPlayer_NotifyCompletions(WINE_WAVEOUT
* wwo
, BOOL force
)
1646 LPWAVEHDR lpWaveHdr
;
1648 /* Start from lpQueuePtr and keep notifying until:
1649 * - we hit an unwritten wavehdr
1650 * - we hit the beginning of a running loop
1651 * - we hit a wavehdr which hasn't finished playing
1654 while ((lpWaveHdr
= wwo
->lpQueuePtr
) &&
1656 (lpWaveHdr
!= wwo
->lpPlayPtr
&&
1657 lpWaveHdr
!= wwo
->lpLoopPtr
&&
1658 lpWaveHdr
->reserved
<= wwo
->dwPlayedTotal
))) {
1660 wwo
->lpQueuePtr
= lpWaveHdr
->lpNext
;
1662 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
1663 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
1665 wodNotifyClient(wwo
, WOM_DONE
, (DWORD_PTR
)lpWaveHdr
, 0);
1670 lpWaveHdr
= wwo
->lpQueuePtr
;
1671 if (!lpWaveHdr
) {TRACE("Empty queue\n"); break;}
1674 if (lpWaveHdr
== wwo
->lpPlayPtr
) {TRACE("play %p\n", lpWaveHdr
); break;}
1675 if (lpWaveHdr
== wwo
->lpLoopPtr
) {TRACE("loop %p\n", lpWaveHdr
); break;}
1676 if (lpWaveHdr
->reserved
> wwo
->dwPlayedTotal
) {TRACE("still playing %p (%lu/%u)\n", lpWaveHdr
, lpWaveHdr
->reserved
, wwo
->dwPlayedTotal
);break;}
1678 wwo
->lpQueuePtr
= lpWaveHdr
->lpNext
;
1680 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
1681 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
1683 wodNotifyClient(wwo
, WOM_DONE
, (DWORD_PTR
)lpWaveHdr
, 0);
1686 return (lpWaveHdr
&& lpWaveHdr
!= wwo
->lpPlayPtr
&& lpWaveHdr
!= wwo
->lpLoopPtr
) ?
1687 wodPlayer_NotifyWait(wwo
, lpWaveHdr
) : INFINITE
;
1690 /**************************************************************************
1691 * wodPlayer_Reset [internal]
1693 * wodPlayer helper. Resets current output stream.
1695 static void wodPlayer_Reset(WINE_WAVEOUT
* wwo
, BOOL reset
)
1697 wodUpdatePlayedTotal(wwo
, NULL
);
1698 /* updates current notify list */
1699 wodPlayer_NotifyCompletions(wwo
, FALSE
);
1701 /* flush all possible output */
1702 if (OSS_ResetDevice(&wwo
->ossdev
) != MMSYSERR_NOERROR
)
1705 wwo
->state
= WINE_WS_STOPPED
;
1710 enum win_wm_message msg
;
1714 /* remove any buffer */
1715 wodPlayer_NotifyCompletions(wwo
, TRUE
);
1717 wwo
->lpPlayPtr
= wwo
->lpQueuePtr
= wwo
->lpLoopPtr
= NULL
;
1718 wwo
->state
= WINE_WS_STOPPED
;
1719 wwo
->dwPlayedTotal
= wwo
->dwWrittenTotal
= 0;
1720 /* Clear partial wavehdr */
1721 wwo
->dwPartialOffset
= 0;
1723 /* remove any existing message in the ring */
1724 EnterCriticalSection(&wwo
->msgRing
.msg_crst
);
1725 /* return all pending headers in queue */
1726 while (OSS_RetrieveRingMessage(&wwo
->msgRing
, &msg
, ¶m
, &ev
))
1728 if (msg
!= WINE_WM_HEADER
)
1730 FIXME("shouldn't have headers left\n");
1734 ((LPWAVEHDR
)param
)->dwFlags
&= ~WHDR_INQUEUE
;
1735 ((LPWAVEHDR
)param
)->dwFlags
|= WHDR_DONE
;
1737 wodNotifyClient(wwo
, WOM_DONE
, param
, 0);
1739 RESET_OMR(&wwo
->msgRing
);
1740 LeaveCriticalSection(&wwo
->msgRing
.msg_crst
);
1742 if (wwo
->lpLoopPtr
) {
1743 /* complicated case, not handled yet (could imply modifying the loop counter */
1744 FIXME("Pausing while in loop isn't correctly handled yet, expect strange results\n");
1745 wwo
->lpPlayPtr
= wwo
->lpLoopPtr
;
1746 wwo
->dwPartialOffset
= 0;
1747 wwo
->dwWrittenTotal
= wwo
->dwPlayedTotal
; /* this is wrong !!! */
1750 DWORD sz
= wwo
->dwPartialOffset
;
1752 /* reset all the data as if we had written only up to lpPlayedTotal bytes */
1753 /* compute the max size playable from lpQueuePtr */
1754 for (ptr
= wwo
->lpQueuePtr
; ptr
!= wwo
->lpPlayPtr
; ptr
= ptr
->lpNext
) {
1755 sz
+= ptr
->dwBufferLength
;
1757 /* because the reset lpPlayPtr will be lpQueuePtr */
1758 if (wwo
->dwWrittenTotal
> wwo
->dwPlayedTotal
+ sz
) ERR("grin\n");
1759 wwo
->dwPartialOffset
= sz
- (wwo
->dwWrittenTotal
- wwo
->dwPlayedTotal
);
1760 wwo
->dwWrittenTotal
= wwo
->dwPlayedTotal
;
1761 wwo
->lpPlayPtr
= wwo
->lpQueuePtr
;
1763 wwo
->state
= WINE_WS_PAUSED
;
1767 /**************************************************************************
1768 * wodPlayer_ProcessMessages [internal]
1770 static void wodPlayer_ProcessMessages(WINE_WAVEOUT
* wwo
)
1772 LPWAVEHDR lpWaveHdr
;
1773 enum win_wm_message msg
;
1777 while (OSS_RetrieveRingMessage(&wwo
->msgRing
, &msg
, ¶m
, &ev
)) {
1778 TRACE("Received %s %lx\n", getCmdString(msg
), param
);
1780 case WINE_WM_PAUSING
:
1781 wodPlayer_Reset(wwo
, FALSE
);
1784 case WINE_WM_RESTARTING
:
1785 if (wwo
->state
== WINE_WS_PAUSED
)
1787 wwo
->state
= WINE_WS_PLAYING
;
1791 case WINE_WM_HEADER
:
1792 lpWaveHdr
= (LPWAVEHDR
)param
;
1794 /* insert buffer at the end of queue */
1797 for (wh
= &(wwo
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
));
1800 if (!wwo
->lpPlayPtr
)
1801 wodPlayer_BeginWaveHdr(wwo
,lpWaveHdr
);
1802 if (wwo
->state
== WINE_WS_STOPPED
)
1803 wwo
->state
= WINE_WS_PLAYING
;
1805 case WINE_WM_RESETTING
:
1806 wodPlayer_Reset(wwo
, TRUE
);
1809 case WINE_WM_UPDATE
:
1810 wodUpdatePlayedTotal(wwo
, NULL
);
1813 case WINE_WM_BREAKLOOP
:
1814 if (wwo
->state
== WINE_WS_PLAYING
&& wwo
->lpLoopPtr
!= NULL
) {
1815 /* ensure exit at end of current loop */
1820 case WINE_WM_CLOSING
:
1821 /* sanity check: this should not happen since the device must have been reset before */
1822 if (wwo
->lpQueuePtr
|| wwo
->lpPlayPtr
) ERR("out of sync\n");
1824 wwo
->state
= WINE_WS_CLOSED
;
1827 /* shouldn't go here */
1829 FIXME("unknown message %d\n", msg
);
1835 /**************************************************************************
1836 * wodPlayer_FeedDSP [internal]
1837 * Feed as much sound data as we can into the DSP and return the number of
1838 * milliseconds before it will be necessary to feed the DSP again.
1840 static DWORD
wodPlayer_FeedDSP(WINE_WAVEOUT
* wwo
)
1842 audio_buf_info dspspace
;
1845 if (!wodUpdatePlayedTotal(wwo
, &dspspace
)) return INFINITE
;
1846 availInQ
= dspspace
.bytes
;
1847 TRACE("fragments=%d/%d, fragsize=%d, bytes=%d\n",
1848 dspspace
.fragments
, dspspace
.fragstotal
, dspspace
.fragsize
, dspspace
.bytes
);
1850 /* no more room... no need to try to feed */
1851 if (dspspace
.fragments
!= 0) {
1852 /* Feed from partial wavehdr */
1853 if (wwo
->lpPlayPtr
&& wwo
->dwPartialOffset
!= 0) {
1854 wodPlayer_WriteMaxFrags(wwo
, &availInQ
);
1857 /* Feed wavehdrs until we run out of wavehdrs or DSP space */
1858 if (wwo
->dwPartialOffset
== 0 && wwo
->lpPlayPtr
) {
1860 TRACE("Setting time to elapse for %p to %u\n",
1861 wwo
->lpPlayPtr
, wwo
->dwWrittenTotal
+ wwo
->lpPlayPtr
->dwBufferLength
);
1862 /* note the value that dwPlayedTotal will return when this wave finishes playing */
1863 wwo
->lpPlayPtr
->reserved
= wwo
->dwWrittenTotal
+ wwo
->lpPlayPtr
->dwBufferLength
;
1864 } while (wodPlayer_WriteMaxFrags(wwo
, &availInQ
) && wwo
->lpPlayPtr
&& availInQ
> 0);
1867 if (wwo
->bNeedPost
) {
1868 /* OSS doesn't start before it gets either 2 fragments or a SNDCTL_DSP_POST;
1869 * if it didn't get one, we give it the other */
1870 if (wwo
->dwBufferSize
< availInQ
+ 2 * wwo
->dwFragmentSize
)
1871 ioctl(wwo
->ossdev
.fd
, SNDCTL_DSP_POST
, 0);
1872 wwo
->bNeedPost
= FALSE
;
1876 return wodPlayer_DSPWait(wwo
);
1880 /**************************************************************************
1881 * wodPlayer [internal]
1883 static DWORD CALLBACK
wodPlayer(LPVOID pmt
)
1885 WORD uDevID
= (DWORD_PTR
)pmt
;
1886 WINE_WAVEOUT
* wwo
= &WOutDev
[uDevID
];
1887 DWORD dwNextFeedTime
= INFINITE
; /* Time before DSP needs feeding */
1888 DWORD dwNextNotifyTime
= INFINITE
; /* Time before next wave completion */
1891 wwo
->state
= WINE_WS_STOPPED
;
1892 SetEvent(wwo
->hStartUpEvent
);
1895 /** Wait for the shortest time before an action is required. If there
1896 * are no pending actions, wait forever for a command.
1898 dwSleepTime
= min(dwNextFeedTime
, dwNextNotifyTime
);
1899 TRACE("waiting %ums (%u,%u)\n", dwSleepTime
, dwNextFeedTime
, dwNextNotifyTime
);
1900 WAIT_OMR(&wwo
->msgRing
, dwSleepTime
);
1901 wodPlayer_ProcessMessages(wwo
);
1902 if (wwo
->state
== WINE_WS_PLAYING
) {
1903 dwNextFeedTime
= wodPlayer_FeedDSP(wwo
);
1904 if (dwNextFeedTime
!= INFINITE
)
1905 wwo
->dwProjectedFinishTime
= GetTickCount() + wodPlayer_TicksTillEmpty(wwo
);
1907 wwo
->dwProjectedFinishTime
= 0;
1909 dwNextNotifyTime
= wodPlayer_NotifyCompletions(wwo
, FALSE
);
1910 if (dwNextFeedTime
== INFINITE
) {
1911 /* FeedDSP ran out of data, but before flushing, */
1912 /* check that a notification didn't give us more */
1913 wodPlayer_ProcessMessages(wwo
);
1914 if (!wwo
->lpPlayPtr
) {
1915 TRACE("flushing\n");
1916 ioctl(wwo
->ossdev
.fd
, SNDCTL_DSP_SYNC
, 0);
1917 wwo
->dwPlayedTotal
= wwo
->dwWrittenTotal
;
1918 dwNextNotifyTime
= wodPlayer_NotifyCompletions(wwo
, FALSE
);
1920 TRACE("recovering\n");
1921 dwNextFeedTime
= wodPlayer_FeedDSP(wwo
);
1925 dwNextFeedTime
= dwNextNotifyTime
= INFINITE
;
1932 /**************************************************************************
1933 * wodGetDevCaps [internal]
1935 static DWORD
wodGetDevCaps(WORD wDevID
, LPWAVEOUTCAPSW lpCaps
, DWORD dwSize
)
1937 TRACE("(%u, %p, %u);\n", wDevID
, lpCaps
, dwSize
);
1939 if (lpCaps
== NULL
) {
1940 WARN("not enabled\n");
1941 return MMSYSERR_NOTENABLED
;
1944 if (wDevID
>= numOutDev
) {
1945 WARN("numOutDev reached !\n");
1946 return MMSYSERR_BADDEVICEID
;
1949 if (WOutDev
[wDevID
].ossdev
.open_access
== O_RDWR
)
1950 memcpy(lpCaps
, &WOutDev
[wDevID
].ossdev
.duplex_out_caps
, min(dwSize
, sizeof(*lpCaps
)));
1952 memcpy(lpCaps
, &WOutDev
[wDevID
].ossdev
.out_caps
, min(dwSize
, sizeof(*lpCaps
)));
1954 return MMSYSERR_NOERROR
;
1957 /**************************************************************************
1958 * wodOpen [internal]
1960 static DWORD
wodOpen(WORD wDevID
, LPWAVEOPENDESC lpDesc
, DWORD dwFlags
)
1964 audio_buf_info info
;
1967 TRACE("(%u, %p, %08X);\n", wDevID
, lpDesc
, dwFlags
);
1968 if (lpDesc
== NULL
) {
1969 WARN("Invalid Parameter !\n");
1970 return MMSYSERR_INVALPARAM
;
1972 if (wDevID
>= numOutDev
) {
1973 TRACE("MAX_WAVOUTDRV reached !\n");
1974 return MMSYSERR_BADDEVICEID
;
1977 /* only PCM format is supported so far... */
1978 if (!supportedFormat(lpDesc
->lpFormat
)) {
1979 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1980 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
1981 lpDesc
->lpFormat
->nSamplesPerSec
);
1982 return WAVERR_BADFORMAT
;
1985 if (dwFlags
& WAVE_FORMAT_QUERY
) {
1986 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1987 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
1988 lpDesc
->lpFormat
->nSamplesPerSec
);
1989 return MMSYSERR_NOERROR
;
1992 /* nBlockAlign and nAvgBytesPerSec are output variables for dsound */
1993 if (lpDesc
->lpFormat
->nBlockAlign
!= lpDesc
->lpFormat
->nChannels
*lpDesc
->lpFormat
->wBitsPerSample
/8) {
1994 lpDesc
->lpFormat
->nBlockAlign
= lpDesc
->lpFormat
->nChannels
*lpDesc
->lpFormat
->wBitsPerSample
/8;
1995 WARN("Fixing nBlockAlign\n");
1997 if (lpDesc
->lpFormat
->nAvgBytesPerSec
!= lpDesc
->lpFormat
->nSamplesPerSec
*lpDesc
->lpFormat
->nBlockAlign
) {
1998 lpDesc
->lpFormat
->nAvgBytesPerSec
= lpDesc
->lpFormat
->nSamplesPerSec
*lpDesc
->lpFormat
->nBlockAlign
;
1999 WARN("Fixing nAvgBytesPerSec\n");
2002 TRACE("OSS_OpenDevice requested this format: %dx%dx%d %s\n",
2003 lpDesc
->lpFormat
->nSamplesPerSec
,
2004 lpDesc
->lpFormat
->wBitsPerSample
,
2005 lpDesc
->lpFormat
->nChannels
,
2006 lpDesc
->lpFormat
->wFormatTag
== WAVE_FORMAT_PCM
? "WAVE_FORMAT_PCM" :
2007 lpDesc
->lpFormat
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
? "WAVE_FORMAT_EXTENSIBLE" :
2010 wwo
= &WOutDev
[wDevID
];
2012 if ((dwFlags
& WAVE_DIRECTSOUND
) &&
2013 !(wwo
->ossdev
.duplex_out_caps
.dwSupport
& WAVECAPS_DIRECTSOUND
))
2014 /* not supported, ignore it */
2015 dwFlags
&= ~WAVE_DIRECTSOUND
;
2017 if (dwFlags
& WAVE_DIRECTSOUND
) {
2018 if (wwo
->ossdev
.duplex_out_caps
.dwSupport
& WAVECAPS_SAMPLEACCURATE
)
2019 /* we have realtime DirectSound, fragments just waste our time,
2020 * but a large buffer is good, so choose 64KB (32 * 2^11) */
2021 audio_fragment
= 0x0020000B;
2023 /* to approximate realtime, we must use small fragments,
2024 * let's try to fragment the above 64KB (256 * 2^8) */
2025 audio_fragment
= 0x01000008;
2027 /* A wave device must have a worst case latency of 10 ms so calculate
2028 * the largest fragment size less than 10 ms long.
2030 int fsize
= lpDesc
->lpFormat
->nAvgBytesPerSec
/ 100; /* 10 ms chunk */
2032 while ((1 << shift
) <= fsize
)
2035 audio_fragment
= 0x00100000 + shift
; /* 16 fragments of 2^shift */
2038 TRACE("requesting %d %d byte fragments (%d ms/fragment)\n",
2039 audio_fragment
>> 16, 1 << (audio_fragment
& 0xffff),
2040 ((1 << (audio_fragment
& 0xffff)) * 1000) / lpDesc
->lpFormat
->nAvgBytesPerSec
);
2042 if (wwo
->state
!= WINE_WS_CLOSED
) {
2043 WARN("already allocated\n");
2044 return MMSYSERR_ALLOCATED
;
2047 /* we want to be able to mmap() the device, which means it must be opened readable,
2048 * otherwise mmap() will fail (at least under Linux) */
2049 ret
= OSS_OpenDevice(&wwo
->ossdev
,
2050 (dwFlags
& WAVE_DIRECTSOUND
) ? O_RDWR
: O_WRONLY
,
2052 (dwFlags
& WAVE_DIRECTSOUND
) ? 0 : 1,
2053 lpDesc
->lpFormat
->nSamplesPerSec
,
2054 lpDesc
->lpFormat
->nChannels
,
2055 (lpDesc
->lpFormat
->wBitsPerSample
== 16)
2056 ? AFMT_S16_LE
: AFMT_U8
);
2057 if ((ret
==MMSYSERR_NOERROR
) && (dwFlags
& WAVE_DIRECTSOUND
)) {
2058 lpDesc
->lpFormat
->nSamplesPerSec
=wwo
->ossdev
.sample_rate
;
2059 lpDesc
->lpFormat
->nChannels
=wwo
->ossdev
.channels
;
2060 lpDesc
->lpFormat
->wBitsPerSample
=(wwo
->ossdev
.format
== AFMT_U8
? 8 : 16);
2061 lpDesc
->lpFormat
->nBlockAlign
=lpDesc
->lpFormat
->nChannels
*lpDesc
->lpFormat
->wBitsPerSample
/8;
2062 lpDesc
->lpFormat
->nAvgBytesPerSec
=lpDesc
->lpFormat
->nSamplesPerSec
*lpDesc
->lpFormat
->nBlockAlign
;
2063 TRACE("OSS_OpenDevice returned this format: %dx%dx%d\n",
2064 lpDesc
->lpFormat
->nSamplesPerSec
,
2065 lpDesc
->lpFormat
->wBitsPerSample
,
2066 lpDesc
->lpFormat
->nChannels
);
2068 if (ret
!= 0) return ret
;
2069 wwo
->state
= WINE_WS_STOPPED
;
2071 wwo
->wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
2073 wwo
->waveDesc
= *lpDesc
;
2074 copy_format(lpDesc
->lpFormat
, &wwo
->waveFormat
);
2076 /* Read output space info for future reference */
2077 if (ioctl(wwo
->ossdev
.fd
, SNDCTL_DSP_GETOSPACE
, &info
) < 0) {
2078 ERR("ioctl(%s, SNDCTL_DSP_GETOSPACE) failed (%s)\n", wwo
->ossdev
.dev_name
, strerror(errno
));
2079 OSS_CloseDevice(&wwo
->ossdev
);
2080 wwo
->state
= WINE_WS_CLOSED
;
2081 return MMSYSERR_NOTENABLED
;
2084 TRACE("got %d %d byte fragments (%d ms/fragment)\n", info
.fragstotal
,
2085 info
.fragsize
, (info
.fragsize
* 1000) / (wwo
->ossdev
.sample_rate
*
2086 wwo
->ossdev
.channels
* (wwo
->ossdev
.format
== AFMT_U8
? 1 : 2)));
2088 /* Check that fragsize is correct per our settings above */
2089 if ((info
.fragsize
> 1024) && (LOWORD(audio_fragment
) <= 10)) {
2090 /* we've tried to set 1K fragments or less, but it didn't work */
2091 WARN("fragment size set failed, size is now %d\n", info
.fragsize
);
2094 /* Remember fragsize and total buffer size for future use */
2095 wwo
->dwFragmentSize
= info
.fragsize
;
2096 wwo
->dwBufferSize
= info
.fragstotal
* info
.fragsize
;
2097 wwo
->dwPlayedTotal
= 0;
2098 wwo
->dwWrittenTotal
= 0;
2099 wwo
->bNeedPost
= TRUE
;
2101 TRACE("fd=%d fragstotal=%d fragsize=%d BufferSize=%d\n",
2102 wwo
->ossdev
.fd
, info
.fragstotal
, info
.fragsize
, wwo
->dwBufferSize
);
2103 if (wwo
->dwFragmentSize
% wwo
->waveFormat
.Format
.nBlockAlign
) {
2104 ERR("Fragment doesn't contain an integral number of data blocks fragsize=%d BlockAlign=%d\n",wwo
->dwFragmentSize
,wwo
->waveFormat
.Format
.nBlockAlign
);
2105 /* Some SoundBlaster 16 cards return an incorrect (odd) fragment
2106 * size for 16 bit sound. This will cause a system crash when we try
2107 * to write just the specified odd number of bytes. So if we
2108 * detect something is wrong we'd better fix it.
2110 wwo
->dwFragmentSize
-=wwo
->dwFragmentSize
% wwo
->waveFormat
.Format
.nBlockAlign
;
2113 OSS_InitRingMessage(&wwo
->msgRing
);
2115 wwo
->hStartUpEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
2116 wwo
->hThread
= CreateThread(NULL
, 0, wodPlayer
, (LPVOID
)(DWORD_PTR
)wDevID
, 0, &(wwo
->dwThreadID
));
2118 SetThreadPriority(wwo
->hThread
, THREAD_PRIORITY_TIME_CRITICAL
);
2119 WaitForSingleObject(wwo
->hStartUpEvent
, INFINITE
);
2120 CloseHandle(wwo
->hStartUpEvent
);
2121 wwo
->hStartUpEvent
= INVALID_HANDLE_VALUE
;
2123 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
2124 wwo
->waveFormat
.Format
.wBitsPerSample
, wwo
->waveFormat
.Format
.nAvgBytesPerSec
,
2125 wwo
->waveFormat
.Format
.nSamplesPerSec
, wwo
->waveFormat
.Format
.nChannels
,
2126 wwo
->waveFormat
.Format
.nBlockAlign
);
2128 wodNotifyClient(wwo
, WOM_OPEN
, 0L, 0L);
2129 return MMSYSERR_NOERROR
;
2132 /**************************************************************************
2133 * wodClose [internal]
2135 static DWORD
wodClose(WORD wDevID
)
2139 TRACE("(%u);\n", wDevID
);
2141 if (wDevID
>= numOutDev
|| WOutDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2142 WARN("bad device ID !\n");
2143 return MMSYSERR_BADDEVICEID
;
2146 wwo
= &WOutDev
[wDevID
];
2147 if (wwo
->lpQueuePtr
) {
2148 WARN("buffers still playing !\n");
2149 return WAVERR_STILLPLAYING
;
2151 if (wwo
->hThread
!= INVALID_HANDLE_VALUE
) {
2152 OSS_AddRingMessage(&wwo
->msgRing
, WINE_WM_CLOSING
, 0, TRUE
);
2155 OSS_DestroyRingMessage(&wwo
->msgRing
);
2157 OSS_CloseDevice(&wwo
->ossdev
);
2158 wwo
->state
= WINE_WS_CLOSED
;
2159 wwo
->dwFragmentSize
= 0;
2160 wodNotifyClient(wwo
, WOM_CLOSE
, 0L, 0L);
2162 return MMSYSERR_NOERROR
;
2165 /**************************************************************************
2166 * wodWrite [internal]
2169 static DWORD
wodWrite(WORD wDevID
, LPWAVEHDR lpWaveHdr
, DWORD dwSize
)
2172 TRACE("(%u, %p, %08X);\n", wDevID
, lpWaveHdr
, dwSize
);
2174 /* first, do the sanity checks... */
2175 if (wDevID
>= numOutDev
|| WOutDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2176 WARN("bad dev ID !\n");
2177 return MMSYSERR_BADDEVICEID
;
2180 if (lpWaveHdr
->lpData
== NULL
|| !(lpWaveHdr
->dwFlags
& WHDR_PREPARED
))
2181 return WAVERR_UNPREPARED
;
2183 if (lpWaveHdr
->dwFlags
& WHDR_INQUEUE
)
2184 return WAVERR_STILLPLAYING
;
2186 lpWaveHdr
->dwFlags
&= ~WHDR_DONE
;
2187 lpWaveHdr
->dwFlags
|= WHDR_INQUEUE
;
2188 lpWaveHdr
->lpNext
= 0;
2190 delta
= lpWaveHdr
->dwBufferLength
% WOutDev
[wDevID
].waveFormat
.Format
.nBlockAlign
;
2193 WARN("WaveHdr length isn't a multiple of the PCM block size: %d %% %d\n",lpWaveHdr
->dwBufferLength
,WOutDev
[wDevID
].waveFormat
.Format
.nBlockAlign
);
2194 lpWaveHdr
->dwBufferLength
-= delta
;
2197 OSS_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_HEADER
, (DWORD_PTR
)lpWaveHdr
, FALSE
);
2199 return MMSYSERR_NOERROR
;
2202 /**************************************************************************
2203 * wodPause [internal]
2205 static DWORD
wodPause(WORD wDevID
)
2207 TRACE("(%u);!\n", wDevID
);
2209 if (wDevID
>= numOutDev
|| WOutDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2210 WARN("bad device ID !\n");
2211 return MMSYSERR_BADDEVICEID
;
2214 OSS_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_PAUSING
, 0, TRUE
);
2216 return MMSYSERR_NOERROR
;
2219 /**************************************************************************
2220 * wodRestart [internal]
2222 static DWORD
wodRestart(WORD wDevID
)
2224 TRACE("(%u);\n", wDevID
);
2226 if (wDevID
>= numOutDev
|| WOutDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2227 WARN("bad device ID !\n");
2228 return MMSYSERR_BADDEVICEID
;
2231 OSS_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_RESTARTING
, 0, TRUE
);
2233 /* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
2234 /* FIXME: Myst crashes with this ... hmm -MM
2235 return wodNotifyClient(wwo, WOM_DONE, 0L, 0L);
2238 return MMSYSERR_NOERROR
;
2241 /**************************************************************************
2242 * wodReset [internal]
2244 static DWORD
wodReset(WORD wDevID
)
2246 TRACE("(%u);\n", wDevID
);
2248 if (wDevID
>= numOutDev
|| WOutDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2249 WARN("bad device ID !\n");
2250 return MMSYSERR_BADDEVICEID
;
2253 OSS_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_RESETTING
, 0, TRUE
);
2255 return MMSYSERR_NOERROR
;
2258 /**************************************************************************
2259 * wodGetPosition [internal]
2261 static DWORD
wodGetPosition(WORD wDevID
, LPMMTIME lpTime
, DWORD uSize
)
2265 TRACE("(%u, %p, %u);\n", wDevID
, lpTime
, uSize
);
2267 if (wDevID
>= numOutDev
|| WOutDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2268 WARN("bad device ID !\n");
2269 return MMSYSERR_BADDEVICEID
;
2272 if (lpTime
== NULL
) {
2273 WARN("invalid parameter: lpTime == NULL\n");
2274 return MMSYSERR_INVALPARAM
;
2277 wwo
= &WOutDev
[wDevID
];
2278 #ifdef EXACT_WODPOSITION
2279 if (wwo
->ossdev
.open_access
== O_RDWR
) {
2280 if (wwo
->ossdev
.duplex_out_caps
.dwSupport
& WAVECAPS_SAMPLEACCURATE
)
2281 OSS_AddRingMessage(&wwo
->msgRing
, WINE_WM_UPDATE
, 0, TRUE
);
2283 if (wwo
->ossdev
.out_caps
.dwSupport
& WAVECAPS_SAMPLEACCURATE
)
2284 OSS_AddRingMessage(&wwo
->msgRing
, WINE_WM_UPDATE
, 0, TRUE
);
2288 return bytes_to_mmtime(lpTime
, wwo
->dwPlayedTotal
, &wwo
->waveFormat
);
2291 /**************************************************************************
2292 * wodBreakLoop [internal]
2294 static DWORD
wodBreakLoop(WORD wDevID
)
2296 TRACE("(%u);\n", wDevID
);
2298 if (wDevID
>= numOutDev
|| WOutDev
[wDevID
].state
== WINE_WS_CLOSED
) {
2299 WARN("bad device ID !\n");
2300 return MMSYSERR_BADDEVICEID
;
2302 OSS_AddRingMessage(&WOutDev
[wDevID
].msgRing
, WINE_WM_BREAKLOOP
, 0, TRUE
);
2303 return MMSYSERR_NOERROR
;
2306 /**************************************************************************
2307 * wodGetVolume [internal]
2309 static DWORD
wodGetVolume(WORD wDevID
, LPDWORD lpdwVol
)
2314 DWORD last_left
, last_right
;
2316 TRACE("(%u, %p);\n", wDevID
, lpdwVol
);
2318 if (lpdwVol
== NULL
) {
2319 WARN("not enabled\n");
2320 return MMSYSERR_NOTENABLED
;
2322 if (wDevID
>= numOutDev
) {
2323 WARN("invalid parameter\n");
2324 return MMSYSERR_INVALPARAM
;
2326 if (WOutDev
[wDevID
].ossdev
.open_access
== O_RDWR
) {
2327 if (!(WOutDev
[wDevID
].ossdev
.duplex_out_caps
.dwSupport
& WAVECAPS_VOLUME
)) {
2328 TRACE("Volume not supported\n");
2329 return MMSYSERR_NOTSUPPORTED
;
2332 if (!(WOutDev
[wDevID
].ossdev
.out_caps
.dwSupport
& WAVECAPS_VOLUME
)) {
2333 TRACE("Volume not supported\n");
2334 return MMSYSERR_NOTSUPPORTED
;
2338 if ((mixer
= open(WOutDev
[wDevID
].ossdev
.mixer_name
, O_RDONLY
|O_NDELAY
)) < 0) {
2339 WARN("mixer device not available !\n");
2340 return MMSYSERR_NOTENABLED
;
2342 if (ioctl(mixer
, SOUND_MIXER_READ_PCM
, &volume
) == -1) {
2344 WARN("ioctl(%s, SOUND_MIXER_READ_PCM) failed (%s)\n",
2345 WOutDev
[wDevID
].ossdev
.mixer_name
, strerror(errno
));
2346 return MMSYSERR_NOTENABLED
;
2350 left
= LOBYTE(volume
);
2351 right
= HIBYTE(volume
);
2352 TRACE("left=%d right=%d !\n", left
, right
);
2353 last_left
= (LOWORD(WOutDev
[wDevID
].volume
) * 100) / 0xFFFFl
;
2354 last_right
= (HIWORD(WOutDev
[wDevID
].volume
) * 100) / 0xFFFFl
;
2355 TRACE("last_left=%d last_right=%d !\n", last_left
, last_right
);
2356 if (last_left
== left
&& last_right
== right
)
2357 *lpdwVol
= WOutDev
[wDevID
].volume
;
2359 *lpdwVol
= ((left
* 0xFFFFl
) / 100) + (((right
* 0xFFFFl
) / 100) << 16);
2360 return MMSYSERR_NOERROR
;
2363 /**************************************************************************
2364 * wodSetVolume [internal]
2366 DWORD
wodSetVolume(WORD wDevID
, DWORD dwParam
)
2372 TRACE("(%u, %08X);\n", wDevID
, dwParam
);
2374 left
= (LOWORD(dwParam
) * 100) / 0xFFFFl
;
2375 right
= (HIWORD(dwParam
) * 100) / 0xFFFFl
;
2376 volume
= left
+ (right
<< 8);
2378 if (wDevID
>= numOutDev
) {
2379 WARN("invalid parameter: wDevID > %d\n", numOutDev
);
2380 return MMSYSERR_INVALPARAM
;
2382 if (WOutDev
[wDevID
].ossdev
.open_access
== O_RDWR
) {
2383 if (!(WOutDev
[wDevID
].ossdev
.duplex_out_caps
.dwSupport
& WAVECAPS_VOLUME
)) {
2384 TRACE("Volume not supported\n");
2385 return MMSYSERR_NOTSUPPORTED
;
2388 if (!(WOutDev
[wDevID
].ossdev
.out_caps
.dwSupport
& WAVECAPS_VOLUME
)) {
2389 TRACE("Volume not supported\n");
2390 return MMSYSERR_NOTSUPPORTED
;
2393 if ((mixer
= open(WOutDev
[wDevID
].ossdev
.mixer_name
, O_WRONLY
|O_NDELAY
)) < 0) {
2394 WARN("open(%s) failed (%s)\n", WOutDev
[wDevID
].ossdev
.mixer_name
, strerror(errno
));
2395 return MMSYSERR_NOTENABLED
;
2397 if (ioctl(mixer
, SOUND_MIXER_WRITE_PCM
, &volume
) == -1) {
2399 WARN("ioctl(%s, SOUND_MIXER_WRITE_PCM) failed (%s)\n",
2400 WOutDev
[wDevID
].ossdev
.mixer_name
, strerror(errno
));
2401 return MMSYSERR_NOTENABLED
;
2403 TRACE("volume=%04x\n", (unsigned)volume
);
2406 /* save requested volume */
2407 WOutDev
[wDevID
].volume
= dwParam
;
2409 return MMSYSERR_NOERROR
;
2412 /**************************************************************************
2413 * wodMessage (WINEOSS.7)
2415 DWORD WINAPI
OSS_wodMessage(UINT wDevID
, UINT wMsg
, DWORD_PTR dwUser
,
2416 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2418 TRACE("(%u, %s, %08lX, %08lX, %08lX);\n",
2419 wDevID
, getMessage(wMsg
), dwUser
, dwParam1
, dwParam2
);
2426 /* FIXME: Pretend this is supported */
2428 case WODM_OPEN
: return wodOpen (wDevID
, (LPWAVEOPENDESC
)dwParam1
, dwParam2
);
2429 case WODM_CLOSE
: return wodClose (wDevID
);
2430 case WODM_WRITE
: return wodWrite (wDevID
, (LPWAVEHDR
)dwParam1
, dwParam2
);
2431 case WODM_PAUSE
: return wodPause (wDevID
);
2432 case WODM_GETPOS
: return wodGetPosition (wDevID
, (LPMMTIME
)dwParam1
, dwParam2
);
2433 case WODM_BREAKLOOP
: return wodBreakLoop (wDevID
);
2434 case WODM_PREPARE
: return MMSYSERR_NOTSUPPORTED
;
2435 case WODM_UNPREPARE
: return MMSYSERR_NOTSUPPORTED
;
2436 case WODM_GETDEVCAPS
: return wodGetDevCaps (wDevID
, (LPWAVEOUTCAPSW
)dwParam1
, dwParam2
);
2437 case WODM_GETNUMDEVS
: return numOutDev
;
2438 case WODM_GETPITCH
: return MMSYSERR_NOTSUPPORTED
;
2439 case WODM_SETPITCH
: return MMSYSERR_NOTSUPPORTED
;
2440 case WODM_GETPLAYBACKRATE
: return MMSYSERR_NOTSUPPORTED
;
2441 case WODM_SETPLAYBACKRATE
: return MMSYSERR_NOTSUPPORTED
;
2442 case WODM_GETVOLUME
: return wodGetVolume (wDevID
, (LPDWORD
)dwParam1
);
2443 case WODM_SETVOLUME
: return wodSetVolume (wDevID
, dwParam1
);
2444 case WODM_RESTART
: return wodRestart (wDevID
);
2445 case WODM_RESET
: return wodReset (wDevID
);
2447 case DRV_QUERYDEVICEINTERFACESIZE
: return wodDevInterfaceSize (wDevID
, (LPDWORD
)dwParam1
);
2448 case DRV_QUERYDEVICEINTERFACE
: return wodDevInterface (wDevID
, (PWCHAR
)dwParam1
, dwParam2
);
2449 case DRV_QUERYDSOUNDIFACE
: return wodDsCreate (wDevID
, (PIDSDRIVER
*)dwParam1
);
2450 case DRV_QUERYDSOUNDDESC
: return wodDsDesc (wDevID
, (PDSDRIVERDESC
)dwParam1
);
2452 FIXME("unknown message %d!\n", wMsg
);
2454 return MMSYSERR_NOTSUPPORTED
;
2457 /*======================================================================*
2458 * Low level WAVE IN implementation *
2459 *======================================================================*/
2461 /**************************************************************************
2462 * widNotifyClient [internal]
2464 static void widNotifyClient(WINE_WAVEIN
* wwi
, WORD wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2466 TRACE("wMsg = 0x%04x (%s) dwParm1 = %04lx dwParam2 = %04lx\n", wMsg
,
2467 wMsg
== WIM_OPEN
? "WIM_OPEN" : wMsg
== WIM_CLOSE
? "WIM_CLOSE" :
2468 wMsg
== WIM_DATA
? "WIM_DATA" : "Unknown", dwParam1
, dwParam2
);
2474 if (wwi
->wFlags
!= DCB_NULL
&&
2475 !DriverCallback(wwi
->waveDesc
.dwCallback
, wwi
->wFlags
,
2476 (HDRVR
)wwi
->waveDesc
.hWave
, wMsg
,
2477 wwi
->waveDesc
.dwInstance
, dwParam1
, dwParam2
)) {
2478 WARN("can't notify client !\n");
2482 FIXME("Unknown callback message %u\n", wMsg
);
2486 /**************************************************************************
2487 * widGetDevCaps [internal]
2489 static DWORD
widGetDevCaps(WORD wDevID
, LPWAVEINCAPSW lpCaps
, DWORD dwSize
)
2491 TRACE("(%u, %p, %u);\n", wDevID
, lpCaps
, dwSize
);
2493 if (lpCaps
== NULL
) return MMSYSERR_NOTENABLED
;
2495 if (wDevID
>= numInDev
) {
2496 TRACE("numOutDev reached !\n");
2497 return MMSYSERR_BADDEVICEID
;
2500 memcpy(lpCaps
, &WInDev
[wDevID
].ossdev
.in_caps
, min(dwSize
, sizeof(*lpCaps
)));
2501 return MMSYSERR_NOERROR
;
2504 /**************************************************************************
2505 * widRecorder_ReadHeaders [internal]
2507 static void widRecorder_ReadHeaders(WINE_WAVEIN
* wwi
)
2509 enum win_wm_message tmp_msg
;
2510 DWORD_PTR tmp_param
;
2514 while (OSS_RetrieveRingMessage(&wwi
->msgRing
, &tmp_msg
, &tmp_param
, &tmp_ev
)) {
2515 if (tmp_msg
== WINE_WM_HEADER
) {
2517 lpWaveHdr
= (LPWAVEHDR
)tmp_param
;
2518 lpWaveHdr
->lpNext
= 0;
2520 if (wwi
->lpQueuePtr
== 0)
2521 wwi
->lpQueuePtr
= lpWaveHdr
;
2523 for (wh
= &(wwi
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
));
2527 ERR("should only have headers left\n");
2532 /**************************************************************************
2533 * widRecorder [internal]
2535 static DWORD CALLBACK
widRecorder(LPVOID pmt
)
2537 WORD uDevID
= (DWORD_PTR
)pmt
;
2538 WINE_WAVEIN
* wwi
= &WInDev
[uDevID
];
2542 LPVOID buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, wwi
->dwFragmentSize
);
2543 char *pOffset
= buffer
;
2544 audio_buf_info info
;
2546 enum win_wm_message msg
;
2551 wwi
->state
= WINE_WS_STOPPED
;
2552 wwi
->dwTotalRecorded
= 0;
2553 wwi
->dwTotalRead
= 0;
2554 wwi
->lpQueuePtr
= NULL
;
2556 SetEvent(wwi
->hStartUpEvent
);
2558 /* disable input so capture will begin when triggered */
2559 wwi
->ossdev
.bInputEnabled
= FALSE
;
2560 enable
= getEnables(&wwi
->ossdev
);
2561 if (ioctl(wwi
->ossdev
.fd
, SNDCTL_DSP_SETTRIGGER
, &enable
) < 0)
2562 ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n", wwi
->ossdev
.dev_name
, strerror(errno
));
2564 /* the soundblaster live needs a micro wake to get its recording started
2565 * (or GETISPACE will have 0 frags all the time)
2567 read(wwi
->ossdev
.fd
, &xs
, 4);
2569 /* make sleep time to be # of ms to output a fragment */
2570 dwSleepTime
= (wwi
->dwFragmentSize
* 1000) / wwi
->waveFormat
.Format
.nAvgBytesPerSec
;
2571 TRACE("sleeptime=%d ms\n", dwSleepTime
);
2574 /* wait for dwSleepTime or an event in thread's queue */
2575 /* FIXME: could improve wait time depending on queue state,
2576 * ie, number of queued fragments
2579 if (wwi
->lpQueuePtr
!= NULL
&& wwi
->state
== WINE_WS_PLAYING
)
2581 lpWaveHdr
= wwi
->lpQueuePtr
;
2583 ioctl(wwi
->ossdev
.fd
, SNDCTL_DSP_GETISPACE
, &info
);
2584 TRACE("info={frag=%d fsize=%d ftotal=%d bytes=%d}\n", info
.fragments
, info
.fragsize
, info
.fragstotal
, info
.bytes
);
2586 /* read all the fragments accumulated so far */
2587 while ((info
.fragments
> 0) && (wwi
->lpQueuePtr
))
2591 if (lpWaveHdr
->dwBufferLength
- lpWaveHdr
->dwBytesRecorded
>= wwi
->dwFragmentSize
)
2593 /* directly read fragment in wavehdr */
2594 bytesRead
= read(wwi
->ossdev
.fd
,
2595 lpWaveHdr
->lpData
+ lpWaveHdr
->dwBytesRecorded
,
2596 wwi
->dwFragmentSize
);
2598 TRACE("bytesRead=%d (direct)\n", bytesRead
);
2599 if (bytesRead
!= (DWORD
) -1)
2601 /* update number of bytes recorded in current buffer and by this device */
2602 lpWaveHdr
->dwBytesRecorded
+= bytesRead
;
2603 wwi
->dwTotalRead
+= bytesRead
;
2604 wwi
->dwTotalRecorded
= wwi
->dwTotalRead
;
2606 /* buffer is full. notify client */
2607 if (lpWaveHdr
->dwBytesRecorded
== lpWaveHdr
->dwBufferLength
)
2609 /* must copy the value of next waveHdr, because we have no idea of what
2610 * will be done with the content of lpWaveHdr in callback
2612 LPWAVEHDR lpNext
= lpWaveHdr
->lpNext
;
2614 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
2615 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
2617 wwi
->lpQueuePtr
= lpNext
;
2618 widNotifyClient(wwi
, WIM_DATA
, (DWORD_PTR
)lpWaveHdr
, 0);
2622 TRACE("read(%s, %p, %d) failed (%s)\n", wwi
->ossdev
.dev_name
,
2623 lpWaveHdr
->lpData
+ lpWaveHdr
->dwBytesRecorded
,
2624 wwi
->dwFragmentSize
, strerror(errno
));
2629 /* read the fragment in a local buffer */
2630 bytesRead
= read(wwi
->ossdev
.fd
, buffer
, wwi
->dwFragmentSize
);
2633 TRACE("bytesRead=%d (local)\n", bytesRead
);
2635 if (bytesRead
== (DWORD
) -1) {
2636 TRACE("read(%s, %p, %d) failed (%s)\n", wwi
->ossdev
.dev_name
,
2637 buffer
, wwi
->dwFragmentSize
, strerror(errno
));
2641 /* copy data in client buffers */
2642 while (bytesRead
!= (DWORD
) -1 && bytesRead
> 0)
2644 DWORD dwToCopy
= min (bytesRead
, lpWaveHdr
->dwBufferLength
- lpWaveHdr
->dwBytesRecorded
);
2646 memcpy(lpWaveHdr
->lpData
+ lpWaveHdr
->dwBytesRecorded
,
2650 /* update number of bytes recorded in current buffer and by this device */
2651 lpWaveHdr
->dwBytesRecorded
+= dwToCopy
;
2652 wwi
->dwTotalRead
+= dwToCopy
;
2653 wwi
->dwTotalRecorded
= wwi
->dwTotalRead
;
2654 bytesRead
-= dwToCopy
;
2655 pOffset
+= dwToCopy
;
2657 /* client buffer is full. notify client */
2658 if (lpWaveHdr
->dwBytesRecorded
== lpWaveHdr
->dwBufferLength
)
2660 /* must copy the value of next waveHdr, because we have no idea of what
2661 * will be done with the content of lpWaveHdr in callback
2663 LPWAVEHDR lpNext
= lpWaveHdr
->lpNext
;
2664 TRACE("lpNext=%p\n", lpNext
);
2666 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
2667 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
2669 wwi
->lpQueuePtr
= lpNext
;
2670 widNotifyClient(wwi
, WIM_DATA
, (DWORD_PTR
)lpWaveHdr
, 0);
2673 if (!lpNext
&& bytesRead
) {
2674 /* before we give up, check for more header messages */
2675 while (OSS_PeekRingMessage(&wwi
->msgRing
, &msg
, ¶m
, &ev
))
2677 if (msg
== WINE_WM_HEADER
) {
2679 OSS_RetrieveRingMessage(&wwi
->msgRing
, &msg
, ¶m
, &ev
);
2680 hdr
= ((LPWAVEHDR
)param
);
2681 TRACE("msg = %s, hdr = %p, ev = %p\n", getCmdString(msg
), hdr
, ev
);
2683 if (lpWaveHdr
== 0) {
2684 /* new head of queue */
2685 wwi
->lpQueuePtr
= lpWaveHdr
= hdr
;
2687 /* insert buffer at the end of queue */
2689 for (wh
= &(wwi
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
));
2696 if (lpWaveHdr
== 0) {
2697 /* no more buffer to copy data to, but we did read more.
2698 * what hasn't been copied will be dropped
2700 WARN("buffer under run! %u bytes dropped.\n", bytesRead
);
2701 wwi
->lpQueuePtr
= NULL
;
2711 WAIT_OMR(&wwi
->msgRing
, dwSleepTime
);
2713 while (OSS_RetrieveRingMessage(&wwi
->msgRing
, &msg
, ¶m
, &ev
))
2715 TRACE("msg=%s param=0x%lx\n", getCmdString(msg
), param
);
2717 case WINE_WM_PAUSING
:
2718 wwi
->state
= WINE_WS_PAUSED
;
2719 /*FIXME("Device should stop recording\n");*/
2722 case WINE_WM_STARTING
:
2723 wwi
->state
= WINE_WS_PLAYING
;
2725 if (wwi
->ossdev
.bTriggerSupport
)
2727 /* start the recording */
2728 wwi
->ossdev
.bInputEnabled
= TRUE
;
2729 enable
= getEnables(&wwi
->ossdev
);
2730 if (ioctl(wwi
->ossdev
.fd
, SNDCTL_DSP_SETTRIGGER
, &enable
) < 0) {
2731 wwi
->ossdev
.bInputEnabled
= FALSE
;
2732 ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n", wwi
->ossdev
.dev_name
, strerror(errno
));
2737 unsigned char data
[4];
2738 /* read 4 bytes to start the recording */
2739 read(wwi
->ossdev
.fd
, data
, 4);
2744 case WINE_WM_HEADER
:
2745 lpWaveHdr
= (LPWAVEHDR
)param
;
2746 lpWaveHdr
->lpNext
= 0;
2748 /* insert buffer at the end of queue */
2751 for (wh
= &(wwi
->lpQueuePtr
); *wh
; wh
= &((*wh
)->lpNext
));
2755 case WINE_WM_STOPPING
:
2756 if (wwi
->state
!= WINE_WS_STOPPED
)
2758 if (wwi
->ossdev
.bTriggerSupport
)
2760 /* stop the recording */
2761 wwi
->ossdev
.bInputEnabled
= FALSE
;
2762 enable
= getEnables(&wwi
->ossdev
);
2763 if (ioctl(wwi
->ossdev
.fd
, SNDCTL_DSP_SETTRIGGER
, &enable
) < 0) {
2764 wwi
->ossdev
.bInputEnabled
= FALSE
;
2765 ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n", wwi
->ossdev
.dev_name
, strerror(errno
));
2769 /* read any headers in queue */
2770 widRecorder_ReadHeaders(wwi
);
2772 /* return current buffer to app */
2773 lpWaveHdr
= wwi
->lpQueuePtr
;
2776 LPWAVEHDR lpNext
= lpWaveHdr
->lpNext
;
2777 TRACE("stop %p %p\n", lpWaveHdr
, lpWaveHdr
->lpNext
);
2778 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
2779 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
2780 wwi
->lpQueuePtr
= lpNext
;
2781 widNotifyClient(wwi
, WIM_DATA
, (DWORD_PTR
)lpWaveHdr
, 0);
2784 wwi
->state
= WINE_WS_STOPPED
;
2787 case WINE_WM_RESETTING
:
2788 if (wwi
->state
!= WINE_WS_STOPPED
)
2790 if (wwi
->ossdev
.bTriggerSupport
)
2792 /* stop the recording */
2793 wwi
->ossdev
.bInputEnabled
= FALSE
;
2794 enable
= getEnables(&wwi
->ossdev
);
2795 if (ioctl(wwi
->ossdev
.fd
, SNDCTL_DSP_SETTRIGGER
, &enable
) < 0) {
2796 wwi
->ossdev
.bInputEnabled
= FALSE
;
2797 ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n", wwi
->ossdev
.dev_name
, strerror(errno
));
2801 wwi
->state
= WINE_WS_STOPPED
;
2802 wwi
->dwTotalRecorded
= 0;
2803 wwi
->dwTotalRead
= 0;
2805 /* read any headers in queue */
2806 widRecorder_ReadHeaders(wwi
);
2808 /* return all buffers to the app */
2809 while (wwi
->lpQueuePtr
) {
2810 lpWaveHdr
= wwi
->lpQueuePtr
;
2811 TRACE("reset %p %p\n", lpWaveHdr
, lpWaveHdr
->lpNext
);
2812 wwi
->lpQueuePtr
= lpWaveHdr
->lpNext
;
2813 lpWaveHdr
->dwFlags
&= ~WHDR_INQUEUE
;
2814 lpWaveHdr
->dwFlags
|= WHDR_DONE
;
2815 widNotifyClient(wwi
, WIM_DATA
, (DWORD_PTR
)lpWaveHdr
, 0);
2820 case WINE_WM_UPDATE
:
2821 if (wwi
->state
== WINE_WS_PLAYING
) {
2822 audio_buf_info tmp_info
;
2823 if (ioctl(wwi
->ossdev
.fd
, SNDCTL_DSP_GETISPACE
, &tmp_info
) < 0)
2824 ERR("ioctl(%s, SNDCTL_DSP_GETISPACE) failed (%s)\n", wwi
->ossdev
.dev_name
, strerror(errno
));
2826 wwi
->dwTotalRecorded
= wwi
->dwTotalRead
+ tmp_info
.bytes
;
2830 case WINE_WM_CLOSING
:
2832 wwi
->state
= WINE_WS_CLOSED
;
2834 HeapFree(GetProcessHeap(), 0, buffer
);
2836 /* shouldn't go here */
2838 FIXME("unknown message %d\n", msg
);
2844 /* just for not generating compilation warnings... should never be executed */
2849 /**************************************************************************
2850 * widOpen [internal]
2852 static DWORD
widOpen(WORD wDevID
, LPWAVEOPENDESC lpDesc
, DWORD dwFlags
)
2855 audio_buf_info info
;
2859 TRACE("(%u, %p, %08X);\n", wDevID
, lpDesc
, dwFlags
);
2860 if (lpDesc
== NULL
) {
2861 WARN("Invalid Parameter !\n");
2862 return MMSYSERR_INVALPARAM
;
2864 if (wDevID
>= numInDev
) {
2865 WARN("bad device id: %d >= %d\n", wDevID
, numInDev
);
2866 return MMSYSERR_BADDEVICEID
;
2869 /* only PCM format is supported so far... */
2870 if (!supportedFormat(lpDesc
->lpFormat
)) {
2871 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
2872 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
2873 lpDesc
->lpFormat
->nSamplesPerSec
);
2874 return WAVERR_BADFORMAT
;
2877 if (dwFlags
& WAVE_FORMAT_QUERY
) {
2878 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
2879 lpDesc
->lpFormat
->wFormatTag
, lpDesc
->lpFormat
->nChannels
,
2880 lpDesc
->lpFormat
->nSamplesPerSec
);
2881 return MMSYSERR_NOERROR
;
2884 /* nBlockAlign and nAvgBytesPerSec are output variables for dsound */
2885 if (lpDesc
->lpFormat
->nBlockAlign
!= lpDesc
->lpFormat
->nChannels
*lpDesc
->lpFormat
->wBitsPerSample
/8) {
2886 lpDesc
->lpFormat
->nBlockAlign
= lpDesc
->lpFormat
->nChannels
*lpDesc
->lpFormat
->wBitsPerSample
/8;
2887 WARN("Fixing nBlockAlign\n");
2889 if (lpDesc
->lpFormat
->nAvgBytesPerSec
!= lpDesc
->lpFormat
->nSamplesPerSec
*lpDesc
->lpFormat
->nBlockAlign
) {
2890 lpDesc
->lpFormat
->nAvgBytesPerSec
= lpDesc
->lpFormat
->nSamplesPerSec
*lpDesc
->lpFormat
->nBlockAlign
;
2891 WARN("Fixing nAvgBytesPerSec\n");
2894 TRACE("OSS_OpenDevice requested this format: %dx%dx%d %s\n",
2895 lpDesc
->lpFormat
->nSamplesPerSec
,
2896 lpDesc
->lpFormat
->wBitsPerSample
,
2897 lpDesc
->lpFormat
->nChannels
,
2898 lpDesc
->lpFormat
->wFormatTag
== WAVE_FORMAT_PCM
? "WAVE_FORMAT_PCM" :
2899 lpDesc
->lpFormat
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
? "WAVE_FORMAT_EXTENSIBLE" :
2902 wwi
= &WInDev
[wDevID
];
2904 if (wwi
->state
!= WINE_WS_CLOSED
) return MMSYSERR_ALLOCATED
;
2906 if ((dwFlags
& WAVE_DIRECTSOUND
) &&
2907 !(wwi
->ossdev
.in_caps_support
& WAVECAPS_DIRECTSOUND
))
2908 /* not supported, ignore it */
2909 dwFlags
&= ~WAVE_DIRECTSOUND
;
2911 if (dwFlags
& WAVE_DIRECTSOUND
) {
2912 TRACE("has DirectSoundCapture driver\n");
2913 if (wwi
->ossdev
.in_caps_support
& WAVECAPS_SAMPLEACCURATE
)
2914 /* we have realtime DirectSound, fragments just waste our time,
2915 * but a large buffer is good, so choose 64KB (32 * 2^11) */
2916 audio_fragment
= 0x0020000B;
2918 /* to approximate realtime, we must use small fragments,
2919 * let's try to fragment the above 64KB (256 * 2^8) */
2920 audio_fragment
= 0x01000008;
2922 TRACE("doesn't have DirectSoundCapture driver\n");
2923 if (wwi
->ossdev
.open_count
> 0) {
2924 TRACE("Using output device audio_fragment\n");
2925 /* FIXME: This may not be optimal for capture but it allows us
2926 * to do hardware playback without hardware capture. */
2927 audio_fragment
= wwi
->ossdev
.audio_fragment
;
2929 /* A wave device must have a worst case latency of 10 ms so calculate
2930 * the largest fragment size less than 10 ms long.
2932 int fsize
= lpDesc
->lpFormat
->nAvgBytesPerSec
/ 100; /* 10 ms chunk */
2934 while ((1 << shift
) <= fsize
)
2937 audio_fragment
= 0x00100000 + shift
; /* 16 fragments of 2^shift */
2941 TRACE("requesting %d %d byte fragments (%d ms)\n", audio_fragment
>> 16,
2942 1 << (audio_fragment
& 0xffff),
2943 ((1 << (audio_fragment
& 0xffff)) * 1000) / lpDesc
->lpFormat
->nAvgBytesPerSec
);
2945 ret
= OSS_OpenDevice(&wwi
->ossdev
, O_RDONLY
, &audio_fragment
,
2947 lpDesc
->lpFormat
->nSamplesPerSec
,
2948 lpDesc
->lpFormat
->nChannels
,
2949 (lpDesc
->lpFormat
->wBitsPerSample
== 16)
2950 ? AFMT_S16_LE
: AFMT_U8
);
2951 if (ret
!= 0) return ret
;
2952 wwi
->state
= WINE_WS_STOPPED
;
2954 if (wwi
->lpQueuePtr
) {
2955 WARN("Should have an empty queue (%p)\n", wwi
->lpQueuePtr
);
2956 wwi
->lpQueuePtr
= NULL
;
2958 wwi
->dwTotalRecorded
= 0;
2959 wwi
->dwTotalRead
= 0;
2960 wwi
->wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
2962 wwi
->waveDesc
= *lpDesc
;
2963 copy_format(lpDesc
->lpFormat
, &wwi
->waveFormat
);
2965 if (ioctl(wwi
->ossdev
.fd
, SNDCTL_DSP_GETISPACE
, &info
) < 0) {
2966 ERR("ioctl(%s, SNDCTL_DSP_GETISPACE) failed (%s)\n",
2967 wwi
->ossdev
.dev_name
, strerror(errno
));
2968 OSS_CloseDevice(&wwi
->ossdev
);
2969 wwi
->state
= WINE_WS_CLOSED
;
2970 return MMSYSERR_NOTENABLED
;
2973 TRACE("got %d %d byte fragments (%d ms/fragment)\n", info
.fragstotal
,
2974 info
.fragsize
, (info
.fragsize
* 1000) / (wwi
->ossdev
.sample_rate
*
2975 wwi
->ossdev
.channels
* (wwi
->ossdev
.format
== AFMT_U8
? 1 : 2)));
2977 wwi
->dwFragmentSize
= info
.fragsize
;
2979 TRACE("dwFragmentSize=%u\n", wwi
->dwFragmentSize
);
2980 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
2981 wwi
->waveFormat
.Format
.wBitsPerSample
, wwi
->waveFormat
.Format
.nAvgBytesPerSec
,
2982 wwi
->waveFormat
.Format
.nSamplesPerSec
, wwi
->waveFormat
.Format
.nChannels
,
2983 wwi
->waveFormat
.Format
.nBlockAlign
);
2985 OSS_InitRingMessage(&wwi
->msgRing
);
2987 wwi
->hStartUpEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
2988 wwi
->hThread
= CreateThread(NULL
, 0, widRecorder
, (LPVOID
)(DWORD_PTR
)wDevID
, 0, &(wwi
->dwThreadID
));
2990 SetThreadPriority(wwi
->hThread
, THREAD_PRIORITY_TIME_CRITICAL
);
2991 WaitForSingleObject(wwi
->hStartUpEvent
, INFINITE
);
2992 CloseHandle(wwi
->hStartUpEvent
);
2993 wwi
->hStartUpEvent
= INVALID_HANDLE_VALUE
;
2995 widNotifyClient(wwi
, WIM_OPEN
, 0L, 0L);
2996 return MMSYSERR_NOERROR
;
2999 /**************************************************************************
3000 * widClose [internal]
3002 static DWORD
widClose(WORD wDevID
)
3006 TRACE("(%u);\n", wDevID
);
3007 if (wDevID
>= numInDev
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
3008 WARN("can't close !\n");
3009 return MMSYSERR_INVALHANDLE
;
3012 wwi
= &WInDev
[wDevID
];
3014 if (wwi
->lpQueuePtr
!= NULL
) {
3015 WARN("still buffers open !\n");
3016 return WAVERR_STILLPLAYING
;
3019 OSS_AddRingMessage(&wwi
->msgRing
, WINE_WM_CLOSING
, 0, TRUE
);
3020 OSS_CloseDevice(&wwi
->ossdev
);
3021 wwi
->state
= WINE_WS_CLOSED
;
3022 wwi
->dwFragmentSize
= 0;
3023 OSS_DestroyRingMessage(&wwi
->msgRing
);
3024 widNotifyClient(wwi
, WIM_CLOSE
, 0L, 0L);
3025 return MMSYSERR_NOERROR
;
3028 /**************************************************************************
3029 * widAddBuffer [internal]
3031 static DWORD
widAddBuffer(WORD wDevID
, LPWAVEHDR lpWaveHdr
, DWORD dwSize
)
3033 TRACE("(%u, %p, %08X);\n", wDevID
, lpWaveHdr
, dwSize
);
3035 if (wDevID
>= numInDev
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
3036 WARN("can't do it !\n");
3037 return MMSYSERR_INVALHANDLE
;
3039 if (!(lpWaveHdr
->dwFlags
& WHDR_PREPARED
)) {
3040 TRACE("never been prepared !\n");
3041 return WAVERR_UNPREPARED
;
3043 if (lpWaveHdr
->dwFlags
& WHDR_INQUEUE
) {
3044 TRACE("header already in use !\n");
3045 return WAVERR_STILLPLAYING
;
3048 lpWaveHdr
->dwFlags
|= WHDR_INQUEUE
;
3049 lpWaveHdr
->dwFlags
&= ~WHDR_DONE
;
3050 lpWaveHdr
->dwBytesRecorded
= 0;
3051 lpWaveHdr
->lpNext
= NULL
;
3053 OSS_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_HEADER
, (DWORD_PTR
)lpWaveHdr
, FALSE
);
3054 return MMSYSERR_NOERROR
;
3057 /**************************************************************************
3058 * widStart [internal]
3060 static DWORD
widStart(WORD wDevID
)
3062 TRACE("(%u);\n", wDevID
);
3063 if (wDevID
>= numInDev
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
3064 WARN("can't start recording !\n");
3065 return MMSYSERR_INVALHANDLE
;
3068 OSS_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_STARTING
, 0, TRUE
);
3069 return MMSYSERR_NOERROR
;
3072 /**************************************************************************
3073 * widStop [internal]
3075 static DWORD
widStop(WORD wDevID
)
3077 TRACE("(%u);\n", wDevID
);
3078 if (wDevID
>= numInDev
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
3079 WARN("can't stop !\n");
3080 return MMSYSERR_INVALHANDLE
;
3083 OSS_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_STOPPING
, 0, TRUE
);
3085 return MMSYSERR_NOERROR
;
3088 /**************************************************************************
3089 * widReset [internal]
3091 static DWORD
widReset(WORD wDevID
)
3093 TRACE("(%u);\n", wDevID
);
3094 if (wDevID
>= numInDev
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
3095 WARN("can't reset !\n");
3096 return MMSYSERR_INVALHANDLE
;
3098 OSS_AddRingMessage(&WInDev
[wDevID
].msgRing
, WINE_WM_RESETTING
, 0, TRUE
);
3099 return MMSYSERR_NOERROR
;
3102 /**************************************************************************
3103 * widGetPosition [internal]
3105 static DWORD
widGetPosition(WORD wDevID
, LPMMTIME lpTime
, DWORD uSize
)
3109 TRACE("(%u, %p, %u);\n", wDevID
, lpTime
, uSize
);
3111 if (wDevID
>= numInDev
|| WInDev
[wDevID
].state
== WINE_WS_CLOSED
) {
3112 WARN("can't get pos !\n");
3113 return MMSYSERR_INVALHANDLE
;
3116 if (lpTime
== NULL
) {
3117 WARN("invalid parameter: lpTime == NULL\n");
3118 return MMSYSERR_INVALPARAM
;
3121 wwi
= &WInDev
[wDevID
];
3122 #ifdef EXACT_WIDPOSITION
3123 if (wwi
->ossdev
.in_caps_support
& WAVECAPS_SAMPLEACCURATE
)
3124 OSS_AddRingMessage(&(wwi
->msgRing
), WINE_WM_UPDATE
, 0, TRUE
);
3127 return bytes_to_mmtime(lpTime
, wwi
->dwTotalRecorded
, &wwi
->waveFormat
);
3130 /**************************************************************************
3131 * widMessage (WINEOSS.6)
3133 DWORD WINAPI
OSS_widMessage(WORD wDevID
, WORD wMsg
, DWORD_PTR dwUser
,
3134 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3136 TRACE("(%u, %s, %08lX, %08lX, %08lX);\n",
3137 wDevID
, getMessage(wMsg
), dwUser
, dwParam1
, dwParam2
);
3141 return OSS_WaveInit();
3143 return OSS_WaveExit();
3146 /* FIXME: Pretend this is supported */
3148 case WIDM_OPEN
: return widOpen (wDevID
, (LPWAVEOPENDESC
)dwParam1
, dwParam2
);
3149 case WIDM_CLOSE
: return widClose (wDevID
);
3150 case WIDM_ADDBUFFER
: return widAddBuffer (wDevID
, (LPWAVEHDR
)dwParam1
, dwParam2
);
3151 case WIDM_PREPARE
: return MMSYSERR_NOTSUPPORTED
;
3152 case WIDM_UNPREPARE
: return MMSYSERR_NOTSUPPORTED
;
3153 case WIDM_GETDEVCAPS
: return widGetDevCaps (wDevID
, (LPWAVEINCAPSW
)dwParam1
, dwParam2
);
3154 case WIDM_GETNUMDEVS
: return numInDev
;
3155 case WIDM_GETPOS
: return widGetPosition(wDevID
, (LPMMTIME
)dwParam1
, dwParam2
);
3156 case WIDM_RESET
: return widReset (wDevID
);
3157 case WIDM_START
: return widStart (wDevID
);
3158 case WIDM_STOP
: return widStop (wDevID
);
3159 case DRV_QUERYDEVICEINTERFACESIZE
: return widDevInterfaceSize (wDevID
, (LPDWORD
)dwParam1
);
3160 case DRV_QUERYDEVICEINTERFACE
: return widDevInterface (wDevID
, (PWCHAR
)dwParam1
, dwParam2
);
3161 case DRV_QUERYDSOUNDIFACE
: return widDsCreate (wDevID
, (PIDSCDRIVER
*)dwParam1
);
3162 case DRV_QUERYDSOUNDDESC
: return widDsDesc (wDevID
, (PDSDRIVERDESC
)dwParam1
);
3164 FIXME("unknown message %u!\n", wMsg
);
3166 return MMSYSERR_NOTSUPPORTED
;
3169 #else /* !HAVE_OSS */
3171 /**************************************************************************
3172 * wodMessage (WINEOSS.7)
3174 DWORD WINAPI
OSS_wodMessage(WORD wDevID
, WORD wMsg
, DWORD_PTR dwUser
,
3175 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3177 FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
3178 return MMSYSERR_NOTENABLED
;
3181 /**************************************************************************
3182 * widMessage (WINEOSS.6)
3184 DWORD WINAPI
OSS_widMessage(WORD wDevID
, WORD wMsg
, DWORD_PTR dwUser
,
3185 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
3187 FIXME("(%u, %04X, %08lX, %08lX, %08lX):stub\n", wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
3188 return MMSYSERR_NOTENABLED
;
3191 #endif /* HAVE_OSS */