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