Clamp source position to the buffer size when it stops
[openal-soft/openal-hmr.git] / Alc / oss.c
blob399d64bd36c008a8bb9fd91963a5c62c0127c891
1 /**
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
21 #include "config.h"
23 #include <sys/ioctl.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <fcntl.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <memory.h>
30 #include <unistd.h>
31 #include <errno.h>
32 #include <math.h>
33 #include "alMain.h"
34 #include "AL/al.h"
35 #include "AL/alc.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
45 #endif
46 #ifndef SOUND_MIXER_WRITE
47 #define SOUND_MIXER_WRITE MIXER_WRITE
48 #endif
50 static char *oss_device;
51 static char *oss_device_capture;
53 typedef struct {
54 int fd;
55 volatile int killNow;
56 ALvoid *thread;
58 ALubyte *mix_data;
59 int data_size;
61 RingBuffer *ring;
62 int doCapture;
63 } oss_data;
66 static int log2i(ALCuint x)
68 int y = 0;
69 while (x > 1)
71 x >>= 1;
72 y++;
74 return y;
78 static ALuint OSSProc(ALvoid *ptr)
80 ALCdevice *pDevice = (ALCdevice*)ptr;
81 oss_data *data = (oss_data*)pDevice->ExtraData;
82 int remaining = 0;
83 int wrote;
85 while(!data->killNow)
87 int len = data->data_size - remaining;
89 if(len > 0)
91 SuspendContext(NULL);
92 aluMixData(pDevice->Context, data->mix_data+remaining, len, pDevice->Format);
93 ProcessContext(NULL);
96 remaining += len;
97 wrote = write(data->fd, data->mix_data, remaining);
98 if(wrote < 0)
100 AL_PRINT("write failed: %s\n", strerror(errno));
101 remaining = 0;
103 else if(wrote > 0)
105 remaining -= wrote;
106 if(remaining > 0)
107 memmove(data->mix_data, data->mix_data+wrote, remaining);
109 else
110 Sleep(1);
113 return 0;
116 static ALuint OSSCaptureProc(ALvoid *ptr)
118 ALCdevice *pDevice = (ALCdevice*)ptr;
119 oss_data *data = (oss_data*)pDevice->ExtraData;
120 int frameSize;
121 int amt;
123 frameSize = aluBytesFromFormat(pDevice->Format);
124 frameSize *= aluChannelsFromFormat(pDevice->Format);
126 while(!data->killNow)
128 amt = read(data->fd, data->mix_data, data->data_size);
129 if(amt < 0)
131 AL_PRINT("read failed: %s\n", strerror(errno));
132 break;
134 if(amt == 0)
136 Sleep(1);
137 continue;
139 if(data->doCapture)
140 WriteRingBuffer(data->ring, data->mix_data, amt/frameSize);
143 return 0;
146 static ALCboolean oss_open_playback(ALCdevice *device, const ALCchar *deviceName)
148 int numFragmentsLogSize;
149 int log2FragmentSize;
150 unsigned int periods;
151 audio_buf_info info;
152 ALuint frameSize;
153 char driver[64];
154 int numChannels;
155 oss_data *data;
156 int ossFormat;
157 int ossSpeed;
158 char *err;
159 int i;
161 strncpy(driver, GetConfigValue("oss", "device", "/dev/dsp"), sizeof(driver)-1);
162 driver[sizeof(driver)-1] = 0;
163 if(deviceName)
165 if(strcmp(deviceName, oss_device))
166 return ALC_FALSE;
167 device->szDeviceName = oss_device;
169 else
170 device->szDeviceName = oss_device;
172 data = (oss_data*)calloc(1, sizeof(oss_data));
173 data->killNow = 0;
175 data->fd = open(driver, O_WRONLY);
176 if(data->fd == -1)
178 free(data);
179 AL_PRINT("Could not open %s: %s\n", driver, strerror(errno));
180 return ALC_FALSE;
183 switch(aluBytesFromFormat(device->Format))
185 case 1:
186 ossFormat = AFMT_U8;
187 break;
188 case 2:
189 ossFormat = AFMT_S16_NE;
190 break;
191 default:
192 ossFormat = -1;
193 AL_PRINT("Unknown format?! %x\n", device->Format);
196 periods = GetConfigValueInt("oss", "periods", 4);
197 if((int)periods <= 0)
198 periods = 4;
199 numChannels = aluChannelsFromFormat(device->Format);
200 frameSize = numChannels * aluBytesFromFormat(device->Format);
202 ossSpeed = device->Frequency;
203 log2FragmentSize = log2i(device->UpdateSize * frameSize / periods);
205 /* according to the OSS spec, 16 bytes are the minimum */
206 if (log2FragmentSize < 4)
207 log2FragmentSize = 4;
208 numFragmentsLogSize = (periods << 16) | log2FragmentSize;
210 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
211 if (!(ok(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize), "set fragment") &&
212 ok(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat), "set format") &&
213 ok(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels), "set channels") &&
214 ok(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed), "set speed") &&
215 ok(ioctl(data->fd, SNDCTL_DSP_GETOSPACE, &info), "get space")))
217 AL_PRINT("%s failed: %s\n", err, strerror(errno));
218 close(data->fd);
219 free(data);
220 return ALC_FALSE;
222 #undef ok
224 device->Frequency = ossSpeed;
226 if((int)aluChannelsFromFormat(device->Format) != numChannels)
228 AL_PRINT("Could not set %d channels, got %d instead\n", aluChannelsFromFormat(device->Format), numChannels);
229 close(data->fd);
230 free(data);
231 return ALC_FALSE;
234 if(!((ossFormat == AFMT_U8 && aluBytesFromFormat(device->Format) == 1) ||
235 (ossFormat == AFMT_S16_NE && aluBytesFromFormat(device->Format) == 2)))
237 AL_PRINT("Could not set %d-bit output, got format %#x\n", aluBytesFromFormat(device->Format)*8, ossFormat);
238 close(data->fd);
239 free(data);
240 return ALC_FALSE;
243 device->UpdateSize = info.fragsize / frameSize;
245 data->data_size = device->UpdateSize * frameSize;
246 data->mix_data = calloc(1, data->data_size);
248 device->ExtraData = data;
249 data->thread = StartThread(OSSProc, device);
250 if(data->thread == NULL)
252 device->ExtraData = NULL;
253 free(data->mix_data);
254 free(data);
255 return ALC_FALSE;
258 return ALC_TRUE;
261 static void oss_close_playback(ALCdevice *device)
263 oss_data *data = (oss_data*)device->ExtraData;
264 data->killNow = 1;
265 StopThread(data->thread);
267 close(data->fd);
269 free(data->mix_data);
270 free(data);
271 device->ExtraData = NULL;
275 static ALCboolean oss_open_capture(ALCdevice *device, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
277 int numFragmentsLogSize;
278 int log2FragmentSize;
279 unsigned int periods;
280 audio_buf_info info;
281 ALuint frameSize;
282 int numChannels;
283 char driver[64];
284 oss_data *data;
285 int ossFormat;
286 int ossSpeed;
287 char *err;
288 int i;
290 strncpy(driver, GetConfigValue("oss", "capture", "/dev/dsp"), sizeof(driver)-1);
291 driver[sizeof(driver)-1] = 0;
292 if(deviceName)
294 if(strcmp(deviceName, oss_device_capture))
295 return ALC_FALSE;
296 device->szDeviceName = oss_device_capture;
298 else
299 device->szDeviceName = oss_device_capture;
301 data = (oss_data*)calloc(1, sizeof(oss_data));
302 data->killNow = 0;
304 data->fd = open(driver, O_RDONLY);
305 if(data->fd == -1)
307 free(data);
308 AL_PRINT("Could not open %s: %s\n", driver, strerror(errno));
309 return ALC_FALSE;
312 switch(aluBytesFromFormat(format))
314 case 1:
315 ossFormat = AFMT_U8;
316 break;
317 case 2:
318 ossFormat = AFMT_S16_NE;
319 break;
320 default:
321 ossFormat = -1;
322 AL_PRINT("Unknown format?! %x\n", device->Format);
325 periods = 4;
326 numChannels = aluChannelsFromFormat(device->Format);
327 frameSize = numChannels * aluBytesFromFormat(device->Format);
328 ossSpeed = frequency;
329 log2FragmentSize = log2i(SampleSize * frameSize / periods);
331 /* according to the OSS spec, 16 bytes are the minimum */
332 if (log2FragmentSize < 4)
333 log2FragmentSize = 4;
334 numFragmentsLogSize = (periods << 16) | log2FragmentSize;
336 #define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
337 if (!(ok(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize), "set fragment") &&
338 ok(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat), "set format") &&
339 ok(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels), "set channels") &&
340 ok(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed), "set speed") &&
341 ok(ioctl(data->fd, SNDCTL_DSP_GETISPACE, &info), "get space")))
343 AL_PRINT("%s failed: %s\n", err, strerror(errno));
344 close(data->fd);
345 free(data);
346 return ALC_FALSE;
348 #undef ok
350 if((int)aluChannelsFromFormat(device->Format) != numChannels)
352 AL_PRINT("Could not set %d channels, got %d instead\n", aluChannelsFromFormat(device->Format), numChannels);
353 close(data->fd);
354 free(data);
355 return ALC_FALSE;
358 if(!((ossFormat == AFMT_U8 && aluBytesFromFormat(device->Format) == 1) ||
359 (ossFormat == AFMT_S16_NE && aluBytesFromFormat(device->Format) == 2)))
361 AL_PRINT("Could not set %d-bit input, got format %#x\n", aluBytesFromFormat(device->Format)*8, ossFormat);
362 close(data->fd);
363 free(data);
364 return ALC_FALSE;
367 data->ring = CreateRingBuffer(frameSize, SampleSize);
368 if(!data->ring)
370 AL_PRINT("ring buffer create failed\n");
371 close(data->fd);
372 free(data);
373 return ALC_FALSE;
376 data->data_size = info.fragsize;
377 data->mix_data = calloc(1, data->data_size);
379 device->ExtraData = data;
380 data->thread = StartThread(OSSCaptureProc, device);
381 if(data->thread == NULL)
383 device->ExtraData = NULL;
384 free(data->mix_data);
385 free(data);
386 return ALC_FALSE;
389 return ALC_TRUE;
392 static void oss_close_capture(ALCdevice *device)
394 oss_data *data = (oss_data*)device->ExtraData;
395 data->killNow = 1;
396 StopThread(data->thread);
398 close(data->fd);
400 DestroyRingBuffer(data->ring);
402 free(data->mix_data);
403 free(data);
404 device->ExtraData = NULL;
407 static void oss_start_capture(ALCdevice *pDevice)
409 oss_data *data = (oss_data*)pDevice->ExtraData;
410 data->doCapture = 1;
413 static void oss_stop_capture(ALCdevice *pDevice)
415 oss_data *data = (oss_data*)pDevice->ExtraData;
416 data->doCapture = 0;
419 static void oss_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
421 oss_data *data = (oss_data*)pDevice->ExtraData;
422 if(lSamples <= (ALCuint)RingBufferSize(data->ring))
423 ReadRingBuffer(data->ring, pBuffer, lSamples);
424 else
425 SetALCError(ALC_INVALID_VALUE);
428 static ALCuint oss_available_samples(ALCdevice *pDevice)
430 oss_data *data = (oss_data*)pDevice->ExtraData;
431 return RingBufferSize(data->ring);
435 BackendFuncs oss_funcs = {
436 oss_open_playback,
437 oss_close_playback,
438 oss_open_capture,
439 oss_close_capture,
440 oss_start_capture,
441 oss_stop_capture,
442 oss_capture_samples,
443 oss_available_samples
446 void alc_oss_init(BackendFuncs *func_list)
448 *func_list = oss_funcs;
450 oss_device = AppendDeviceList("OSS Software");
451 AppendAllDeviceList(oss_device);
453 oss_device_capture = AppendCaptureDeviceList("OSS Capture");