2 * This file is part of MPlayer.
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.
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.
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.
23 #include "osdep/strsep.h"
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
;
55 static af_info_t
* filter_list
[]={
68 #ifdef HAVE_SYS_MMAN_H
73 #ifdef CONFIG_LIBAVCODEC_A
76 #ifdef CONFIG_LIBAVCODEC
77 &af_info_lavcresample
,
85 &af_info_sinesuppress
,
96 int* af_cpu_speed
= NULL
;
98 /* Find a filter in the static list of filters using it's name. This
99 function is used internally */
100 static af_info_t
* af_find(char*name
)
103 while(filter_list
[i
]){
104 if(!strcmp(filter_list
[i
]->name
,name
))
105 return filter_list
[i
];
108 mp_msg(MSGT_AFILTER
, MSGL_ERR
, "Couldn't find audio filter '%s'\n",name
);
112 /* Find filter in the dynamic filter list using it's name This
113 function is used for finding already initialized filters */
114 af_instance_t
* af_get(af_stream_t
* s
, char* name
)
116 af_instance_t
* af
=s
->first
;
119 if(!strcmp(af
->info
->name
,name
))
126 /*/ Function for creating a new filter of type name. The name may
127 contain the commandline parameters for the filter */
128 static af_instance_t
* af_create(af_stream_t
* s
, const char* name_with_cmd
)
130 char* name
= strdup(name_with_cmd
);
131 char* cmdline
= name
;
133 // Allocate space for the new filter and reset all pointers
134 af_instance_t
* new=malloc(sizeof(af_instance_t
));
136 mp_msg(MSGT_AFILTER
, MSGL_ERR
, "[libaf] Could not allocate memory\n");
139 memset(new,0,sizeof(af_instance_t
));
141 // Check for commandline parameters
142 strsep(&cmdline
, "=");
144 // Find filter from name
145 if(NULL
== (new->info
=af_find(name
)))
148 /* Make sure that the filter is not already in the list if it is
150 if(new->info
->flags
& AF_FLAGS_NOT_REENTRANT
){
152 mp_msg(MSGT_AFILTER
, MSGL_ERR
, "[libaf] There can only be one instance of"
153 " the filter '%s' in each stream\n",name
);
158 mp_msg(MSGT_AFILTER
, MSGL_V
, "[libaf] Adding filter %s \n",name
);
160 // Initialize the new filter
161 if(AF_OK
== new->info
->open(new) &&
162 AF_ERROR
< new->control(new,AF_CONTROL_POST_CREATE
,&s
->cfg
)){
164 if(AF_ERROR
>=new->control(new,AF_CONTROL_COMMAND_LINE
,cmdline
))
173 mp_msg(MSGT_AFILTER
, MSGL_ERR
, "[libaf] Couldn't create or open audio filter '%s'\n",
179 /* Create and insert a new filter of type name before the filter in the
180 argument. This function can be called during runtime, the return
181 value is the new filter */
182 static af_instance_t
* af_prepend(af_stream_t
* s
, af_instance_t
* af
, char* name
)
184 // Create the new filter and make sure it is OK
185 af_instance_t
* new=af_create(s
,name
);
203 /* Create and insert a new filter of type name after the filter in the
204 argument. This function can be called during runtime, the return
205 value is the new filter */
206 static af_instance_t
* af_append(af_stream_t
* s
, af_instance_t
* af
, char* name
)
208 // Create the new filter and make sure it is OK
209 af_instance_t
* new=af_create(s
,name
);
227 // Uninit and remove the filter "af"
228 void af_remove(af_stream_t
* s
, af_instance_t
* af
)
232 // Print friendly message
233 mp_msg(MSGT_AFILTER
, MSGL_V
, "[libaf] Removing filter %s \n",af
->info
->name
);
235 // Notify filter before changing anything
236 af
->control(af
,AF_CONTROL_PRE_DESTROY
,0);
240 af
->prev
->next
=af
->next
;
244 af
->next
->prev
=af
->prev
;
248 // Uninitialize af and free memory
253 /* Reinitializes all filters downstream from the filter given in the
254 argument the return value is AF_OK if success and AF_ERROR if
256 static int af_reinit(af_stream_t
* s
, af_instance_t
* af
)
259 af_data_t in
; // Format of the input to current filter
260 int rv
=0; // Return value
262 // Check if there are any filters left in the list
264 if(!(af
=af_append(s
,s
->first
,"dummy")))
270 // Check if this is the first filter
272 memcpy(&in
,&(s
->input
),sizeof(af_data_t
));
274 memcpy(&in
,af
->prev
->data
,sizeof(af_data_t
));
275 // Reset just in case...
279 rv
= af
->control(af
,AF_CONTROL_REINIT
,&in
);
284 case AF_FALSE
:{ // Configuration filter is needed
285 // Do auto insertion only if force is not specified
286 if((AF_INIT_TYPE_MASK
& s
->cfg
.force
) != AF_INIT_FORCE
){
287 af_instance_t
* new = NULL
;
288 // Insert channels filter
289 if((af
->prev
?af
->prev
->data
->nch
:s
->input
.nch
) != in
.nch
){
290 // Create channels filter
291 if(NULL
== (new = af_prepend(s
,af
,"channels")))
293 // Set number of output channels
294 if(AF_OK
!= (rv
= new->control(new,AF_CONTROL_CHANNELS
,&in
.nch
)))
296 // Initialize channels filter
298 memcpy(&in
,&(s
->input
),sizeof(af_data_t
));
300 memcpy(&in
,new->prev
->data
,sizeof(af_data_t
));
301 if(AF_OK
!= (rv
= new->control(new,AF_CONTROL_REINIT
,&in
)))
304 // Insert format filter
305 if((af
->prev
?af
->prev
->data
->format
:s
->input
.format
) != in
.format
){
306 // Create format filter
307 if(NULL
== (new = af_prepend(s
,af
,"format")))
309 // Set output bits per sample
310 in
.format
|= af_bits2fmt(in
.bps
*8);
311 if(AF_OK
!= (rv
= new->control(new,AF_CONTROL_FORMAT_FMT
,&in
.format
)))
313 // Initialize format filter
315 memcpy(&in
,&(s
->input
),sizeof(af_data_t
));
317 memcpy(&in
,new->prev
->data
,sizeof(af_data_t
));
318 if(AF_OK
!= (rv
= new->control(new,AF_CONTROL_REINIT
,&in
)))
321 if(!new){ // Should _never_ happen
322 mp_msg(MSGT_AFILTER
, MSGL_ERR
, "[libaf] Unable to correct audio format. "
323 "This error should never uccur, please send bugreport.\n");
329 mp_msg(MSGT_AFILTER
, MSGL_ERR
, "[libaf] Automatic filter insertion disabled "
330 "but formats do not match. Giving up.\n");
335 case AF_DETACH
:{ // Filter is redundant and wants to be unloaded
336 // Do auto remove only if force is not specified
337 if((AF_INIT_TYPE_MASK
& s
->cfg
.force
) != AF_INIT_FORCE
){
338 af_instance_t
* aft
=af
->prev
;
343 af
=s
->first
; // Restart configuration
348 mp_msg(MSGT_AFILTER
, MSGL_ERR
, "[libaf] Reinitialization did not work, audio"
349 " filter '%s' returned error code %i\n",af
->info
->name
,rv
);
356 // Uninit and remove all filters
357 void af_uninit(af_stream_t
* s
)
360 af_remove(s
,s
->first
);
364 * Extend the filter chain so we get the required output format at the end.
365 * \return AF_ERROR on error, AF_OK if successful.
367 static int fixup_output_format(af_stream_t
* s
)
369 af_instance_t
* af
= NULL
;
370 // Check number of output channels fix if not OK
371 // If needed always inserted last -> easy to screw up other filters
372 if(s
->output
.nch
&& s
->last
->data
->nch
!=s
->output
.nch
){
373 if(!strcmp(s
->last
->info
->name
,"format"))
374 af
= af_prepend(s
,s
->last
,"channels");
376 af
= af_append(s
,s
->last
,"channels");
377 // Init the new filter
378 if(!af
|| (AF_OK
!= af
->control(af
,AF_CONTROL_CHANNELS
,&(s
->output
.nch
))))
380 if(AF_OK
!= af_reinit(s
,af
))
384 // Check output format fix if not OK
385 if(s
->output
.format
!= AF_FORMAT_UNKNOWN
&&
386 s
->last
->data
->format
!= s
->output
.format
){
387 if(strcmp(s
->last
->info
->name
,"format"))
388 af
= af_append(s
,s
->last
,"format");
391 // Init the new filter
392 s
->output
.format
|= af_bits2fmt(s
->output
.bps
*8);
393 if(!af
|| (AF_OK
!= af
->control(af
,AF_CONTROL_FORMAT_FMT
,&(s
->output
.format
))))
395 if(AF_OK
!= af_reinit(s
,af
))
399 // Re init again just in case
400 if(AF_OK
!= af_reinit(s
,s
->first
))
403 if (s
->output
.format
== AF_FORMAT_UNKNOWN
)
404 s
->output
.format
= s
->last
->data
->format
;
405 if (!s
->output
.nch
) s
->output
.nch
= s
->last
->data
->nch
;
406 if (!s
->output
.rate
) s
->output
.rate
= s
->last
->data
->rate
;
407 if((s
->last
->data
->format
!= s
->output
.format
) ||
408 (s
->last
->data
->nch
!= s
->output
.nch
) ||
409 (s
->last
->data
->rate
!= s
->output
.rate
)) {
415 /* Initialize the stream "s". This function creates a new filter list
416 if necessary according to the values set in input and output. Input
417 and output should contain the format of the current movie and the
418 formate of the preferred output respectively. The function is
419 reentrant i.e. if called with an already initialized stream the
420 stream will be reinitialized.
421 If one of the prefered output parameters is 0 the one that needs
422 no conversion is used (i.e. the output format in the last filter).
423 The return value is 0 if success and -1 if failure */
424 int af_init(af_stream_t
* s
)
431 // Precaution in case caller is misbehaving
432 s
->input
.audio
= s
->output
.audio
= NULL
;
433 s
->input
.len
= s
->output
.len
= 0;
435 // Figure out how fast the machine is
436 if(AF_INIT_AUTO
== (AF_INIT_TYPE_MASK
& s
->cfg
.force
))
437 s
->cfg
.force
= (s
->cfg
.force
& ~AF_INIT_TYPE_MASK
) | AF_INIT_TYPE
;
439 // Check if this is the first call
441 // Add all filters in the list (if there are any)
442 if(!s
->cfg
.list
){ // To make automatic format conversion work
443 if(!af_append(s
,s
->first
,"dummy"))
447 while(s
->cfg
.list
[i
]){
448 if(!af_append(s
,s
->last
,s
->cfg
.list
[i
++]))
455 if(AF_OK
!= af_reinit(s
,s
->first
))
458 // make sure the chain is not empty and valid (e.g. because of AF_DETACH)
460 if (!af_append(s
,s
->first
,"dummy") || AF_OK
!= af_reinit(s
,s
->first
))
463 // Check output format
464 if((AF_INIT_TYPE_MASK
& s
->cfg
.force
) != AF_INIT_FORCE
){
465 af_instance_t
* af
= NULL
; // New filter
466 // Check output frequency if not OK fix with resample
467 if(s
->output
.rate
&& s
->last
->data
->rate
!=s
->output
.rate
){
468 // try to find a filter that can change samplrate
469 af
= af_control_any_rev(s
, AF_CONTROL_RESAMPLE_RATE
| AF_CONTROL_SET
,
472 char *resampler
= "resample";
473 #ifdef CONFIG_LIBAVCODEC
474 if ((AF_INIT_TYPE_MASK
& s
->cfg
.force
) == AF_INIT_SLOW
)
475 resampler
= "lavcresample";
477 if((AF_INIT_TYPE_MASK
& s
->cfg
.force
) == AF_INIT_SLOW
){
478 if(!strcmp(s
->first
->info
->name
,"format"))
479 af
= af_append(s
,s
->first
,resampler
);
481 af
= af_prepend(s
,s
->first
,resampler
);
484 if(!strcmp(s
->last
->info
->name
,"format"))
485 af
= af_prepend(s
,s
->last
,resampler
);
487 af
= af_append(s
,s
->last
,resampler
);
489 // Init the new filter
490 if(!af
|| (AF_OK
!= af
->control(af
,AF_CONTROL_RESAMPLE_RATE
| AF_CONTROL_SET
,
493 // Use lin int if the user wants fast
494 if ((AF_INIT_TYPE_MASK
& s
->cfg
.force
) == AF_INIT_FAST
) {
496 sprintf(args
, "%d", s
->output
.rate
);
497 #ifdef CONFIG_LIBAVCODEC
498 if (strcmp(resampler
, "lavcresample") == 0)
502 strcat(args
, ":0:0");
503 af
->control(af
, AF_CONTROL_COMMAND_LINE
, args
);
506 if(AF_OK
!= af_reinit(s
,af
))
509 if (AF_OK
!= fixup_output_format(s
)) {
510 // Something is stuffed audio out will not work
511 mp_msg(MSGT_AFILTER
, MSGL_ERR
, "[libaf] Unable to setup filter system can not"
512 " meet sound-card demands, please send bugreport. \n");
520 /* Add filter during execution. This function adds the filter "name"
521 to the stream s. The filter will be inserted somewhere nice in the
522 list of filters. The return value is a pointer to the new filter,
523 If the filter couldn't be added the return value is NULL. */
524 af_instance_t
* af_add(af_stream_t
* s
, char* name
){
527 if(!s
|| !s
->first
|| !name
)
529 // Insert the filter somwhere nice
530 if(!strcmp(s
->first
->info
->name
,"format"))
531 new = af_append(s
, s
->first
, name
);
533 new = af_prepend(s
, s
->first
, name
);
537 // Reinitalize the filter list
538 if(AF_OK
!= af_reinit(s
, s
->first
) ||
539 AF_OK
!= fixup_output_format(s
)){
546 // Filter data chunk through the filters in the list
547 af_data_t
* af_play(af_stream_t
* s
, af_data_t
* data
)
549 af_instance_t
* af
=s
->first
;
550 // Iterate through all filters
552 if (data
->len
<= 0) break;
553 data
=af
->play(af
,data
);
559 /* Calculate the minimum output buffer size for given input data d
560 * when using the RESIZE_LOCAL_BUFFER macro. The +t+1 part ensures the
561 * value is >= len*mul rounded upwards to whole samples even if the
562 * double 'mul' is inexact. */
563 int af_lencalc(double mul
, af_data_t
* d
)
565 int t
= d
->bps
* d
->nch
;
566 return d
->len
* mul
+ t
+ 1;
569 // Calculate average ratio of filter output size to input size
570 double af_calc_filter_multiplier(af_stream_t
* s
)
572 af_instance_t
* af
=s
->first
;
574 // Iterate through all filters and calculate total multiplication factor
583 /* Calculate the total delay [bytes output] caused by the filters */
584 double af_calc_delay(af_stream_t
* s
)
586 af_instance_t
* af
=s
->first
;
587 register double delay
= 0.0;
588 // Iterate through all filters
597 /* Helper function called by the macro with the same name this
598 function should not be called directly */
599 int af_resize_local_buffer(af_instance_t
* af
, af_data_t
* data
)
601 // Calculate new length
602 register int len
= af_lencalc(af
->mul
,data
);
603 mp_msg(MSGT_AFILTER
, MSGL_V
, "[libaf] Reallocating memory in module %s, "
604 "old len = %i, new len = %i\n",af
->info
->name
,af
->data
->len
,len
);
605 // If there is a buffer free it
607 free(af
->data
->audio
);
608 // Create new buffer and check that it is OK
609 af
->data
->audio
= malloc(len
);
610 if(!af
->data
->audio
){
611 mp_msg(MSGT_AFILTER
, MSGL_FATAL
, "[libaf] Could not allocate memory \n");
618 // documentation in af.h
619 af_instance_t
*af_control_any_rev (af_stream_t
* s
, int cmd
, void* arg
) {
620 int res
= AF_UNKNOWN
;
621 af_instance_t
* filt
= s
->last
;
623 res
= filt
->control(filt
, cmd
, arg
);
631 void af_help (void) {
633 mp_msg(MSGT_AFILTER
, MSGL_INFO
, "Available audio filters:\n");
634 while (filter_list
[i
]) {
635 if (filter_list
[i
]->comment
&& filter_list
[i
]->comment
[0])
636 mp_msg(MSGT_AFILTER
, MSGL_INFO
, " %-15s: %s (%s)\n", filter_list
[i
]->name
, filter_list
[i
]->info
, filter_list
[i
]->comment
);
638 mp_msg(MSGT_AFILTER
, MSGL_INFO
, " %-15s: %s\n", filter_list
[i
]->name
, filter_list
[i
]->info
);
643 void af_fix_parameters(af_data_t
*data
)
645 data
->bps
= af_fmt2bits(data
->format
)/8;