#include <stdio.h>#include <stdlib.h>#include <string.h>#ifdef HAVE_MALLOC_H#include <malloc.h>#endif#include "af.h"// Static list of filtersextern af_info_t af_info_dummy;extern af_info_t af_info_delay;extern af_info_t af_info_channels;extern af_info_t af_info_format;extern af_info_t af_info_resample;extern af_info_t af_info_volume;extern af_info_t af_info_equalizer;extern af_info_t af_info_gate;extern af_info_t af_info_comp;extern af_info_t af_info_pan;extern af_info_t af_info_surround;extern af_info_t af_info_sub;extern af_info_t af_info_export;extern af_info_t af_info_volnorm;extern af_info_t af_info_extrastereo;extern af_info_t af_info_lavcresample;extern af_info_t af_info_sweep;extern af_info_t af_info_hrtf;extern af_info_t af_info_ladspa;extern af_info_t af_info_center;static af_info_t* filter_list[]={    &af_info_dummy,   &af_info_delay,   &af_info_channels,   &af_info_format,   &af_info_resample,   &af_info_volume,   &af_info_equalizer,   &af_info_gate,   &af_info_comp,   &af_info_pan,   &af_info_surround,   &af_info_sub,#ifdef HAVE_SYS_MMAN_H   &af_info_export,#endif   &af_info_volnorm,   &af_info_extrastereo,#ifdef USE_LIBAVCODEC   &af_info_lavcresample,#endif   &af_info_sweep,   &af_info_hrtf,#ifdef HAVE_LADSPA   &af_info_ladspa,#endif   &af_info_center,   NULL };// Message printingaf_msg_cfg_t af_msg_cfg={0,NULL,NULL};// CPU speedint* af_cpu_speed = NULL;/* Find a filter in the static list of filters using it's name. This   function is used internally */af_info_t* af_find(char*name){  int i=0;  while(filter_list[i]){    if(!strcmp(filter_list[i]->name,name))      return filter_list[i];    i++;  }  af_msg(AF_MSG_ERROR,"Couldn't find audio filter '%s'\n",name);  return NULL;} /* Find filter in the dynamic filter list using it's name This   function is used for finding already initialized filters */af_instance_t* af_get(af_stream_t* s, char* name){  af_instance_t* af=s->first;   // Find the filter  while(af != NULL){    if(!strcmp(af->info->name,name))      return af;    af=af->next;  }  return NULL;}/*/ Function for creating a new filter of type name. The name may  contain the commandline parameters for the filter */af_instance_t* af_create(af_stream_t* s, char* name){  char* cmdline = name;  // Allocate space for the new filter and reset all pointers  af_instance_t* new=malloc(sizeof(af_instance_t));  if(!new){    af_msg(AF_MSG_ERROR,"[libaf] Could not allocate memory\n");    return NULL;  }    memset(new,0,sizeof(af_instance_t));  // Check for commandline parameters  strsep(&cmdline, "=");  // Find filter from name  if(NULL == (new->info=af_find(name)))    return NULL;  /* Make sure that the filter is not already in the list if it is     non-reentrant */  if(new->info->flags & AF_FLAGS_NOT_REENTRANT){    if(af_get(s,name)){      af_msg(AF_MSG_ERROR,"[libaf] There can only be one instance of" 	     " the filter '%s' in each stream\n",name);        free(new);      return NULL;    }  }    af_msg(AF_MSG_VERBOSE,"[libaf] Adding filter %s \n",name);    // Initialize the new filter  if(AF_OK == new->info->open(new) &&      AF_ERROR < new->control(new,AF_CONTROL_POST_CREATE,&s->cfg)){    if(cmdline){      if(AF_ERROR<new->control(new,AF_CONTROL_COMMAND_LINE,cmdline))	return new;    }    else      return new;   }    free(new);  af_msg(AF_MSG_ERROR,"[libaf] Couldn't create or open audio filter '%s'\n",	 name);    return NULL;}/* Create and insert a new filter of type name before the filter in the   argument. This function can be called during runtime, the return   value is the new filter */af_instance_t* af_prepend(af_stream_t* s, af_instance_t* af, char* name){  // Create the new filter and make sure it is OK  af_instance_t* new=af_create(s,name);  if(!new)    return NULL;  // Update pointers  new->next=af;  if(af){    new->prev=af->prev;    af->prev=new;  }  else    s->last=new;  if(new->prev)    new->prev->next=new;  else    s->first=new;  return new;}/* Create and insert a new filter of type name after the filter in the   argument. This function can be called during runtime, the return   value is the new filter */af_instance_t* af_append(af_stream_t* s, af_instance_t* af, char* name){  // Create the new filter and make sure it is OK  af_instance_t* new=af_create(s,name);  if(!new)    return NULL;  // Update pointers  new->prev=af;  if(af){    new->next=af->next;    af->next=new;  }  else    s->first=new;  if(new->next)    new->next->prev=new;  else    s->last=new;  return new;}// Uninit and remove the filter "af"void af_remove(af_stream_t* s, af_instance_t* af){  if(!af) return;  // Print friendly message   af_msg(AF_MSG_VERBOSE,"[libaf] Removing filter %s \n",af->info->name);   // Notify filter before changing anything  af->control(af,AF_CONTROL_PRE_DESTROY,0);  // Detach pointers  if(af->prev)    af->prev->next=af->next;  else    s->first=af->next;  if(af->next)    af->next->prev=af->prev;  else    s->last=af->prev;  // Uninitialize af and free memory     af->uninit(af);  free(af);}/* Reinitializes all filters downstream from the filter given in the   argument the return value is AF_OK if success and AF_ERROR if   failure */int af_reinit(af_stream_t* s, af_instance_t* af){  do{    af_data_t in; // Format of the input to current filter    int rv=0; // Return value    // Check if there are any filters left in the list    if(NULL == af){      if(!(af=af_append(s,s->first,"dummy"))) 	return AF_UNKNOWN;       else	return AF_ERROR;    }    // Check if this is the first filter     if(!af->prev)       memcpy(&in,&(s->input),sizeof(af_data_t));    else      memcpy(&in,af->prev->data,sizeof(af_data_t));    // Reset just in case...    in.audio=NULL;    in.len=0;        rv = af->control(af,AF_CONTROL_REINIT,&in);    switch(rv){    case AF_OK:	af = af->next;      break;    case AF_FALSE:{ // Configuration filter is needed      // Do auto insertion only if force is not specified      if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){	af_instance_t* new = NULL;	// Insert channels filter	if((af->prev?af->prev->data->nch:s->input.nch) != in.nch){	  // Create channels filter	  if(NULL == (new = af_prepend(s,af,"channels")))	    return AF_ERROR;	  // Set number of output channels	  if(AF_OK != (rv = new->control(new,AF_CONTROL_CHANNELS,&in.nch)))	    return rv;	  // Initialize channels filter	  if(!new->prev) 	    memcpy(&in,&(s->input),sizeof(af_data_t));	  else	    memcpy(&in,new->prev->data,sizeof(af_data_t));	  if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in)))	    return rv;	}	// Insert format filter	if((af->prev?af->prev->data->format:s->input.format) != in.format){	  // Create format filter	  if(NULL == (new = af_prepend(s,af,"format")))	    return AF_ERROR;	  // Set output bits per sample	  in.format |= af_bits2fmt(in.bps*8);	  if(AF_OK != (rv = new->control(new,AF_CONTROL_FORMAT_FMT,&in.format)))	    return rv;	  // Initialize format filter	  if(!new->prev) 	    memcpy(&in,&(s->input),sizeof(af_data_t));	  else	    memcpy(&in,new->prev->data,sizeof(af_data_t));	  if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in)))	    return rv;	}	if(!new){ // Should _never_ happen	  af_msg(AF_MSG_ERROR,"[libaf] Unable to correct audio format. " 		 "This error should never uccur, please send bugreport.\n");	  return AF_ERROR;	}	af=new->next;      }      break;    }    case AF_DETACH:{ // Filter is redundant and wants to be unloaded      // Do auto remove only if force is not specified      if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){	af_instance_t* aft=af->prev;	af_remove(s,af);	if(aft)	  af=aft->next;	else	  af=s->first; // Restart configuration      }      break;    }    default:      af_msg(AF_MSG_ERROR,"[libaf] Reinitialization did not work, audio" 	     " filter '%s' returned error code %i\n",af->info->name,rv);      return AF_ERROR;    }  }while(af);  return AF_OK;}// Uninit and remove all filtersvoid af_uninit(af_stream_t* s){  while(s->first)    af_remove(s,s->first);}/* Initialize the stream "s". This function creates a new filter list   if necessary according to the values set in input and output. Input   and output should contain the format of the current movie and the   formate of the preferred output respectively. The function is   reentrant i.e. if called with an already initialized stream the   stream will be reinitialized. If the binary parameter   "force_output" is set, the output format will be converted to the   format given in "s", otherwise the output fromat in the last filter   will be copied "s". The return value is 0 if success and -1 if   failure */int af_init(af_stream_t* s, int force_output){  int i=0;  // Sanity check  if(!s) return -1;  // Precaution in case caller is misbehaving  s->input.audio  = s->output.audio  = NULL;  s->input.len    = s->output.len    = 0;  // Figure out how fast the machine is  if(AF_INIT_AUTO == (AF_INIT_TYPE_MASK & s->cfg.force))    s->cfg.force = (s->cfg.force & ~AF_INIT_TYPE_MASK) | AF_INIT_TYPE;