libmpcodecs/dec_audio.c

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