source: roaraudio/roard/driver_oss.c @ 4846:58d1d4cb7602

Last change on this file since 4846:58d1d4cb7602 was 4846:58d1d4cb7602, checked in by phi, 13 years ago

Auto select a stream if no stream has sync flag. (Closes: #30)

File size: 15.4 KB
Line 
1//driver_oss.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2011
5 *
6 *  This file is part of roard a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  RoarAudio 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
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 */
25
26#include "roard.h"
27#if defined(ROAR_HAVE_OSS_BSD) || defined(ROAR_HAVE_OSS)
28
29
30#define _get(vio,obj) (((struct driver_oss*)((vio)->inst))->obj)
31
32int driver_oss_init_vio(struct roar_vio_calls * vio, struct driver_oss * inst) {
33 if ( vio == NULL )
34  return -1;
35
36 memset(vio, 0, sizeof(struct roar_vio_calls));
37
38 vio->write    = driver_oss_write;
39 vio->read     = driver_oss_read;
40 vio->nonblock = driver_oss_nonblock;
41 vio->sync     = driver_oss_sync;
42 vio->ctl      = driver_oss_ctl;
43 vio->close    = driver_oss_close_vio;
44
45 vio->inst     = (void*) inst;
46
47 return 0;
48}
49
50int driver_oss_open_device(struct driver_oss * self) {
51 int    flags  = 0;
52 int    rw     = 0;
53 int    fh     = self->fh;
54 char * device = self->device;
55
56 if ( fh != -1 )
57  return 0;
58
59#ifdef ROAR_DEFAULT_OSS_DEV
60 if ( device == NULL )
61  device = ROAR_DEFAULT_OSS_DEV;
62#endif
63
64 if ( device == NULL ) {
65  ROAR_ERR("driver_oss_open_device(*): no default device found, you need to specify one manuelly");
66  return -1;
67 }
68
69 if ( self->ssid != -1 ) {
70  rw = streams_get_flag(self->ssid, ROAR_FLAG_RECSOURCE);
71 }
72
73 if ( rw ) {
74  flags |= O_RDWR;
75 } else {
76  flags |= O_WRONLY;
77 }
78
79 if ( (fh = open(device, flags, 0644)) == -1 ) {
80  ROAR_ERR("driver_oss_open_device(*): Can not open OSS device: %s: %s", device, strerror(errno));
81  return -1;
82 }
83
84 self->fh          = fh;
85 self->need_config = 1;
86
87 return 0;
88}
89
90int driver_oss_config_device(struct driver_oss * self) {
91 int                      fh   =   self->fh;
92 struct roar_audio_info * info = &(self->info);
93 int tmp, ctmp;
94 char * es;
95 int autoconfig         = 0;
96 int need_update_server = 0;
97
98 if ( fh == -1 )
99  return -1;
100
101 if ( self->ssid != -1 ) {
102  autoconfig = streams_get_flag(self->ssid, ROAR_FLAG_AUTOCONF);
103 }
104
105 ROAR_DBG("driver_oss_config_device(self=%p): ssid=%i, autoconfig=%i", self, self->ssid, autoconfig);
106
107#ifdef SNDCTL_DSP_CHANNELS
108 tmp = info->channels;
109
110 if ( ioctl(fh, SNDCTL_DSP_CHANNELS, &tmp) == -1 ) {
111  ROAR_ERR("driver_oss_config_device(*): can not set number of channels");
112  return -1;
113 }
114
115 if ( tmp != info->channels ) {
116  if ( autoconfig ) {
117   need_update_server = 1;
118   self->info.channels = tmp;
119  } else {
120   ROAR_ERR("driver_oss_config_device(*): can not set requested numer of channels, OSS suggested %i channels, to use this restart with -oO channels=%i or set codec manuelly via -oO channels=num", tmp, tmp);
121   return -1;
122  }
123 }
124#else
125 switch (info->channels) {
126  case  1: tmp = 0; break;
127  case  2: tmp = 1; break;
128  default: return -1;
129 }
130
131 if ( ioctl(fh, SNDCTL_DSP_STEREO, &tmp) == -1 ) {
132  ROAR_ERR("driver_oss_config_device(*): can not set number of channels");
133  return -1;
134 }
135#endif
136
137 switch (info->codec) {
138  case ROAR_CODEC_PCM_S_LE:
139    switch (info->bits) {
140     case  8: tmp = AFMT_S8;     break;
141     case 16: tmp = AFMT_S16_LE; break;
142//     case 24: tmp = AFMT_S24_PACKED; break;
143#ifdef AFMT_S32_LE
144     case 32: tmp = AFMT_S32_LE; break;
145#endif
146     default: return -1;
147    }
148   break;
149  case ROAR_CODEC_PCM_S_BE:
150    switch (info->bits) {
151     case  8: tmp = AFMT_S8;     break;
152     case 16: tmp = AFMT_S16_BE; break;
153//     case 24: tmp = AFMT_S24_PACKED; break;
154#ifdef AFMT_S32_BE
155     case 32: tmp = AFMT_S32_BE; break;
156#endif
157     default: return -1;
158    }
159   break;
160  case ROAR_CODEC_PCM_U_LE:
161    switch (info->bits) {
162     case  8: tmp = AFMT_U8;     break;
163     case 16: tmp = AFMT_U16_LE; break;
164     default: return -1;
165    }
166   break;
167  case ROAR_CODEC_PCM_U_BE:
168    switch (info->bits) {
169     case  8: tmp = AFMT_U8;     break;
170     case 16: tmp = AFMT_U16_BE; break;
171     default: return -1;
172    }
173  case ROAR_CODEC_ALAW:
174    tmp = AFMT_A_LAW;
175   break;
176  case ROAR_CODEC_MULAW:
177    tmp = AFMT_MU_LAW;
178   break;
179#ifdef AFMT_VORBIS
180  case ROAR_CODEC_OGG_VORBIS:
181    tmp = AFMT_VORBIS;
182   break;
183#endif
184  default:
185    return -1;
186   break;
187 }
188
189 ctmp = tmp;
190#ifdef SNDCTL_DSP_SETFMT
191 if ( ioctl(fh, SNDCTL_DSP_SETFMT, &tmp) == -1 ) {
192#else
193 if ( ioctl(fh, SNDCTL_DSP_SAMPLESIZE, &tmp) == -1 ) {
194#endif
195  ROAR_ERR("driver_oss_config_device(*): can not set sample format");
196  return -1;
197 }
198
199 if ( tmp != ctmp ) {
200  if ( autoconfig ) {
201   need_update_server = 1;
202   switch (tmp) {
203    case AFMT_S8    : self->info.bits =  8; self->info.codec = ROAR_CODEC_PCM;      break;
204    case AFMT_U8    : self->info.bits =  8; self->info.codec = ROAR_CODEC_PCM_U_LE; break;
205    case AFMT_S16_LE: self->info.bits = 16; self->info.codec = ROAR_CODEC_PCM_S_LE; break;
206    case AFMT_S16_BE: self->info.bits = 16; self->info.codec = ROAR_CODEC_PCM_S_BE; break;
207    case AFMT_U16_LE: self->info.bits = 16; self->info.codec = ROAR_CODEC_PCM_U_LE; break;
208    case AFMT_U16_BE: self->info.bits = 16; self->info.codec = ROAR_CODEC_PCM_U_BE; break;
209#ifdef AFMT_S32_LE
210    case AFMT_S32_LE: self->info.bits = 32; self->info.codec = ROAR_CODEC_PCM_S_LE; break;
211#endif
212#ifdef AFMT_S32_BE
213    case AFMT_S32_BE: self->info.bits = 32; self->info.codec = ROAR_CODEC_PCM_S_BE; break;
214#endif
215/*
216    case AFMT_A_LAW : self->info.bits =  8; self->info.codec = ROAR_CODEC_ALAW;     break;
217    case AFMT_MU_LAW: self->info.bits =  8; self->info.codec = ROAR_CODEC_MULAW;    break;
218#ifdef AFMT_VORBIS
219    case AFMT_VORBIS: self->info.codec = ROAR_CODEC_OGG_VORBIS;                     break;
220#endif
221*/
222    case AFMT_A_LAW:
223    case AFMT_MU_LAW:
224#ifdef AFMT_VORBIS
225    case AFMT_VORBIS:
226#endif
227      ROAR_WARN("driver_oss_config_device(*): Auto config failed: OSS Codec %i needs a codecfilter!", tmp);
228      ROAR_ERR("driver_oss_config_device(*): can not set requested codec, set codec manuelly via -oO codec=somecodec");
229      return -1;
230     break;
231    default:
232      ROAR_WARN("driver_oss_config_device(*): Auto config failed: unknown OSS Codec %i", tmp);
233      ROAR_ERR("driver_oss_config_device(*): can not set requested codec, set codec manuelly via -oO codec=somecodec");
234      return -1;
235     break;
236   }
237  } else {
238   es = NULL;
239   switch (tmp) {
240    case AFMT_S8    : es = "bits=8,codec=pcm";       break;
241    case AFMT_U8    : es = "bits=8,codec=pcm_u_le";  break;
242    case AFMT_S16_LE: es = "bits=16,codec=pcm_s_le"; break;
243    case AFMT_S16_BE: es = "bits=16,codec=pcm_s_be"; break;
244    case AFMT_U16_LE: es = "bits=16,codec=pcm_u_le"; break;
245    case AFMT_U16_BE: es = "bits=16,codec=pcm_u_be"; break;
246#ifdef AFMT_S32_LE
247    case AFMT_S32_LE: es = "bits=32,codec=pcm_s_le"; break;
248#endif
249#ifdef AFMT_S32_BE
250    case AFMT_S32_BE: es = "bits=32,codec=pcm_s_be"; break;
251#endif
252    case AFMT_A_LAW : es = "codec=alaw";             break;
253    case AFMT_MU_LAW: es = "codec=mulaw";            break;
254#ifdef AFMT_VORBIS
255    case AFMT_VORBIS: es = "codec=ogg_vorbis";       break;
256#endif
257   }
258
259   if ( es != NULL ) {
260    ROAR_ERR("driver_oss_config_device(*): can not set requested codec, OSS retruned another codec than requested, to use this restart with -oO %s or set codec manuelly via -oO codec=somecodec", es);
261   } else {
262    ROAR_ERR("driver_oss_config_device(*): can not set requested codec, set codec manuelly via -oO codec=somecodec");
263   }
264   return -1;
265  }
266 }
267
268 tmp = info->rate;
269
270 if ( ioctl(fh, SNDCTL_DSP_SPEED, &tmp) == -1 ) {
271  ROAR_ERR("driver_oss_config_device(*): can not set sample rate");
272  return -1;
273 }
274
275 if ( tmp != info->rate ) {
276  if ( autoconfig ) {
277   need_update_server = 1;
278   self->info.rate = tmp;
279  } else {
280   ROAR_WARN("driver_oss_config_device(*): Device does not support requested sample rate: req=%iHz, sug=%iHz",
281                     info->rate, tmp);
282
283   if ( tmp < info->rate * 0.98 || tmp > info->rate * 1.02 ) {
284    ROAR_ERR("driver_oss_config_device(*): sample rate out of acceptable accuracy");
285    return -1;
286   }
287  }
288 }
289
290 // latency things:
291#ifdef SNDCTL_DSP_SETFRAGMENT
292
293 // defaults
294 if ( self->blocksize < 1 )
295  self->blocksize = 2048;
296 if ( self->blocks < 1 )
297  self->blocks    =    4;
298
299 switch (self->blocksize) {
300  case 1<< 4: tmp =  4; break;
301  case 1<< 5: tmp =  5; break;
302  case 1<< 6: tmp =  6; break;
303  case 1<< 7: tmp =  7; break;
304  case 1<< 8: tmp =  8; break;
305  case 1<< 9: tmp =  9; break;
306  case 1<<10: tmp = 10; break;
307  case 1<<11: tmp = 11; break;
308  case 1<<12: tmp = 12; break;
309  case 1<<13: tmp = 13; break;
310  case 1<<14: tmp = 14; break;
311  case 1<<15: tmp = 15; break;
312  case 1<<16: tmp = 16; break;
313  default: tmp = 11;
314    ROAR_WARN("driver_oss_config_device(*): blocksize of %i byte is not a valid value. trying 2KB", self->blocksize);
315   break;
316 }
317
318 ROAR_DBG("driver_oss_config_device(*): blocksize=%i(N=%i), blocks=%i", self->blocksize, tmp, self->blocks);
319
320 tmp |= self->blocks << 16;
321 if ( ioctl(fh, SNDCTL_DSP_SETFRAGMENT, &tmp) == -1 ) {
322  ROAR_WARN("driver_oss_ctl(*): Can not set fragment size, sorry :(");
323 }
324#endif
325
326 if ( need_update_server ) {
327  if ( self->stream == NULL ) {
328   streams_get(self->ssid, &(self->stream));
329  }
330
331  if ( self->stream == NULL ) {
332   ROAR_ERR("driver_oss_config_device(*): Auto config failed: can not set new values for stream: no stream object known");
333   return -1;
334  }
335
336  memcpy(&(ROAR_STREAM(self->stream)->info), info, sizeof(struct roar_audio_info));
337 }
338
339 ROAR_DBG("driver_oss_config_device(*): self->ssid=%i, fh=%i", self->ssid, fh);
340 streams_set_fh(self->ssid, -2);
341 self->need_config = 0;
342
343 ROAR_DBG("driver_oss_config_device(*) = 0");
344 return 0;
345}
346
347#define er() close(self->fh); if ( self->device ) free(self->device); free(self); return -1
348int driver_oss_open(struct roar_vio_calls * inst, char * device, struct roar_audio_info * info, int fh, struct roar_stream_server * sstream) {
349 struct driver_oss * self = NULL;
350
351 if ( (self = malloc(sizeof(struct driver_oss))) == NULL ) {
352  ROAR_ERR("driver_oss_open(*): Can not malloc() instance data: %s", strerror(errno));
353  return -1;
354 }
355
356 memset(self, 0, sizeof(struct driver_oss));
357 memcpy(&(self->info), info, sizeof(struct roar_audio_info));
358
359 self->ssid = -1;
360 self->fh   = fh;
361
362 if ( sstream != NULL )
363  self->ssid = ROAR_STREAM(sstream)->id;
364
365 if ( fh != -1 ) {
366  self->fh_savemode = 1;
367 } else {
368  self->fh_savemode = 0;
369 }
370
371 if ( device != NULL )
372  self->device = strdup(device);
373
374 if ( driver_oss_init_vio(inst, self) == -1 ) {
375  ROAR_ERR("driver_oss_open(*): Can not init vio interface");
376  er();
377 }
378
379 if ( driver_oss_open_device(self) == -1 ) {
380  ROAR_ERR("driver_oss_open(*): Can not open audio device");
381  er();
382 }
383
384 ROAR_DBG("driver_oss_open(*): OSS devices opened :)");
385
386 if ( sstream != NULL )
387  driver_oss_ctl(inst, ROAR_VIO_CTL_SET_SSTREAM, sstream);
388
389 return 0;
390}
391#undef er
392
393int     driver_oss_reopen_device(struct driver_oss * self) {
394
395 // we need to reject in fh save mode.
396 if ( self->fh_savemode )
397  return -1;
398
399#ifdef SNDCTL_DSP_SYNC
400 ioctl(self->fh, SNDCTL_DSP_SYNC, NULL);
401#endif
402
403 close(self->fh);
404
405 if ( driver_oss_open_device(self) == -1 )
406  return -1;
407
408 self->need_config = 1;
409
410 return 0;
411}
412
413int driver_oss_close(DRIVER_USERDATA_T   inst) {
414 return roar_vio_close((struct roar_vio_calls *)inst);
415}
416
417int     driver_oss_close_vio(struct roar_vio_calls * vio) {
418 close(_get(vio,fh));
419
420 if ( _get(vio,device) != NULL )
421  free(_get(vio,device));
422
423 free(vio->inst);
424 return 0;
425}
426
427int     driver_oss_nonblock(struct roar_vio_calls * vio, int state) {
428 ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = ?", vio, state);
429
430 if ( roar_socket_nonblock(_get(vio,fh), state) == -1 ) {
431  ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = -1", vio, state);
432  return -1;
433 }
434
435 if ( state == ROAR_SOCKET_NONBLOCK ) {
436  ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = 0", vio, state);
437  return 0;
438 }
439
440 roar_vio_sync(vio);
441
442 ROAR_DBG("driver_oss_nonblock(vio=%p, state=%i) = 0", vio, state);
443
444 return 0;
445}
446
447int driver_oss_sync(struct roar_vio_calls * vio) {
448#ifdef SNDCTL_DSP_SYNC
449 return ioctl(_get(vio,fh), SNDCTL_DSP_SYNC, NULL);
450#else
451 return 0;
452#endif
453}
454
455int driver_oss_ctl(struct roar_vio_calls * vio, int cmd, void * data) {
456 struct driver_oss * self = vio->inst;
457#ifdef SNDCTL_DSP_GETODELAY
458 int d;
459#endif
460
461 ROAR_DBG("driver_oss_ctl(vio=%p, cmd=0x%.8x, data=%p) = ?", vio, cmd, data);
462
463 if ( vio == NULL )
464  return -1;
465
466 switch (cmd) {
467  case ROAR_VIO_CTL_GET_DELAY:
468#ifdef SNDCTL_DSP_GETODELAY
469    if ( ioctl(_get(vio,fh), SNDCTL_DSP_GETODELAY, &d) == -1 )
470     return -1;
471
472    ROAR_DBG("driver_oss_ctl(*): delay=%i byte", d);
473
474    *(uint_least32_t *)data = d;
475#else
476    return -1;
477#endif
478   break;
479  case ROAR_VIO_CTL_SET_DBLOCKS:
480#ifdef SNDCTL_DSP_SETFRAGMENT
481    if ( !self->need_config ) {
482     ROAR_WARN("driver_oss_ctl(*): possible late ROAR_VIO_CTL_SET_DBLOCKS, setting anyway.");
483    }
484
485    self->blocks    = *(uint_least32_t *)data;
486#else
487    return -1;
488#endif
489   break;
490  case ROAR_VIO_CTL_SET_DBLKSIZE:
491#ifdef SNDCTL_DSP_SETFRAGMENT
492    if ( !self->need_config ) {
493     ROAR_WARN("driver_oss_ctl(*): possible late ROAR_VIO_CTL_SET_DBLKSIZE, setting anyway.");
494    }
495
496    self->blocksize = *(uint_least32_t *)data;
497#else
498    return -1;
499#endif
500   break;
501  case ROAR_VIO_CTL_GET_DBLKSIZE:
502    if ( !self->blocksize )
503     return -1;
504
505    *(uint_least32_t *)data = self->blocksize;
506   break;
507  case ROAR_VIO_CTL_SET_SSTREAMID:
508    self->ssid = *(int *)data;
509   break;
510  case ROAR_VIO_CTL_SET_SSTREAM:
511    self->stream = data;
512   break;
513  case ROAR_VIO_CTL_GET_AUINFO:
514    memcpy(data, &(self->info), sizeof(struct roar_audio_info));
515   break;
516  case ROAR_VIO_CTL_SET_AUINFO:
517    memcpy(&(self->info), data, sizeof(struct roar_audio_info));
518    return driver_oss_reopen_device(self);
519   break;
520#ifdef SNDCTL_DSP_SETPLAYVOL
521  case ROAR_VIO_CTL_SET_VOLUME:
522    switch (self->info.channels) {
523     case 1:
524       d  = ROAR_MIXER(data)->mixer[0] * 100 / ROAR_MIXER(data)->scale;
525       d |= d << 8;
526      break;
527     case 2:
528       d  =  ROAR_MIXER(data)->mixer[0] * 100 / ROAR_MIXER(data)->scale;
529       d |= (ROAR_MIXER(data)->mixer[0] * 100 / ROAR_MIXER(data)->scale) << 8;
530      break;
531     default:
532      return -1;
533    }
534    return ioctl(_get(vio,fh), SNDCTL_DSP_SETPLAYVOL, &d);
535   break;
536#endif
537  default:
538   return -1;
539 }
540
541 return 0;
542}
543
544ssize_t driver_oss_write   (struct roar_vio_calls * vio, void *buf, size_t count) {
545 ROAR_DBG("driver_oss_write(vio=%p, buf=%p, count=%llu) = ?", vio, buf, (long long unsigned int)count);
546
547 if ( _get(vio,fh) == -1 )
548  return -1;
549
550 if ( _get(vio,need_config) ) {
551  if ( driver_oss_config_device(vio->inst) == -1 ) {
552   return -1;
553  }
554 }
555
556 return write(_get(vio,fh), buf, count);
557}
558
559ssize_t driver_oss_read     (struct roar_vio_calls * vio, void *buf, size_t count) {
560 ROAR_DBG("driver_oss_read(vio=%p, buf=%p, count=%llu) = ?", vio, buf, (long long unsigned int)count);
561
562 if ( _get(vio,fh) == -1 )
563  return -1;
564
565 if ( _get(vio,need_config) ) {
566  if ( driver_oss_config_device(vio->inst) == -1 ) {
567   ROAR_DBG("driver_oss_read(vio=%p, buf=%p, count=%llu) = -1", vio, buf, (long long unsigned int)count);
568   return -1;
569  }
570 }
571
572 ROAR_DBG("driver_oss_read(vio=%p, buf=%p, count=%llu) = ?", vio, buf, (long long unsigned int)count);
573
574 return read(_get(vio,fh), buf, count);
575}
576
577#endif
578//ll
Note: See TracBrowser for help on using the repository browser.