libao2/ao_alsa5.c

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