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 int af_reinit(af_stream_t* s, af_instance_t* af)
 252 {
 253   do{
 254     af_data_t in; // Format of the input to current filter
 255     int rv=0; // Return value
 256
 257     // Check if there are any filters left in the list
 258     if(NULL == af){
 259       if(!(af=af_append(s,s->first,"dummy")))
 260         return AF_UNKNOWN;
 261       else
 262         return AF_ERROR;
 263     }
 264
 265     // Check if this is the first filter
 266     if(!af->prev)
 267       memcpy(&in,&(s->input),sizeof(af_data_t));
 268     else
 269       memcpy(&in,af->prev->data,sizeof(af_data_t));
 270     // Reset just in case...
 271     in.audio=NULL;
 272     in.len=0;
 273
 274     rv = af->control(af,AF_CONTROL_REINIT,&in);
 275     switch(rv){
 276     case AF_OK:
 277         af = af->next;
 278       break;
 279     case AF_FALSE:{ // Configuration filter is needed
 280       // Do auto insertion only if force is not specified
 281       if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){
 282         af_instance_t* new = NULL;
 283         // Insert channels filter
 284         if((af->prev?af->prev->data->nch:s->input.nch) != in.nch){
 285           // Create channels filter
 286           if(NULL == (new = af_prepend(s,af,"channels")))
 287             return AF_ERROR;
 288           // Set number of output channels
 289           if(AF_OK != (rv = new->control(new,AF_CONTROL_CHANNELS,&in.nch)))
 290             return rv;
 291           // Initialize channels filter
 292           if(!new->prev)
 293             memcpy(&in,&(s->input),sizeof(af_data_t));
 294           else
 295             memcpy(&in,new->prev->data,sizeof(af_data_t));
 296           if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in)))
 297             return rv;
 298         }
 299         // Insert format filter
 300         if((af->prev?af->prev->data->format:s->input.format) != in.format){
 301           // Create format filter
 302           if(NULL == (new = af_prepend(s,af,"format")))
 303             return AF_ERROR;
 304           // Set output bits per sample
 305           in.format |= af_bits2fmt(in.bps*8);
 306           if(AF_OK != (rv = new->control(new,AF_CONTROL_FORMAT_FMT,&in.format)))
 307             return rv;
 308           // Initialize format filter
 309           if(!new->prev)
 310             memcpy(&in,&(s->input),sizeof(af_data_t));
 311           else
 312             memcpy(&in,new->prev->data,sizeof(af_data_t));
 313           if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in)))
 314             return rv;
 315         }
 316         if(!new){ // Should _never_ happen
 317           mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Unable to correct audio format. "
 318                  "This error should never uccur, please send bugreport.\n");
 319           return AF_ERROR;
 320         }
 321         af=new->next;
 322       }
 323       else {
 324         mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Automatic filter insertion disabled "
 325                "but formats do not match. Giving up.\n");
 326         return AF_ERROR;
 327       }
 328       break;
 329     }
 330     case AF_DETACH:{ // Filter is redundant and wants to be unloaded
 331       // Do auto remove only if force is not specified
 332       if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){
 333         af_instance_t* aft=af->prev;
 334         af_remove(s,af);
 335         if(aft)
 336           af=aft->next;
 337         else
 338           af=s->first; // Restart configuration
 339       }
 340       break;
 341     }
 342     default:
 343       mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Reinitialization did not work, audio"
 344              " filter '%s' returned error code %i\n",af->info->name,rv);
 345       return AF_ERROR;
 346     }
 347   }while(af);
 348   return AF_OK;
 349 }
 350
 351 // Uninit and remove all filters
 352 void af_uninit(af_stream_t* s)
 353 {
 354   while(s->first)
 355     af_remove(s,s->first);
 356 }
 357
 358 /**
 359  * Extend the filter chain so we get the required output format at the end.
 360  * \return AF_ERROR on error, AF_OK if successful.
 361  */
 362 static int fixup_output_format(af_stream_t* s)
 363 {
 364     af_instance_t* af = NULL;
 365     // Check number of output channels fix if not OK
 366     // If needed always inserted last -> easy to screw up other filters
 367     if(s->output.nch && s->last->data->nch!=s->output.nch){
 368       if(!strcmp(s->last->info->name,"format"))
 369         af = af_prepend(s,s->last,"channels");
 370       else
 371         af = af_append(s,s->last,"channels");
 372       // Init the new filter
 373       if(!af || (AF_OK != af->control(af,AF_CONTROL_CHANNELS,&(s->output.nch))))
 374         return AF_ERROR;
 375       if(AF_OK != af_reinit(s,af))
 376         return AF_ERROR;
 377     }
 378
 379     // Check output format fix if not OK
 380     if(s->output.format != AF_FORMAT_UNKNOWN &&
 381                 s->last->data->format != s->output.format){
 382       if(strcmp(s->last->info->name,"format"))
 383         af = af_append(s,s->last,"format");
 384       else
 385         af = s->last;
 386       // Init the new filter
 387       s->output.format |= af_bits2fmt(s->output.bps*8);
 388       if(!af || (AF_OK != af->control(af,AF_CONTROL_FORMAT_FMT,&(s->output.format))))
 389         return AF_ERROR;
 390       if(AF_OK != af_reinit(s,af))
 391         return AF_ERROR;
 392     }
 393
 394     // Re init again just in case
 395     if(AF_OK != af_reinit(s,s->first))
 396       return AF_ERROR;
 397
 398     if (s->output.format == AF_FORMAT_UNKNOWN)
 399         s->output.format = s->last->data->format;
 400     if (!s->output.nch) s->output.nch = s->last->data->nch;
 401     if (!s->output.rate) s->output.rate = s->last->data->rate;
 402     if((s->last->data->format != s->output.format) ||
 403        (s->last->data->nch    != s->output.nch)    ||
 404        (s->last->data->rate   != s->output.rate))  {
 405       return AF_ERROR;
 406     }
 407     return AF_OK;
 408 }
 409
 410 /**
 411  * Automatic downmix to stereo in case the codec does not implement it.
 412  */
 413 static void af_downmix(af_stream_t* s)
 414 {
 415     static const char * const downmix_strs[AF_NCH + 1] = {
 416         /*                FL       FR       RL       RR          FC          LF         AL      AR */
 417         [3] = "pan=2:" "0.6:0:" "0:0.6:"                     "0.4:0.4",
 418         [4] = "pan=2:" "0.6:0:" "0:0.6:" "0.4:0:"  "0:0.4",
 419         [5] = "pan=2:" "0.5:0:" "0:0.5:" "0.2:0:"  "0:0.2:"  "0.3:0.3",
 420         [6] = "pan=2:" "0.4:0:" "0:0.4:" "0.2:0:"  "0:0.2:"  "0.3:0.3:"   "0.1:0.1",
 421         [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",
 422         [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",
 423     };
 424     const char *af_pan_str = downmix_strs[s->input.nch];
 425
 426     if (af_pan_str)
 427         af_append(s, s->first, af_pan_str);
 428 }
 429
 430 /* Initialize the stream "s". This function creates a new filter list
 431    if necessary according to the values set in input and output. Input
 432    and output should contain the format of the current movie and the
 433    formate of the preferred output respectively. The function is
 434    reentrant i.e. if called with an already initialized stream the
 435    stream will be reinitialized.
 436    If one of the prefered output parameters is 0 the one that needs
 437    no conversion is used (i.e. the output format in the last filter).
 438    The return value is 0 if success and -1 if failure */
 439 int af_init(af_stream_t* s)
 440 {
 441     struct MPOpts *opts = s->opts;
 442   int i=0;
 443
 444   // Sanity check
 445   if(!s) return -1;
 446
 447   // Precaution in case caller is misbehaving
 448   s->input.audio  = s->output.audio  = NULL;
 449   s->input.len    = s->output.len    = 0;
 450
 451   // Figure out how fast the machine is
 452   if(AF_INIT_AUTO == (AF_INIT_TYPE_MASK & s->cfg.force))
 453     s->cfg.force = (s->cfg.force & ~AF_INIT_TYPE_MASK) | AF_INIT_TYPE;
 454
 455   // Check if this is the first call
 456   if(!s->first){
 457     // Append a downmix pan filter at the beginning of the chain if needed
 458     if (s->input.nch != opts->audio_output_channels
 459         && opts->audio_output_channels == 2)
 460       af_downmix(s);
 461     // Add all filters in the list (if there are any)
 462     if (s->cfg.list) {
 463       while(s->cfg.list[i]){
 464         if(!af_append(s,s->last,s->cfg.list[i++]))
 465           return -1;
 466       }
 467     }
 468   }
 469
 470   // If we do not have any filters otherwise
 471   // add dummy to make automatic format conversion work
 472   if (!s->first && !af_append(s, s->first, "dummy"))
 473     return -1;
 474
 475   // Init filters
 476   if(AF_OK != af_reinit(s,s->first))
 477     return -1;
 478
 479   // make sure the chain is not empty and valid (e.g. because of AF_DETACH)
 480   if (!s->first)
 481     if (!af_append(s,s->first,"dummy") || AF_OK != af_reinit(s,s->first))
 482       return -1;
 483
 484   // Check output format
 485   if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){
 486     af_instance_t* af = NULL; // New filter
 487     // Check output frequency if not OK fix with resample
 488     if(s->output.rate && s->last->data->rate!=s->output.rate){
 489       // try to find a filter that can change samplrate
 490       af = af_control_any_rev(s, AF_CONTROL_RESAMPLE_RATE | AF_CONTROL_SET,
 491                &(s->output.rate));
 492       if (!af) {
 493         char *resampler = "resample";
 494 #ifdef CONFIG_FFMPEG
 495         if ((AF_INIT_TYPE_MASK & s->cfg.force) == AF_INIT_SLOW)
 496           resampler = "lavcresample";
 497 #endif
 498         if((AF_INIT_TYPE_MASK & s->cfg.force) == AF_INIT_SLOW){
 499           if(!strcmp(s->first->info->name,"format"))
 500             af = af_append(s,s->first,resampler);
 501           else
 502             af = af_prepend(s,s->first,resampler);
 503         }
 504         else{
 505           if(!strcmp(s->last->info->name,"format"))
 506             af = af_prepend(s,s->last,resampler);
 507           else
 508             af = af_append(s,s->last,resampler);
 509         }
 510       // Init the new filter
 511       if(!af || (AF_OK != af->control(af,AF_CONTROL_RESAMPLE_RATE | AF_CONTROL_SET,
 512                                       &(s->output.rate))))
 513         return -1;
 514       // Use lin int if the user wants fast
 515       if ((AF_INIT_TYPE_MASK & s->cfg.force) == AF_INIT_FAST) {
 516         char args[32];
 517         sprintf(args, "%d", s->output.rate);
 518 #ifdef CONFIG_FFMPEG
 519         if (strcmp(resampler, "lavcresample") == 0)
 520           strcat(args, ":1");
 521         else
 522 #endif
 523         strcat(args, ":0:0");
 524         af->control(af, AF_CONTROL_COMMAND_LINE, args);
 525       }
 526       }
 527       if(AF_OK != af_reinit(s,af))
 528         return -1;
 529     }
 530     if (AF_OK != fixup_output_format(s)) {
 531       // Something is stuffed audio out will not work
 532       mp_msg(MSGT_AFILTER, MSGL_ERR, "[libaf] Unable to setup filter system can not"
 533              " meet sound-card demands, please send bugreport. \n");
 534       af_uninit(s);
 535       return -1;
 536     }
 537   }
 538   return 0;
 539 }
 540
 541 /* Add filter during execution. This function adds the filter "name"
 542    to the stream s. The filter will be inserted somewhere nice in the
 543    list of filters. The return value is a pointer to the new filter,
 544    If the filter couldn't be added the return value is NULL. */
 545 af_instance_t* af_add(af_stream_t* s, char* name){
 546   af_instance_t* new;
 547   // Sanity check
 548   if(!s || !s->first || !name)
 549     return NULL;
 550   // Insert the filter somwhere nice
 551   if(!strcmp(s->first->info->name,"format"))
 552     new = af_append(s, s->first, name);
 553   else
 554     new = af_prepend(s, s->first, name);
 555   if(!new)
 556     return NULL;
 557
 558   // Reinitalize the filter list
 559   if(AF_OK != af_reinit(s, s->first) ||
 560      AF_OK != fixup_output_format(s)){
 561     free(new);
 562     return NULL;
 563   }
 564   return new;
 565 }
 566
 567 // Filter data chunk through the filters in the list
 568 af_data_t* af_play(af_stream_t* s, af_data_t* data)
 569 {
 570   af_instance_t* af=s->first;
 571   // Iterate through all filters
 572   do{
 573     if (data->len <= 0) break;
 574     data=af->play(af,data);
 575     af=af->next;
 576   }while(af && data);
 577   return data;
 578 }
 579
 580 /* Calculate the minimum output buffer size for given input data d
 581  * when using the RESIZE_LOCAL_BUFFER macro. The +t+1 part ensures the
 582  * value is >= len*mul rounded upwards to whole samples even if the
 583  * double 'mul' is inexact. */
 584 int af_lencalc(double mul, af_data_t* d)
 585 {
 586   int t = d->bps * d->nch;
 587   return d->len * mul + t + 1;
 588 }
 589
 590 // Calculate average ratio of filter output size to input size
 591 double af_calc_filter_multiplier(af_stream_t* s)
 592 {
 593   af_instance_t* af=s->first;
 594   double mul = 1;
 595   // Iterate through all filters and calculate total multiplication factor
 596   do{
 597       mul *= af->mul;
 598       af=af->next;
 599   }while(af);
 600
 601   return mul;
 602 }
 603
 604 /* Calculate the total delay [bytes output] caused by the filters */
 605 double af_calc_delay(af_stream_t* s)
 606 {
 607   af_instance_t* af=s->first;
 608   register double delay = 0.0;
 609   // Iterate through all filters
 610   while(af){
 611     delay += af->delay;
 612     delay *= af->mul;
 613     af=af->next;
 614   }
 615   return delay;
 616 }
 617
 618 /* Helper function called by the macro with the same name this
 619    function should not be called directly */
 620 int af_resize_local_buffer(af_instance_t* af, af_data_t* data)
 621 {
 622   // Calculate new length
 623   register int len = af_lencalc(af->mul,data);
 624   mp_msg(MSGT_AFILTER, MSGL_V, "[libaf] Reallocating memory in module %s, "
 625          "old len = %i, new len = %i\n",af->info->name,af->data->len,len);
 626   // If there is a buffer free it
 627   free(af->data->audio);
 628   // Create new buffer and check that it is OK
 629   af->data->audio = malloc(len);
 630   if(!af->data->audio){
 631     mp_msg(MSGT_AFILTER, MSGL_FATAL, "[libaf] Could not allocate memory \n");
 632     return AF_ERROR;
 633   }
 634   af->data->len=len;
 635   return AF_OK;
 636 }
 637
 638 // documentation in af.h
 639 af_instance_t *af_control_any_rev (af_stream_t* s, int cmd, void* arg) {
 640   int res = AF_UNKNOWN;
 641   af_instance_t* filt = s->last;
 642   while (filt) {
 643     res = filt->control(filt, cmd, arg);
 644     if (res == AF_OK)
 645       return filt;
 646     filt = filt->prev;
 647   }
 648   return NULL;
 649 }
 650
 651 void af_help (void) {
 652   int i = 0;
 653   mp_msg(MSGT_AFILTER, MSGL_INFO, "Available audio filters:\n");
 654   while (filter_list[i]) {
 655     if (filter_list[i]->comment && filter_list[i]->comment[0])
 656       mp_msg(MSGT_AFILTER, MSGL_INFO, "  %-15s: %s (%s)\n", filter_list[i]->name, filter_list[i]->info, filter_list[i]->comment);
 657     else
 658       mp_msg(MSGT_AFILTER, MSGL_INFO, "  %-15s: %s\n", filter_list[i]->name, filter_list[i]->info);
 659     i++;
 660   }
 661 }
 662
 663 void af_fix_parameters(af_data_t *data)
 664 {
 665     data->bps = af_fmt2bits(data->format)/8;
 666 }