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
;
37 static af_info_t
* filter_list
[]={
50 #ifdef HAVE_SYS_MMAN_H
55 #ifdef CONFIG_LIBAVCODEC_A
58 #ifdef CONFIG_LIBAVCODEC
59 &af_info_lavcresample
,
67 &af_info_sinesuppress
,
74 af_msg_cfg_t af_msg_cfg
={0,NULL
,NULL
};
77 int* af_cpu_speed
= NULL
;
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
)
84 while(filter_list
[i
]){
85 if(!strcmp(filter_list
[i
]->name
,name
))
86 return filter_list
[i
];
89 af_msg(AF_MSG_ERROR
,"Couldn't find audio filter '%s'\n",name
);
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
)
97 af_instance_t
* af
=s
->first
;
100 if(!strcmp(af
->info
->name
,name
))
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
)
111 char* name
= strdup(name_with_cmd
);
112 char* cmdline
= name
;
114 // Allocate space for the new filter and reset all pointers
115 af_instance_t
* new=malloc(sizeof(af_instance_t
));
117 af_msg(AF_MSG_ERROR
,"[libaf] Could not allocate memory\n");
120 memset(new,0,sizeof(af_instance_t
));
122 // Check for commandline parameters
123 strsep(&cmdline
, "=");
125 // Find filter from name
126 if(NULL
== (new->info
=af_find(name
)))
129 /* Make sure that the filter is not already in the list if it is
131 if(new->info
->flags
& AF_FLAGS_NOT_REENTRANT
){
133 af_msg(AF_MSG_ERROR
,"[libaf] There can only be one instance of"
134 " the filter '%s' in each stream\n",name
);
139 af_msg(AF_MSG_VERBOSE
,"[libaf] Adding filter %s \n",name
);
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
)){
145 if(AF_ERROR
>=new->control(new,AF_CONTROL_COMMAND_LINE
,cmdline
))
154 af_msg(AF_MSG_ERROR
,"[libaf] Couldn't create or open audio filter '%s'\n",
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
)
165 // Create the new filter and make sure it is OK
166 af_instance_t
* new=af_create(s
,name
);
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
)
189 // Create the new filter and make sure it is OK
190 af_instance_t
* new=af_create(s
,name
);
208 // Uninit and remove the filter "af"
209 void af_remove(af_stream_t
* s
, af_instance_t
* af
)
213 // Print friendly message
214 af_msg(AF_MSG_VERBOSE
,"[libaf] Removing filter %s \n",af
->info
->name
);
216 // Notify filter before changing anything
217 af
->control(af
,AF_CONTROL_PRE_DESTROY
,0);
221 af
->prev
->next
=af
->next
;
225 af
->next
->prev
=af
->prev
;
229 // Uninitialize af and free memory
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
237 static int af_reinit(af_stream_t
* s
, af_instance_t
* af
)
240 af_data_t in
; // Format of the input to current filter
241 int rv
=0; // Return value
243 // Check if there are any filters left in the list
245 if(!(af
=af_append(s
,s
->first
,"dummy")))
251 // Check if this is the first filter
253 memcpy(&in
,&(s
->input
),sizeof(af_data_t
));
255 memcpy(&in
,af
->prev
->data
,sizeof(af_data_t
));
256 // Reset just in case...
260 rv
= af
->control(af
,AF_CONTROL_REINIT
,&in
);
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")))
274 // Set number of output channels
275 if(AF_OK
!= (rv
= new->control(new,AF_CONTROL_CHANNELS
,&in
.nch
)))
277 // Initialize channels filter
279 memcpy(&in
,&(s
->input
),sizeof(af_data_t
));
281 memcpy(&in
,new->prev
->data
,sizeof(af_data_t
));
282 if(AF_OK
!= (rv
= new->control(new,AF_CONTROL_REINIT
,&in
)))
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")))
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
)))
294 // Initialize format filter
296 memcpy(&in
,&(s
->input
),sizeof(af_data_t
));
298 memcpy(&in
,new->prev
->data
,sizeof(af_data_t
));
299 if(AF_OK
!= (rv
= new->control(new,AF_CONTROL_REINIT
,&in
)))
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");
310 af_msg(AF_MSG_ERROR
, "[libaf] Automatic filter insertion disabled "
311 "but formats do not match. Giving up.\n");
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
;
324 af
=s
->first
; // Restart configuration
329 af_msg(AF_MSG_ERROR
,"[libaf] Reinitialization did not work, audio"
330 " filter '%s' returned error code %i\n",af
->info
->name
,rv
);
337 // Uninit and remove all filters
338 void af_uninit(af_stream_t
* s
)
341 af_remove(s
,s
->first
);
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
)
360 // Precaution in case caller is misbehaving
361 s
->input
.audio
= s
->output
.audio
= NULL
;
362 s
->input
.len
= s
->output
.len
= 0;
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
;
368 // Check if this is the first call
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"))
376 while(s
->cfg
.list
[i
]){
377 if(!af_append(s
,s
->last
,s
->cfg
.list
[i
++]))
384 if(AF_OK
!= af_reinit(s
,s
->first
))
387 // make sure the chain is not empty and valid (e.g. because of AF_DETACH)
389 if (!af_append(s
,s
->first
,"dummy") || AF_OK
!= af_reinit(s
,s
->first
))
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
,
401 char *resampler
= "resample";
402 #ifdef CONFIG_LIBAVCODEC
403 if ((AF_INIT_TYPE_MASK
& s
->cfg
.force
) == AF_INIT_SLOW
)
404 resampler
= "lavcresample";
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
);
410 af
= af_prepend(s
,s
->first
,resampler
);
413 if(!strcmp(s
->last
->info
->name
,"format"))
414 af
= af_prepend(s
,s
->last
,resampler
);
416 af
= af_append(s
,s
->last
,resampler
);
418 // Init the new filter
419 if(!af
|| (AF_OK
!= af
->control(af
,AF_CONTROL_RESAMPLE_RATE
| AF_CONTROL_SET
,
422 // Use lin int if the user wants fast
423 if ((AF_INIT_TYPE_MASK
& s
->cfg
.force
) == AF_INIT_FAST
) {
425 sprintf(args
, "%d", s
->output
.rate
);
426 #ifdef CONFIG_LIBAVCODEC
427 if (strcmp(resampler
, "lavcresample") == 0)
431 strcat(args
, ":0:0");
432 af
->control(af
, AF_CONTROL_COMMAND_LINE
, args
);
435 if(AF_OK
!= af_reinit(s
,af
))
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");
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
))))
449 if(AF_OK
!= af_reinit(s
,af
))
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");
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
))))
464 if(AF_OK
!= af_reinit(s
,af
))
468 // Re init again just in case
469 if(AF_OK
!= af_reinit(s
,s
->first
))
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");
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
){
496 if(!s
|| !s
->first
|| !name
)
498 // Insert the filter somwhere nice
499 if(!strcmp(s
->first
->info
->name
,"format"))
500 new = af_append(s
, s
->first
, name
);
502 new = af_prepend(s
, s
->first
, name
);
506 // Reinitalize the filter list
507 if(AF_OK
!= af_reinit(s
, s
->first
)){
514 // Filter data chunk through the filters in the list
515 af_data_t
* af_play(af_stream_t
* s
, af_data_t
* data
)
517 af_instance_t
* af
=s
->first
;
518 // Iterate through all filters
520 if (data
->len
<= 0) break;
521 data
=af
->play(af
,data
);
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
)
533 int t
= d
->bps
* d
->nch
;
534 return d
->len
* mul
+ t
+ 1;
537 // Calculate average ratio of filter output size to input size
538 double af_calc_filter_multiplier(af_stream_t
* s
)
540 af_instance_t
* af
=s
->first
;
542 // Iterate through all filters and calculate total multiplication factor
551 /* Calculate the total delay [bytes output] caused by the filters */
552 double af_calc_delay(af_stream_t
* s
)
554 af_instance_t
* af
=s
->first
;
555 register double delay
= 0.0;
556 // Iterate through all filters
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
)
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
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");
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
;
591 res
= filt
->control(filt
, cmd
, arg
);
599 void af_help (void) {
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
);
606 af_msg(AF_MSG_INFO
, " %-15s: %s\n", filter_list
[i
]->name
, filter_list
[i
]->info
);
611 void af_fix_parameters(af_data_t
*data
)
613 data
->bps
= af_fmt2bits(data
->format
)/8;