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