libaf/af.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 "config.h"
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include "af.h"
  25
  26 // Static list of filters
  27 extern af_info_t af_info_dummy;
  28 extern af_info_t af_info_delay;
  29 extern af_info_t af_info_channels;
  30 extern af_info_t af_info_format;
  31 extern af_info_t af_info_resample;
  32 extern af_info_t af_info_volume;
  33 extern af_info_t af_info_equalizer;
  34 extern af_info_t af_info_gate;
  35 extern af_info_t af_info_comp;
  36 extern af_info_t af_info_pan;
  37 extern af_info_t af_info_surround;
  38 extern af_info_t af_info_sub;
  39 extern af_info_t af_info_export;
  40 extern af_info_t af_info_volnorm;
  41 extern af_info_t af_info_extrastereo;
  42 extern af_info_t af_info_lavcac3enc;
  43 extern af_info_t af_info_lavcresample;
  44 extern af_info_t af_info_sweep;
  45 extern af_info_t af_info_hrtf;
  46 extern af_info_t af_info_ladspa;
  47 extern af_info_t af_info_center;
  48 extern af_info_t af_info_sinesuppress;
  49 extern af_info_t af_info_karaoke;
  50 extern af_info_t af_info_scaletempo;
  51 extern af_info_t af_info_stats;
  52 extern af_info_t af_info_bs2b;
  53
  54 static af_info_t* filter_list[]={
  55    &af_info_dummy,
  56    &af_info_delay,
  57    &af_info_channels,
  58    &af_info_format,
  59    &af_info_resample,
  60    &af_info_volume,
  61    &af_info_equalizer,
  62    &af_info_gate,
  63    &af_info_comp,
  64    &af_info_pan,
  65    &af_info_surround,
  66    &af_info_sub,
  67 #ifdef HAVE_SYS_MMAN_H
  68    &af_info_export,
  69 #endif
  70    &af_info_volnorm,
  71    &af_info_extrastereo,
  72 #ifdef CONFIG_LIBAVCODEC_A
  73    &af_info_lavcac3enc,
  74 #endif
  75 #ifdef CONFIG_LIBAVCODEC
  76    &af_info_lavcresample,
  77 #endif
  78    &af_info_sweep,
  79    &af_info_hrtf,
  80 #ifdef CONFIG_LADSPA
  81    &af_info_ladspa,
  82 #endif
  83    &af_info_center,
  84    &af_info_sinesuppress,
  85    &af_info_karaoke,
  86    &af_info_scaletempo,
  87    &af_info_stats,
  88 #ifdef CONFIG_LIBBS2B
  89    &af_info_bs2b,
  90 #endif
  91    NULL
  92 };
  93
  94 // CPU speed
  95 int* af_cpu_speed = NULL;
  96
  97 /* Find a filter in the static list of filters using it's name. This
  98    function is used internally */
  99 static af_info_t* af_find(char*name)
 100 {
 101   int i=0;
 102   while(filter_list[i]){
 103     if(!strcmp(filter_list[i]->name,name))
 104       return filter_list[i];
 105     i++;
 106   }
 107   mp_msg(MSGT_AFILTER, MSGL_ERR, "Couldn't find audio filter '%s'\n",name);
 108   return NULL;
 109 }
 110
 111 /* Find filter in the dynamic filter list using it's name This
 112    function is used for finding already initialized filters */
 113 af_instance_t* af_get(af_stream_t* s, char* name)
 114 {
 115   af_instance_t* af=s->first;
 116   // Find the filter
 117   while(af != NULL){
 118     if(!strcmp(af->info->name,name))
 119       return af;
 120     af=af->next;
 121   }
 122   return NULL;
 123 }
 124
 125 /*/ Function for creating a new filter of type name. The name may
 126   contain the commandline parameters for the filter */
 127 static af_instance_t* af_create(af_stream_t* s, const char* name_with_cmd)
 128 {
 129   char* name = strdup(name_with_cmd);
 130   char* cmdline = name;
 131
 132   // Allocate space for the new filter and reset all pointers
 133   af_instance_t* new=malloc(sizeof(af_instance_t));
 134   if (!name || !new) {
 135     mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Could not allocate memory\n");
 136     goto err_out;
 137   }
 138   memset(new,0,sizeof(af_instance_t));
 139
 140   // Check for commandline parameters
 141   strsep(&cmdline, "=");
 142
 143   // Find filter from name
 144   if(NULL == (new->info=af_find(name)))
 145     goto err_out;
 146
 147   /* Make sure that the filter is not already in the list if it is
 148      non-reentrant */
 149   if(new->info->flags & AF_FLAGS_NOT_REENTRANT){
 150     if(af_get(s,name)){
 151       mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] There can only be one instance of"
 152              " the filter '%s' in each stream\n",name);
 153       goto err_out;
 154     }
 155   }
 156
 157   mp_msg(MSGT_AFILTER, MSGL_V, "[libaf] Adding filter %s \n",name);
 158
 159   // Initialize the new filter
 160   if(AF_OK == new->info->open(new) &&
 161      AF_ERROR < new->control(new,AF_CONTROL_POST_CREATE,&s->cfg)){
 162     if(cmdline){
 163       if(AF_ERROR>=new->control(new,AF_CONTROL_COMMAND_LINE,cmdline))
 164         goto err_out;
 165     }
 166     free(name);
 167     return new;
 168   }
 169
 170 err_out:
 171   free(new);
 172   mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Couldn't create or open audio filter '%s'\n",
 173          name);
 174   free(name);
 175   return NULL;
 176 }
 177
 178 /* Create and insert a new filter of type name before the filter in the
 179    argument. This function can be called during runtime, the return
 180    value is the new filter */
 181 static af_instance_t* af_prepend(af_stream_t* s, af_instance_t* af, char* name)
 182 {
 183   // Create the new filter and make sure it is OK
 184   af_instance_t* new=af_create(s,name);
 185   if(!new)
 186     return NULL;
 187   // Update pointers
 188   new->next=af;
 189   if(af){
 190     new->prev=af->prev;
 191     af->prev=new;
 192   }
 193   else
 194     s->last=new;
 195   if(new->prev)
 196     new->prev->next=new;
 197   else
 198     s->first=new;
 199   return new;
 200 }
 201
 202 /* Create and insert a new filter of type name after the filter in the
 203    argument. This function can be called during runtime, the return
 204    value is the new filter */
 205 static af_instance_t* af_append(af_stream_t* s, af_instance_t* af, char* name)
 206 {
 207   // Create the new filter and make sure it is OK
 208   af_instance_t* new=af_create(s,name);
 209   if(!new)
 210     return NULL;
 211   // Update pointers
 212   new->prev=af;
 213   if(af){
 214     new->next=af->next;
 215     af->next=new;
 216   }
 217   else
 218     s->first=new;
 219   if(new->next)
 220     new->next->prev=new;
 221   else
 222     s->last=new;
 223   return new;
 224 }
 225
 226 // Uninit and remove the filter "af"
 227 void af_remove(af_stream_t* s, af_instance_t* af)
 228 {
 229   if(!af) return;
 230
 231   // Print friendly message
 232   mp_msg(MSGT_AFILTER, MSGL_V, "[libaf] Removing filter %s \n",af->info->name);
 233
 234   // Notify filter before changing anything
 235   af->control(af,AF_CONTROL_PRE_DESTROY,0);
 236
 237   // Detach pointers
 238   if(af->prev)
 239     af->prev->next=af->next;
 240   else
 241     s->first=af->next;
 242   if(af->next)
 243     af->next->prev=af->prev;
 244   else
 245     s->last=af->prev;
 246
 247   // Uninitialize af and free memory
 248   af->uninit(af);
 249   free(af);
 250 }
 251
 252 /* Reinitializes all filters downstream from the filter given in the
 253    argument the return value is AF_OK if success and AF_ERROR if
 254    failure */
 255 static int af_reinit(af_stream_t* s, af_instance_t* af)
 256 {
 257   do{
 258     af_data_t in; // Format of the input to current filter
 259     int rv=0; // Return value
 260
 261     // Check if there are any filters left in the list
 262     if(NULL == af){
 263       if(!(af=af_append(s,s->first,"dummy")))
 264         return AF_UNKNOWN;
 265       else
 266         return AF_ERROR;
 267     }
 268
 269     // Check if this is the first filter
 270     if(!af->prev)
 271       memcpy(&in,&(s->input),sizeof(af_data_t));
 272     else
 273       memcpy(&in,af->prev->data,sizeof(af_data_t));
 274     // Reset just in case...
 275     in.audio=NULL;
 276     in.len=0;
 277
 278     rv = af->control(af,AF_CONTROL_REINIT,&in);
 279     switch(rv){
 280     case AF_OK:
 281         af = af->next;
 282       break;
 283     case AF_FALSE:{ // Configuration filter is needed
 284       // Do auto insertion only if force is not specified
 285       if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){
 286         af_instance_t* new = NULL;
 287         // Insert channels filter
 288         if((af->prev?af->prev->data->nch:s->input.nch) != in.nch){
 289           // Create channels filter
 290           if(NULL == (new = af_prepend(s,af,"channels")))
 291             return AF_ERROR;
 292           // Set number of output channels
 293           if(AF_OK != (rv = new->control(new,AF_CONTROL_CHANNELS,&in.nch)))
 294             return rv;
 295           // Initialize channels filter
 296           if(!new->prev)
 297             memcpy(&in,&(s->input),sizeof(af_data_t));
 298           else
 299             memcpy(&in,new->prev->data,sizeof(af_data_t));
 300           if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in)))
 301             return rv;
 302         }
 303         // Insert format filter
 304         if((af->prev?af->prev->data->format:s->input.format) != in.format){
 305           // Create format filter
 306           if(NULL == (new = af_prepend(s,af,"format")))
 307             return AF_ERROR;
 308           // Set output bits per sample
 309           in.format |= af_bits2fmt(in.bps*8);
 310           if(AF_OK != (rv = new->control(new,AF_CONTROL_FORMAT_FMT,&in.format)))
 311             return rv;
 312           // Initialize format filter
 313           if(!new->prev)
 314             memcpy(&in,&(s->input),sizeof(af_data_t));
 315           else
 316             memcpy(&in,new->prev->data,sizeof(af_data_t));
 317           if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in)))
 318             return rv;
 319         }
 320         if(!new){ // Should _never_ happen
 321           mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Unable to correct audio format. "
 322                  "This error should never uccur, please send bugreport.\n");
 323           return AF_ERROR;
 324         }
 325         af=new->next;
 326       }
 327       else {
 328         mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Automatic filter insertion disabled "
 329                "but formats do not match. Giving up.\n");
 330         return AF_ERROR;
 331       }
 332       break;
 333     }
 334     case AF_DETACH:{ // Filter is redundant and wants to be unloaded
 335       // Do auto remove only if force is not specified
 336       if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){
 337         af_instance_t* aft=af->prev;
 338         af_remove(s,af);
 339         if(aft)
 340           af=aft->next;
 341         else
 342           af=s->first; // Restart configuration
 343       }
 344       break;
 345     }
 346     default:
 347       mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Reinitialization did not work, audio"
 348              " filter '%s' returned error code %i\n",af->info->name,rv);
 349       return AF_ERROR;
 350     }
 351   }while(af);
 352   return AF_OK;
 353 }
 354
 355 // Uninit and remove all filters
 356 void af_uninit(af_stream_t* s)
 357 {
 358   while(s->first)
 359     af_remove(s,s->first);
 360 }
 361
 362 /* Initialize the stream "s". This function creates a new filter list
 363    if necessary according to the values set in input and output. Input
 364    and output should contain the format of the current movie and the
 365    formate of the preferred output respectively. The function is
 366    reentrant i.e. if called with an already initialized stream the
 367    stream will be reinitialized.
 368    If one of the prefered output parameters is 0 the one that needs
 369    no conversion is used (i.e. the output format in the last filter).
 370    The return value is 0 if success and -1 if failure */
 371 int af_init(af_stream_t* s)
 372 {
 373   int i=0;
 374
 375   // Sanity check
 376   if(!s) return -1;
 377
 378   // Precaution in case caller is misbehaving
 379   s->input.audio  = s->output.audio  = NULL;
 380   s->input.len    = s->output.len    = 0;
 381
 382   // Figure out how fast the machine is
 383   if(AF_INIT_AUTO == (AF_INIT_TYPE_MASK & s->cfg.force))
 384     s->cfg.force = (s->cfg.force & ~AF_INIT_TYPE_MASK) | AF_INIT_TYPE;
 385
 386   // Check if this is the first call
 387   if(!s->first){
 388     // Add all filters in the list (if there are any)
 389     if(!s->cfg.list){      // To make automatic format conversion work
 390       if(!af_append(s,s->first,"dummy"))
 391         return -1;
 392     }
 393     else{
 394       while(s->cfg.list[i]){
 395         if(!af_append(s,s->last,s->cfg.list[i++]))
 396           return -1;
 397       }
 398     }
 399   }
 400
 401   // Init filters
 402   if(AF_OK != af_reinit(s,s->first))
 403     return -1;
 404
 405   // make sure the chain is not empty and valid (e.g. because of AF_DETACH)
 406   if (!s->first)
 407     if (!af_append(s,s->first,"dummy") || AF_OK != af_reinit(s,s->first))
 408       return -1;
 409
 410   // Check output format
 411   if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){
 412     af_instance_t* af = NULL; // New filter
 413     // Check output frequency if not OK fix with resample
 414     if(s->output.rate && s->last->data->rate!=s->output.rate){
 415       // try to find a filter that can change samplrate
 416       af = af_control_any_rev(s, AF_CONTROL_RESAMPLE_RATE | AF_CONTROL_SET,
 417                &(s->output.rate));
 418       if (!af) {
 419         char *resampler = "resample";
 420 #ifdef CONFIG_LIBAVCODEC
 421         if ((AF_INIT_TYPE_MASK & s->cfg.force) == AF_INIT_SLOW)
 422           resampler = "lavcresample";
 423 #endif
 424         if((AF_INIT_TYPE_MASK & s->cfg.force) == AF_INIT_SLOW){
 425           if(!strcmp(s->first->info->name,"format"))
 426             af = af_append(s,s->first,resampler);
 427           else
 428             af = af_prepend(s,s->first,resampler);
 429         }
 430         else{
 431           if(!strcmp(s->last->info->name,"format"))
 432             af = af_prepend(s,s->last,resampler);
 433           else
 434             af = af_append(s,s->last,resampler);
 435         }
 436       // Init the new filter
 437       if(!af || (AF_OK != af->control(af,AF_CONTROL_RESAMPLE_RATE | AF_CONTROL_SET,
 438                                       &(s->output.rate))))
 439         return -1;
 440       // Use lin int if the user wants fast
 441       if ((AF_INIT_TYPE_MASK & s->cfg.force) == AF_INIT_FAST) {
 442         char args[32];
 443         sprintf(args, "%d", s->output.rate);
 444 #ifdef CONFIG_LIBAVCODEC
 445         if (strcmp(resampler, "lavcresample") == 0)
 446           strcat(args, ":1");
 447         else
 448 #endif
 449         strcat(args, ":0:0");
 450         af->control(af, AF_CONTROL_COMMAND_LINE, args);
 451       }
 452       }
 453       if(AF_OK != af_reinit(s,af))
 454         return -1;
 455     }
 456
 457     // Check number of output channels fix if not OK
 458     // If needed always inserted last -> easy to screw up other filters
 459     if(s->output.nch && s->last->data->nch!=s->output.nch){
 460       if(!strcmp(s->last->info->name,"format"))
 461         af = af_prepend(s,s->last,"channels");
 462       else
 463         af = af_append(s,s->last,"channels");
 464       // Init the new filter
 465       if(!af || (AF_OK != af->control(af,AF_CONTROL_CHANNELS,&(s->output.nch))))
 466         return -1;
 467       if(AF_OK != af_reinit(s,af))
 468         return -1;
 469     }
 470
 471     // Check output format fix if not OK
 472     if(s->output.format != AF_FORMAT_UNKNOWN &&
 473                 s->last->data->format != s->output.format){
 474       if(strcmp(s->last->info->name,"format"))
 475         af = af_append(s,s->last,"format");
 476       else
 477         af = s->last;
 478       // Init the new filter
 479       s->output.format |= af_bits2fmt(s->output.bps*8);
 480       if(!af || (AF_OK != af->control(af,AF_CONTROL_FORMAT_FMT,&(s->output.format))))
 481         return -1;
 482       if(AF_OK != af_reinit(s,af))
 483         return -1;
 484     }
 485
 486     // Re init again just in case
 487     if(AF_OK != af_reinit(s,s->first))
 488       return -1;
 489
 490     if (s->output.format == AF_FORMAT_UNKNOWN)
 491         s->output.format = s->last->data->format;
 492     if (!s->output.nch) s->output.nch = s->last->data->nch;
 493     if (!s->output.rate) s->output.rate = s->last->data->rate;
 494     if((s->last->data->format != s->output.format) ||
 495        (s->last->data->nch    != s->output.nch)    ||
 496        (s->last->data->rate   != s->output.rate))  {
 497       // Something is stuffed audio out will not work
 498       mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Unable to setup filter system can not"
 499              " meet sound-card demands, please send bugreport. \n");
 500       af_uninit(s);
 501       return -1;
 502     }
 503   }
 504   return 0;
 505 }
 506
 507 /* Add filter during execution. This function adds the filter "name"
 508    to the stream s. The filter will be inserted somewhere nice in the
 509    list of filters. The return value is a pointer to the new filter,
 510    If the filter couldn't be added the return value is NULL. */
 511 af_instance_t* af_add(af_stream_t* s, char* name){
 512   af_instance_t* new;
 513   // Sanity check
 514   if(!s || !s->first || !name)
 515     return NULL;
 516   // Insert the filter somwhere nice
 517   if(!strcmp(s->first->info->name,"format"))
 518     new = af_append(s, s->first, name);
 519   else
 520     new = af_prepend(s, s->first, name);
 521   if(!new)
 522     return NULL;
 523
 524   // Reinitalize the filter list
 525   if(AF_OK != af_reinit(s, s->first)){
 526     free(new);
 527     return NULL;
 528   }
 529   return new;
 530 }
 531
 532 // Filter data chunk through the filters in the list
 533 af_data_t* af_play(af_stream_t* s, af_data_t* data)
 534 {
 535   af_instance_t* af=s->first;
 536   // Iterate through all filters
 537   do{
 538     if (data->len <= 0) break;
 539     data=af->play(af,data);
 540     af=af->next;
 541   }while(af && data);
 542   return data;
 543 }
 544
 545 /* Calculate the minimum output buffer size for given input data d
 546  * when using the RESIZE_LOCAL_BUFFER macro. The +t+1 part ensures the
 547  * value is >= len*mul rounded upwards to whole samples even if the
 548  * double 'mul' is inexact. */
 549 int af_lencalc(double mul, af_data_t* d)
 550 {
 551   int t = d->bps * d->nch;
 552   return d->len * mul + t + 1;
 553 }
 554
 555 // Calculate average ratio of filter output size to input size
 556 double af_calc_filter_multiplier(af_stream_t* s)
 557 {
 558   af_instance_t* af=s->first;
 559   double mul = 1;
 560   // Iterate through all filters and calculate total multiplication factor
 561   do{
 562       mul *= af->mul;
 563       af=af->next;
 564   }while(af);
 565
 566   return mul;
 567 }
 568
 569 /* Calculate the total delay [bytes output] caused by the filters */
 570 double af_calc_delay(af_stream_t* s)
 571 {
 572   af_instance_t* af=s->first;
 573   register double delay = 0.0;
 574   // Iterate through all filters
 575   while(af){
 576     delay += af->delay;
 577     delay *= af->mul;
 578     af=af->next;
 579   }
 580   return delay;
 581 }
 582
 583 /* Helper function called by the macro with the same name this
 584    function should not be called directly */
 585 int af_resize_local_buffer(af_instance_t* af, af_data_t* data)
 586 {
 587   // Calculate new length
 588   register int len = af_lencalc(af->mul,data);
 589   mp_msg(MSGT_AFILTER, MSGL_V, "[libaf] Reallocating memory in module %s, "
 590          "old len = %i, new len = %i\n",af->info->name,af->data->len,len);
 591   // If there is a buffer free it
 592   if(af->data->audio)
 593     free(af->data->audio);
 594   // Create new buffer and check that it is OK
 595   af->data->audio = malloc(len);
 596   if(!af->data->audio){
 597     mp_msg(MSGT_AFILTER, MSGL_FATAL, "[libaf] Could not allocate memory \n");
 598     return AF_ERROR;
 599   }
 600   af->data->len=len;
 601   return AF_OK;
 602 }
 603
 604 // documentation in af.h
 605 af_instance_t *af_control_any_rev (af_stream_t* s, int cmd, void* arg) {
 606   int res = AF_UNKNOWN;
 607   af_instance_t* filt = s->last;
 608   while (filt) {
 609     res = filt->control(filt, cmd, arg);
 610     if (res == AF_OK)
 611       return filt;
 612     filt = filt->prev;
 613   }
 614   return NULL;
 615 }
 616
 617 void af_help (void) {
 618   int i = 0;
 619   mp_msg(MSGT_AFILTER, MSGL_INFO, "Available audio filters:\n");
 620   while (filter_list[i]) {
 621     if (filter_list[i]->comment && filter_list[i]->comment[0])
 622       mp_msg(MSGT_AFILTER, MSGL_INFO, "  %-15s: %s (%s)\n", filter_list[i]->name, filter_list[i]->info, filter_list[i]->comment);
 623     else
 624       mp_msg(MSGT_AFILTER, MSGL_INFO, "  %-15s: %s\n", filter_list[i]->name, filter_list[i]->info);
 625     i++;
 626   }
 627 }
 628
 629 void af_fix_parameters(af_data_t *data)
 630 {
 631     data->bps = af_fmt2bits(data->format)/8;
 632 }