80127ccfe954abc707085583bdedde35aa2910f0
[vlc.git] / modules / audio_filter / equalizer.c
1 /*****************************************************************************
2  * equalizer.c:
3  *****************************************************************************
4  * Copyright (C) 2004, 2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <math.h>
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_charset.h>
37
38 #include <vlc_aout.h>
39
40 #include "equalizer_presets.h"
41 /* TODO:
42  *  - add tables for other rates ( 22500, 11250, ...)
43  *  - optimize a bit (you can hardly do slower ;)
44  *  - add tables for more bands (15 and 32 would be cool), maybe with auto coeffs
45  *  computation (not too hard once the Q is found).
46  *  - support for external preset
47  *  - callback to handle preset changes on the fly
48  *  - ...
49  */
50
51 /*****************************************************************************
52  * Module descriptor
53  *****************************************************************************/
54 static int  Open ( vlc_object_t * );
55 static void Close( vlc_object_t * );
56
57 #define PRESET_TEXT N_( "Equalizer preset" )
58 #define PRESET_LONGTEXT N_("Preset to use for the equalizer." )
59
60 #define BANDS_TEXT N_( "Bands gain")
61 #define BANDS_LONGTEXT N_( \
62          "Don't use presets, but manually specified bands. You need to " \
63          "provide 10 values between -20dB and 20dB, separated by spaces, " \
64          "e.g. \"0 2 4 2 0 -2 -4 -2 0\"." )
65
66 #define TWOPASS_TEXT N_( "Two pass" )
67 #define TWOPASS_LONGTEXT N_( "Filter the audio twice. This provides a more "  \
68          "intense effect.")
69
70 #define PREAMP_TEXT N_("Global gain" )
71 #define PREAMP_LONGTEXT N_("Set the global gain in dB (-20 ... 20)." )
72
73 vlc_module_begin ()
74     set_description( N_("Equalizer with 10 bands") )
75     set_shortname( N_("Equalizer" ) )
76     set_capability( "audio filter", 0 )
77     set_category( CAT_AUDIO )
78     set_subcategory( SUBCAT_AUDIO_AFILTER )
79
80     add_string( "equalizer-preset", "flat", NULL, PRESET_TEXT,
81                 PRESET_LONGTEXT, false )
82         change_string_list( preset_list, preset_list_text, 0 )
83     add_string( "equalizer-bands", NULL, NULL, BANDS_TEXT,
84                 BANDS_LONGTEXT, true )
85     add_bool( "equalizer-2pass", 0, NULL, TWOPASS_TEXT,
86               TWOPASS_LONGTEXT, true )
87     add_float( "equalizer-preamp", 12.0, NULL, PREAMP_TEXT,
88                PREAMP_LONGTEXT, true )
89     set_callbacks( Open, Close )
90     add_shortcut( "equalizer" )
91 vlc_module_end ()
92
93 /*****************************************************************************
94  * Local prototypes
95  *****************************************************************************/
96 struct aout_filter_sys_t
97 {
98     /* Filter static config */
99     int i_band;
100     float *f_alpha;
101     float *f_beta;
102     float *f_gamma;
103
104     float f_newpreamp;
105     char *psz_newbands;
106     bool b_first;
107
108     /* Filter dyn config */
109     float *f_amp;   /* Per band amp */
110     float f_gamp;   /* Global preamp */
111     bool b_2eqz;
112
113     /* Filter state */
114     float x[32][2];
115     float y[32][128][2];
116
117     /* Second filter state */
118     float x2[32][2];
119     float y2[32][128][2];
120
121 };
122
123 static void DoWork( aout_instance_t *, aout_filter_t *,
124                     aout_buffer_t *, aout_buffer_t * );
125
126 #define EQZ_IN_FACTOR (0.25)
127 static int  EqzInit( aout_filter_t *, int );
128 static void EqzFilter( aout_filter_t *, float *, float *,
129                         int, int );
130 static void EqzClean( aout_filter_t * );
131
132 static int PresetCallback( vlc_object_t *, char const *,
133                                            vlc_value_t, vlc_value_t, void * );
134 static int PreampCallback( vlc_object_t *, char const *,
135                                            vlc_value_t, vlc_value_t, void * );
136 static int BandsCallback ( vlc_object_t *, char const *,
137                                            vlc_value_t, vlc_value_t, void * );
138
139
140
141 /*****************************************************************************
142  * Open:
143  *****************************************************************************/
144 static int Open( vlc_object_t *p_this )
145 {
146     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
147     aout_filter_sys_t *p_sys;
148     bool         b_fit = true;
149
150     if( p_filter->input.i_format != VLC_CODEC_FL32 ||
151         p_filter->output.i_format != VLC_CODEC_FL32 )
152     {
153         b_fit = false;
154         p_filter->input.i_format = VLC_CODEC_FL32;
155         p_filter->output.i_format = VLC_CODEC_FL32;
156         msg_Warn( p_filter, "bad input or output format" );
157     }
158     if ( !AOUT_FMTS_SIMILAR( &p_filter->input, &p_filter->output ) )
159     {
160         b_fit = false;
161         memcpy( &p_filter->output, &p_filter->input,
162                 sizeof(audio_sample_format_t) );
163         msg_Warn( p_filter, "input and output formats are not similar" );
164     }
165
166     if ( ! b_fit )
167     {
168         return VLC_EGENERIC;
169     }
170
171     p_filter->pf_do_work = DoWork;
172     p_filter->b_in_place = true;
173
174     /* Allocate structure */
175     p_sys = p_filter->p_sys = malloc( sizeof( aout_filter_sys_t ) );
176     if( !p_sys )
177         return VLC_ENOMEM;
178
179     if( EqzInit( p_filter, p_filter->input.i_rate ) != VLC_SUCCESS )
180     {
181         free( p_sys );
182         return VLC_EGENERIC;
183     }
184
185     return VLC_SUCCESS;
186 }
187
188 /*****************************************************************************
189  * Close: close the plugin
190  *****************************************************************************/
191 static void Close( vlc_object_t *p_this )
192 {
193     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
194     aout_filter_sys_t *p_sys = p_filter->p_sys;
195
196     EqzClean( p_filter );
197     free( p_sys );
198 }
199
200 /*****************************************************************************
201  * DoWork: process samples buffer
202  *****************************************************************************
203  *
204  *****************************************************************************/
205 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
206                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
207 {
208     VLC_UNUSED(p_aout);
209     p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
210     p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes;
211
212     EqzFilter( p_filter, (float*)p_out_buf->p_buffer,
213                (float*)p_in_buf->p_buffer, p_in_buf->i_nb_samples,
214                aout_FormatNbChannels( &p_filter->input ) );
215 }
216
217 /*****************************************************************************
218  * Equalizer stuff
219  *****************************************************************************/
220 typedef struct
221 {
222     int   i_band;
223
224     struct
225     {
226         float f_frequency;
227         float f_alpha;
228         float f_beta;
229         float f_gamma;
230     } band[EQZ_BANDS_MAX];
231
232 } eqz_config_t;
233
234 /* Value from equ-xmms */
235 static const eqz_config_t eqz_config_44100_10b =
236 {
237     10,
238     {
239         {    60, 0.003013, 0.993973, 1.993901 },
240         {   170, 0.008490, 0.983019, 1.982437 },
241         {   310, 0.015374, 0.969252, 1.967331 },
242         {   600, 0.029328, 0.941343, 1.934254 },
243         {  1000, 0.047918, 0.904163, 1.884869 },
244         {  3000, 0.130408, 0.739184, 1.582718 },
245         {  6000, 0.226555, 0.546889, 1.015267 },
246         { 12000, 0.344937, 0.310127, -0.181410 },
247         { 14000, 0.366438, 0.267123, -0.521151 },
248         { 16000, 0.379009, 0.241981, -0.808451 },
249     }
250 };
251 static const eqz_config_t eqz_config_48000_10b =
252 {
253     10,
254     {
255         {    60, 0.002769, 0.994462, 1.994400 },
256         {   170, 0.007806, 0.984388, 1.983897 },
257         {   310, 0.014143, 0.971714, 1.970091 },
258         {   600, 0.027011, 0.945978, 1.939979 },
259         {  1000, 0.044203, 0.911595, 1.895241 },
260         {  3000, 0.121223, 0.757553, 1.623767 },
261         {  6000, 0.212888, 0.574224, 1.113145 },
262         { 12000, 0.331347, 0.337307, 0.000000 },
263         { 14000, 0.355263, 0.289473, -0.333740 },
264         { 16000, 0.371900, 0.256201, -0.628100 }
265     }
266 };
267
268 static inline float EqzConvertdB( float db )
269 {
270     /* Map it to gain,
271      * (we do as if the input of iir is /EQZ_IN_FACTOR, but in fact it's the non iir data that is *EQZ_IN_FACTOR)
272      * db = 20*log( out / in ) with out = in + amp*iir(i/EQZ_IN_FACTOR)
273      * or iir(i) == i for the center freq so
274      * db = 20*log( 1 + amp/EQZ_IN_FACTOR )
275      * -> amp = EQZ_IN_FACTOR*(10^(db/20) - 1)
276      **/
277
278     if( db < -20.0 )
279         db = -20.0;
280     else if(  db > 20.0 )
281         db = 20.0;
282     return EQZ_IN_FACTOR * ( pow( 10, db / 20.0 ) - 1.0 );
283 }
284
285 static int EqzInit( aout_filter_t *p_filter, int i_rate )
286 {
287     aout_filter_sys_t *p_sys = p_filter->p_sys;
288     const eqz_config_t *p_cfg;
289     int i, ch;
290     vlc_value_t val1, val2, val3;
291     aout_instance_t *p_aout = (aout_instance_t *)p_filter->p_parent;
292
293     /* Select the config */
294     if( i_rate == 48000 )
295     {
296         p_cfg = &eqz_config_48000_10b;
297     }
298     else if( i_rate == 44100 )
299     {
300         p_cfg = &eqz_config_44100_10b;
301     }
302     else
303     {
304         /* TODO compute the coeffs on the fly */
305         msg_Err( p_filter, "rate not supported" );
306         return VLC_EGENERIC;
307     }
308
309     /* Create the static filter config */
310     p_sys->i_band = p_cfg->i_band;
311     p_sys->f_alpha = malloc( p_sys->i_band * sizeof(float) );
312     p_sys->f_beta  = malloc( p_sys->i_band * sizeof(float) );
313     p_sys->f_gamma = malloc( p_sys->i_band * sizeof(float) );
314     if( !p_sys->f_alpha || !p_sys->f_beta || !p_sys->f_gamma )
315     {
316         free( p_sys->f_alpha );
317         free( p_sys->f_beta );
318         free( p_sys->f_gamma );
319         return VLC_ENOMEM;
320     }
321
322     for( i = 0; i < p_sys->i_band; i++ )
323     {
324         p_sys->f_alpha[i] = p_cfg->band[i].f_alpha;
325         p_sys->f_beta[i]  = p_cfg->band[i].f_beta;
326         p_sys->f_gamma[i] = p_cfg->band[i].f_gamma;
327     }
328
329     /* Filter dyn config */
330     p_sys->b_2eqz = false;
331     p_sys->f_gamp = 1.0;
332     p_sys->f_amp  = malloc( p_sys->i_band * sizeof(float) );
333     if( !p_sys->f_amp )
334     {
335         free( p_sys->f_alpha );
336         free( p_sys->f_beta );
337         free( p_sys->f_gamma );
338         return VLC_ENOMEM;
339     }
340     for( i = 0; i < p_sys->i_band; i++ )
341     {
342         p_sys->f_amp[i] = 0.0;
343     }
344
345     /* Filter state */
346     for( ch = 0; ch < 32; ch++ )
347     {
348         p_sys->x[ch][0]  =
349         p_sys->x[ch][1]  =
350         p_sys->x2[ch][0] =
351         p_sys->x2[ch][1] = 0.0;
352
353         for( i = 0; i < p_sys->i_band; i++ )
354         {
355             p_sys->y[ch][i][0]  =
356             p_sys->y[ch][i][1]  =
357             p_sys->y2[ch][i][0] =
358             p_sys->y2[ch][i][1] = 0.0;
359         }
360     }
361
362     var_Create( p_aout, "equalizer-bands", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
363     var_Create( p_aout, "equalizer-preset", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
364
365     p_sys->b_2eqz = var_CreateGetBool( p_aout, "equalizer-2pass" );
366
367     var_Create( p_aout, "equalizer-preamp", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
368
369     /* Get initial values */
370     var_Get( p_aout, "equalizer-preset", &val1 );
371     var_Get( p_aout, "equalizer-bands", &val2 );
372     var_Get( p_aout, "equalizer-preamp", &val3 );
373
374     p_sys->b_first = true;
375     PresetCallback( VLC_OBJECT( p_aout ), NULL, val1, val1, p_sys );
376     BandsCallback(  VLC_OBJECT( p_aout ), NULL, val2, val2, p_sys );
377     PreampCallback( VLC_OBJECT( p_aout ), NULL, val3, val3, p_sys );
378     p_sys->b_first = false;
379
380     free( val1.psz_string );
381
382     /* Register preset bands (for intf) if : */
383     /* We have no bands info --> the preset info must be given to the intf */
384     /* or The bands info matches the preset */
385     if (p_sys->psz_newbands == NULL)
386     {
387         msg_Err(p_filter, "No preset selected");
388         free( val2.psz_string );
389         free( p_sys->f_amp );
390         free( p_sys->f_alpha );
391         free( p_sys->f_beta );
392         free( p_sys->f_gamma );
393         return VLC_EGENERIC;
394     }
395     if( ( *(val2.psz_string) &&
396         strstr( p_sys->psz_newbands, val2.psz_string ) ) || !*val2.psz_string )
397     {
398         var_SetString( p_aout, "equalizer-bands", p_sys->psz_newbands );
399         if( p_sys->f_newpreamp == p_sys->f_gamp )
400             var_SetFloat( p_aout, "equalizer-preamp", p_sys->f_newpreamp );
401     }
402     free( val2.psz_string );
403
404     /* Add our own callbacks */
405     var_AddCallback( p_aout, "equalizer-preset", PresetCallback, p_sys );
406     var_AddCallback( p_aout, "equalizer-bands", BandsCallback, p_sys );
407     var_AddCallback( p_aout, "equalizer-preamp", PreampCallback, p_sys );
408
409     msg_Dbg( p_filter, "equalizer loaded for %d Hz with %d bands %d pass",
410                         i_rate, p_sys->i_band, p_sys->b_2eqz ? 2 : 1 );
411     for( i = 0; i < p_sys->i_band; i++ )
412     {
413         msg_Dbg( p_filter, "   %d Hz -> factor:%f alpha:%f beta:%f gamma:%f",
414                  (int)p_cfg->band[i].f_frequency, p_sys->f_amp[i],
415                  p_sys->f_alpha[i], p_sys->f_beta[i], p_sys->f_gamma[i]);
416     }
417     return VLC_SUCCESS;
418 }
419
420 static void EqzFilter( aout_filter_t *p_filter, float *out, float *in,
421                        int i_samples, int i_channels )
422 {
423     aout_filter_sys_t *p_sys = p_filter->p_sys;
424     int i, ch, j;
425
426     for( i = 0; i < i_samples; i++ )
427     {
428         for( ch = 0; ch < i_channels; ch++ )
429         {
430             const float x = in[ch];
431             float o = 0.0;
432
433             for( j = 0; j < p_sys->i_band; j++ )
434             {
435                 float y = p_sys->f_alpha[j] * ( x - p_sys->x[ch][1] ) +
436                           p_sys->f_gamma[j] * p_sys->y[ch][j][0] -
437                           p_sys->f_beta[j]  * p_sys->y[ch][j][1];
438
439                 p_sys->y[ch][j][1] = p_sys->y[ch][j][0];
440                 p_sys->y[ch][j][0] = y;
441
442                 o += y * p_sys->f_amp[j];
443             }
444             p_sys->x[ch][1] = p_sys->x[ch][0];
445             p_sys->x[ch][0] = x;
446
447             /* Second filter */
448             if( p_sys->b_2eqz )
449             {
450                 const float x2 = EQZ_IN_FACTOR * x + o;
451                 o = 0.0;
452                 for( j = 0; j < p_sys->i_band; j++ )
453                 {
454                     float y = p_sys->f_alpha[j] * ( x2 - p_sys->x2[ch][1] ) +
455                               p_sys->f_gamma[j] * p_sys->y2[ch][j][0] -
456                               p_sys->f_beta[j]  * p_sys->y2[ch][j][1];
457
458                     p_sys->y2[ch][j][1] = p_sys->y2[ch][j][0];
459                     p_sys->y2[ch][j][0] = y;
460
461                     o += y * p_sys->f_amp[j];
462                 }
463                 p_sys->x2[ch][1] = p_sys->x2[ch][0];
464                 p_sys->x2[ch][0] = x2;
465
466                 /* We add source PCM + filtered PCM */
467                 out[ch] = p_sys->f_gamp *( EQZ_IN_FACTOR * x2 + o );
468             }
469             else
470             {
471                 /* We add source PCM + filtered PCM */
472                 out[ch] = p_sys->f_gamp *( EQZ_IN_FACTOR * x + o );
473             }
474         }
475
476         in  += i_channels;
477         out += i_channels;
478     }
479 }
480
481 static void EqzClean( aout_filter_t *p_filter )
482 {
483     aout_filter_sys_t *p_sys = p_filter->p_sys;
484
485     var_DelCallback( (aout_instance_t *)p_filter->p_parent,
486                         "equalizer-bands", BandsCallback, p_sys );
487     var_DelCallback( (aout_instance_t *)p_filter->p_parent,
488                         "equalizer-preset", PresetCallback, p_sys );
489     var_DelCallback( (aout_instance_t *)p_filter->p_parent,
490                         "equalizer-preamp", PreampCallback, p_sys );
491
492     free( p_sys->f_alpha );
493     free( p_sys->f_beta );
494     free( p_sys->f_gamma );
495
496     free( p_sys->f_amp );
497     free( p_sys->psz_newbands );
498 }
499
500
501 static int PresetCallback( vlc_object_t *p_this, char const *psz_cmd,
502                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
503 {
504     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
505     aout_filter_sys_t *p_sys = (aout_filter_sys_t *)p_data;
506     aout_instance_t *p_aout = (aout_instance_t *)p_this;
507
508     char *psz_preset = newval.psz_string;
509
510     if( !*psz_preset || p_sys->i_band != 10 )
511         return VLC_SUCCESS;
512
513     for( unsigned i = 0; eqz_preset_10b[i] != NULL; i++ )
514     {
515         if( !strcasecmp( eqz_preset_10b[i]->psz_name, psz_preset ) )
516         {
517             char *psz_newbands = NULL;
518
519             p_sys->f_gamp *= pow( 10, eqz_preset_10b[i]->f_preamp / 20.0 );
520             for( int j = 0; j < p_sys->i_band; j++ )
521             {
522                 lldiv_t d;
523                 char *psz;
524
525                 p_sys->f_amp[j] = EqzConvertdB( eqz_preset_10b[i]->f_amp[j] );
526                 d = lldiv( eqz_preset_10b[i]->f_amp[j] * 10000000, 10000000 );
527                 if( asprintf( &psz, "%s %lld.%07llu",
528                               psz_newbands ? psz_newbands : "",
529                               d.quot, d.rem ) == -1 )
530                 {
531                     free( psz_newbands );
532                     return VLC_ENOMEM;
533                 }
534                 free( psz_newbands );
535                 psz_newbands = psz;
536             }
537             if( p_sys->b_first == false )
538             {
539                 var_SetString( p_aout, "equalizer-bands", psz_newbands );
540                 var_SetFloat( p_aout, "equalizer-preamp",
541                               eqz_preset_10b[i]->f_preamp );
542                 free( psz_newbands );
543             }
544             else
545             {
546                 p_sys->psz_newbands = psz_newbands;
547                 p_sys->f_newpreamp = eqz_preset_10b[i]->f_preamp;
548             }
549             return VLC_SUCCESS;
550         }
551     }
552     msg_Err( p_aout, "equalizer preset '%s' not found", psz_preset );
553     msg_Info( p_aout, "full list:" );
554     for( unsigned i = 0; eqz_preset_10b[i] != NULL; i++ )
555          msg_Info( p_aout, "  - '%s'", eqz_preset_10b[i]->psz_name );
556     return VLC_SUCCESS;
557 }
558
559 static int PreampCallback( vlc_object_t *p_this, char const *psz_cmd,
560                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
561 {
562     VLC_UNUSED(p_this); VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
563     aout_filter_sys_t *p_sys = (aout_filter_sys_t *)p_data;
564
565     if( newval.f_float < -20.0 )
566         newval.f_float = -20.0;
567     else if( newval.f_float > 20.0 )
568         newval.f_float = 20.0;
569     p_sys->f_gamp = pow( 10, newval.f_float /20.0);
570
571     return VLC_SUCCESS;
572 }
573
574 static int BandsCallback( vlc_object_t *p_this, char const *psz_cmd,
575                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
576 {
577     VLC_UNUSED(p_this); VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
578     aout_filter_sys_t *p_sys = (aout_filter_sys_t *)p_data;
579     char *psz_bands = newval.psz_string;
580     char *psz_next;
581     char *p = psz_bands;
582     int i;
583
584     /* Same thing for bands */
585     for( i = 0; i < p_sys->i_band; i++ )
586     {
587         float f;
588
589         if( *psz_bands == '\0' )
590             break;
591
592         /* Read dB -20/20 */
593         f = us_strtof( p, &psz_next );
594
595         if( psz_next == p )
596             break; /* no conversion */
597
598         p_sys->f_amp[i] = EqzConvertdB( f );
599
600         if( *psz_next == '\0' )
601             break; /* end of line */
602         p = &psz_next[1];
603     }
604     return VLC_SUCCESS;
605 }
606