libmpcodecs/dec_audio.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4
   5 #include "config.h"
   6 #include "mp_msg.h"
   7 #include "help_mp.h"
   8
   9 #include "stream.h"
  10 #include "demuxer.h"
  11
  12 #include "codec-cfg.h"
  13 #include "stheader.h"
  14
  15 #include "dec_audio.h"
  16 #include "ad.h"
  17 #include "../libao2/afmt.h"
  18
  19 #include "../libaf/af.h"
  20
  21 #ifdef DYNAMIC_PLUGINS
  22 #include <dlfcn.h>
  23 #endif
  24
  25 #ifdef USE_FAKE_MONO
  26 int fakemono=0;
  27 #endif
  28 /* used for ac3surround decoder - set using -channels option */
  29 int audio_output_channels = 2;
  30 af_cfg_t af_cfg; // Configuration for audio filters
  31
  32 static ad_functions_t* mpadec;
  33
  34 void afm_help(){
  35     int i;
  36     mp_msg(MSGT_DECAUDIO,MSGL_INFO,MSGTR_AvailableAudioFm);
  37     mp_msg(MSGT_DECAUDIO,MSGL_INFO,"    afm:    info:  (comment)\n");
  38     for (i=0; mpcodecs_ad_drivers[i] != NULL; i++)
  39       if(mpcodecs_ad_drivers[i]->info->comment && mpcodecs_ad_drivers[i]->info->comment[0])
  40         mp_msg(MSGT_DECAUDIO,MSGL_INFO,"%9s  %s (%s)\n",
  41             mpcodecs_ad_drivers[i]->info->short_name,
  42             mpcodecs_ad_drivers[i]->info->name,
  43             mpcodecs_ad_drivers[i]->info->comment);
  44       else
  45         mp_msg(MSGT_DECAUDIO,MSGL_INFO,"%9s  %s\n",
  46             mpcodecs_ad_drivers[i]->info->short_name,
  47             mpcodecs_ad_drivers[i]->info->name);
  48 }
  49
  50 int init_audio_codec(sh_audio_t *sh_audio)
  51 {
  52   if(!mpadec->preinit(sh_audio))
  53   {
  54       mp_msg(MSGT_DECAUDIO,MSGL_ERR,MSGTR_ADecoderPreinitFailed);
  55       return 0;
  56   }
  57
  58 /* allocate audio in buffer: */
  59   if(sh_audio->audio_in_minsize>0){
  60       sh_audio->a_in_buffer_size=sh_audio->audio_in_minsize;
  61       mp_msg(MSGT_DECAUDIO,MSGL_V,MSGTR_AllocatingBytesForInputBuffer,
  62           sh_audio->a_in_buffer_size);
  63       sh_audio->a_in_buffer=malloc(sh_audio->a_in_buffer_size);
  64       memset(sh_audio->a_in_buffer,0,sh_audio->a_in_buffer_size);
  65       sh_audio->a_in_buffer_len=0;
  66   }
  67
  68 /* allocate audio out buffer: */
  69   sh_audio->a_buffer_size=sh_audio->audio_out_minsize+MAX_OUTBURST; /* worst case calc.*/
  70
  71   mp_msg(MSGT_DECAUDIO,MSGL_V,MSGTR_AllocatingBytesForOutputBuffer,
  72       sh_audio->audio_out_minsize,MAX_OUTBURST,sh_audio->a_buffer_size);
  73
  74   sh_audio->a_buffer=malloc(sh_audio->a_buffer_size);
  75   if(!sh_audio->a_buffer){
  76       mp_msg(MSGT_DECAUDIO,MSGL_ERR,MSGTR_CantAllocAudioBuf);
  77       return 0;
  78   }
  79   memset(sh_audio->a_buffer,0,sh_audio->a_buffer_size);
  80   sh_audio->a_buffer_len=0;
  81
  82   if(!mpadec->init(sh_audio)){
  83       mp_msg(MSGT_DECAUDIO,MSGL_WARN,MSGTR_ADecoderInitFailed);
  84       uninit_audio(sh_audio); // free buffers
  85       return 0;
  86   }
  87
  88   sh_audio->inited=1;
  89
  90   if(!sh_audio->channels || !sh_audio->samplerate){
  91     mp_msg(MSGT_DECAUDIO,MSGL_WARN,MSGTR_UnknownAudio);
  92     uninit_audio(sh_audio); // free buffers
  93     return 0;
  94   }
  95
  96   if(!sh_audio->o_bps)
  97   sh_audio->o_bps=sh_audio->channels*sh_audio->samplerate*sh_audio->samplesize;
  98
  99   mp_msg(MSGT_DECAUDIO,MSGL_INFO,"AUDIO: %d Hz, %d ch, %d bit (0x%X), ratio: %d->%d (%3.1f kbit)\n",
 100         sh_audio->samplerate,sh_audio->channels,
 101         sh_audio->samplesize*8,sh_audio->sample_format,
 102         sh_audio->i_bps,sh_audio->o_bps,sh_audio->i_bps*8*0.001);
 103
 104   sh_audio->a_out_buffer_size=sh_audio->a_buffer_size;
 105   sh_audio->a_out_buffer=sh_audio->a_buffer;
 106   sh_audio->a_out_buffer_len=sh_audio->a_buffer_len;
 107
 108   return 1;
 109 }
 110
 111 int init_audio(sh_audio_t *sh_audio,char* codecname,char* afm,int status){
 112     unsigned int orig_fourcc=sh_audio->wf?sh_audio->wf->wFormatTag:0;
 113     sh_audio->codec=NULL;
 114     while(1){
 115         int i;
 116         // restore original fourcc:
 117         if(sh_audio->wf) sh_audio->wf->wFormatTag=i=orig_fourcc;
 118         if(!(sh_audio->codec=find_codec(sh_audio->format,
 119           sh_audio->wf?(&i):NULL, sh_audio->codec,1) )) break;
 120         if(sh_audio->wf) sh_audio->wf->wFormatTag=i;
 121         // ok we found one codec
 122         if(sh_audio->codec->flags&CODECS_FLAG_SELECTED) continue; // already tried & failed
 123         if(codecname && strcmp(sh_audio->codec->name,codecname)) continue; // -ac
 124         if(afm && strcmp(sh_audio->codec->drv,afm)) continue; // afm doesn't match
 125         if(sh_audio->codec->status<status) continue; // too unstable
 126         sh_audio->codec->flags|=CODECS_FLAG_SELECTED; // tagging it
 127         // ok, it matches all rules, let's find the driver!
 128         for (i=0; mpcodecs_ad_drivers[i] != NULL; i++)
 129             if(!strcmp(mpcodecs_ad_drivers[i]->info->short_name,sh_audio->codec->drv)) break;
 130         mpadec=mpcodecs_ad_drivers[i];
 131 #ifdef DYNAMIC_PLUGINS
 132         if (!mpadec)
 133         {
 134             /* try to open shared decoder plugin */
 135             int buf_len;
 136             char *buf;
 137             ad_functions_t *funcs_sym;
 138             ad_info_t *info_sym;
 139
 140             buf_len = strlen(MPLAYER_LIBDIR)+strlen(sh_audio->codec->drv)+16;
 141             buf = malloc(buf_len);
 142             if (!buf)
 143                 break;
 144             snprintf(buf, buf_len, "%s/mplayer/ad_%s.so", MPLAYER_LIBDIR, sh_audio->codec->drv);
 145             mp_msg(MSGT_DECAUDIO, MSGL_DBG2, "Trying to open external plugin: %s\n", buf);
 146             sh_audio->dec_handle = dlopen(buf, RTLD_LAZY);
 147             if (!sh_audio->dec_handle)
 148                 break;
 149             snprintf(buf, buf_len, "mpcodecs_ad_%s", sh_audio->codec->drv);
 150             funcs_sym = dlsym(sh_audio->dec_handle, buf);
 151             if (!funcs_sym || !funcs_sym->info || !funcs_sym->preinit ||
 152                 !funcs_sym->init || !funcs_sym->uninit || !funcs_sym->control ||
 153                 !funcs_sym->decode_audio)
 154                 break;
 155             info_sym = funcs_sym->info;
 156             if (strcmp(info_sym->short_name, sh_audio->codec->drv))
 157                 break;
 158             free(buf);
 159             mpadec = funcs_sym;
 160             mp_msg(MSGT_DECAUDIO, MSGL_V, "Using external decoder plugin (%s/mplayer/ad_%s.so)!\n",
 161                 MPLAYER_LIBDIR, sh_audio->codec->drv);
 162         }
 163 #endif
 164         if(!mpadec){ // driver not available (==compiled in)
 165             mp_msg(MSGT_DECAUDIO,MSGL_ERR,MSGTR_AudioCodecFamilyNotAvailableStr,
 166                 sh_audio->codec->name, sh_audio->codec->drv);
 167             continue;
 168         }
 169         // it's available, let's try to init!
 170         // init()
 171         mp_msg(MSGT_DECAUDIO,MSGL_INFO,MSGTR_OpeningAudioDecoder,mpadec->info->short_name,mpadec->info->name);
 172         if(!init_audio_codec(sh_audio)){
 173             mp_msg(MSGT_DECAUDIO,MSGL_INFO,MSGTR_ADecoderInitFailed);
 174             continue; // try next...
 175         }
 176         // Yeah! We got it!
 177         return 1;
 178     }
 179     return 0;
 180 }
 181
 182 extern char *get_path(char *filename);
 183
 184 int init_best_audio_codec(sh_audio_t *sh_audio,char** audio_codec_list,char** audio_fm_list){
 185 char* ac_l_default[2]={"",(char*)NULL};
 186 // hack:
 187 if(!audio_codec_list) audio_codec_list=ac_l_default;
 188 // Go through the codec.conf and find the best codec...
 189 sh_audio->inited=0;
 190 codecs_reset_selection(1);
 191 while(!sh_audio->inited && *audio_codec_list){
 192   char* audio_codec=*(audio_codec_list++);
 193   if(audio_codec[0]){
 194     if(audio_codec[0]=='-'){
 195       // disable this codec:
 196       select_codec(audio_codec+1,1);
 197     } else {
 198       // forced codec by name:
 199       mp_msg(MSGT_DECAUDIO,MSGL_INFO,MSGTR_ForcedAudioCodec,audio_codec);
 200       init_audio(sh_audio,audio_codec,NULL,-1);
 201     }
 202   } else {
 203     int status;
 204     // try in stability order: UNTESTED, WORKING, BUGGY. never try CRASHING.
 205     if(audio_fm_list){
 206       char** fmlist=audio_fm_list;
 207       // try first the preferred codec families:
 208       while(!sh_audio->inited && *fmlist){
 209         char* audio_fm=*(fmlist++);
 210         mp_msg(MSGT_DECAUDIO,MSGL_INFO,MSGTR_TryForceAudioFmtStr,audio_fm);
 211         for(status=CODECS_STATUS__MAX;status>=CODECS_STATUS__MIN;--status)
 212             if(init_audio(sh_audio,NULL,audio_fm,status)) break;
 213       }
 214     }
 215     if(!sh_audio->inited)
 216         for(status=CODECS_STATUS__MAX;status>=CODECS_STATUS__MIN;--status)
 217             if(init_audio(sh_audio,NULL,NULL,status)) break;
 218   }
 219 }
 220
 221 if(!sh_audio->inited){
 222     mp_msg(MSGT_DECAUDIO,MSGL_ERR,MSGTR_CantFindAudioCodec,sh_audio->format);
 223     mp_msg(MSGT_DECAUDIO,MSGL_HINT, MSGTR_RTFMCodecs);
 224     return 0; // failed
 225 }
 226
 227 mp_msg(MSGT_DECAUDIO,MSGL_INFO,"Selected audio codec: [%s] afm:%s (%s)\n",
 228     sh_audio->codec->name,sh_audio->codec->drv,sh_audio->codec->info);
 229 return 1; // success
 230 }
 231
 232 void uninit_audio(sh_audio_t *sh_audio)
 233 {
 234     if(sh_audio->afilter){
 235         mp_msg(MSGT_DECAUDIO,MSGL_V,"Uninit audio filters...\n");
 236         af_uninit(sh_audio->afilter);
 237         free(sh_audio->afilter);
 238         sh_audio->afilter=NULL;
 239     }
 240     if(sh_audio->inited){
 241         mp_msg(MSGT_DECAUDIO,MSGL_V,MSGTR_UninitAudioStr,sh_audio->codec->drv);
 242         mpadec->uninit(sh_audio);
 243 #ifdef DYNAMIC_PLUGINS
 244         if (sh_audio->dec_handle)
 245             dlclose(sh_audio->dec_handle);
 246 #endif
 247         sh_audio->inited=0;
 248     }
 249     if(sh_audio->a_out_buffer!=sh_audio->a_buffer) free(sh_audio->a_out_buffer);
 250     sh_audio->a_out_buffer=NULL;
 251     if(sh_audio->a_buffer) free(sh_audio->a_buffer);
 252     sh_audio->a_buffer=NULL;
 253     if(sh_audio->a_in_buffer) free(sh_audio->a_in_buffer);
 254     sh_audio->a_in_buffer=NULL;
 255 }
 256
 257  /* Init audio filters */
 258 int preinit_audio_filters(sh_audio_t *sh_audio,
 259         int in_samplerate, int in_channels, int in_format, int in_bps,
 260         int* out_samplerate, int* out_channels, int* out_format, int out_bps){
 261   char strbuf[200];
 262   af_stream_t* afs=malloc(sizeof(af_stream_t));
 263   memset(afs,0,sizeof(af_stream_t));
 264
 265   // input format: same as codec's output format:
 266   afs->input.rate   = in_samplerate;
 267   afs->input.nch    = in_channels;
 268   afs->input.format = af_format_decode(in_format);
 269   afs->input.bps    = in_bps;
 270
 271   // output format: same as ao driver's input format (if missing, fallback to input)
 272   afs->output.rate   = *out_samplerate ? *out_samplerate : afs->input.rate;
 273   afs->output.nch    = *out_channels ? *out_channels : afs->input.nch;
 274   afs->output.format = *out_format ? af_format_decode(*out_format) : afs->input.format;
 275   afs->output.bps    = out_bps ? out_bps : afs->input.bps;
 276
 277   // filter config:
 278   memcpy(&afs->cfg,&af_cfg,sizeof(af_cfg_t));
 279
 280   mp_msg(MSGT_DECAUDIO, MSGL_INFO, "Checking audio filter chain for %dHz/%dch/%dbit -> %dHz/%dch/%dbit...\n",
 281       afs->input.rate,afs->input.nch,afs->input.bps*8,
 282       afs->output.rate,afs->output.nch,afs->output.bps*8);
 283
 284   // let's autoprobe it!
 285   if(0 != af_init(afs,0)){
 286     free(afs);
 287     return 0; // failed :(
 288   }
 289
 290   *out_samplerate=afs->output.rate;
 291   *out_channels=afs->output.nch;
 292   *out_format=af_format_encode((void*)(&afs->output));
 293
 294   mp_msg(MSGT_DECAUDIO, MSGL_INFO, "AF_pre: af format: %d bps, %d ch, %d hz, %s\n",
 295       afs->output.bps, afs->output.nch, afs->output.rate,
 296       fmt2str(afs->output.format,strbuf,200));
 297
 298   sh_audio->afilter=(void*)afs;
 299   return 1;
 300 }
 301
 302  /* Init audio filters */
 303 int init_audio_filters(sh_audio_t *sh_audio,
 304         int in_samplerate, int in_channels, int in_format, int in_bps,
 305         int out_samplerate, int out_channels, int out_format, int out_bps,
 306         int out_minsize, int out_maxsize){
 307   af_stream_t* afs=sh_audio->afilter;
 308   if(!afs){
 309     afs = (af_stream_t*)malloc(sizeof(af_stream_t));
 310     memset(afs,0,sizeof(af_stream_t));
 311   }
 312
 313   // input format: same as codec's output format:
 314   afs->input.rate   = in_samplerate;
 315   afs->input.nch    = in_channels;
 316   afs->input.format = af_format_decode(in_format);
 317   afs->input.bps    = in_bps;
 318
 319   // output format: same as ao driver's input format (if missing, fallback to input)
 320   afs->output.rate   = out_samplerate ? out_samplerate : afs->input.rate;
 321   afs->output.nch    = out_channels ? out_channels : afs->input.nch;
 322   afs->output.format = af_format_decode(out_format ? out_format : afs->input.format);
 323   afs->output.bps    = out_bps ? out_bps : afs->input.bps;
 324
 325   // filter config:
 326   memcpy(&afs->cfg,&af_cfg,sizeof(af_cfg_t));
 327
 328   mp_msg(MSGT_DECAUDIO, MSGL_INFO, "Building audio filter chain for %dHz/%dch/%dbit -> %dHz/%dch/%dbit...\n",
 329       afs->input.rate,afs->input.nch,afs->input.bps*8,
 330       afs->output.rate,afs->output.nch,afs->output.bps*8);
 331
 332   // let's autoprobe it!
 333   if(0 != af_init(afs,1)){
 334     sh_audio->afilter=NULL;
 335     free(afs);
 336     return 0; // failed :(
 337   }
 338
 339   // allocate the a_out_* buffers:
 340   if(out_maxsize<out_minsize) out_maxsize=out_minsize;
 341   if(out_maxsize<8192) out_maxsize=MAX_OUTBURST; // not sure this is ok
 342
 343   sh_audio->a_out_buffer_size=out_maxsize;
 344   sh_audio->a_out_buffer=malloc(sh_audio->a_out_buffer_size);
 345   memset(sh_audio->a_out_buffer,0,sh_audio->a_out_buffer_size);
 346   sh_audio->a_out_buffer_len=0;
 347
 348   // ok!
 349   sh_audio->afilter=(void*)afs;
 350   return 1;
 351 }
 352
 353 int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
 354 {
 355   int declen;
 356   af_data_t  afd;  // filter input
 357   af_data_t* pafd; // filter output
 358
 359   if(!sh_audio->inited) return -1; // no codec
 360   if(!sh_audio->afilter){
 361       // no filter, just decode:
 362       // FIXME: don't drop initial decoded data in a_buffer!
 363       return mpadec->decode_audio(sh_audio,buf,minlen,maxlen);
 364   }
 365
 366 //  declen=af_inputlen(sh_audio->afilter,minlen);
 367   declen=af_calc_insize_constrained(sh_audio->afilter,minlen,maxlen,
 368       sh_audio->a_buffer_size-sh_audio->audio_out_minsize);
 369
 370   mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"\ndecaudio: minlen=%d maxlen=%d declen=%d (max=%d)\n",
 371       minlen, maxlen, declen, sh_audio->a_buffer_size);
 372
 373   if(declen<=0) return -1; // error!
 374
 375   // limit declen to buffer size: - DONE by af_calc_insize_constrained
 376 //  if(declen>sh_audio->a_buffer_size) declen=sh_audio->a_buffer_size;
 377
 378   // decode if needed:
 379   while(declen>sh_audio->a_buffer_len){
 380       int len=declen-sh_audio->a_buffer_len;
 381       int maxlen=sh_audio->a_buffer_size-sh_audio->a_buffer_len;
 382
 383       mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"decaudio: decoding %d bytes, max: %d (%d)\n",
 384         len, maxlen, sh_audio->audio_out_minsize);
 385
 386       if(maxlen<sh_audio->audio_out_minsize) break; // don't overflow buffer!
 387       // not enough decoded data waiting, decode 'len' bytes more:
 388       len=mpadec->decode_audio(sh_audio,
 389           sh_audio->a_buffer+sh_audio->a_buffer_len, len, maxlen);
 390       if(len<=0) break; // EOF?
 391       sh_audio->a_buffer_len+=len;
 392   }
 393   if(declen>sh_audio->a_buffer_len)
 394     declen=sh_audio->a_buffer_len; // still no enough data (EOF) :(
 395
 396   // round to whole samples:
 397 //  declen/=sh_audio->samplesize*sh_audio->channels;
 398 //  declen*=sh_audio->samplesize*sh_audio->channels;
 399
 400   // run the filters:
 401   afd.audio=sh_audio->a_buffer;
 402   afd.len=declen;
 403   afd.rate=sh_audio->samplerate;
 404   afd.nch=sh_audio->channels;
 405   afd.format=af_format_decode(sh_audio->sample_format);
 406   afd.bps=sh_audio->samplesize;
 407   //pafd=&afd;
 408 //  printf("\nAF: %d --> ",declen);
 409   pafd=af_play(sh_audio->afilter,&afd);
 410 //  printf("%d  \n",pafd->len);
 411
 412   if(!pafd) return -1; // error
 413
 414   mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"decaudio: declen=%d out=%d (max %d)\n",
 415       declen, pafd->len, maxlen);
 416
 417   // copy filter==>out:
 418   if(maxlen < pafd->len) {
 419     maxlen -= maxlen % (sh_audio->channels * sh_audio->samplesize);
 420     mp_msg(MSGT_DECAUDIO,MSGL_WARN,"%i bytes of audio data lost due to buffer overflow, len = %i\n", pafd->len - maxlen,pafd->len);
 421   }
 422   else
 423     maxlen=pafd->len;
 424   memmove(buf, pafd->audio, maxlen);
 425
 426   // remove processed data from decoder buffer:
 427   sh_audio->a_buffer_len-=declen;
 428   if(sh_audio->a_buffer_len>0)
 429     memmove(sh_audio->a_buffer, sh_audio->a_buffer+declen, sh_audio->a_buffer_len);
 430
 431   return maxlen;
 432 }
 433
 434 void resync_audio_stream(sh_audio_t *sh_audio)
 435 {
 436   sh_audio->a_in_buffer_len=0;        // clear audio input buffer
 437   if(!sh_audio->inited) return;
 438   mpadec->control(sh_audio,ADCTRL_RESYNC_STREAM,NULL);
 439 }
 440
 441 void skip_audio_frame(sh_audio_t *sh_audio)
 442 {
 443   if(!sh_audio->inited) return;
 444   if(mpadec->control(sh_audio,ADCTRL_SKIP_FRAME,NULL)==CONTROL_TRUE) return;
 445   // default skip code:
 446   ds_fill_buffer(sh_audio->ds);  // skip block
 447 }