libmpcodecs/dec_audio.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <assert.h>
   5
   6 #include "config.h"
   7 #include "mp_msg.h"
   8 #include "help_mp.h"
   9
  10 #include "stream/stream.h"
  11 #include "libmpdemux/demuxer.h"
  12
  13 #include "codec-cfg.h"
  14 #include "libmpdemux/stheader.h"
  15
  16 #include "dec_audio.h"
  17 #include "ad.h"
  18 #include "libaf/af_format.h"
  19
  20 #include "libaf/af.h"
  21
  22 #ifdef CONFIG_DYNAMIC_PLUGINS
  23 #include <dlfcn.h>
  24 #endif
  25
  26 #ifdef CONFIG_FAKE_MONO
  27 int fakemono = 0;
  28 #endif
  29
  30 /* used for ac3surround decoder - set using -channels option */
  31 int audio_output_channels = 2;
  32 af_cfg_t af_cfg = { 1, NULL };  // Configuration for audio filters
  33
  34 void afm_help(void)
  35 {
  36     int i;
  37     mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "Available (compiled-in) audio codec families/drivers:\n");
  38     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_DRIVERS\n");
  39     mp_msg(MSGT_DECAUDIO, MSGL_INFO, "    afm:    info:  (comment)\n");
  40     for (i = 0; mpcodecs_ad_drivers[i] != NULL; i++)
  41         if (mpcodecs_ad_drivers[i]->info->comment
  42             && mpcodecs_ad_drivers[i]->info->comment[0])
  43             mp_msg(MSGT_DECAUDIO, MSGL_INFO, "%9s  %s (%s)\n",
  44                    mpcodecs_ad_drivers[i]->info->short_name,
  45                    mpcodecs_ad_drivers[i]->info->name,
  46                    mpcodecs_ad_drivers[i]->info->comment);
  47         else
  48             mp_msg(MSGT_DECAUDIO, MSGL_INFO, "%9s  %s\n",
  49                    mpcodecs_ad_drivers[i]->info->short_name,
  50                    mpcodecs_ad_drivers[i]->info->name);
  51 }
  52
  53 static int init_audio_codec(sh_audio_t *sh_audio)
  54 {
  55     if ((af_cfg.force & AF_INIT_FORMAT_MASK) == AF_INIT_FLOAT) {
  56         int fmt = AF_FORMAT_FLOAT_NE;
  57         if (sh_audio->ad_driver->control(sh_audio, ADCTRL_QUERY_FORMAT,
  58                                          &fmt) == CONTROL_TRUE) {
  59             sh_audio->sample_format = fmt;
  60             sh_audio->samplesize = 4;
  61         }
  62     }
  63     if (!sh_audio->ad_driver->preinit(sh_audio)) {
  64         mp_tmsg(MSGT_DECAUDIO, MSGL_ERR, "ADecoder preinit failed :(\n");
  65         return 0;
  66     }
  67
  68     /* allocate audio in buffer: */
  69     if (sh_audio->audio_in_minsize > 0) {
  70         sh_audio->a_in_buffer_size = sh_audio->audio_in_minsize;
  71         mp_tmsg(MSGT_DECAUDIO, MSGL_V, "dec_audio: Allocating %d bytes for input buffer.\n",
  72                sh_audio->a_in_buffer_size);
  73         sh_audio->a_in_buffer = av_mallocz(sh_audio->a_in_buffer_size);
  74         sh_audio->a_in_buffer_len = 0;
  75     }
  76
  77     const int base_size = 65536;
  78     // At least 64 KiB plus rounding up to next decodable unit size
  79     sh_audio->a_buffer_size = base_size + sh_audio->audio_out_minsize;
  80
  81     mp_tmsg(MSGT_DECAUDIO, MSGL_V, "dec_audio: Allocating %d + %d = %d bytes for output buffer.\n",
  82            sh_audio->audio_out_minsize, base_size, sh_audio->a_buffer_size);
  83
  84     sh_audio->a_buffer = av_mallocz(sh_audio->a_buffer_size);
  85     if (!sh_audio->a_buffer) {
  86         mp_tmsg(MSGT_DECAUDIO, MSGL_ERR, "Cannot allocate audio out buffer.\n");
  87         return 0;
  88     }
  89     sh_audio->a_buffer_len = 0;
  90
  91     if (!sh_audio->ad_driver->init(sh_audio)) {
  92         mp_tmsg(MSGT_DECAUDIO, MSGL_WARN, "ADecoder init failed :(\n");
  93         uninit_audio(sh_audio); // free buffers
  94         return 0;
  95     }
  96
  97     sh_audio->initialized = 1;
  98
  99     if (!sh_audio->channels || !sh_audio->samplerate) {
 100         mp_tmsg(MSGT_DECAUDIO, MSGL_WARN, "Unknown/missing audio format -> no sound\n");
 101         uninit_audio(sh_audio); // free buffers
 102         return 0;
 103     }
 104
 105     if (!sh_audio->o_bps)
 106         sh_audio->o_bps = sh_audio->channels * sh_audio->samplerate
 107                           * sh_audio->samplesize;
 108
 109     mp_msg(MSGT_DECAUDIO, MSGL_INFO,
 110            "AUDIO: %d Hz, %d ch, %s, %3.1f kbit/%3.2f%% (ratio: %d->%d)\n",
 111            sh_audio->samplerate, sh_audio->channels,
 112            af_fmt2str_short(sh_audio->sample_format),
 113            sh_audio->i_bps * 8 * 0.001,
 114            ((float) sh_audio->i_bps / sh_audio->o_bps) * 100.0,
 115            sh_audio->i_bps, sh_audio->o_bps);
 116     mp_msg(MSGT_IDENTIFY, MSGL_INFO,
 117            "ID_AUDIO_BITRATE=%d\nID_AUDIO_RATE=%d\n" "ID_AUDIO_NCH=%d\n",
 118            sh_audio->i_bps * 8, sh_audio->samplerate, sh_audio->channels);
 119
 120     sh_audio->a_out_buffer_size = 0;
 121     sh_audio->a_out_buffer = NULL;
 122     sh_audio->a_out_buffer_len = 0;
 123
 124     return 1;
 125 }
 126
 127 static int init_audio(sh_audio_t *sh_audio, char *codecname, char *afm,
 128                       int status, stringset_t *selected)
 129 {
 130     unsigned int orig_fourcc = sh_audio->wf ? sh_audio->wf->wFormatTag : 0;
 131     int force = 0;
 132     if (codecname && codecname[0] == '+') {
 133         codecname = &codecname[1];
 134         force = 1;
 135     }
 136     sh_audio->codec = NULL;
 137     while (1) {
 138         ad_functions_t *mpadec;
 139         int i;
 140         sh_audio->ad_driver = 0;
 141         // restore original fourcc:
 142         if (sh_audio->wf)
 143             sh_audio->wf->wFormatTag = i = orig_fourcc;
 144         if (!(sh_audio->codec = find_audio_codec(sh_audio->format,
 145                                                  sh_audio->wf ? (&i) : NULL,
 146                                                  sh_audio->codec, force)))
 147             break;
 148         if (sh_audio->wf)
 149             sh_audio->wf->wFormatTag = i;
 150         // ok we found one codec
 151         if (stringset_test(selected, sh_audio->codec->name))
 152             continue;   // already tried & failed
 153         if (codecname && strcmp(sh_audio->codec->name, codecname))
 154             continue;   // -ac
 155         if (afm && strcmp(sh_audio->codec->drv, afm))
 156             continue;   // afm doesn't match
 157         if (!force && sh_audio->codec->status < status)
 158             continue;   // too unstable
 159         stringset_add(selected, sh_audio->codec->name); // tagging it
 160         // ok, it matches all rules, let's find the driver!
 161         for (i = 0; mpcodecs_ad_drivers[i] != NULL; i++)
 162             if (!strcmp(mpcodecs_ad_drivers[i]->info->short_name,
 163                  sh_audio->codec->drv))
 164                 break;
 165         mpadec = mpcodecs_ad_drivers[i];
 166 #ifdef CONFIG_DYNAMIC_PLUGINS
 167         if (!mpadec) {
 168             /* try to open shared decoder plugin */
 169             int buf_len;
 170             char *buf;
 171             ad_functions_t *funcs_sym;
 172             ad_info_t *info_sym;
 173
 174             buf_len =
 175                 strlen(MPLAYER_LIBDIR) + strlen(sh_audio->codec->drv) + 16;
 176             buf = malloc(buf_len);
 177             if (!buf)
 178                 break;
 179             snprintf(buf, buf_len, "%s/mplayer/ad_%s.so", MPLAYER_LIBDIR,
 180                      sh_audio->codec->drv);
 181             mp_msg(MSGT_DECAUDIO, MSGL_DBG2,
 182                    "Trying to open external plugin: %s\n", buf);
 183             sh_audio->dec_handle = dlopen(buf, RTLD_LAZY);
 184             if (!sh_audio->dec_handle)
 185                 break;
 186             snprintf(buf, buf_len, "mpcodecs_ad_%s", sh_audio->codec->drv);
 187             funcs_sym = dlsym(sh_audio->dec_handle, buf);
 188             if (!funcs_sym || !funcs_sym->info || !funcs_sym->preinit
 189                 || !funcs_sym->init || !funcs_sym->uninit
 190                 || !funcs_sym->control || !funcs_sym->decode_audio)
 191                 break;
 192             info_sym = funcs_sym->info;
 193             if (strcmp(info_sym->short_name, sh_audio->codec->drv))
 194                 break;
 195             free(buf);
 196             mpadec = funcs_sym;
 197             mp_msg(MSGT_DECAUDIO, MSGL_V,
 198                    "Using external decoder plugin (%s/mplayer/ad_%s.so)!\n",
 199                    MPLAYER_LIBDIR, sh_audio->codec->drv);
 200         }
 201 #endif
 202         if (!mpadec) {          // driver not available (==compiled in)
 203             mp_tmsg(MSGT_DECAUDIO, MSGL_ERR,
 204                    "Requested audio codec family [%s] (afm=%s) not available.\nEnable it at compilation.\n",
 205                    sh_audio->codec->name, sh_audio->codec->drv);
 206             continue;
 207         }
 208         // it's available, let's try to init!
 209         // init()
 210         mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "Opening audio decoder: [%s] %s\n",
 211                mpadec->info->short_name, mpadec->info->name);
 212         sh_audio->ad_driver = mpadec;
 213         if (!init_audio_codec(sh_audio)) {
 214             mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "ADecoder init failed :(\n");
 215             continue;           // try next...
 216         }
 217         // Yeah! We got it!
 218         return 1;
 219     }
 220     return 0;
 221 }
 222
 223 int init_best_audio_codec(sh_audio_t *sh_audio, char **audio_codec_list,
 224                           char **audio_fm_list)
 225 {
 226     stringset_t selected;
 227     char *ac_l_default[2] = { "", (char *) NULL };
 228     // hack:
 229     if (!audio_codec_list)
 230         audio_codec_list = ac_l_default;
 231     // Go through the codec.conf and find the best codec...
 232     sh_audio->initialized = 0;
 233     stringset_init(&selected);
 234     while (!sh_audio->initialized && *audio_codec_list) {
 235         char *audio_codec = *(audio_codec_list++);
 236         if (audio_codec[0]) {
 237             if (audio_codec[0] == '-') {
 238                 // disable this codec:
 239                 stringset_add(&selected, audio_codec + 1);
 240             } else {
 241                 // forced codec by name:
 242                 mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "Forced audio codec: %s\n",
 243                        audio_codec);
 244                 init_audio(sh_audio, audio_codec, NULL, -1, &selected);
 245             }
 246         } else {
 247             int status;
 248             // try in stability order: UNTESTED, WORKING, BUGGY.
 249             // never try CRASHING.
 250             if (audio_fm_list) {
 251                 char **fmlist = audio_fm_list;
 252                 // try first the preferred codec families:
 253                 while (!sh_audio->initialized && *fmlist) {
 254                     char *audio_fm = *(fmlist++);
 255                     mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "Trying to force audio codec driver family %s...\n",
 256                            audio_fm);
 257                     for (status = CODECS_STATUS__MAX;
 258                          status >= CODECS_STATUS__MIN; --status)
 259                         if (init_audio(sh_audio, NULL, audio_fm, status, &selected))
 260                             break;
 261                 }
 262             }
 263             if (!sh_audio->initialized)
 264                 for (status = CODECS_STATUS__MAX; status >= CODECS_STATUS__MIN;
 265                      --status)
 266                     if (init_audio(sh_audio, NULL, NULL, status, &selected))
 267                         break;
 268         }
 269     }
 270     stringset_free(&selected);
 271
 272     if (!sh_audio->initialized) {
 273         mp_tmsg(MSGT_DECAUDIO, MSGL_ERR, "Cannot find codec for audio format 0x%X.\n",
 274                sh_audio->format);
 275         return 0;   // failed
 276     }
 277
 278     mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "Selected audio codec: [%s] afm: %s (%s)\n",
 279            sh_audio->codec->name, sh_audio->codec->drv, sh_audio->codec->info);
 280     return 1;   // success
 281 }
 282
 283 void uninit_audio(sh_audio_t *sh_audio)
 284 {
 285     if (sh_audio->afilter) {
 286         mp_msg(MSGT_DECAUDIO, MSGL_V, "Uninit audio filters...\n");
 287         af_uninit(sh_audio->afilter);
 288         free(sh_audio->afilter);
 289         sh_audio->afilter = NULL;
 290     }
 291     if (sh_audio->initialized) {
 292         mp_tmsg(MSGT_DECAUDIO, MSGL_V, "Uninit audio: %s\n",
 293                sh_audio->codec->drv);
 294         sh_audio->ad_driver->uninit(sh_audio);
 295 #ifdef CONFIG_DYNAMIC_PLUGINS
 296         if (sh_audio->dec_handle)
 297             dlclose(sh_audio->dec_handle);
 298 #endif
 299         sh_audio->initialized = 0;
 300     }
 301     free(sh_audio->a_out_buffer);
 302     sh_audio->a_out_buffer = NULL;
 303     sh_audio->a_out_buffer_size = 0;
 304     av_freep(&sh_audio->a_buffer);
 305     av_freep(&sh_audio->a_in_buffer);
 306 }
 307
 308
 309 int init_audio_filters(sh_audio_t *sh_audio, int in_samplerate,
 310                        int *out_samplerate, int *out_channels, int *out_format)
 311 {
 312     af_stream_t *afs = sh_audio->afilter;
 313     if (!afs) {
 314         afs = malloc(sizeof(af_stream_t));
 315         memset(afs, 0, sizeof(af_stream_t));
 316     }
 317     // input format: same as codec's output format:
 318     afs->input.rate   = in_samplerate;
 319     afs->input.nch    = sh_audio->channels;
 320     afs->input.format = sh_audio->sample_format;
 321     af_fix_parameters(&(afs->input));
 322
 323     // output format: same as ao driver's input format (if missing, fallback to input)
 324     afs->output.rate   = *out_samplerate;
 325     afs->output.nch    = *out_channels;
 326     afs->output.format = *out_format;
 327     af_fix_parameters(&(afs->output));
 328
 329     // filter config:
 330     memcpy(&afs->cfg, &af_cfg, sizeof(af_cfg_t));
 331
 332     mp_tmsg(MSGT_DECAUDIO, MSGL_V, "Building audio filter chain for %dHz/%dch/%s -> %dHz/%dch/%s...\n",
 333            afs->input.rate, afs->input.nch,
 334            af_fmt2str_short(afs->input.format), afs->output.rate,
 335            afs->output.nch, af_fmt2str_short(afs->output.format));
 336
 337     // let's autoprobe it!
 338     if (0 != af_init(afs)) {
 339         sh_audio->afilter = NULL;
 340         free(afs);
 341         return 0;   // failed :(
 342     }
 343
 344     *out_samplerate = afs->output.rate;
 345     *out_channels = afs->output.nch;
 346     *out_format = afs->output.format;
 347
 348     sh_audio->a_out_buffer_len = 0;
 349
 350     // ok!
 351     sh_audio->afilter = (void *) afs;
 352     return 1;
 353 }
 354
 355 static int filter_n_bytes(sh_audio_t *sh, int len)
 356 {
 357     assert(len-1 + sh->audio_out_minsize <= sh->a_buffer_size);
 358
 359     int error = 0;
 360
 361     // Decode more bytes if needed
 362     while (sh->a_buffer_len < len) {
 363         unsigned char *buf = sh->a_buffer + sh->a_buffer_len;
 364         int minlen = len - sh->a_buffer_len;
 365         int maxlen = sh->a_buffer_size - sh->a_buffer_len;
 366         int ret = sh->ad_driver->decode_audio(sh, buf, minlen, maxlen);
 367         if (ret <= 0) {
 368             error = -1;
 369             len = sh->a_buffer_len;
 370             break;
 371         }
 372         sh->a_buffer_len += ret;
 373     }
 374
 375     // Filter
 376     af_data_t filter_input = {
 377         .audio = sh->a_buffer,
 378         .len = len,
 379         .rate = sh->samplerate,
 380         .nch = sh->channels,
 381         .format = sh->sample_format
 382     };
 383     af_fix_parameters(&filter_input);
 384     af_data_t *filter_output = af_play(sh->afilter, &filter_input);
 385     if (!filter_output)
 386         return -1;
 387     if (sh->a_out_buffer_size < sh->a_out_buffer_len + filter_output->len) {
 388         int newlen = sh->a_out_buffer_len + filter_output->len;
 389         mp_msg(MSGT_DECAUDIO, MSGL_V, "Increasing filtered audio buffer size "
 390                "from %d to %d\n", sh->a_out_buffer_size, newlen);
 391         sh->a_out_buffer = realloc(sh->a_out_buffer, newlen);
 392         sh->a_out_buffer_size = newlen;
 393     }
 394     memcpy(sh->a_out_buffer + sh->a_out_buffer_len, filter_output->audio,
 395            filter_output->len);
 396     sh->a_out_buffer_len += filter_output->len;
 397
 398     // remove processed data from decoder buffer:
 399     sh->a_buffer_len -= len;
 400     memmove(sh->a_buffer, sh->a_buffer + len, sh->a_buffer_len);
 401
 402     return error;
 403 }
 404
 405 /* Try to get at least minlen decoded+filtered bytes in sh_audio->a_out_buffer
 406  * (total length including possible existing data).
 407  * Return 0 on success, -1 on error/EOF (not distinguished).
 408  * In the former case sh_audio->a_out_buffer_len is always >= minlen
 409  * on return. In case of EOF/error it might or might not be.
 410  * Can reallocate sh_audio->a_out_buffer if needed to fit all filter output. */
 411 int decode_audio(sh_audio_t *sh_audio, int minlen)
 412 {
 413     // Indicates that a filter seems to be buffering large amounts of data
 414     int huge_filter_buffer = 0;
 415     // Decoded audio must be cut at boundaries of this many bytes
 416     int unitsize = sh_audio->channels * sh_audio->samplesize * 16;
 417
 418     /* Filter output size will be about filter_multiplier times input size.
 419      * If some filter buffers audio in big blocks this might only hold
 420      * as average over time. */
 421     double filter_multiplier = af_calc_filter_multiplier(sh_audio->afilter);
 422
 423     /* If the decoder set audio_out_minsize then it can do the equivalent of
 424      * "while (output_len < target_len) output_len += audio_out_minsize;",
 425      * so we must guarantee there is at least audio_out_minsize-1 bytes
 426      * more space in the output buffer than the minimum length we try to
 427      * decode. */
 428     int max_decode_len = sh_audio->a_buffer_size - sh_audio->audio_out_minsize;
 429     max_decode_len -= max_decode_len % unitsize;
 430
 431     while (sh_audio->a_out_buffer_len < minlen) {
 432         int declen = (minlen - sh_audio->a_out_buffer_len) / filter_multiplier
 433             + (unitsize << 5); // some extra for possible filter buffering
 434         if (huge_filter_buffer)
 435         /* Some filter must be doing significant buffering if the estimated
 436          * input length didn't produce enough output from filters.
 437          * Feed the filters 2k bytes at a time until we have enough output.
 438          * Very small amounts could make filtering inefficient while large
 439          * amounts can make MPlayer demux the file unnecessarily far ahead
 440          * to get audio data and buffer video frames in memory while doing
 441          * so. However the performance impact of either is probably not too
 442          * significant as long as the value is not completely insane. */
 443             declen = 2000;
 444         declen -= declen % unitsize;
 445         if (declen > max_decode_len)
 446             declen = max_decode_len;
 447         else
 448             /* if this iteration does not fill buffer, we must have lots
 449              * of buffering in filters */
 450             huge_filter_buffer = 1;
 451         if (filter_n_bytes(sh_audio, declen) < 0)
 452             return -1;
 453     }
 454     return 0;
 455 }
 456
 457 void resync_audio_stream(sh_audio_t *sh_audio)
 458 {
 459     sh_audio->a_in_buffer_len = 0;      // clear audio input buffer
 460     if (!sh_audio->initialized)
 461         return;
 462     sh_audio->ad_driver->control(sh_audio, ADCTRL_RESYNC_STREAM, NULL);
 463 }
 464
 465 void skip_audio_frame(sh_audio_t *sh_audio)
 466 {
 467     if (!sh_audio->initialized)
 468         return;
 469     if (sh_audio->ad_driver->control(sh_audio, ADCTRL_SKIP_FRAME, NULL) ==
 470         CONTROL_TRUE)
 471         return;
 472     // default skip code:
 473     ds_fill_buffer(sh_audio->ds);       // skip block
 474 }