libao2/ao_oss.c

   1 /*
   2  * OSS audio output driver
   3  *
   4  * This file is part of MPlayer.
   5  *
   6  * MPlayer is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * MPlayer is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23
  24 #include <sys/ioctl.h>
  25 #include <unistd.h>
  26 #include <sys/time.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31 #include <string.h>
  32
  33 #include "config.h"
  34 #include "mp_msg.h"
  35 #include "mixer.h"
  36
  37 #ifdef HAVE_SYS_SOUNDCARD_H
  38 #include <sys/soundcard.h>
  39 #else
  40 #ifdef HAVE_SOUNDCARD_H
  41 #include <soundcard.h>
  42 #endif
  43 #endif
  44
  45 #include "libaf/af_format.h"
  46
  47 #include "audio_out.h"
  48 #include "audio_out_internal.h"
  49
  50 static const ao_info_t info =
  51 {
  52         "OSS/ioctl audio output",
  53         "oss",
  54         "A'rpi",
  55         ""
  56 };
  57
  58 /* Support for >2 output channels added 2001-11-25 - Steve Davies <steve@daviesfam.org> */
  59
  60 LIBAO_EXTERN(oss)
  61
  62 static int format2oss(int format)
  63 {
  64     switch(format)
  65     {
  66     case AF_FORMAT_U8: return AFMT_U8;
  67     case AF_FORMAT_S8: return AFMT_S8;
  68     case AF_FORMAT_U16_LE: return AFMT_U16_LE;
  69     case AF_FORMAT_U16_BE: return AFMT_U16_BE;
  70     case AF_FORMAT_S16_LE: return AFMT_S16_LE;
  71     case AF_FORMAT_S16_BE: return AFMT_S16_BE;
  72 #ifdef AFMT_S24_PACKED
  73     case AF_FORMAT_S24_LE: return AFMT_S24_PACKED;
  74 #endif
  75 #ifdef AFMT_U32_LE
  76     case AF_FORMAT_U32_LE: return AFMT_U32_LE;
  77 #endif
  78 #ifdef AFMT_U32_BE
  79     case AF_FORMAT_U32_BE: return AFMT_U32_BE;
  80 #endif
  81 #ifdef AFMT_S32_LE
  82     case AF_FORMAT_S32_LE: return AFMT_S32_LE;
  83 #endif
  84 #ifdef AFMT_S32_BE
  85     case AF_FORMAT_S32_BE: return AFMT_S32_BE;
  86 #endif
  87 #ifdef AFMT_FLOAT
  88     case AF_FORMAT_FLOAT_NE: return AFMT_FLOAT;
  89 #endif
  90     // SPECIALS
  91     case AF_FORMAT_MU_LAW: return AFMT_MU_LAW;
  92     case AF_FORMAT_A_LAW: return AFMT_A_LAW;
  93     case AF_FORMAT_IMA_ADPCM: return AFMT_IMA_ADPCM;
  94 #ifdef AFMT_MPEG
  95     case AF_FORMAT_MPEG2: return AFMT_MPEG;
  96 #endif
  97 #ifdef AFMT_AC3
  98     case AF_FORMAT_AC3_NE: return AFMT_AC3;
  99 #endif
 100     }
 101     mp_msg(MSGT_AO, MSGL_V, "OSS: Unknown/not supported internal format: %s\n", af_fmt2str_short(format));
 102     return -1;
 103 }
 104
 105 static int oss2format(int format)
 106 {
 107     switch(format)
 108     {
 109     case AFMT_U8: return AF_FORMAT_U8;
 110     case AFMT_S8: return AF_FORMAT_S8;
 111     case AFMT_U16_LE: return AF_FORMAT_U16_LE;
 112     case AFMT_U16_BE: return AF_FORMAT_U16_BE;
 113     case AFMT_S16_LE: return AF_FORMAT_S16_LE;
 114     case AFMT_S16_BE: return AF_FORMAT_S16_BE;
 115 #ifdef AFMT_S24_PACKED
 116     case AFMT_S24_PACKED: return AF_FORMAT_S24_LE;
 117 #endif
 118 #ifdef AFMT_U32_LE
 119     case AFMT_U32_LE: return AF_FORMAT_U32_LE;
 120 #endif
 121 #ifdef AFMT_U32_BE
 122     case AFMT_U32_BE: return AF_FORMAT_U32_BE;
 123 #endif
 124 #ifdef AFMT_S32_LE
 125     case AFMT_S32_LE: return AF_FORMAT_S32_LE;
 126 #endif
 127 #ifdef AFMT_S32_BE
 128     case AFMT_S32_BE: return AF_FORMAT_S32_BE;
 129 #endif
 130 #ifdef AFMT_FLOAT
 131     case AFMT_FLOAT: return AF_FORMAT_FLOAT_NE;
 132 #endif
 133     // SPECIALS
 134     case AFMT_MU_LAW: return AF_FORMAT_MU_LAW;
 135     case AFMT_A_LAW: return AF_FORMAT_A_LAW;
 136     case AFMT_IMA_ADPCM: return AF_FORMAT_IMA_ADPCM;
 137 #ifdef AFMT_MPEG
 138     case AFMT_MPEG: return AF_FORMAT_MPEG2;
 139 #endif
 140 #ifdef AFMT_AC3
 141     case AFMT_AC3: return AF_FORMAT_AC3_NE;
 142 #endif
 143     }
 144     mp_tmsg(MSGT_GLOBAL,MSGL_ERR,"[AO OSS] Unknown/Unsupported OSS format: %x.\n", format);
 145     return -1;
 146 }
 147
 148 static char *dsp=PATH_DEV_DSP;
 149 static audio_buf_info zz;
 150 static int audio_fd=-1;
 151 static int prepause_space;
 152
 153 static const char *oss_mixer_device = PATH_DEV_MIXER;
 154 static int oss_mixer_channel = SOUND_MIXER_PCM;
 155
 156 #ifdef SNDCTL_DSP_GETPLAYVOL
 157 static int volume_oss4(ao_control_vol_t *vol, int cmd) {
 158     int v;
 159
 160     if (audio_fd < 0)
 161         return CONTROL_ERROR;
 162
 163     if (cmd == AOCONTROL_GET_VOLUME) {
 164         if (ioctl(audio_fd, SNDCTL_DSP_GETPLAYVOL, &v) == -1)
 165             return CONTROL_ERROR;
 166         vol->right = (v & 0xff00) >> 8;
 167         vol->left = v & 0x00ff;
 168         return CONTROL_OK;
 169     } else if (cmd == AOCONTROL_SET_VOLUME) {
 170         v = ((int) vol->right << 8) | (int) vol->left;
 171         if (ioctl(audio_fd, SNDCTL_DSP_SETPLAYVOL, &v) == -1)
 172             return CONTROL_ERROR;
 173         return CONTROL_OK;
 174     } else
 175         return CONTROL_UNKNOWN;
 176 }
 177 #endif
 178
 179 // to set/get/query special features/parameters
 180 static int control(int cmd,void *arg){
 181     switch(cmd){
 182         case AOCONTROL_GET_VOLUME:
 183         case AOCONTROL_SET_VOLUME:
 184         {
 185             ao_control_vol_t *vol = (ao_control_vol_t *)arg;
 186             int fd, v, devs;
 187
 188 #ifdef SNDCTL_DSP_GETPLAYVOL
 189         // Try OSS4 first
 190         if (volume_oss4(vol, cmd) == CONTROL_OK)
 191             return CONTROL_OK;
 192 #endif
 193
 194             if(AF_FORMAT_IS_AC3(ao_data.format))
 195                 return CONTROL_TRUE;
 196
 197             if ((fd = open(oss_mixer_device, O_RDONLY)) > 0)
 198             {
 199                 ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devs);
 200                 if (devs & (1 << oss_mixer_channel))
 201                 {
 202                     if (cmd == AOCONTROL_GET_VOLUME)
 203                     {
 204                         ioctl(fd, MIXER_READ(oss_mixer_channel), &v);
 205                         vol->right = (v & 0xFF00) >> 8;
 206                         vol->left = v & 0x00FF;
 207                     }
 208                     else
 209                     {
 210                         v = ((int)vol->right << 8) | (int)vol->left;
 211                         ioctl(fd, MIXER_WRITE(oss_mixer_channel), &v);
 212                     }
 213                 }
 214                 else
 215                 {
 216                     close(fd);
 217                     return CONTROL_ERROR;
 218                 }
 219                 close(fd);
 220                 return CONTROL_OK;
 221             }
 222         }
 223         return CONTROL_ERROR;
 224     }
 225     return CONTROL_UNKNOWN;
 226 }
 227
 228 // open & setup audio device
 229 // return: 1=success 0=fail
 230 static int init(int rate,int channels,int format,int flags){
 231   char *mixer_channels [SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
 232   int oss_format;
 233   char *mdev = mixer_device, *mchan = mixer_channel;
 234
 235   mp_msg(MSGT_AO,MSGL_V,"ao2: %d Hz  %d chans  %s\n",rate,channels,
 236     af_fmt2str_short(format));
 237
 238   if (ao_subdevice) {
 239     char *m,*c;
 240     m = strchr(ao_subdevice,':');
 241     if(m) {
 242       c = strchr(m+1,':');
 243       if(c) {
 244         mchan = c+1;
 245         c[0] = '\0';
 246       }
 247       mdev = m+1;
 248       m[0] = '\0';
 249     }
 250     dsp = ao_subdevice;
 251   }
 252
 253   if(mdev)
 254     oss_mixer_device=mdev;
 255   else
 256     oss_mixer_device=PATH_DEV_MIXER;
 257
 258   if(mchan){
 259     int fd, devs, i;
 260
 261     if ((fd = open(oss_mixer_device, O_RDONLY)) == -1){
 262       mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS] audio_setup: Can't open mixer device %s: %s\n",
 263         oss_mixer_device, strerror(errno));
 264     }else{
 265       ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devs);
 266       close(fd);
 267
 268       for (i=0; i<SOUND_MIXER_NRDEVICES; i++){
 269         if(!strcasecmp(mixer_channels[i], mchan)){
 270           if(!(devs & (1 << i))){
 271             mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS] audio_setup: Audio card mixer does not have channel '%s', using default.\n",mchan);
 272             i = SOUND_MIXER_NRDEVICES+1;
 273             break;
 274           }
 275           oss_mixer_channel = i;
 276           break;
 277         }
 278       }
 279       if(i==SOUND_MIXER_NRDEVICES){
 280         mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS] audio_setup: Audio card mixer does not have channel '%s', using default.\n",mchan);
 281       }
 282     }
 283   } else
 284     oss_mixer_channel = SOUND_MIXER_PCM;
 285
 286   mp_msg(MSGT_AO,MSGL_V,"audio_setup: using '%s' dsp device\n", dsp);
 287   mp_msg(MSGT_AO,MSGL_V,"audio_setup: using '%s' mixer device\n", oss_mixer_device);
 288   mp_msg(MSGT_AO,MSGL_V,"audio_setup: using '%s' mixer device\n", mixer_channels[oss_mixer_channel]);
 289
 290 #ifdef __linux__
 291   audio_fd=open(dsp, O_WRONLY | O_NONBLOCK);
 292 #else
 293   audio_fd=open(dsp, O_WRONLY);
 294 #endif
 295   if(audio_fd<0){
 296     mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS] audio_setup: Can't open audio device %s: %s\n", dsp, strerror(errno));
 297     return 0;
 298   }
 299
 300 #ifdef __linux__
 301   /* Remove the non-blocking flag */
 302   if(fcntl(audio_fd, F_SETFL, 0) < 0) {
 303    mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS] audio_setup: Can't make file descriptor blocking: %s\n", strerror(errno));
 304    return 0;
 305   }
 306 #endif
 307
 308 #if defined(FD_CLOEXEC) && defined(F_SETFD)
 309   fcntl(audio_fd, F_SETFD, FD_CLOEXEC);
 310 #endif
 311
 312   if(AF_FORMAT_IS_AC3(format)) {
 313     ao_data.samplerate=rate;
 314     ioctl (audio_fd, SNDCTL_DSP_SPEED, &ao_data.samplerate);
 315   }
 316
 317 ac3_retry:
 318   if (AF_FORMAT_IS_AC3(format))
 319     format = AF_FORMAT_AC3_NE;
 320   ao_data.format=format;
 321   oss_format=format2oss(format);
 322   if (oss_format == -1) {
 323 #if HAVE_BIGENDIAN
 324     oss_format=AFMT_S16_BE;
 325 #else
 326     oss_format=AFMT_S16_LE;
 327 #endif
 328     format=AF_FORMAT_S16_NE;
 329   }
 330   if( ioctl(audio_fd, SNDCTL_DSP_SETFMT, &oss_format)<0 ||
 331       oss_format != format2oss(format)) {
 332     mp_tmsg(MSGT_AO,MSGL_WARN, "[AO OSS] Can't set audio device %s to %s output, trying %s...\n", dsp,
 333             af_fmt2str_short(format), af_fmt2str_short(AF_FORMAT_S16_NE) );
 334     format=AF_FORMAT_S16_NE;
 335     goto ac3_retry;
 336   }
 337 #if 0
 338   if(oss_format!=format2oss(format))
 339         mp_msg(MSGT_AO,MSGL_WARN,"WARNING! Your soundcard does NOT support %s sample format! Broken audio or bad playback speed are possible! Try with '-af format'\n",audio_out_format_name(format));
 340 #endif
 341
 342   ao_data.format = oss2format(oss_format);
 343   if (ao_data.format == -1) return 0;
 344
 345   mp_msg(MSGT_AO,MSGL_V,"audio_setup: sample format: %s (requested: %s)\n",
 346     af_fmt2str_short(ao_data.format), af_fmt2str_short(format));
 347
 348   ao_data.channels = channels;
 349   if(!AF_FORMAT_IS_AC3(format)) {
 350     // We only use SNDCTL_DSP_CHANNELS for >2 channels, in case some drivers don't have it
 351     if (ao_data.channels > 2) {
 352       if ( ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &ao_data.channels) == -1 ||
 353            ao_data.channels != channels ) {
 354         mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS] audio_setup: Failed to set audio device to %d channels.\n", channels);
 355         return 0;
 356       }
 357     }
 358     else {
 359       int c = ao_data.channels-1;
 360       if (ioctl (audio_fd, SNDCTL_DSP_STEREO, &c) == -1) {
 361         mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS] audio_setup: Failed to set audio device to %d channels.\n", ao_data.channels);
 362         return 0;
 363       }
 364       ao_data.channels=c+1;
 365     }
 366     mp_msg(MSGT_AO,MSGL_V,"audio_setup: using %d channels (requested: %d)\n", ao_data.channels, channels);
 367     // set rate
 368     ao_data.samplerate=rate;
 369     ioctl (audio_fd, SNDCTL_DSP_SPEED, &ao_data.samplerate);
 370     mp_msg(MSGT_AO,MSGL_V,"audio_setup: using %d Hz samplerate (requested: %d)\n",ao_data.samplerate,rate);
 371   }
 372
 373   if(ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &zz)==-1){
 374       int r=0;
 375       mp_tmsg(MSGT_AO,MSGL_WARN,"[AO OSS] audio_setup: driver doesn't support SNDCTL_DSP_GETOSPACE :-(\n");
 376       if(ioctl(audio_fd, SNDCTL_DSP_GETBLKSIZE, &r)==-1){
 377           mp_msg(MSGT_AO,MSGL_V,"audio_setup: %d bytes/frag (config.h)\n",ao_data.outburst);
 378       } else {
 379           ao_data.outburst=r;
 380           mp_msg(MSGT_AO,MSGL_V,"audio_setup: %d bytes/frag (GETBLKSIZE)\n",ao_data.outburst);
 381       }
 382   } else {
 383       mp_msg(MSGT_AO,MSGL_V,"audio_setup: frags: %3d/%d  (%d bytes/frag)  free: %6d\n",
 384           zz.fragments, zz.fragstotal, zz.fragsize, zz.bytes);
 385       if(ao_data.buffersize==-1) ao_data.buffersize=zz.bytes;
 386       ao_data.outburst=zz.fragsize;
 387   }
 388
 389   if(ao_data.buffersize==-1){
 390     // Measuring buffer size:
 391     void* data;
 392     ao_data.buffersize=0;
 393 #ifdef HAVE_AUDIO_SELECT
 394     data=malloc(ao_data.outburst); memset(data,0,ao_data.outburst);
 395     while(ao_data.buffersize<0x40000){
 396       fd_set rfds;
 397       struct timeval tv;
 398       FD_ZERO(&rfds); FD_SET(audio_fd,&rfds);
 399       tv.tv_sec=0; tv.tv_usec = 0;
 400       if(!select(audio_fd+1, NULL, &rfds, NULL, &tv)) break;
 401       write(audio_fd,data,ao_data.outburst);
 402       ao_data.buffersize+=ao_data.outburst;
 403     }
 404     free(data);
 405     if(ao_data.buffersize==0){
 406         mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS]\n   ***  Your audio driver DOES NOT support select()  ***\n Recompile MPlayer with #undef HAVE_AUDIO_SELECT in config.h !\n\n");
 407         return 0;
 408     }
 409 #endif
 410   }
 411
 412   ao_data.bps=ao_data.channels;
 413   switch (ao_data.format & AF_FORMAT_BITS_MASK) {
 414   case AF_FORMAT_8BIT:
 415     break;
 416   case AF_FORMAT_16BIT:
 417     ao_data.bps*=2;
 418     break;
 419   case AF_FORMAT_24BIT:
 420     ao_data.bps*=3;
 421     break;
 422   case AF_FORMAT_32BIT:
 423     ao_data.bps*=4;
 424     break;
 425   }
 426
 427   ao_data.outburst-=ao_data.outburst % ao_data.bps; // round down
 428   ao_data.bps*=ao_data.samplerate;
 429
 430     return 1;
 431 }
 432
 433 // close audio device
 434 static void uninit(int immed){
 435     if(audio_fd == -1) return;
 436 #ifdef SNDCTL_DSP_SYNC
 437     // to get the buffer played
 438     if (!immed)
 439         ioctl(audio_fd, SNDCTL_DSP_SYNC, NULL);
 440 #endif
 441 #ifdef SNDCTL_DSP_RESET
 442     if (immed)
 443         ioctl(audio_fd, SNDCTL_DSP_RESET, NULL);
 444 #endif
 445     close(audio_fd);
 446     audio_fd = -1;
 447 }
 448
 449 // stop playing and empty buffers (for seeking/pause)
 450 static void reset(void){
 451   int oss_format;
 452     uninit(1);
 453     audio_fd=open(dsp, O_WRONLY);
 454     if(audio_fd < 0){
 455         mp_tmsg(MSGT_AO,MSGL_ERR,"[AO OSS]\nFatal error: *** CANNOT RE-OPEN / RESET AUDIO DEVICE *** %s\n", strerror(errno));
 456         return;
 457     }
 458
 459 #if defined(FD_CLOEXEC) && defined(F_SETFD)
 460   fcntl(audio_fd, F_SETFD, FD_CLOEXEC);
 461 #endif
 462
 463   oss_format = format2oss(ao_data.format);
 464   if(AF_FORMAT_IS_AC3(ao_data.format))
 465     ioctl (audio_fd, SNDCTL_DSP_SPEED, &ao_data.samplerate);
 466   ioctl (audio_fd, SNDCTL_DSP_SETFMT, &oss_format);
 467   if(!AF_FORMAT_IS_AC3(ao_data.format)) {
 468     if (ao_data.channels > 2)
 469       ioctl (audio_fd, SNDCTL_DSP_CHANNELS, &ao_data.channels);
 470     else {
 471       int c = ao_data.channels-1;
 472       ioctl (audio_fd, SNDCTL_DSP_STEREO, &c);
 473     }
 474     ioctl (audio_fd, SNDCTL_DSP_SPEED, &ao_data.samplerate);
 475   }
 476 }
 477
 478 // stop playing, keep buffers (for pause)
 479 static void audio_pause(void)
 480 {
 481     prepause_space = get_space();
 482     uninit(1);
 483 }
 484
 485 // resume playing, after audio_pause()
 486 static void audio_resume(void)
 487 {
 488     int fillcnt;
 489     reset();
 490     fillcnt = get_space() - prepause_space;
 491     if (fillcnt > 0 && !(ao_data.format & AF_FORMAT_SPECIAL_MASK)) {
 492       void *silence = calloc(fillcnt, 1);
 493       play(silence, fillcnt, 0);
 494       free(silence);
 495     }
 496 }
 497
 498
 499 // return: how many bytes can be played without blocking
 500 static int get_space(void){
 501   int playsize=ao_data.outburst;
 502
 503 #ifdef SNDCTL_DSP_GETOSPACE
 504   if(ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &zz)!=-1){
 505       // calculate exact buffer space:
 506       playsize = zz.fragments*zz.fragsize;
 507       return playsize;
 508   }
 509 #endif
 510
 511     // check buffer
 512 #ifdef HAVE_AUDIO_SELECT
 513     {  fd_set rfds;
 514        struct timeval tv;
 515        FD_ZERO(&rfds);
 516        FD_SET(audio_fd, &rfds);
 517        tv.tv_sec = 0;
 518        tv.tv_usec = 0;
 519        if(!select(audio_fd+1, NULL, &rfds, NULL, &tv)) return 0; // not block!
 520     }
 521 #endif
 522
 523   return ao_data.outburst;
 524 }
 525
 526 // plays 'len' bytes of 'data'
 527 // it should round it down to outburst*n
 528 // return: number of bytes played
 529 static int play(void* data,int len,int flags){
 530     if(len==0)
 531         return len;
 532     if(len>ao_data.outburst || !(flags & AOPLAY_FINAL_CHUNK)) {
 533         len/=ao_data.outburst;
 534         len*=ao_data.outburst;
 535     }
 536     len=write(audio_fd,data,len);
 537     return len;
 538 }
 539
 540 static int audio_delay_method=2;
 541
 542 // return: delay in seconds between first and last sample in buffer
 543 static float get_delay(void){
 544   /* Calculate how many bytes/second is sent out */
 545   if(audio_delay_method==2){
 546 #ifdef SNDCTL_DSP_GETODELAY
 547       int r=0;
 548       if(ioctl(audio_fd, SNDCTL_DSP_GETODELAY, &r)!=-1)
 549          return ((float)r)/(float)ao_data.bps;
 550 #endif
 551       audio_delay_method=1; // fallback if not supported
 552   }
 553   if(audio_delay_method==1){
 554       // SNDCTL_DSP_GETOSPACE
 555       if(ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &zz)!=-1)
 556          return ((float)(ao_data.buffersize-zz.bytes))/(float)ao_data.bps;
 557       audio_delay_method=0; // fallback if not supported
 558   }
 559   return ((float)ao_data.buffersize)/(float)ao_data.bps;
 560 }