libaf/af.c

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