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