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