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