libao2/ao_alsa5.c

   1 /*
   2   ao_alsa5 - ALSA-0.5.x output plugin for MPlayer
   3
   4   (C) Alex Beregszaszi
   5
   6   Thanks to Arpi for helping me ;)
   7 */
   8
   9 #include <errno.h>
  10 #include <sys/asoundlib.h>
  11
  12 #include "config.h"
  13
  14 #include "audio_out.h"
  15 #include "audio_out_internal.h"
  16 #include "libaf/af_format.h"
  17
  18 #include "mp_msg.h"
  19 #include "help_mp.h"
  20
  21 static ao_info_t info =
  22 {
  23     "ALSA-0.5.x audio output",
  24     "alsa5",
  25     "Alex Beregszaszi",
  26     ""
  27 };
  28
  29 LIBAO_EXTERN(alsa5)
  30
  31 static snd_pcm_t *alsa_handler;
  32 static snd_pcm_format_t alsa_format;
  33 static int alsa_rate = SND_PCM_RATE_CONTINUOUS;
  34
  35 /* to set/get/query special features/parameters */
  36 static int control(int cmd, void *arg)
  37 {
  38     return CONTROL_UNKNOWN;
  39 }
  40
  41 /*
  42     open & setup audio device
  43     return: 1=success 0=fail
  44 */
  45 static int init(int rate_hz, int channels, int format, int flags)
  46 {
  47     int err;
  48     int cards = -1;
  49     snd_pcm_channel_params_t params;
  50     snd_pcm_channel_setup_t setup;
  51     snd_pcm_info_t info;
  52     snd_pcm_channel_info_t chninfo;
  53
  54     mp_msg(MSGT_AO, MSGL_INFO, MSGTR_AO_ALSA5_InitInfo, rate_hz,
  55         channels, af_fmt2str_short(format));
  56
  57     alsa_handler = NULL;
  58
  59     mp_msg(MSGT_AO, MSGL_V, "alsa-init: compiled for ALSA-%s (%d)\n", SND_LIB_VERSION_STR,
  60         SND_LIB_VERSION);
  61
  62     if ((cards = snd_cards()) < 0)
  63     {
  64         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_SoundCardNotFound);
  65         return 0;
  66     }
  67
  68     ao_data.format = format;
  69     ao_data.channels = channels;
  70     ao_data.samplerate = rate_hz;
  71     ao_data.bps = ao_data.samplerate*ao_data.channels;
  72     ao_data.outburst = OUTBURST;
  73     ao_data.buffersize = 16384;
  74
  75     memset(&alsa_format, 0, sizeof(alsa_format));
  76     switch (format)
  77     {
  78         case AF_FORMAT_S8:
  79             alsa_format.format = SND_PCM_SFMT_S8;
  80             break;
  81         case AF_FORMAT_U8:
  82             alsa_format.format = SND_PCM_SFMT_U8;
  83             break;
  84         case AF_FORMAT_U16_LE:
  85             alsa_format.format = SND_PCM_SFMT_U16_LE;
  86             break;
  87         case AF_FORMAT_U16_BE:
  88             alsa_format.format = SND_PCM_SFMT_U16_BE;
  89             break;
  90 #ifndef WORDS_BIGENDIAN
  91         case AF_FORMAT_AC3:
  92 #endif
  93         case AF_FORMAT_S16_LE:
  94             alsa_format.format = SND_PCM_SFMT_S16_LE;
  95             break;
  96 #ifdef WORDS_BIGENDIAN
  97         case AF_FORMAT_AC3:
  98 #endif
  99         case AF_FORMAT_S16_BE:
 100             alsa_format.format = SND_PCM_SFMT_S16_BE;
 101             break;
 102         default:
 103             alsa_format.format = SND_PCM_SFMT_MPEG;
 104             break;
 105     }
 106
 107     switch(alsa_format.format)
 108     {
 109         case SND_PCM_SFMT_S16_LE:
 110         case SND_PCM_SFMT_U16_LE:
 111             ao_data.bps *= 2;
 112             break;
 113         case -1:
 114             mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_InvalidFormatReq,af_fmt2str_short(format));
 115             return 0;
 116         default:
 117             break;
 118     }
 119
 120     switch(rate_hz)
 121     {
 122         case 8000:
 123             alsa_rate = SND_PCM_RATE_8000;
 124             break;
 125         case 11025:
 126             alsa_rate = SND_PCM_RATE_11025;
 127             break;
 128         case 16000:
 129             alsa_rate = SND_PCM_RATE_16000;
 130             break;
 131         case 22050:
 132             alsa_rate = SND_PCM_RATE_22050;
 133             break;
 134         case 32000:
 135             alsa_rate = SND_PCM_RATE_32000;
 136             break;
 137         case 44100:
 138             alsa_rate = SND_PCM_RATE_44100;
 139             break;
 140         case 48000:
 141             alsa_rate = SND_PCM_RATE_48000;
 142             break;
 143         case 88200:
 144             alsa_rate = SND_PCM_RATE_88200;
 145             break;
 146         case 96000:
 147             alsa_rate = SND_PCM_RATE_96000;
 148             break;
 149         case 176400:
 150             alsa_rate = SND_PCM_RATE_176400;
 151             break;
 152         case 192000:
 153             alsa_rate = SND_PCM_RATE_192000;
 154             break;
 155         default:
 156             alsa_rate = SND_PCM_RATE_CONTINUOUS;
 157             break;
 158     }
 159
 160     alsa_format.rate = ao_data.samplerate;
 161     alsa_format.voices = ao_data.channels;
 162     alsa_format.interleave = 1;
 163
 164     if ((err = snd_pcm_open(&alsa_handler, 0, 0, SND_PCM_OPEN_PLAYBACK)) < 0)
 165     {
 166         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_PlayBackError, snd_strerror(err));
 167         return 0;
 168     }
 169
 170     if ((err = snd_pcm_info(alsa_handler, &info)) < 0)
 171     {
 172         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_PcmInfoError, snd_strerror(err));
 173         return 0;
 174     }
 175
 176     mp_msg(MSGT_AO, MSGL_INFO, MSGTR_AO_ALSA5_SoundcardsFound,
 177         cards, info.name);
 178
 179     if (info.flags & SND_PCM_INFO_PLAYBACK)
 180     {
 181         memset(&chninfo, 0, sizeof(chninfo));
 182         chninfo.channel = SND_PCM_CHANNEL_PLAYBACK;
 183         if ((err = snd_pcm_channel_info(alsa_handler, &chninfo)) < 0)
 184         {
 185             mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_PcmChanInfoError, snd_strerror(err));
 186             return 0;
 187         }
 188
 189 #ifndef __QNX__
 190         if (chninfo.buffer_size)
 191             ao_data.buffersize = chninfo.buffer_size;
 192 #endif
 193
 194         mp_msg(MSGT_AO, MSGL_V, "alsa-init: setting preferred buffer size from driver: %d bytes\n",
 195             ao_data.buffersize);
 196     }
 197
 198     memset(&params, 0, sizeof(params));
 199     params.channel = SND_PCM_CHANNEL_PLAYBACK;
 200     params.mode = SND_PCM_MODE_STREAM;
 201     params.format = alsa_format;
 202     params.start_mode = SND_PCM_START_DATA;
 203     params.stop_mode = SND_PCM_STOP_ROLLOVER;
 204     params.buf.stream.queue_size = ao_data.buffersize;
 205     params.buf.stream.fill = SND_PCM_FILL_NONE;
 206
 207     if ((err = snd_pcm_channel_params(alsa_handler, &params)) < 0)
 208     {
 209         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_CantSetParms, snd_strerror(err));
 210         return 0;
 211     }
 212
 213     memset(&setup, 0, sizeof(setup));
 214     setup.channel = SND_PCM_CHANNEL_PLAYBACK;
 215     setup.mode = SND_PCM_MODE_STREAM;
 216     setup.format = alsa_format;
 217     setup.buf.stream.queue_size = ao_data.buffersize;
 218     setup.msbits_per_sample = ao_data.bps;
 219
 220     if ((err = snd_pcm_channel_setup(alsa_handler, &setup)) < 0)
 221     {
 222         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_CantSetChan, snd_strerror(err));
 223         return 0;
 224     }
 225
 226     if ((err = snd_pcm_channel_prepare(alsa_handler, SND_PCM_CHANNEL_PLAYBACK)) < 0)
 227     {
 228         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_ChanPrepareError, snd_strerror(err));
 229         return 0;
 230     }
 231
 232     mp_msg(MSGT_AO, MSGL_INFO, "AUDIO: %d Hz/%d channels/%d bps/%d bytes buffer/%s\n",
 233         ao_data.samplerate, ao_data.channels, ao_data.bps, ao_data.buffersize,
 234         snd_pcm_get_format_name(alsa_format.format));
 235     return 1;
 236 }
 237
 238 /* close audio device */
 239 static void uninit(int immed)
 240 {
 241     int err;
 242
 243     if ((err = snd_pcm_playback_drain(alsa_handler)) < 0)
 244     {
 245         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_DrainError, snd_strerror(err));
 246         return;
 247     }
 248
 249     if ((err = snd_pcm_channel_flush(alsa_handler, SND_PCM_CHANNEL_PLAYBACK)) < 0)
 250     {
 251         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_FlushError, snd_strerror(err));
 252         return;
 253     }
 254
 255     if ((err = snd_pcm_close(alsa_handler)) < 0)
 256     {
 257         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_PcmCloseError, snd_strerror(err));
 258         return;
 259     }
 260 }
 261
 262 /* stop playing and empty buffers (for seeking/pause) */
 263 static void reset(void)
 264 {
 265     int err;
 266
 267     if ((err = snd_pcm_playback_drain(alsa_handler)) < 0)
 268     {
 269         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_ResetDrainError, snd_strerror(err));
 270         return;
 271     }
 272
 273     if ((err = snd_pcm_channel_flush(alsa_handler, SND_PCM_CHANNEL_PLAYBACK)) < 0)
 274     {
 275         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_ResetFlushError, snd_strerror(err));
 276         return;
 277     }
 278
 279     if ((err = snd_pcm_channel_prepare(alsa_handler, SND_PCM_CHANNEL_PLAYBACK)) < 0)
 280     {
 281         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_ResetChanPrepareError, snd_strerror(err));
 282         return;
 283     }
 284 }
 285
 286 /* stop playing, keep buffers (for pause) */
 287 static void audio_pause(void)
 288 {
 289     int err;
 290
 291     if ((err = snd_pcm_playback_drain(alsa_handler)) < 0)
 292     {
 293         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_PauseDrainError, snd_strerror(err));
 294         return;
 295     }
 296
 297     if ((err = snd_pcm_channel_flush(alsa_handler, SND_PCM_CHANNEL_PLAYBACK)) < 0)
 298     {
 299         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_PauseFlushError, snd_strerror(err));
 300         return;
 301     }
 302 }
 303
 304 /* resume playing, after audio_pause() */
 305 static void audio_resume(void)
 306 {
 307     int err;
 308     if ((err = snd_pcm_channel_prepare(alsa_handler, SND_PCM_CHANNEL_PLAYBACK)) < 0)
 309     {
 310         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_ResumePrepareError, snd_strerror(err));
 311         return;
 312     }
 313 }
 314
 315 /*
 316     plays 'len' bytes of 'data'
 317     returns: number of bytes played
 318 */
 319 static int play(void* data, int len, int flags)
 320 {
 321     int got_len;
 322
 323     if (!len)
 324         return 0;
 325
 326     if ((got_len = snd_pcm_write(alsa_handler, data, len)) < 0)
 327     {
 328         if (got_len == -EPIPE) /* underrun? */
 329         {
 330             mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_Underrun);
 331             if ((got_len = snd_pcm_channel_prepare(alsa_handler, SND_PCM_CHANNEL_PLAYBACK)) < 0)
 332             {
 333                 mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_PlaybackPrepareError, snd_strerror(got_len));
 334                 return 0;
 335             }
 336             if ((got_len = snd_pcm_write(alsa_handler, data, len)) < 0)
 337             {
 338                 mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_WriteErrorAfterReset,
 339                     snd_strerror(got_len));
 340                 return 0;
 341             }
 342             return got_len; /* 2nd write was ok */
 343         }
 344         mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ALSA5_OutPutError, snd_strerror(got_len));
 345         return 0;
 346     }
 347     return got_len;
 348 }
 349
 350 /* how many byes are free in the buffer */
 351 static int get_space(void)
 352 {
 353     snd_pcm_channel_status_t ch_stat;
 354
 355     ch_stat.channel = SND_PCM_CHANNEL_PLAYBACK;
 356
 357     if (snd_pcm_channel_status(alsa_handler, &ch_stat) < 0)
 358         return 0; /* error occurred */
 359     else
 360         return ch_stat.free;
 361 }
 362
 363 /* delay in seconds between first and last sample in buffer */
 364 static float get_delay(void)
 365 {
 366     snd_pcm_channel_status_t ch_stat;
 367
 368     ch_stat.channel = SND_PCM_CHANNEL_PLAYBACK;
 369
 370     if (snd_pcm_channel_status(alsa_handler, &ch_stat) < 0)
 371         return (float)ao_data.buffersize/(float)ao_data.bps; /* error occurred */
 372     else
 373         return (float)ch_stat.count/(float)ao_data.bps;
 374 }