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