libao2/ao_alsa.c

   1 /*
   2   ao_alsa9/1.x - ALSA-0.9.x-1.x output plugin for MPlayer
   3
   4   (C) Alex Beregszaszi
   5
   6   modified for real alsa-0.9.0-support by Zsolt Barat <joy@streamminister.de>
   7   additional AC3 passthrough support by Andy Lo A Foe <andy@alsaplayer.org>
   8   08/22/2002 iec958-init rewritten and merged with common init, zsolt
   9   04/13/2004 merged with ao_alsa1.x, fixes provided by Jindrich Makovicka
  10   04/25/2004 printfs converted to mp_msg, Zsolt.
  11
  12   Any bugreports regarding to this driver are welcome.
  13 */
  14
  15 #include <errno.h>
  16 #include <sys/time.h>
  17 #include <stdlib.h>
  18 #include <stdarg.h>
  19 #include <ctype.h>
  20 #include <math.h>
  21 #include <string.h>
  22 #include <alloca.h>
  23
  24 #include "config.h"
  25 #include "subopt-helper.h"
  26 #include "mixer.h"
  27 #include "mp_msg.h"
  28 #include "help_mp.h"
  29
  30 #define ALSA_PCM_NEW_HW_PARAMS_API
  31 #define ALSA_PCM_NEW_SW_PARAMS_API
  32
  33 #if HAVE_SYS_ASOUNDLIB_H
  34 #include <sys/asoundlib.h>
  35 #elif HAVE_ALSA_ASOUNDLIB_H
  36 #include <alsa/asoundlib.h>
  37 #else
  38 #error "asoundlib.h is not in sys/ or alsa/ - please bugreport"
  39 #endif
  40
  41
  42 #include "audio_out.h"
  43 #include "audio_out_internal.h"
  44 #include "libaf/af_format.h"
  45
  46 static ao_info_t info =
  47 {
  48     "ALSA-0.9.x-1.x audio output",
  49     "alsa",
  50     "Alex Beregszaszi, Zsolt Barat <joy@streamminister.de>",
  51     "under developement"
  52 };
  53
  54 LIBAO_EXTERN(alsa)
  55
  56 static snd_pcm_t *alsa_handler;
  57 static snd_pcm_format_t alsa_format;
  58 static snd_pcm_hw_params_t *alsa_hwparams;
  59 static snd_pcm_sw_params_t *alsa_swparams;
  60
  61 /* 16 sets buffersize to 16 * chunksize is as default 1024
  62  * which seems to be good avarge for most situations
  63  * so buffersize is 16384 frames by default */
  64 static int alsa_fragcount = 16;
  65 static snd_pcm_uframes_t chunk_size = 1024;
  66
  67 static size_t bytes_per_sample;
  68
  69 static int ao_noblock = 0;
  70
  71 static int open_mode;
  72 static int alsa_can_pause = 0;
  73 static snd_pcm_sframes_t prepause_frames;
  74
  75 #define ALSA_DEVICE_SIZE 256
  76
  77 #undef BUFFERTIME
  78 #define SET_CHUNKSIZE
  79
  80 static void alsa_error_handler(const char *file, int line, const char *function,
  81                                int err, const char *format, ...)
  82 {
  83   char tmp[0xc00];
  84   va_list va;
  85
  86   va_start(va, format);
  87   vsnprintf(tmp, sizeof tmp, format, va);
  88   va_end(va);
  89   tmp[sizeof tmp - 1] = '\0';
  90
  91   if (err)
  92     mp_msg(MSGT_AO, MSGL_ERR, "[AO_ALSA] alsa-lib: %s:%i:(%s) %s: %s\n",
  93            file, line, function, tmp, snd_strerror(err));
  94   else
  95     mp_msg(MSGT_AO, MSGL_ERR, "[AO_ALSA] alsa-lib: %s:%i:(%s) %s\n",
  96            file, line, function, tmp);
  97 }
  98
  99 /* to set/get/query special features/parameters */
 100 static int control(int cmd, void *arg)
 101 {
 102   switch(cmd) {
 103   case AOCONTROL_QUERY_FORMAT:
 104     return CONTROL_TRUE;
 105   case AOCONTROL_GET_VOLUME:
 106   case AOCONTROL_SET_VOLUME:
 107     {
 108       ao_control_vol_t *vol = (ao_control_vol_t *)arg;
 109
 110       int err;
 111       snd_mixer_t *handle;
 112       snd_mixer_elem_t *elem;
 113       snd_mixer_selem_id_t *sid;
 114
 115       static char *mix_name = "PCM";
 116       static char *card = "default";
 117       static int mix_index = 0;
 118
 119       long pmin, pmax;
 120       long get_vol, set_vol;
 121       float f_multi;
 122
 123       if(ao_data.format == AF_FORMAT_AC3)
 124         return CONTROL_TRUE;
 125
 126       if(mixer_channel) {
 127          char *test_mix_index;
 128
 129          mix_name = strdup(mixer_channel);
 130          if ((test_mix_index = strchr(mix_name, ','))){
 131                 *test_mix_index = 0;
 132                 test_mix_index++;
 133                 mix_index = strtol(test_mix_index, &test_mix_index, 0);
 134
 135                 if (*test_mix_index){
 136                   mp_msg(MSGT_AO,MSGL_ERR,
 137                     MSGTR_AO_ALSA_InvalidMixerIndexDefaultingToZero);
 138                   mix_index = 0 ;
 139                 }
 140          }
 141       }
 142       if(mixer_device) card = mixer_device;
 143
 144       //allocate simple id
 145       snd_mixer_selem_id_alloca(&sid);
 146
 147       //sets simple-mixer index and name
 148       snd_mixer_selem_id_set_index(sid, mix_index);
 149       snd_mixer_selem_id_set_name(sid, mix_name);
 150
 151       if (mixer_channel) {
 152         free(mix_name);
 153         mix_name = NULL;
 154       }
 155
 156       if ((err = snd_mixer_open(&handle, 0)) < 0) {
 157         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_MixerOpenError, snd_strerror(err));
 158         return CONTROL_ERROR;
 159       }
 160
 161       if ((err = snd_mixer_attach(handle, card)) < 0) {
 162         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_MixerAttachError,
 163                card, snd_strerror(err));
 164         snd_mixer_close(handle);
 165         return CONTROL_ERROR;
 166       }
 167
 168       if ((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0) {
 169         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_MixerRegisterError, snd_strerror(err));
 170         snd_mixer_close(handle);
 171         return CONTROL_ERROR;
 172       }
 173       err = snd_mixer_load(handle);
 174       if (err < 0) {
 175         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_MixerLoadError, snd_strerror(err));
 176         snd_mixer_close(handle);
 177         return CONTROL_ERROR;
 178       }
 179
 180       elem = snd_mixer_find_selem(handle, sid);
 181       if (!elem) {
 182         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToFindSimpleControl,
 183                snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid));
 184         snd_mixer_close(handle);
 185         return CONTROL_ERROR;
 186         }
 187
 188       snd_mixer_selem_get_playback_volume_range(elem,&pmin,&pmax);
 189       f_multi = (100 / (float)(pmax - pmin));
 190
 191       if (cmd == AOCONTROL_SET_VOLUME) {
 192
 193         set_vol = vol->left / f_multi + pmin + 0.5;
 194
 195         //setting channels
 196         if ((err = snd_mixer_selem_set_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, set_vol)) < 0) {
 197           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ErrorSettingLeftChannel,
 198                  snd_strerror(err));
 199           return CONTROL_ERROR;
 200         }
 201         mp_msg(MSGT_AO,MSGL_DBG2,"left=%li, ", set_vol);
 202
 203         set_vol = vol->right / f_multi + pmin + 0.5;
 204
 205         if ((err = snd_mixer_selem_set_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, set_vol)) < 0) {
 206           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ErrorSettingRightChannel,
 207                  snd_strerror(err));
 208           return CONTROL_ERROR;
 209         }
 210         mp_msg(MSGT_AO,MSGL_DBG2,"right=%li, pmin=%li, pmax=%li, mult=%f\n",
 211                set_vol, pmin, pmax, f_multi);
 212
 213         if (snd_mixer_selem_has_playback_switch(elem)) {
 214           int lmute = (vol->left == 0.0);
 215           int rmute = (vol->right == 0.0);
 216           if (snd_mixer_selem_has_playback_switch_joined(elem)) {
 217             lmute = rmute = lmute && rmute;
 218           } else {
 219             snd_mixer_selem_set_playback_switch(elem, SND_MIXER_SCHN_FRONT_RIGHT, !rmute);
 220           }
 221           snd_mixer_selem_set_playback_switch(elem, SND_MIXER_SCHN_FRONT_LEFT, !lmute);
 222         }
 223       }
 224       else {
 225         snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &get_vol);
 226         vol->left = (get_vol - pmin) * f_multi;
 227         snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &get_vol);
 228         vol->right = (get_vol - pmin) * f_multi;
 229
 230         mp_msg(MSGT_AO,MSGL_DBG2,"left=%f, right=%f\n",vol->left,vol->right);
 231       }
 232       snd_mixer_close(handle);
 233       return CONTROL_OK;
 234     }
 235
 236   } //end switch
 237   return CONTROL_UNKNOWN;
 238 }
 239
 240 static void parse_device (char *dest, const char *src, int len)
 241 {
 242   char *tmp;
 243   memmove(dest, src, len);
 244   dest[len] = 0;
 245   while ((tmp = strrchr(dest, '.')))
 246     tmp[0] = ',';
 247   while ((tmp = strrchr(dest, '=')))
 248     tmp[0] = ':';
 249 }
 250
 251 static void print_help (void)
 252 {
 253   mp_msg (MSGT_AO, MSGL_FATAL,
 254            MSGTR_AO_ALSA_CommandlineHelp);
 255 }
 256
 257 static int str_maxlen(strarg_t *str) {
 258   if (str->len > ALSA_DEVICE_SIZE)
 259     return 0;
 260   return 1;
 261 }
 262
 263 static int try_open_device(const char *device, int open_mode, int try_ac3)
 264 {
 265   int err, len;
 266   char *ac3_device, *args;
 267
 268   if (try_ac3) {
 269     /* to set the non-audio bit, use AES0=6 */
 270     len = strlen(device);
 271     ac3_device = malloc(len + 7 + 1);
 272     if (!ac3_device)
 273       return -ENOMEM;
 274     strcpy(ac3_device, device);
 275     args = strchr(ac3_device, ':');
 276     if (!args) {
 277       /* no existing parameters: add it behind device name */
 278       strcat(ac3_device, ":AES0=6");
 279     } else {
 280       do
 281         ++args;
 282       while (isspace(*args));
 283       if (*args == '\0') {
 284         /* ":" but no parameters */
 285         strcat(ac3_device, "AES0=6");
 286       } else if (*args != '{') {
 287         /* a simple list of parameters: add it at the end of the list */
 288         strcat(ac3_device, ",AES0=6");
 289       } else {
 290         /* parameters in config syntax: add it inside the { } block */
 291         do
 292           --len;
 293         while (len > 0 && isspace(ac3_device[len]));
 294         if (ac3_device[len] == '}')
 295           strcpy(ac3_device + len, " AES0=6}");
 296       }
 297     }
 298     err = snd_pcm_open(&alsa_handler, ac3_device, SND_PCM_STREAM_PLAYBACK,
 299                        open_mode);
 300     free(ac3_device);
 301   }
 302   if (!try_ac3 || err < 0)
 303     err = snd_pcm_open(&alsa_handler, device, SND_PCM_STREAM_PLAYBACK,
 304                        open_mode);
 305   return err;
 306 }
 307
 308 /*
 309     open & setup audio device
 310     return: 1=success 0=fail
 311 */
 312 static int init(int rate_hz, int channels, int format, int flags)
 313 {
 314     int err;
 315     int block;
 316     strarg_t device;
 317     snd_pcm_uframes_t bufsize;
 318     snd_pcm_uframes_t boundary;
 319     opt_t subopts[] = {
 320       {"block", OPT_ARG_BOOL, &block, NULL},
 321       {"device", OPT_ARG_STR, &device, (opt_test_f)str_maxlen},
 322       {NULL}
 323     };
 324
 325     char alsa_device[ALSA_DEVICE_SIZE + 1];
 326     // make sure alsa_device is null-terminated even when using strncpy etc.
 327     memset(alsa_device, 0, ALSA_DEVICE_SIZE + 1);
 328
 329     mp_msg(MSGT_AO,MSGL_V,"alsa-init: requested format: %d Hz, %d channels, %x\n", rate_hz,
 330         channels, format);
 331     alsa_handler = NULL;
 332 #if SND_LIB_VERSION >= 0x010005
 333     mp_msg(MSGT_AO,MSGL_V,"alsa-init: using ALSA %s\n", snd_asoundlib_version());
 334 #else
 335     mp_msg(MSGT_AO,MSGL_V,"alsa-init: compiled for ALSA-%s\n", SND_LIB_VERSION_STR);
 336 #endif
 337
 338     prepause_frames = 0;
 339
 340     snd_lib_error_set_handler(alsa_error_handler);
 341
 342     ao_data.samplerate = rate_hz;
 343     ao_data.format = format;
 344     ao_data.channels = channels;
 345
 346     switch (format)
 347       {
 348       case AF_FORMAT_S8:
 349         alsa_format = SND_PCM_FORMAT_S8;
 350         break;
 351       case AF_FORMAT_U8:
 352         alsa_format = SND_PCM_FORMAT_U8;
 353         break;
 354       case AF_FORMAT_U16_LE:
 355         alsa_format = SND_PCM_FORMAT_U16_LE;
 356         break;
 357       case AF_FORMAT_U16_BE:
 358         alsa_format = SND_PCM_FORMAT_U16_BE;
 359         break;
 360 #ifndef WORDS_BIGENDIAN
 361       case AF_FORMAT_AC3:
 362 #endif
 363       case AF_FORMAT_S16_LE:
 364         alsa_format = SND_PCM_FORMAT_S16_LE;
 365         break;
 366 #ifdef WORDS_BIGENDIAN
 367       case AF_FORMAT_AC3:
 368 #endif
 369       case AF_FORMAT_S16_BE:
 370         alsa_format = SND_PCM_FORMAT_S16_BE;
 371         break;
 372       case AF_FORMAT_U32_LE:
 373         alsa_format = SND_PCM_FORMAT_U32_LE;
 374         break;
 375       case AF_FORMAT_U32_BE:
 376         alsa_format = SND_PCM_FORMAT_U32_BE;
 377         break;
 378       case AF_FORMAT_S32_LE:
 379         alsa_format = SND_PCM_FORMAT_S32_LE;
 380         break;
 381       case AF_FORMAT_S32_BE:
 382         alsa_format = SND_PCM_FORMAT_S32_BE;
 383         break;
 384       case AF_FORMAT_FLOAT_LE:
 385         alsa_format = SND_PCM_FORMAT_FLOAT_LE;
 386         break;
 387       case AF_FORMAT_FLOAT_BE:
 388         alsa_format = SND_PCM_FORMAT_FLOAT_BE;
 389         break;
 390       case AF_FORMAT_MU_LAW:
 391         alsa_format = SND_PCM_FORMAT_MU_LAW;
 392         break;
 393       case AF_FORMAT_A_LAW:
 394         alsa_format = SND_PCM_FORMAT_A_LAW;
 395         break;
 396
 397       default:
 398         alsa_format = SND_PCM_FORMAT_MPEG; //? default should be -1
 399         break;
 400       }
 401
 402     //subdevice parsing
 403     // set defaults
 404     block = 1;
 405     /* switch for spdif
 406      * sets opening sequence for SPDIF
 407      * sets also the playback and other switches 'on the fly'
 408      * while opening the abstract alias for the spdif subdevice
 409      * 'iec958'
 410      */
 411     if (format == AF_FORMAT_AC3) {
 412         device.str = "iec958";
 413         mp_msg(MSGT_AO,MSGL_V,"alsa-spdif-init: playing AC3, %i channels\n", channels);
 414     }
 415   else
 416         /* in any case for multichannel playback we should select
 417          * appropriate device
 418          */
 419         switch (channels) {
 420         case 1:
 421         case 2:
 422           device.str = "default";
 423           mp_msg(MSGT_AO,MSGL_V,"alsa-init: setup for 1/2 channel(s)\n");
 424           break;
 425         case 4:
 426           if (alsa_format == SND_PCM_FORMAT_FLOAT_LE)
 427             // hack - use the converter plugin
 428             device.str = "plug:surround40";
 429           else
 430             device.str = "surround40";
 431           mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround40\n");
 432           break;
 433         case 6:
 434           if (alsa_format == SND_PCM_FORMAT_FLOAT_LE)
 435             device.str = "plug:surround51";
 436           else
 437             device.str = "surround51";
 438           mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround51\n");
 439           break;
 440         default:
 441           device.str = "default";
 442           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ChannelsNotSupported,channels);
 443         }
 444     device.len = strlen(device.str);
 445     if (subopt_parse(ao_subdevice, subopts) != 0) {
 446         print_help();
 447         return 0;
 448     }
 449     ao_noblock = !block;
 450     parse_device(alsa_device, device.str, device.len);
 451
 452     mp_msg(MSGT_AO,MSGL_V,"alsa-init: using device %s\n", alsa_device);
 453
 454     //setting modes for block or nonblock-mode
 455     if (ao_noblock) {
 456       open_mode = SND_PCM_NONBLOCK;
 457     }
 458     else {
 459       open_mode = 0;
 460     }
 461
 462     //sets buff/chunksize if its set manually
 463     if (ao_data.buffersize) {
 464       switch (ao_data.buffersize)
 465         {
 466         case 1:
 467           alsa_fragcount = 16;
 468           chunk_size = 512;
 469             mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 8192\n");
 470             mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 512\n");
 471           break;
 472         case 2:
 473           alsa_fragcount = 8;
 474           chunk_size = 1024;
 475             mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 8192\n");
 476             mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 1024\n");
 477           break;
 478         case 3:
 479           alsa_fragcount = 32;
 480           chunk_size = 512;
 481             mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 16384\n");
 482             mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 512\n");
 483           break;
 484         case 4:
 485           alsa_fragcount = 16;
 486           chunk_size = 1024;
 487             mp_msg(MSGT_AO,MSGL_V,"alsa-init: buffersize set manually to 16384\n");
 488             mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set manually to 1024\n");
 489           break;
 490         default:
 491           alsa_fragcount = 16;
 492           chunk_size = 1024;
 493           break;
 494         }
 495     }
 496
 497     if (!alsa_handler) {
 498       //modes = 0, SND_PCM_NONBLOCK, SND_PCM_ASYNC
 499       if ((err = try_open_device(alsa_device, open_mode, format == AF_FORMAT_AC3)) < 0)
 500         {
 501           if (err != -EBUSY && ao_noblock) {
 502             mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_OpenInNonblockModeFailed);
 503             if ((err = try_open_device(alsa_device, 0, format == AF_FORMAT_AC3)) < 0) {
 504               mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PlaybackOpenError, snd_strerror(err));
 505               return 0;
 506             }
 507           } else {
 508             mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PlaybackOpenError, snd_strerror(err));
 509             return 0;
 510           }
 511         }
 512
 513       if ((err = snd_pcm_nonblock(alsa_handler, 0)) < 0) {
 514          mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ErrorSetBlockMode, snd_strerror(err));
 515       } else {
 516         mp_msg(MSGT_AO,MSGL_V,"alsa-init: pcm opened in blocking mode\n");
 517       }
 518
 519       snd_pcm_hw_params_alloca(&alsa_hwparams);
 520       snd_pcm_sw_params_alloca(&alsa_swparams);
 521
 522       // setting hw-parameters
 523       if ((err = snd_pcm_hw_params_any(alsa_handler, alsa_hwparams)) < 0)
 524         {
 525           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetInitialParameters,
 526                  snd_strerror(err));
 527           return 0;
 528         }
 529
 530       err = snd_pcm_hw_params_set_access(alsa_handler, alsa_hwparams,
 531                                          SND_PCM_ACCESS_RW_INTERLEAVED);
 532       if (err < 0) {
 533         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetAccessType,
 534                snd_strerror(err));
 535         return 0;
 536       }
 537
 538       /* workaround for nonsupported formats
 539          sets default format to S16_LE if the given formats aren't supported */
 540       if ((err = snd_pcm_hw_params_test_format(alsa_handler, alsa_hwparams,
 541                                              alsa_format)) < 0)
 542       {
 543          mp_msg(MSGT_AO,MSGL_INFO,
 544                 MSGTR_AO_ALSA_FormatNotSupportedByHardware, af_fmt2str_short(format));
 545          alsa_format = SND_PCM_FORMAT_S16_LE;
 546          ao_data.format = AF_FORMAT_S16_LE;
 547       }
 548
 549       if ((err = snd_pcm_hw_params_set_format(alsa_handler, alsa_hwparams,
 550                                               alsa_format)) < 0)
 551         {
 552           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetFormat,
 553                  snd_strerror(err));
 554           return 0;
 555         }
 556
 557       if ((err = snd_pcm_hw_params_set_channels_near(alsa_handler, alsa_hwparams,
 558                                                      &ao_data.channels)) < 0)
 559         {
 560           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetChannels,
 561                  snd_strerror(err));
 562           return 0;
 563         }
 564
 565       /* workaround for buggy rate plugin (should be fixed in ALSA 1.0.11)
 566          prefer our own resampler */
 567 #if SND_LIB_VERSION >= 0x010009
 568       if ((err = snd_pcm_hw_params_set_rate_resample(alsa_handler, alsa_hwparams,
 569                                                      0)) < 0)
 570         {
 571           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToDisableResampling,
 572                  snd_strerror(err));
 573           return 0;
 574         }
 575 #endif
 576
 577       if ((err = snd_pcm_hw_params_set_rate_near(alsa_handler, alsa_hwparams,
 578                                                  &ao_data.samplerate, NULL)) < 0)
 579         {
 580           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSamplerate2,
 581                  snd_strerror(err));
 582           return 0;
 583         }
 584
 585       bytes_per_sample = snd_pcm_format_physical_width(alsa_format) / 8;
 586       bytes_per_sample *= ao_data.channels;
 587       ao_data.bps = ao_data.samplerate * bytes_per_sample;
 588
 589 #ifdef BUFFERTIME
 590       {
 591         int alsa_buffer_time = 500000; /* original 60 */
 592         int alsa_period_time;
 593         alsa_period_time = alsa_buffer_time/4;
 594         if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa_handler, alsa_hwparams,
 595                                                           &alsa_buffer_time, NULL)) < 0)
 596           {
 597             mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetBufferTimeNear,
 598                    snd_strerror(err));
 599             return 0;
 600           } else
 601             alsa_buffer_time = err;
 602
 603         if ((err = snd_pcm_hw_params_set_period_time_near(alsa_handler, alsa_hwparams,
 604                                                           &alsa_period_time, NULL)) < 0)
 605           /* original: alsa_buffer_time/ao_data.bps */
 606           {
 607             mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriodTime,
 608                    snd_strerror(err));
 609             return 0;
 610           }
 611         mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_BufferTimePeriodTime,
 612                alsa_buffer_time, err);
 613       }
 614 #endif//end SET_BUFFERTIME
 615
 616 #ifdef SET_CHUNKSIZE
 617       {
 618         //set chunksize
 619         if ((err = snd_pcm_hw_params_set_period_size_near(alsa_handler, alsa_hwparams,
 620                                                           &chunk_size, NULL)) < 0)
 621           {
 622             mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriodSize,
 623                             chunk_size, snd_strerror(err));
 624             return 0;
 625           }
 626         else {
 627           mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set to %li\n", chunk_size);
 628         }
 629         if ((err = snd_pcm_hw_params_set_periods_near(alsa_handler, alsa_hwparams,
 630                                                       &alsa_fragcount, NULL)) < 0) {
 631           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriods,
 632                  snd_strerror(err));
 633           return 0;
 634         }
 635         else {
 636           mp_msg(MSGT_AO,MSGL_V,"alsa-init: fragcount=%i\n", alsa_fragcount);
 637         }
 638       }
 639 #endif//end SET_CHUNKSIZE
 640
 641       /* finally install hardware parameters */
 642       if ((err = snd_pcm_hw_params(alsa_handler, alsa_hwparams)) < 0)
 643         {
 644           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetHwParameters,
 645                  snd_strerror(err));
 646           return 0;
 647         }
 648       // end setting hw-params
 649
 650
 651       // gets buffersize for control
 652       if ((err = snd_pcm_hw_params_get_buffer_size(alsa_hwparams, &bufsize)) < 0)
 653         {
 654           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBufferSize, snd_strerror(err));
 655           return 0;
 656         }
 657       else {
 658         ao_data.buffersize = bufsize * bytes_per_sample;
 659           mp_msg(MSGT_AO,MSGL_V,"alsa-init: got buffersize=%i\n", ao_data.buffersize);
 660       }
 661
 662       if ((err = snd_pcm_hw_params_get_period_size(alsa_hwparams, &chunk_size, NULL)) < 0) {
 663         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetPeriodSize, snd_strerror(err));
 664         return 0;
 665       } else {
 666         mp_msg(MSGT_AO,MSGL_V,"alsa-init: got period size %li\n", chunk_size);
 667       }
 668       ao_data.outburst = chunk_size * bytes_per_sample;
 669
 670       /* setting software parameters */
 671       if ((err = snd_pcm_sw_params_current(alsa_handler, alsa_swparams)) < 0) {
 672         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters,
 673                snd_strerror(err));
 674         return 0;
 675       }
 676 #if SND_LIB_VERSION >= 0x000901
 677       if ((err = snd_pcm_sw_params_get_boundary(alsa_swparams, &boundary)) < 0) {
 678         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBoundary,
 679                snd_strerror(err));
 680         return 0;
 681       }
 682 #else
 683       boundary = 0x7fffffff;
 684 #endif
 685       /* start playing when one period has been written */
 686       if ((err = snd_pcm_sw_params_set_start_threshold(alsa_handler, alsa_swparams, chunk_size)) < 0) {
 687         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStartThreshold,
 688                snd_strerror(err));
 689         return 0;
 690       }
 691       /* disable underrun reporting */
 692       if ((err = snd_pcm_sw_params_set_stop_threshold(alsa_handler, alsa_swparams, boundary)) < 0) {
 693         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStopThreshold,
 694                snd_strerror(err));
 695         return 0;
 696       }
 697 #if SND_LIB_VERSION >= 0x000901
 698       /* play silence when there is an underrun */
 699       if ((err = snd_pcm_sw_params_set_silence_size(alsa_handler, alsa_swparams, boundary)) < 0) {
 700         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSilenceSize,
 701                snd_strerror(err));
 702         return 0;
 703       }
 704 #endif
 705       if ((err = snd_pcm_sw_params(alsa_handler, alsa_swparams)) < 0) {
 706         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters,
 707                snd_strerror(err));
 708         return 0;
 709       }
 710       /* end setting sw-params */
 711
 712       mp_msg(MSGT_AO,MSGL_V,"alsa: %d Hz/%d channels/%d bpf/%d bytes buffer/%s\n",
 713              ao_data.samplerate, ao_data.channels, (int)bytes_per_sample, ao_data.buffersize,
 714              snd_pcm_format_description(alsa_format));
 715
 716     } // end switch alsa_handler (spdif)
 717     alsa_can_pause = snd_pcm_hw_params_can_pause(alsa_hwparams);
 718     return 1;
 719 } // end init
 720
 721
 722 /* close audio device */
 723 static void uninit(int immed)
 724 {
 725
 726   if (alsa_handler) {
 727     int err;
 728
 729     if (!immed)
 730       snd_pcm_drain(alsa_handler);
 731
 732     if ((err = snd_pcm_close(alsa_handler)) < 0)
 733       {
 734         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmCloseError, snd_strerror(err));
 735         return;
 736       }
 737     else {
 738       alsa_handler = NULL;
 739       mp_msg(MSGT_AO,MSGL_V,"alsa-uninit: pcm closed\n");
 740     }
 741   }
 742   else {
 743     mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_NoHandlerDefined);
 744   }
 745 }
 746
 747 static void audio_pause(void)
 748 {
 749     int err;
 750
 751     if (alsa_can_pause) {
 752         if ((err = snd_pcm_pause(alsa_handler, 1)) < 0)
 753         {
 754             mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPauseError, snd_strerror(err));
 755             return;
 756         }
 757           mp_msg(MSGT_AO,MSGL_V,"alsa-pause: pause supported by hardware\n");
 758     } else {
 759         if (snd_pcm_delay(alsa_handler, &prepause_frames) < 0
 760             || prepause_frames < 0)
 761             prepause_frames = 0;
 762
 763         if ((err = snd_pcm_drop(alsa_handler)) < 0)
 764         {
 765             mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmDropError, snd_strerror(err));
 766             return;
 767         }
 768     }
 769 }
 770
 771 static void audio_resume(void)
 772 {
 773     int err;
 774
 775     if (snd_pcm_state(alsa_handler) == SND_PCM_STATE_SUSPENDED) {
 776         mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_PcmInSuspendModeTryingResume);
 777         while ((err = snd_pcm_resume(alsa_handler)) == -EAGAIN) sleep(1);
 778     }
 779     if (alsa_can_pause) {
 780         if ((err = snd_pcm_pause(alsa_handler, 0)) < 0)
 781         {
 782             mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmResumeError, snd_strerror(err));
 783             return;
 784         }
 785           mp_msg(MSGT_AO,MSGL_V,"alsa-resume: resume supported by hardware\n");
 786     } else {
 787         if ((err = snd_pcm_prepare(alsa_handler)) < 0)
 788         {
 789            mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPrepareError, snd_strerror(err));
 790             return;
 791         }
 792         if (prepause_frames) {
 793             void *silence = calloc(prepause_frames, bytes_per_sample);
 794             play(silence, prepause_frames * bytes_per_sample, 0);
 795             free(silence);
 796         }
 797     }
 798 }
 799
 800 /* stop playing and empty buffers (for seeking/pause) */
 801 static void reset(void)
 802 {
 803     int err;
 804
 805     prepause_frames = 0;
 806     if ((err = snd_pcm_drop(alsa_handler)) < 0)
 807     {
 808         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPrepareError, snd_strerror(err));
 809         return;
 810     }
 811     if ((err = snd_pcm_prepare(alsa_handler)) < 0)
 812     {
 813         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPrepareError, snd_strerror(err));
 814         return;
 815     }
 816     return;
 817 }
 818
 819 /*
 820     plays 'len' bytes of 'data'
 821     returns: number of bytes played
 822     modified last at 29.06.02 by jp
 823     thanxs for marius <marius@rospot.com> for giving us the light ;)
 824 */
 825
 826 static int play(void* data, int len, int flags)
 827 {
 828   int num_frames = len / bytes_per_sample;
 829   snd_pcm_sframes_t res = 0;
 830
 831   //mp_msg(MSGT_AO,MSGL_ERR,"alsa-play: frames=%i, len=%i\n",num_frames,len);
 832
 833   if (!alsa_handler) {
 834     mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_DeviceConfigurationError);
 835     return 0;
 836   }
 837
 838   if (num_frames == 0)
 839     return 0;
 840
 841   do {
 842     res = snd_pcm_writei(alsa_handler, data, num_frames);
 843
 844       if (res == -EINTR) {
 845         /* nothing to do */
 846         res = 0;
 847       }
 848       else if (res == -ESTRPIPE) {      /* suspend */
 849         mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_PcmInSuspendModeTryingResume);
 850         while ((res = snd_pcm_resume(alsa_handler)) == -EAGAIN)
 851           sleep(1);
 852       }
 853       if (res < 0) {
 854         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_WriteError, snd_strerror(res));
 855         mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_TryingToResetSoundcard);
 856         if ((res = snd_pcm_prepare(alsa_handler)) < 0) {
 857           mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PcmPrepareError, snd_strerror(res));
 858           return 0;
 859           break;
 860         }
 861       }
 862   } while (res == 0);
 863
 864   return res < 0 ? res : res * bytes_per_sample;
 865 }
 866
 867 /* how many byes are free in the buffer */
 868 static int get_space(void)
 869 {
 870     snd_pcm_status_t *status;
 871     int ret;
 872
 873     snd_pcm_status_alloca(&status);
 874
 875     if ((ret = snd_pcm_status(alsa_handler, status)) < 0)
 876     {
 877         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_CannotGetPcmStatus, snd_strerror(ret));
 878         return 0;
 879     }
 880
 881     unsigned space = snd_pcm_status_get_avail(status) * bytes_per_sample;
 882     if (space > ao_data.buffersize) // Buffer underrun?
 883         space = ao_data.buffersize;
 884     return space;
 885 }
 886
 887 /* delay in seconds between first and last sample in buffer */
 888 static float get_delay(void)
 889 {
 890   if (alsa_handler) {
 891     snd_pcm_sframes_t delay;
 892
 893     if (snd_pcm_delay(alsa_handler, &delay) < 0)
 894       return 0;
 895
 896     if (delay < 0) {
 897       /* underrun - move the application pointer forward to catch up */
 898 #if SND_LIB_VERSION >= 0x000901 /* snd_pcm_forward() exists since 0.9.0rc8 */
 899       snd_pcm_forward(alsa_handler, -delay);
 900 #endif
 901       delay = 0;
 902     }
 903     return (float)delay / (float)ao_data.samplerate;
 904   } else {
 905     return 0;
 906   }
 907 }