libao2/ao_alsa.c

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