* strtof is C99 and not present on pre BSD 5 (including older Mac OSX).
[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 /* TODO:
36  *  - add tables for other rates ( 22500, 11250, ...)
37  *  - optimize a bit (you can hardly do slower ;)
38  *  - add tables for more bands (15 and 32 would be cool), maybe with auto coeffs
39  *  computation (not too hard once the Q is found).
40  *  - support for external preset
41  *  - callback to handle preset changes on the fly
42  *  - ...
43  */
44
45 /*****************************************************************************
46  * Module descriptor
47  *****************************************************************************/
48 static int  Open ( vlc_object_t * );
49 static void Close( vlc_object_t * );
50
51 #define PRESET_TEXT N_( "Equalizer preset" )
52 #define PRESET_LONGTEXT PRESET_TEXT
53
54 #define BANDS_TEXT N_( "Bands gain")
55 #define BANDS_LONGTEXT N_( "Override preset bands gain in dB (-20 ... 20)" )
56
57 #define TWOPASS_TEXT N_( "Two pass" )
58 #define TWOPASS_LONGTEXT N_( "Filter twice the audio" )
59
60 #define PREAMP_TEXT N_("Global gain" )
61 #define PREAMP_LONGTEXT N_("Set the global gain in dB (-20 ... 20)" )
62
63 static char *preset_list[] = {
64     "flat", "classical", "club", "dance", "fullbass", "fullbasstreeble",
65     "fulltreeble", "headphones","largehall", "live", "party", "pop", "reggae",
66     "rock", "ska", "soft", "softrock", "techno"
67 };
68 static char *preset_list_text[] = {
69     N_("Flat"), N_("Classical"), N_("Club"), N_("Dance"), N_("Full bass"),
70     N_("Full bass and treeble"), N_("Full treeble"), N_("Headphones"),
71     N_("Large Hall"), N_("Live"), N_("Party"), N_("Pop"), N_("Reggae"),
72     N_("Rock"), N_("Ska"), N_("Soft"), N_("Soft rock"), N_("Techno"),
73 };
74
75 vlc_module_begin();
76     set_description( _("Equalizer 10 bands") );
77     set_capability( "audio filter", 0 );
78     add_string( "equalizer-preset", "flat", NULL, PRESET_TEXT,
79                 PRESET_LONGTEXT, VLC_TRUE );
80         change_string_list( preset_list, preset_list_text, 0 );
81     add_string( "equalizer-bands", NULL, NULL, BANDS_TEXT,
82                 BANDS_LONGTEXT, VLC_TRUE );
83     add_bool( "equalizer-2pass", 0, NULL, TWOPASS_TEXT,
84               TWOPASS_LONGTEXT, VLC_TRUE );
85     add_float( "equalizer-preamp", 0.0, NULL, PREAMP_TEXT,
86                PREAMP_LONGTEXT, VLC_TRUE );
87     set_callbacks( Open, Close );
88     add_shortcut( "equalizer" );
89 vlc_module_end();
90
91 /*****************************************************************************
92  * Local prototypes
93  *****************************************************************************/
94
95 typedef 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     vlc_bool_t b_first;
106
107     /* Filter dyn config */
108     float *f_amp;   /* Per band amp */
109     float f_gamp;   /* Global preamp */
110     vlc_bool_t 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 } aout_filter_sys_t;
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_instance_t *,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
148     if( p_filter->input.i_format != VLC_FOURCC('f','l','3','2' ) ||
149         p_filter->output.i_format != VLC_FOURCC('f','l','3','2') )
150     {
151         msg_Warn( p_filter, "Bad input or output format" );
152         return VLC_EGENERIC;
153     }
154     if ( !AOUT_FMTS_SIMILAR( &p_filter->input, &p_filter->output ) )
155     {
156         msg_Warn( p_filter, "input and output formats are not similar" );
157         return VLC_EGENERIC;
158     }
159
160     p_filter->pf_do_work = DoWork;
161     p_filter->b_in_place = VLC_TRUE;
162
163     /* Allocate structure */
164     p_sys = p_filter->p_sys = malloc( sizeof( aout_filter_sys_t ) );
165
166     if( EqzInit( p_filter, p_filter->input.i_rate ) )
167         return VLC_EGENERIC;
168
169     return VLC_SUCCESS;
170 }
171
172 /*****************************************************************************
173  * Close: close the plugin
174  *****************************************************************************/
175 static void Close( vlc_object_t *p_this )
176 {
177     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
178     aout_filter_sys_t *p_sys = p_filter->p_sys;
179
180     EqzClean( p_filter );
181     free( p_sys );
182 }
183
184 /*****************************************************************************
185  * DoWork: process samples buffer
186  *****************************************************************************
187  *
188  *****************************************************************************/
189 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
190                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
191 {
192     p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
193     p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes;
194
195     EqzFilter( p_aout, p_filter, (float*)p_out_buf->p_buffer,
196                (float*)p_in_buf->p_buffer, p_in_buf->i_nb_samples,
197                aout_FormatNbChannels( &p_filter->input ) );
198 }
199
200 /*****************************************************************************
201  * Equalizer stuff
202  *****************************************************************************/
203 typedef struct
204 {
205     int   i_band;
206
207     struct
208     {
209         float f_frequency;
210         float f_alpha;
211         float f_beta;
212         float f_gamma;
213     } band[];
214
215 } eqz_config_t;
216
217 /* Value from equ-xmms */
218 static const eqz_config_t eqz_config_44100_10b =
219 {
220     10,
221     {
222         {    60, 0.003013, 0.993973, 1.993901 },
223         {   170, 0.008490, 0.983019, 1.982437 },
224         {   310, 0.015374, 0.969252, 1.967331 },
225         {   600, 0.029328, 0.941343, 1.934254 },
226         {  1000, 0.047918, 0.904163, 1.884869 },
227         {  3000, 0.130408, 0.739184, 1.582718 },
228         {  6000, 0.226555, 0.546889, 1.015267 },
229         { 12000, 0.344937, 0.310127, -0.181410 },
230         { 14000, 0.366438, 0.267123, -0.521151 },
231         { 16000, 0.379009, 0.241981, -0.808451 },
232     }
233 };
234 static const eqz_config_t eqz_config_48000_10b =
235 {
236     10,
237     {
238         {    60, 0.002769, 0.994462, 1.994400 },
239         {   170, 0.007806, 0.984388, 1.983897 },
240         {   310, 0.014143, 0.971714, 1.970091 },
241         {   600, 0.027011, 0.945978, 1.939979 },
242         {  1000, 0.044203, 0.911595, 1.895241 },
243         {  3000, 0.121223, 0.757553, 1.623767 },
244         {  6000, 0.212888, 0.574224, 1.113145 },
245         { 12000, 0.331347, 0.337307, 0.000000 },
246         { 14000, 0.355263, 0.289473, -0.333740 },
247         { 16000, 0.371900, 0.256201, -0.628100 }
248     }
249 };
250
251 typedef struct
252 {
253     char *psz_name;
254     int  i_band;
255     float f_preamp;
256     float f_amp[];
257 } eqz_preset_t;
258
259 static const eqz_preset_t eqz_preset_flat_10b=
260 {
261     "flat", 10, 12.0,
262     { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
263 };
264 static const eqz_preset_t eqz_preset_classical_10b=
265 {
266     "classical", 10, 12.0,
267     { -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15, -7.2, -7.2, -7.2, -9.6 }
268 };
269 static const eqz_preset_t eqz_preset_club_10b=
270 {
271     "club", 10, 6.0,
272     { -1.11022e-15, -1.11022e-15, 8, 5.6, 5.6, 5.6, 3.2, -1.11022e-15, -1.11022e-15, -1.11022e-15 }
273 };
274 static const eqz_preset_t eqz_preset_dance_10b=
275 {
276     "dance", 10, 5.0,
277     { 9.6, 7.2, 2.4, -1.11022e-15, -1.11022e-15, -5.6, -7.2, -7.2, -1.11022e-15, -1.11022e-15 }
278 };
279 static const eqz_preset_t eqz_preset_fullbass_10b=
280 {
281     "fullbass", 10, 5.0,
282     { -8, 9.6, 9.6, 5.6, 1.6, -4, -8, -10.4, -11.2, -11.2  }
283 };
284 static const eqz_preset_t eqz_preset_fullbasstreeble_10b=
285 {
286     "fullbasstreeble", 10, 4.0,
287     { 7.2, 5.6, -1.11022e-15, -7.2, -4.8, 1.6, 8, 11.2, 12, 12 }
288 };
289
290 static const eqz_preset_t eqz_preset_fulltreeble_10b=
291 {
292     "fulltreeble", 10, 3.0,
293     { -9.6, -9.6, -9.6, -4, 2.4, 11.2, 16, 16, 16, 16.8 }
294 };
295 static const eqz_preset_t eqz_preset_headphones_10b=
296 {
297     "headphones", 10, 4.0,
298     { 4.8, 11.2, 5.6, -3.2, -2.4, 1.6, 4.8, 9.6, 12.8, 14.4 }
299 };
300 static const eqz_preset_t eqz_preset_largehall_10b=
301 {
302     "largehall", 10, 5.0,
303     { 10.4, 10.4, 5.6, 5.6, -1.11022e-15, -4.8, -4.8, -4.8, -1.11022e-15, -1.11022e-15 }
304 };
305 static const eqz_preset_t eqz_preset_live_10b=
306 {
307     "live", 10, 7.0,
308     { -4.8, -1.11022e-15, 4, 5.6, 5.6, 5.6, 4, 2.4, 2.4, 2.4 }
309 };
310 static const eqz_preset_t eqz_preset_party_10b=
311 {
312     "party", 10, 6.0,
313     { 7.2, 7.2, -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15, 7.2, 7.2 }
314 };
315 static const eqz_preset_t eqz_preset_pop_10b=
316 {
317     "pop", 10, 6.0,
318     { -1.6, 4.8, 7.2, 8, 5.6, -1.11022e-15, -2.4, -2.4, -1.6, -1.6 }
319 };
320 static const eqz_preset_t eqz_preset_reggae_10b=
321 {
322     "reggae", 10, 8.0,
323     { -1.11022e-15, -1.11022e-15, -1.11022e-15, -5.6, -1.11022e-15, 6.4, 6.4, -1.11022e-15, -1.11022e-15, -1.11022e-15 }
324 };
325 static const eqz_preset_t eqz_preset_rock_10b=
326 {
327     "rock", 10, 5.0,
328     { 8, 4.8, -5.6, -8, -3.2, 4, 8.8, 11.2, 11.2, 11.2 }
329 };
330 static const eqz_preset_t eqz_preset_ska_10b=
331 {
332     "ska", 10, 6.0,
333     { -2.4, -4.8, -4, -1.11022e-15, 4, 5.6, 8.8, 9.6, 11.2, 9.6 }
334 };
335 static const eqz_preset_t eqz_preset_soft_10b=
336 {
337     "soft", 10, 5.0,
338     { 4.8, 1.6, -1.11022e-15, -2.4, -1.11022e-15, 4, 8, 9.6, 11.2, 12 }
339 };
340 static const eqz_preset_t eqz_preset_softrock_10b=
341 {
342     "softrock", 10, 7.0,
343     { 4, 4, 2.4, -1.11022e-15, -4, -5.6, -3.2, -1.11022e-15, 2.4, 8.8 }
344 };
345 static const eqz_preset_t eqz_preset_techno_10b=
346 {
347     "techno", 10, 5.0,
348     { 8, 5.6, -1.11022e-15, -5.6, -4.8, -1.11022e-15, 8, 9.6, 9.6, 8.8 }
349 };
350
351 static const eqz_preset_t *eqz_preset_10b[] =
352 {
353     &eqz_preset_flat_10b,
354     &eqz_preset_classical_10b,
355     &eqz_preset_club_10b,
356     &eqz_preset_dance_10b,
357     &eqz_preset_fullbass_10b,
358     &eqz_preset_fullbasstreeble_10b,
359     &eqz_preset_fulltreeble_10b,
360     &eqz_preset_headphones_10b,
361     &eqz_preset_largehall_10b,
362     &eqz_preset_live_10b,
363     &eqz_preset_party_10b,
364     &eqz_preset_pop_10b,
365     &eqz_preset_reggae_10b,
366     &eqz_preset_rock_10b,
367     &eqz_preset_ska_10b,
368     &eqz_preset_soft_10b,
369     &eqz_preset_softrock_10b,
370     &eqz_preset_techno_10b,
371     NULL
372 };
373
374
375 static inline float EqzConvertdB( float db )
376 {
377     /* Map it to gain,
378      * (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)
379      * db = 20*log( out / in ) with out = in + amp*iir(i/EQZ_IN_FACTOR)
380      * or iir(i) == i for the center freq so
381      * db = 20*log( 1 + amp/EQZ_IN_FACTOR )
382      * -> amp = EQZ_IN_FACTOR*(10^(db/20) - 1)
383      **/
384
385     if( db < -20.0 )
386         db = -20.0;
387     else if(  db > 20.0 )
388         db = 20.0;
389     return EQZ_IN_FACTOR * ( pow( 10, db / 20.0 ) - 1.0 );
390 }
391
392 static int EqzInit( aout_filter_t *p_filter, int i_rate )
393 {
394     aout_filter_sys_t *p_sys = p_filter->p_sys;
395     const eqz_config_t *p_cfg;
396     int i, ch;
397     vlc_value_t val1, val2, val3;
398     aout_instance_t *p_aout = (aout_instance_t *)p_filter->p_parent;
399
400     /* Select the config */
401     if( i_rate == 48000 )
402     {
403         p_cfg = &eqz_config_48000_10b;
404     }
405     else if( i_rate == 44100 )
406     {
407         p_cfg = &eqz_config_44100_10b;
408     }
409     else
410     {
411         /* TODO compute the coeffs on the fly */
412         msg_Err( p_filter, "unsupported rate" );
413         return VLC_EGENERIC;
414     }
415
416     /* Create the static filter config */
417     p_sys->i_band = p_cfg->i_band;
418     p_sys->f_alpha = malloc( p_sys->i_band * sizeof(float) );
419     p_sys->f_beta  = malloc( p_sys->i_band * sizeof(float) );
420     p_sys->f_gamma = malloc( p_sys->i_band * sizeof(float) );
421     for( i = 0; i < p_sys->i_band; i++ )
422     {
423         p_sys->f_alpha[i] = p_cfg->band[i].f_alpha;
424         p_sys->f_beta[i]  = p_cfg->band[i].f_beta;
425         p_sys->f_gamma[i] = p_cfg->band[i].f_gamma;
426     }
427
428     /* Filter dyn config */
429     p_sys->b_2eqz = VLC_FALSE;
430     p_sys->f_gamp = 1.0;
431     p_sys->f_amp   = malloc( p_sys->i_band * sizeof(float) );
432     for( i = 0; i < p_sys->i_band; i++ )
433     {
434         p_sys->f_amp[i] = 0.0;
435     }
436
437     /* Filter state */
438     for( ch = 0; ch < 32; ch++ )
439     {
440         p_sys->x[ch][0]  =
441         p_sys->x[ch][1]  =
442         p_sys->x2[ch][0] =
443         p_sys->x2[ch][1] = 0.0;
444
445         for( i = 0; i < p_sys->i_band; i++ )
446         {
447             p_sys->y[ch][i][0]  =
448             p_sys->y[ch][i][1]  =
449             p_sys->y2[ch][i][0] =
450             p_sys->y2[ch][i][1] = 0.0;
451         }
452     }
453
454     var_CreateGetString( p_aout,"equalizer-bands" );
455     var_CreateGetString( p_aout, "equalizer-preset" );
456
457     p_sys->b_2eqz = var_CreateGetBool( p_aout, "equalizer-2pass" );
458
459     var_CreateGetFloat( p_aout, "equalizer-preamp" );
460
461     /* Get initial values */
462     var_Get( p_aout, "equalizer-preset", &val1 );
463     var_Get( p_aout, "equalizer-bands", &val2 );
464     var_Get( p_aout, "equalizer-preamp", &val3 );
465
466     p_sys->b_first = VLC_TRUE;
467     PresetCallback( VLC_OBJECT( p_aout ), NULL, val1, val1, p_sys );
468     BandsCallback(  VLC_OBJECT( p_aout ), NULL, val2, val2, p_sys );
469     PreampCallback( VLC_OBJECT( p_aout ), NULL, val3, val3, p_sys );
470     p_sys->b_first = VLC_FALSE;
471
472     /* Register preset bands (for intf) if : */
473     /* We have no bands info --> the preset info must be given to the intf */
474     /* or The bands info matches the preset */
475     if( ( *(val2.psz_string) &&
476         strstr( p_sys->psz_newbands, val2.psz_string ) ) || !*val2.psz_string )
477     {
478         var_SetString( p_aout, "equalizer-bands", p_sys->psz_newbands );
479         var_SetFloat( p_aout, "equalizer-preamp", p_sys->f_newpreamp );
480     }
481
482     /* Add our own callbacks */
483     var_AddCallback( p_aout, "equalizer-preset", PresetCallback, p_sys );
484     var_AddCallback( p_aout, "equalizer-bands", BandsCallback, p_sys );
485     var_AddCallback( p_aout, "equalizer-preamp", PreampCallback, p_sys );
486
487     msg_Dbg( p_filter, "equalizer loaded for %d Hz with %d bands %d pass",
488                         i_rate, p_sys->i_band, p_sys->b_2eqz ? 2 : 1 );
489     for( i = 0; i < p_sys->i_band; i++ )
490     {
491         msg_Dbg( p_filter, "   %d Hz -> factor:%f alpha:%f beta:%f gamma:%f",
492                  (int)p_cfg->band[i].f_frequency, p_sys->f_amp[i],
493                  p_sys->f_alpha[i], p_sys->f_beta[i], p_sys->f_gamma[i]);
494     }
495     return VLC_SUCCESS;
496 }
497
498 static void EqzFilter( aout_instance_t *p_aout,
499                        aout_filter_t *p_filter, float *out, float *in,
500                        int i_samples, int i_channels )
501 {
502     aout_filter_sys_t *p_sys = p_filter->p_sys;
503     int i, ch, j;
504
505     for( i = 0; i < i_samples; i++ )
506     {
507         for( ch = 0; ch < i_channels; ch++ )
508         {
509             const float x = in[ch];
510             float o = 0.0;
511
512             for( j = 0; j < p_sys->i_band; j++ )
513             {
514                 float y = p_sys->f_alpha[j] * ( x - p_sys->x[ch][1] ) +
515                           p_sys->f_gamma[j] * p_sys->y[ch][j][0] -
516                           p_sys->f_beta[j]  * p_sys->y[ch][j][1];
517
518                 p_sys->y[ch][j][1] = p_sys->y[ch][j][0];
519                 p_sys->y[ch][j][0] = y;
520
521                 o += y * p_sys->f_amp[j];
522             }
523             p_sys->x[ch][1] = p_sys->x[ch][0];
524             p_sys->x[ch][0] = x;
525
526             /* Second filter */
527             if( p_sys->b_2eqz )
528             {
529                 const float x2 = EQZ_IN_FACTOR * x + o;
530                 o = 0.0;
531                 for( j = 0; j < p_sys->i_band; j++ )
532                 {
533                     float y = p_sys->f_alpha[j] * ( x2 - p_sys->x2[ch][1] ) +
534                               p_sys->f_gamma[j] * p_sys->y2[ch][j][0] -
535                               p_sys->f_beta[j]  * p_sys->y2[ch][j][1];
536
537                     p_sys->y2[ch][j][1] = p_sys->y2[ch][j][0];
538                     p_sys->y2[ch][j][0] = y;
539
540                     o += y * p_sys->f_amp[j];
541                 }
542                 p_sys->x2[ch][1] = p_sys->x2[ch][0];
543                 p_sys->x2[ch][0] = x2;
544
545                 /* We add source PCM + filtered PCM */
546                 out[ch] = p_sys->f_gamp *( EQZ_IN_FACTOR * x2 + o );
547             }
548             else
549             {
550                 /* We add source PCM + filtered PCM */
551                 out[ch] = p_sys->f_gamp *( EQZ_IN_FACTOR * x + o );
552             }
553         }
554
555         in  += i_channels;
556         out += i_channels;
557     }
558 }
559
560 static void EqzClean( aout_filter_t *p_filter )
561 {
562     aout_filter_sys_t *p_sys = p_filter->p_sys;
563
564     var_DelCallback( (aout_instance_t *)p_filter->p_parent,
565                         "equalizer-bands", BandsCallback, p_sys );
566     var_DelCallback( (aout_instance_t *)p_filter->p_parent,
567                         "equalizer-preset", PresetCallback, p_sys );
568     var_DelCallback( (aout_instance_t *)p_filter->p_parent,
569                         "equalizer-preamp", PreampCallback, p_sys );
570
571     free( p_sys->f_alpha );
572     free( p_sys->f_beta );
573     free( p_sys->f_gamma );
574
575     free( p_sys->f_amp );
576 }
577
578
579 static int PresetCallback( vlc_object_t *p_this, char const *psz_cmd,
580                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
581 {
582     aout_filter_sys_t *p_sys = (aout_filter_sys_t *)p_data;
583     aout_instance_t *p_aout = (aout_instance_t *)p_this;
584
585     char *psz_preset = newval.psz_string;
586     char psz_newbands[120];
587
588     memset( psz_newbands, 0, 120 );
589
590     if( *psz_preset && p_sys->i_band == 10 )
591     {
592         int i;
593         /* */
594         for( i = 0; eqz_preset_10b[i] != NULL; i++ )
595         {
596             if( !strcasecmp( eqz_preset_10b[i]->psz_name, psz_preset ) )
597             {
598                 int j;
599                 p_sys->f_gamp *= pow( 10, eqz_preset_10b[i]->f_preamp / 20.0 );
600                 for( j = 0; j < p_sys->i_band; j++ )
601                 {
602                     p_sys->f_amp[j] = EqzConvertdB(
603                                         eqz_preset_10b[i]->f_amp[j] );
604                     sprintf( psz_newbands, "%s %f", psz_newbands,
605                                          eqz_preset_10b[i]->f_amp[j] );
606                 }
607                 if( p_sys->b_first == VLC_FALSE )
608                 {
609                     var_SetString( p_aout, "equalizer-bands", psz_newbands );
610                     var_SetFloat( p_aout, "equalizer-preamp",
611                                     eqz_preset_10b[i]->f_preamp );
612                 }
613                 else
614                 {
615                     p_sys->psz_newbands = strdup( psz_newbands );
616                     p_sys->f_newpreamp = eqz_preset_10b[i]->f_preamp;
617                 }
618                 break;
619             }
620         }
621         if( eqz_preset_10b[i] == NULL )
622         {
623             msg_Err( p_aout, "equalizer preset '%s' not found", psz_preset );
624             msg_Dbg( p_aout, "full list:" );
625             for( i = 0; eqz_preset_10b[i] != NULL; i++ )
626                 msg_Dbg( p_aout, "  - '%s'", eqz_preset_10b[i]->psz_name );
627         }
628     }
629     return VLC_SUCCESS;
630 }
631
632 static int PreampCallback( vlc_object_t *p_this, char const *psz_cmd,
633                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
634 {
635     aout_filter_sys_t *p_sys = (aout_filter_sys_t *)p_data;
636
637     if( newval.f_float < -20.0 )
638         newval.f_float = -20.0;
639     else if( newval.f_float > 20.0 )
640         newval.f_float = 20.0;
641     p_sys->f_gamp = pow( 10, newval.f_float /20.0);
642
643     return VLC_SUCCESS;
644 }
645
646 static int BandsCallback( vlc_object_t *p_this, char const *psz_cmd,
647                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
648 {
649     aout_filter_sys_t *p_sys = (aout_filter_sys_t *)p_data;
650     char *psz_bands = newval.psz_string;
651
652     /* Same thing for bands */
653     if( *psz_bands )
654     {
655         char *p = psz_bands, *p_next;
656         int i;
657
658         for( i = 0; i < p_sys->i_band; i++ )
659         {
660             /* Read dB -20/20 */
661 #ifdef HAVE_STRTOF
662             float f = strtof( p, &p_next );
663 #else
664             float f = (float) strtod( p, &p_next );
665 #endif
666             if( !p_next || p_next == p ) break; /* strtof() failed */
667
668             p_sys->f_amp[i] = EqzConvertdB( f );
669
670             if( !*p ) break; /* end of line */
671             p++;
672         }
673     }
674
675     return VLC_SUCCESS;
676 }