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