2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
23 #include <sys/ioctl.h>
24 #include <sys/types.h>
37 #include <sys/soundcard.h>
40 * The OSS documentation talks about SOUND_MIXER_READ, but the header
41 * only contains MIXER_READ. Play safe. Same for WRITE.
43 #ifndef SOUND_MIXER_READ
44 #define SOUND_MIXER_READ MIXER_READ
46 #ifndef SOUND_MIXER_WRITE
47 #define SOUND_MIXER_WRITE MIXER_WRITE
50 static const ALCchar oss_device
[] = "OSS Default";
65 static int log2i(ALCuint x
)
77 static ALuint
OSSProc(ALvoid
*ptr
)
79 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
80 oss_data
*data
= (oss_data
*)pDevice
->ExtraData
;
86 frameSize
= FrameSizeFromDevFmt(pDevice
->FmtChans
, pDevice
->FmtType
);
88 while(!data
->killNow
&& pDevice
->Connected
)
90 ALint len
= data
->data_size
;
91 ALubyte
*WritePtr
= data
->mix_data
;
93 aluMixData(pDevice
, WritePtr
, len
/frameSize
);
94 while(len
> 0 && !data
->killNow
)
96 wrote
= write(data
->fd
, WritePtr
, len
);
99 if(errno
!= EAGAIN
&& errno
!= EWOULDBLOCK
&& errno
!= EINTR
)
101 ERR("write failed: %s\n", strerror(errno
));
102 aluHandleDisconnect(pDevice
);
118 static ALuint
OSSCaptureProc(ALvoid
*ptr
)
120 ALCdevice
*pDevice
= (ALCdevice
*)ptr
;
121 oss_data
*data
= (oss_data
*)pDevice
->ExtraData
;
127 frameSize
= FrameSizeFromDevFmt(pDevice
->FmtChans
, pDevice
->FmtType
);
129 while(!data
->killNow
)
131 amt
= read(data
->fd
, data
->mix_data
, data
->data_size
);
134 ERR("read failed: %s\n", strerror(errno
));
135 aluHandleDisconnect(pDevice
);
144 WriteRingBuffer(data
->ring
, data
->mix_data
, amt
/frameSize
);
150 static ALCenum
oss_open_playback(ALCdevice
*device
, const ALCchar
*deviceName
)
155 strncpy(driver
, GetConfigValue("oss", "device", "/dev/dsp"), sizeof(driver
)-1);
156 driver
[sizeof(driver
)-1] = 0;
158 deviceName
= oss_device
;
159 else if(strcmp(deviceName
, oss_device
) != 0)
160 return ALC_INVALID_VALUE
;
162 data
= (oss_data
*)calloc(1, sizeof(oss_data
));
165 data
->fd
= open(driver
, O_WRONLY
);
169 ERR("Could not open %s: %s\n", driver
, strerror(errno
));
170 return ALC_INVALID_VALUE
;
173 device
->szDeviceName
= strdup(deviceName
);
174 device
->ExtraData
= data
;
178 static void oss_close_playback(ALCdevice
*device
)
180 oss_data
*data
= (oss_data
*)device
->ExtraData
;
184 device
->ExtraData
= NULL
;
187 static ALCboolean
oss_reset_playback(ALCdevice
*device
)
189 oss_data
*data
= (oss_data
*)device
->ExtraData
;
190 int numFragmentsLogSize
;
191 int log2FragmentSize
;
192 unsigned int periods
;
200 switch(device
->FmtType
)
212 device
->FmtType
= DevFmtShort
;
215 ossFormat
= AFMT_S16_NE
;
219 periods
= device
->NumUpdates
;
220 numChannels
= ChannelsFromDevFmt(device
->FmtChans
);
221 frameSize
= numChannels
* BytesFromDevFmt(device
->FmtType
);
223 ossSpeed
= device
->Frequency
;
224 log2FragmentSize
= log2i(device
->UpdateSize
* frameSize
);
226 /* according to the OSS spec, 16 bytes are the minimum */
227 if (log2FragmentSize
< 4)
228 log2FragmentSize
= 4;
229 /* Subtract one period since the temp mixing buffer counts as one. Still
230 * need at least two on the card, though. */
231 if(periods
> 2) periods
--;
232 numFragmentsLogSize
= (periods
<< 16) | log2FragmentSize
;
234 #define CHECKERR(func) if((func) < 0) { \
238 /* Don't fail if SETFRAGMENT fails. We can handle just about anything
239 * that's reported back via GETOSPACE */
240 ioctl(data
->fd
, SNDCTL_DSP_SETFRAGMENT
, &numFragmentsLogSize
);
241 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_SETFMT
, &ossFormat
));
242 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_CHANNELS
, &numChannels
));
243 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_SPEED
, &ossSpeed
));
244 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_GETOSPACE
, &info
));
248 ERR("%s failed: %s\n", err
, strerror(errno
));
253 if((int)ChannelsFromDevFmt(device
->FmtChans
) != numChannels
)
255 ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(device
->FmtChans
), numChannels
);
259 if(!((ossFormat
== AFMT_S8
&& device
->FmtType
== DevFmtByte
) ||
260 (ossFormat
== AFMT_U8
&& device
->FmtType
== DevFmtUByte
) ||
261 (ossFormat
== AFMT_S16_NE
&& device
->FmtType
== DevFmtShort
)))
263 ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(device
->FmtType
), ossFormat
);
267 device
->Frequency
= ossSpeed
;
268 device
->UpdateSize
= info
.fragsize
/ frameSize
;
269 device
->NumUpdates
= info
.fragments
+ 1;
271 data
->data_size
= device
->UpdateSize
* frameSize
;
272 data
->mix_data
= calloc(1, data
->data_size
);
274 SetDefaultChannelOrder(device
);
276 data
->thread
= StartThread(OSSProc
, device
);
277 if(data
->thread
== NULL
)
279 free(data
->mix_data
);
280 data
->mix_data
= NULL
;
287 static void oss_stop_playback(ALCdevice
*device
)
289 oss_data
*data
= (oss_data
*)device
->ExtraData
;
295 StopThread(data
->thread
);
299 if(ioctl(data
->fd
, SNDCTL_DSP_RESET
) != 0)
300 ERR("Error resetting device: %s\n", strerror(errno
));
302 free(data
->mix_data
);
303 data
->mix_data
= NULL
;
307 static ALCenum
oss_open_capture(ALCdevice
*device
, const ALCchar
*deviceName
)
309 int numFragmentsLogSize
;
310 int log2FragmentSize
;
311 unsigned int periods
;
321 strncpy(driver
, GetConfigValue("oss", "capture", "/dev/dsp"), sizeof(driver
)-1);
322 driver
[sizeof(driver
)-1] = 0;
325 deviceName
= oss_device
;
326 else if(strcmp(deviceName
, oss_device
) != 0)
327 return ALC_INVALID_VALUE
;
329 data
= (oss_data
*)calloc(1, sizeof(oss_data
));
332 data
->fd
= open(driver
, O_RDONLY
);
336 ERR("Could not open %s: %s\n", driver
, strerror(errno
));
337 return ALC_INVALID_VALUE
;
340 switch(device
->FmtType
)
349 ossFormat
= AFMT_S16_NE
;
356 ERR("%s capture samples not supported on OSS\n", DevFmtTypeString(device
->FmtType
));
357 return ALC_INVALID_VALUE
;
361 numChannels
= ChannelsFromDevFmt(device
->FmtChans
);
362 frameSize
= numChannels
* BytesFromDevFmt(device
->FmtType
);
363 ossSpeed
= device
->Frequency
;
364 log2FragmentSize
= log2i(device
->UpdateSize
* device
->NumUpdates
*
365 frameSize
/ periods
);
367 /* according to the OSS spec, 16 bytes are the minimum */
368 if (log2FragmentSize
< 4)
369 log2FragmentSize
= 4;
370 numFragmentsLogSize
= (periods
<< 16) | log2FragmentSize
;
372 #define CHECKERR(func) if((func) < 0) { \
376 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_SETFRAGMENT
, &numFragmentsLogSize
));
377 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_SETFMT
, &ossFormat
));
378 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_CHANNELS
, &numChannels
));
379 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_SPEED
, &ossSpeed
));
380 CHECKERR(ioctl(data
->fd
, SNDCTL_DSP_GETISPACE
, &info
));
384 ERR("%s failed: %s\n", err
, strerror(errno
));
387 return ALC_INVALID_VALUE
;
391 if((int)ChannelsFromDevFmt(device
->FmtChans
) != numChannels
)
393 ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(device
->FmtChans
), numChannels
);
396 return ALC_INVALID_VALUE
;
399 if(!((ossFormat
== AFMT_S8
&& device
->FmtType
== DevFmtByte
) ||
400 (ossFormat
== AFMT_U8
&& device
->FmtType
== DevFmtUByte
) ||
401 (ossFormat
== AFMT_S16_NE
&& device
->FmtType
== DevFmtShort
)))
403 ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(device
->FmtType
), ossFormat
);
406 return ALC_INVALID_VALUE
;
409 data
->ring
= CreateRingBuffer(frameSize
, device
->UpdateSize
* device
->NumUpdates
);
412 ERR("Ring buffer create failed\n");
415 return ALC_OUT_OF_MEMORY
;
418 data
->data_size
= info
.fragsize
;
419 data
->mix_data
= calloc(1, data
->data_size
);
421 device
->ExtraData
= data
;
422 data
->thread
= StartThread(OSSCaptureProc
, device
);
423 if(data
->thread
== NULL
)
425 device
->ExtraData
= NULL
;
426 free(data
->mix_data
);
428 return ALC_OUT_OF_MEMORY
;
431 device
->szDeviceName
= strdup(deviceName
);
435 static void oss_close_capture(ALCdevice
*device
)
437 oss_data
*data
= (oss_data
*)device
->ExtraData
;
439 StopThread(data
->thread
);
443 DestroyRingBuffer(data
->ring
);
445 free(data
->mix_data
);
447 device
->ExtraData
= NULL
;
450 static void oss_start_capture(ALCdevice
*pDevice
)
452 oss_data
*data
= (oss_data
*)pDevice
->ExtraData
;
456 static void oss_stop_capture(ALCdevice
*pDevice
)
458 oss_data
*data
= (oss_data
*)pDevice
->ExtraData
;
462 static ALCenum
oss_capture_samples(ALCdevice
*pDevice
, ALCvoid
*pBuffer
, ALCuint lSamples
)
464 oss_data
*data
= (oss_data
*)pDevice
->ExtraData
;
465 ReadRingBuffer(data
->ring
, pBuffer
, lSamples
);
469 static ALCuint
oss_available_samples(ALCdevice
*pDevice
)
471 oss_data
*data
= (oss_data
*)pDevice
->ExtraData
;
472 return RingBufferSize(data
->ring
);
476 static const BackendFuncs oss_funcs
= {
486 oss_available_samples
489 ALCboolean
alc_oss_init(BackendFuncs
*func_list
)
491 *func_list
= oss_funcs
;
495 void alc_oss_deinit(void)
499 void alc_oss_probe(enum DevProbe type
)
503 case ALL_DEVICE_PROBE
:
507 if(stat(GetConfigValue("oss", "device", "/dev/dsp"), &buf
) == 0)
509 AppendAllDeviceList(oss_device
);
513 case CAPTURE_DEVICE_PROBE
:
517 if(stat(GetConfigValue("oss", "capture", "/dev/dsp"), &buf
) == 0)
519 AppendCaptureDeviceList(oss_device
);