git.sesse.net Git - vlc/blob - 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     /* Filter dyn config */
 104     float *f_amp;   /* Per band amp */
 105     float f_gamp;   /* Global preamp */
 106     vlc_bool_t b_2eqz;
 107
 108     /* Filter state */
 109     float x[32][2];
 110     float y[32][128][2];
 111
 112     /* Second filter state */
 113     float x2[32][2];
 114     float y2[32][128][2];
 115
 116 } aout_filter_sys_t;
 117
 118 static void DoWork( aout_instance_t *, aout_filter_t *,
 119                     aout_buffer_t *, aout_buffer_t * );
 120
 121 #define EQZ_IN_FACTOR (0.25)
 122 static int  EqzInit( aout_filter_t *, int );
 123 static void EqzFilter( aout_filter_t *, float *, float *, int, int );
 124 static void EqzClean( aout_filter_t * );
 125
 126 /*****************************************************************************
 127  * Open:
 128  *****************************************************************************/
 129 static int Open( vlc_object_t *p_this )
 130 {
 131     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
 132     aout_filter_sys_t *p_sys;
 133
 134     if( p_filter->input.i_format != VLC_FOURCC('f','l','3','2' ) ||
 135         p_filter->output.i_format != VLC_FOURCC('f','l','3','2') )
 136     {
 137         msg_Warn( p_filter, "Bad input or output format" );
 138         return VLC_EGENERIC;
 139     }
 140     if ( !AOUT_FMTS_SIMILAR( &p_filter->input, &p_filter->output ) )
 141     {
 142         msg_Warn( p_filter, "input and output formats are not similar" );
 143         return VLC_EGENERIC;
 144     }
 145
 146     p_filter->pf_do_work = DoWork;
 147     p_filter->b_in_place = VLC_TRUE;
 148
 149     /* Allocate structure */
 150     p_sys = p_filter->p_sys = malloc( sizeof( aout_filter_sys_t ) );
 151
 152     if( EqzInit( p_filter, p_filter->input.i_rate ) )
 153         return VLC_EGENERIC;
 154
 155     return VLC_SUCCESS;
 156 }
 157
 158 /*****************************************************************************
 159  * Close: close the plugin
 160  *****************************************************************************/
 161 static void Close( vlc_object_t *p_this )
 162 {
 163     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
 164     aout_filter_sys_t *p_sys = p_filter->p_sys;
 165
 166     EqzClean( p_filter );
 167     free( p_sys );
 168 }
 169
 170 /*****************************************************************************
 171  * DoWork: process samples buffer
 172  *****************************************************************************
 173  *
 174  *****************************************************************************/
 175 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
 176                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
 177 {
 178     p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
 179     p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes;
 180
 181     EqzFilter( p_filter, (float*)p_out_buf->p_buffer,
 182                (float*)p_in_buf->p_buffer, p_in_buf->i_nb_samples,
 183                aout_FormatNbChannels( &p_filter->input ) );
 184 }
 185
 186 /*****************************************************************************
 187  * Equalizer stuff
 188  *****************************************************************************/
 189 typedef struct
 190 {
 191     int   i_band;
 192
 193     struct
 194     {
 195         float f_frequency;
 196         float f_alpha;
 197         float f_beta;
 198         float f_gamma;
 199     } band[];
 200
 201 } eqz_config_t;
 202
 203 /* Value from equ-xmms */
 204 static const eqz_config_t eqz_config_44100_10b =
 205 {
 206     10,
 207     {
 208         {    60, 0.003013, 0.993973, 1.993901 },
 209         {   170, 0.008490, 0.983019, 1.982437 },
 210         {   310, 0.015374, 0.969252, 1.967331 },
 211         {   600, 0.029328, 0.941343, 1.934254 },
 212         {  1000, 0.047918, 0.904163, 1.884869 },
 213         {  3000, 0.130408, 0.739184, 1.582718 },
 214         {  6000, 0.226555, 0.546889, 1.015267 },
 215         { 12000, 0.344937, 0.310127, -0.181410 },
 216         { 14000, 0.366438, 0.267123, -0.521151 },
 217         { 16000, 0.379009, 0.241981, -0.808451 },
 218     }
 219 };
 220 static const eqz_config_t eqz_config_48000_10b =
 221 {
 222     10,
 223     {
 224         {    60, 0.002769, 0.994462, 1.994400 },
 225         {   170, 0.007806, 0.984388, 1.983897 },
 226         {   310, 0.014143, 0.971714, 1.970091 },
 227         {   600, 0.027011, 0.945978, 1.939979 },
 228         {  1000, 0.044203, 0.911595, 1.895241 },
 229         {  3000, 0.121223, 0.757553, 1.623767 },
 230         {  6000, 0.212888, 0.574224, 1.113145 },
 231         { 12000, 0.331347, 0.337307, 0.000000 },
 232         { 14000, 0.355263, 0.289473, -0.333740 },
 233         { 16000, 0.371900, 0.256201, -0.628100 }
 234     }
 235 };
 236
 237 typedef struct
 238 {
 239     char *psz_name;
 240     int  i_band;
 241     float f_amp[];
 242 } eqz_preset_t;
 243
 244 static const eqz_preset_t eqz_preset_flat_10b=
 245 {
 246     "flat", 10,
 247     { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
 248 };
 249 static const eqz_preset_t eqz_preset_classical_10b=
 250 {
 251     "classical", 10,
 252     { -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 }
 253 };
 254 static const eqz_preset_t eqz_preset_club_10b=
 255 {
 256     "club", 10,
 257     { -1.11022e-15, -1.11022e-15, 8, 5.6, 5.6, 5.6, 3.2, -1.11022e-15, -1.11022e-15, -1.11022e-15 }
 258 };
 259 static const eqz_preset_t eqz_preset_dance_10b=
 260 {
 261     "dance", 10,
 262     { 9.6, 7.2, 2.4, -1.11022e-15, -1.11022e-15, -5.6, -7.2, -7.2, -1.11022e-15, -1.11022e-15 }
 263 };
 264 static const eqz_preset_t eqz_preset_fullbass_10b=
 265 {
 266     "fullbass", 10,
 267     { -8, 9.6, 9.6, 5.6, 1.6, -4, -8, -10.4, -11.2, -11.2  }
 268 };
 269 static const eqz_preset_t eqz_preset_fullbasstreeble_10b=
 270 {
 271     "fullbasstreeble", 10,
 272     { 7.2, 5.6, -1.11022e-15, -7.2, -4.8, 1.6, 8, 11.2, 12, 12 }
 273 };
 274
 275 static const eqz_preset_t eqz_preset_fulltreeble_10b=
 276 {
 277     "fulltreeble", 10,
 278     { -9.6, -9.6, -9.6, -4, 2.4, 11.2, 16, 16, 16, 16.8 }
 279 };
 280 static const eqz_preset_t eqz_preset_headphones_10b=
 281 {
 282     "headphones", 10,
 283     { 4.8, 11.2, 5.6, -3.2, -2.4, 1.6, 4.8, 9.6, 12.8, 14.4 }
 284 };
 285 static const eqz_preset_t eqz_preset_largehall_10b=
 286 {
 287     "largehall", 10,
 288     { 10.4, 10.4, 5.6, 5.6, -1.11022e-15, -4.8, -4.8, -4.8, -1.11022e-15, -1.11022e-15 }
 289 };
 290 static const eqz_preset_t eqz_preset_live_10b=
 291 {
 292     "live", 10,
 293     { -4.8, -1.11022e-15, 4, 5.6, 5.6, 5.6, 4, 2.4, 2.4, 2.4 }
 294 };
 295 static const eqz_preset_t eqz_preset_party_10b=
 296 {
 297     "party", 10,
 298     { 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 }
 299 };
 300 static const eqz_preset_t eqz_preset_pop_10b=
 301 {
 302     "pop", 10,
 303     { -1.6, 4.8, 7.2, 8, 5.6, -1.11022e-15, -2.4, -2.4, -1.6, -1.6 }
 304 };
 305 static const eqz_preset_t eqz_preset_reggae_10b=
 306 {
 307     "reggae", 10,
 308     { -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 }
 309 };
 310 static const eqz_preset_t eqz_preset_rock_10b=
 311 {
 312     "rock", 10,
 313     { 8, 4.8, -5.6, -8, -3.2, 4, 8.8, 11.2, 11.2, 11.2 }
 314 };
 315 static const eqz_preset_t eqz_preset_ska_10b=
 316 {
 317     "ska", 10,
 318     { -2.4, -4.8, -4, -1.11022e-15, 4, 5.6, 8.8, 9.6, 11.2, 9.6 }
 319 };
 320 static const eqz_preset_t eqz_preset_soft_10b=
 321 {
 322     "soft", 10,
 323     { 4.8, 1.6, -1.11022e-15, -2.4, -1.11022e-15, 4, 8, 9.6, 11.2, 12 }
 324 };
 325 static const eqz_preset_t eqz_preset_softrock_10b=
 326 {
 327     "softrock", 10,
 328     { 4, 4, 2.4, -1.11022e-15, -4, -5.6, -3.2, -1.11022e-15, 2.4, 8.8 }
 329 };
 330 static const eqz_preset_t eqz_preset_techno_10b=
 331 {
 332     "techno", 10,
 333     { 8, 5.6, -1.11022e-15, -5.6, -4.8, -1.11022e-15, 8, 9.6, 9.6, 8.8 }
 334 };
 335
 336 static const eqz_preset_t *eqz_preset_10b[] =
 337 {
 338     &eqz_preset_flat_10b,
 339     &eqz_preset_classical_10b,
 340     &eqz_preset_club_10b,
 341     &eqz_preset_dance_10b,
 342     &eqz_preset_fullbass_10b,
 343     &eqz_preset_fullbasstreeble_10b,
 344     &eqz_preset_fulltreeble_10b,
 345     &eqz_preset_headphones_10b,
 346     &eqz_preset_largehall_10b,
 347     &eqz_preset_live_10b,
 348     &eqz_preset_party_10b,
 349     &eqz_preset_pop_10b,
 350     &eqz_preset_reggae_10b,
 351     &eqz_preset_rock_10b,
 352     &eqz_preset_ska_10b,
 353     &eqz_preset_soft_10b,
 354     &eqz_preset_softrock_10b,
 355     &eqz_preset_techno_10b,
 356     NULL
 357 };
 358
 359
 360 static inline float EqzConvertdB( float db )
 361 {
 362     /* Map it to gain,
 363      * (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)
 364      * db = 20*log( out / in ) with out = in + amp*iir(i/EQZ_IN_FACTOR)
 365      * or iir(i) == i for the center freq so
 366      * db = 20*log( 1 + amp/EQZ_IN_FACTOR )
 367      * -> amp = EQZ_IN_FACTOR*(10^(db/20) - 1)
 368      **/
 369
 370     if( db < -20.0 )
 371         db = -20.0;
 372     else if(  db > 20.0 )
 373         db = 20.0;
 374     return EQZ_IN_FACTOR * ( pow( 10, db / 20.0 ) - 1.0 );
 375 }
 376
 377 static int EqzInit( aout_filter_t *p_filter, int i_rate )
 378 {
 379     aout_filter_sys_t *p_sys = p_filter->p_sys;
 380     const eqz_config_t *p_cfg;
 381     char *psz;
 382     int i, ch;
 383     float f_float;
 384
 385     /* Select the config */
 386     if( i_rate == 48000 )
 387     {
 388         p_cfg = &eqz_config_48000_10b;
 389     }
 390     else if( i_rate == 44100 )
 391     {
 392         p_cfg = &eqz_config_44100_10b;
 393     }
 394     else
 395     {
 396         /* TODO compute the coeffs on the fly */
 397         msg_Err( p_filter, "unsupported rate" );
 398         return VLC_EGENERIC;
 399     }
 400
 401     /* Create the static filter config */
 402     p_sys->i_band = p_cfg->i_band;
 403     p_sys->f_alpha = malloc( p_sys->i_band * sizeof(float) );
 404     p_sys->f_beta  = malloc( p_sys->i_band * sizeof(float) );
 405     p_sys->f_gamma = malloc( p_sys->i_band * sizeof(float) );
 406     for( i = 0; i < p_sys->i_band; i++ )
 407     {
 408         p_sys->f_alpha[i] = p_cfg->band[i].f_alpha;
 409         p_sys->f_beta[i]  = p_cfg->band[i].f_beta;
 410         p_sys->f_gamma[i] = p_cfg->band[i].f_gamma;
 411     }
 412
 413     /* Filter dyn config */
 414     p_sys->b_2eqz = VLC_FALSE;
 415     p_sys->f_gamp = 1.0;
 416     p_sys->f_amp   = malloc( p_sys->i_band * sizeof(float) );
 417     for( i = 0; i < p_sys->i_band; i++ )
 418     {
 419         p_sys->f_amp[i] = 0.0;
 420     }
 421
 422     /* Filter state */
 423     for( ch = 0; ch < 32; ch++ )
 424     {
 425         p_sys->x[ch][0]  =
 426         p_sys->x[ch][1]  =
 427         p_sys->x2[ch][0] =
 428         p_sys->x2[ch][1] = 0.0;
 429
 430         for( i = 0; i < p_sys->i_band; i++ )
 431         {
 432             p_sys->y[ch][i][0]  =
 433             p_sys->y[ch][i][1]  =
 434             p_sys->y2[ch][i][0] =
 435             p_sys->y2[ch][i][1] = 0.0;
 436         }
 437     }
 438
 439     /* Now parse config */
 440     p_sys->b_2eqz = var_CreateGetBool( p_filter, "equalizer-2pass" );
 441     f_float = var_CreateGetFloat( p_filter, "equalizer-preamp" );
 442     if( f_float < -20.0 )
 443         f_float = -20.0;
 444     else if( f_float > 20.0 )
 445         f_float = 20.0;
 446     p_sys->f_gamp = pow( 10, f_float /20.0);
 447
 448     psz = var_CreateGetString( p_filter, "equalizer-preset" );
 449     if( *psz && p_sys->i_band == 10 )
 450     {
 451         int i;
 452         /* */
 453         for( i = 0; eqz_preset_10b[i] != NULL; i++ )
 454         {
 455             if( !strcasecmp( eqz_preset_10b[i]->psz_name, psz ) )
 456             {
 457                 int j;
 458                 for( j = 0; j < p_sys->i_band; j++ )
 459                     p_sys->f_amp[j] = EqzConvertdB( eqz_preset_10b[i]->f_amp[j] );
 460                 break;
 461             }
 462         }
 463         if( eqz_preset_10b[i] == NULL )
 464         {
 465             msg_Err( p_filter, "equalizer preset '%s' not found", psz );
 466             msg_Dbg( p_filter, "full list:" );
 467             for( i = 0; eqz_preset_10b[i] != NULL; i++ )
 468                 msg_Dbg( p_filter, "  - '%s'", eqz_preset_10b[i]->psz_name );
 469         }
 470     }
 471     free( psz );
 472
 473     psz = var_CreateGetString( p_filter, "equalizer-bands" );
 474     if( *psz )
 475     {
 476         char *p = psz;
 477         int i;
 478         for( i = 0; i < p_sys->i_band; i++ )
 479         {
 480             float f;
 481
 482             /* Read dB -20/20*/
 483             f = strtof( p, &p );
 484
 485             p_sys->f_amp[i] = EqzConvertdB( f );
 486
 487             if( p == NULL )
 488                 break;
 489             p++;
 490             if( *p == '\0' )
 491                 break;
 492         }
 493     }
 494     free( psz );
 495
 496     msg_Dbg( p_filter, "equalizer loaded for %d Hz with %d bands %d pass",
 497              i_rate, p_sys->i_band, p_sys->b_2eqz ? 2 : 1 );
 498     for( i = 0; i < p_sys->i_band; i++ )
 499     {
 500         msg_Dbg( p_filter, "   %d Hz -> factor:%f alpha:%f beta:%f gamma:%f",
 501                  (int)p_cfg->band[i].f_frequency, p_sys->f_amp[i],
 502                  p_sys->f_alpha[i], p_sys->f_beta[i], p_sys->f_gamma[i]);
 503     }
 504     return VLC_SUCCESS;
 505 }
 506
 507 static void EqzFilter( aout_filter_t *p_filter, float *out, float *in,
 508                        int i_samples, int i_channels )
 509 {
 510     aout_filter_sys_t *p_sys = p_filter->p_sys;
 511     int i, ch, j;
 512
 513     for( i = 0; i < i_samples; i++ )
 514     {
 515         for( ch = 0; ch < i_channels; ch++ )
 516         {
 517             const float x = in[ch];
 518             float o = 0.0;
 519
 520             for( j = 0; j < p_sys->i_band; j++ )
 521             {
 522                 float y = p_sys->f_alpha[j] * ( x - p_sys->x[ch][1] ) +
 523                           p_sys->f_gamma[j] * p_sys->y[ch][j][0] -
 524                           p_sys->f_beta[j]  * p_sys->y[ch][j][1];
 525
 526                 p_sys->y[ch][j][1] = p_sys->y[ch][j][0];
 527                 p_sys->y[ch][j][0] = y;
 528
 529                 o += y * p_sys->f_amp[j];
 530             }
 531             p_sys->x[ch][1] = p_sys->x[ch][0];
 532             p_sys->x[ch][0] = x;
 533
 534             /* Second filter */
 535             if( p_sys->b_2eqz )
 536             {
 537                 const float x2 = EQZ_IN_FACTOR * x + o;
 538                 o = 0.0;
 539                 for( j = 0; j < p_sys->i_band; j++ )
 540                 {
 541                     float y = p_sys->f_alpha[j] * ( x2 - p_sys->x2[ch][1] ) +
 542                               p_sys->f_gamma[j] * p_sys->y2[ch][j][0] -
 543                               p_sys->f_beta[j]  * p_sys->y2[ch][j][1];
 544
 545                     p_sys->y2[ch][j][1] = p_sys->y2[ch][j][0];
 546                     p_sys->y2[ch][j][0] = y;
 547
 548                     o += y * p_sys->f_amp[j];
 549                 }
 550                 p_sys->x2[ch][1] = p_sys->x2[ch][0];
 551                 p_sys->x2[ch][0] = x2;
 552
 553                 /* We add source PCM + filtered PCM */
 554                 out[ch] = p_sys->f_gamp *( EQZ_IN_FACTOR * x2 + o );
 555             }
 556             else
 557             {
 558                 /* We add source PCM + filtered PCM */
 559                 out[ch] = p_sys->f_gamp *( EQZ_IN_FACTOR * x + o );
 560             }
 561         }
 562
 563         in  += i_channels;
 564         out += i_channels;
 565     }
 566 }
 567
 568 static void EqzClean( aout_filter_t *p_filter )
 569 {
 570     aout_filter_sys_t *p_sys = p_filter->p_sys;
 571
 572     free( p_sys->f_alpha );
 573     free( p_sys->f_beta );
 574     free( p_sys->f_gamma );
 575
 576     free( p_sys->f_amp );
 577 }