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_preamp;
 242     float f_amp[];
 243 } eqz_preset_t;
 244
 245 static const eqz_preset_t eqz_preset_flat_10b=
 246 {
 247     "flat", 10, 12.0,
 248     { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
 249 };
 250 static const eqz_preset_t eqz_preset_classical_10b=
 251 {
 252     "classical", 10, 12.0,
 253     { -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 }
 254 };
 255 static const eqz_preset_t eqz_preset_club_10b=
 256 {
 257     "club", 10, 6.0,
 258     { -1.11022e-15, -1.11022e-15, 8, 5.6, 5.6, 5.6, 3.2, -1.11022e-15, -1.11022e-15, -1.11022e-15 }
 259 };
 260 static const eqz_preset_t eqz_preset_dance_10b=
 261 {
 262     "dance", 10, 5.0,
 263     { 9.6, 7.2, 2.4, -1.11022e-15, -1.11022e-15, -5.6, -7.2, -7.2, -1.11022e-15, -1.11022e-15 }
 264 };
 265 static const eqz_preset_t eqz_preset_fullbass_10b=
 266 {
 267     "fullbass", 10, 5.0,
 268     { -8, 9.6, 9.6, 5.6, 1.6, -4, -8, -10.4, -11.2, -11.2  }
 269 };
 270 static const eqz_preset_t eqz_preset_fullbasstreeble_10b=
 271 {
 272     "fullbasstreeble", 10, 4.0,
 273     { 7.2, 5.6, -1.11022e-15, -7.2, -4.8, 1.6, 8, 11.2, 12, 12 }
 274 };
 275
 276 static const eqz_preset_t eqz_preset_fulltreeble_10b=
 277 {
 278     "fulltreeble", 10, 3.0,
 279     { -9.6, -9.6, -9.6, -4, 2.4, 11.2, 16, 16, 16, 16.8 }
 280 };
 281 static const eqz_preset_t eqz_preset_headphones_10b=
 282 {
 283     "headphones", 10, 4.0,
 284     { 4.8, 11.2, 5.6, -3.2, -2.4, 1.6, 4.8, 9.6, 12.8, 14.4 }
 285 };
 286 static const eqz_preset_t eqz_preset_largehall_10b=
 287 {
 288     "largehall", 10, 5.0,
 289     { 10.4, 10.4, 5.6, 5.6, -1.11022e-15, -4.8, -4.8, -4.8, -1.11022e-15, -1.11022e-15 }
 290 };
 291 static const eqz_preset_t eqz_preset_live_10b=
 292 {
 293     "live", 10, 7.0,
 294     { -4.8, -1.11022e-15, 4, 5.6, 5.6, 5.6, 4, 2.4, 2.4, 2.4 }
 295 };
 296 static const eqz_preset_t eqz_preset_party_10b=
 297 {
 298     "party", 10, 6.0,
 299     { 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 }
 300 };
 301 static const eqz_preset_t eqz_preset_pop_10b=
 302 {
 303     "pop", 10, 6.0,
 304     { -1.6, 4.8, 7.2, 8, 5.6, -1.11022e-15, -2.4, -2.4, -1.6, -1.6 }
 305 };
 306 static const eqz_preset_t eqz_preset_reggae_10b=
 307 {
 308     "reggae", 10, 8.0,
 309     { -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 }
 310 };
 311 static const eqz_preset_t eqz_preset_rock_10b=
 312 {
 313     "rock", 10, 5.0,
 314     { 8, 4.8, -5.6, -8, -3.2, 4, 8.8, 11.2, 11.2, 11.2 }
 315 };
 316 static const eqz_preset_t eqz_preset_ska_10b=
 317 {
 318     "ska", 10, 6.0,
 319     { -2.4, -4.8, -4, -1.11022e-15, 4, 5.6, 8.8, 9.6, 11.2, 9.6 }
 320 };
 321 static const eqz_preset_t eqz_preset_soft_10b=
 322 {
 323     "soft", 10, 5.0,
 324     { 4.8, 1.6, -1.11022e-15, -2.4, -1.11022e-15, 4, 8, 9.6, 11.2, 12 }
 325 };
 326 static const eqz_preset_t eqz_preset_softrock_10b=
 327 {
 328     "softrock", 10, 7.0,
 329     { 4, 4, 2.4, -1.11022e-15, -4, -5.6, -3.2, -1.11022e-15, 2.4, 8.8 }
 330 };
 331 static const eqz_preset_t eqz_preset_techno_10b=
 332 {
 333     "techno", 10, 5.0,
 334     { 8, 5.6, -1.11022e-15, -5.6, -4.8, -1.11022e-15, 8, 9.6, 9.6, 8.8 }
 335 };
 336
 337 static const eqz_preset_t *eqz_preset_10b[] =
 338 {
 339     &eqz_preset_flat_10b,
 340     &eqz_preset_classical_10b,
 341     &eqz_preset_club_10b,
 342     &eqz_preset_dance_10b,
 343     &eqz_preset_fullbass_10b,
 344     &eqz_preset_fullbasstreeble_10b,
 345     &eqz_preset_fulltreeble_10b,
 346     &eqz_preset_headphones_10b,
 347     &eqz_preset_largehall_10b,
 348     &eqz_preset_live_10b,
 349     &eqz_preset_party_10b,
 350     &eqz_preset_pop_10b,
 351     &eqz_preset_reggae_10b,
 352     &eqz_preset_rock_10b,
 353     &eqz_preset_ska_10b,
 354     &eqz_preset_soft_10b,
 355     &eqz_preset_softrock_10b,
 356     &eqz_preset_techno_10b,
 357     NULL
 358 };
 359
 360
 361 static inline float EqzConvertdB( float db )
 362 {
 363     /* Map it to gain,
 364      * (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)
 365      * db = 20*log( out / in ) with out = in + amp*iir(i/EQZ_IN_FACTOR)
 366      * or iir(i) == i for the center freq so
 367      * db = 20*log( 1 + amp/EQZ_IN_FACTOR )
 368      * -> amp = EQZ_IN_FACTOR*(10^(db/20) - 1)
 369      **/
 370
 371     if( db < -20.0 )
 372         db = -20.0;
 373     else if(  db > 20.0 )
 374         db = 20.0;
 375     return EQZ_IN_FACTOR * ( pow( 10, db / 20.0 ) - 1.0 );
 376 }
 377
 378 static int EqzInit( aout_filter_t *p_filter, int i_rate )
 379 {
 380     aout_filter_sys_t *p_sys = p_filter->p_sys;
 381     const eqz_config_t *p_cfg;
 382     char *psz;
 383     int i, ch;
 384     float f_float;
 385
 386     /* Select the config */
 387     if( i_rate == 48000 )
 388     {
 389         p_cfg = &eqz_config_48000_10b;
 390     }
 391     else if( i_rate == 44100 )
 392     {
 393         p_cfg = &eqz_config_44100_10b;
 394     }
 395     else
 396     {
 397         /* TODO compute the coeffs on the fly */
 398         msg_Err( p_filter, "unsupported rate" );
 399         return VLC_EGENERIC;
 400     }
 401
 402     /* Create the static filter config */
 403     p_sys->i_band = p_cfg->i_band;
 404     p_sys->f_alpha = malloc( p_sys->i_band * sizeof(float) );
 405     p_sys->f_beta  = malloc( p_sys->i_band * sizeof(float) );
 406     p_sys->f_gamma = malloc( p_sys->i_band * sizeof(float) );
 407     for( i = 0; i < p_sys->i_band; i++ )
 408     {
 409         p_sys->f_alpha[i] = p_cfg->band[i].f_alpha;
 410         p_sys->f_beta[i]  = p_cfg->band[i].f_beta;
 411         p_sys->f_gamma[i] = p_cfg->band[i].f_gamma;
 412     }
 413
 414     /* Filter dyn config */
 415     p_sys->b_2eqz = VLC_FALSE;
 416     p_sys->f_gamp = 1.0;
 417     p_sys->f_amp   = malloc( p_sys->i_band * sizeof(float) );
 418     for( i = 0; i < p_sys->i_band; i++ )
 419     {
 420         p_sys->f_amp[i] = 0.0;
 421     }
 422
 423     /* Filter state */
 424     for( ch = 0; ch < 32; ch++ )
 425     {
 426         p_sys->x[ch][0]  =
 427         p_sys->x[ch][1]  =
 428         p_sys->x2[ch][0] =
 429         p_sys->x2[ch][1] = 0.0;
 430
 431         for( i = 0; i < p_sys->i_band; i++ )
 432         {
 433             p_sys->y[ch][i][0]  =
 434             p_sys->y[ch][i][1]  =
 435             p_sys->y2[ch][i][0] =
 436             p_sys->y2[ch][i][1] = 0.0;
 437         }
 438     }
 439
 440     /* Now parse config */
 441     p_sys->b_2eqz = var_CreateGetBool( p_filter, "equalizer-2pass" );
 442     f_float = var_CreateGetFloat( p_filter, "equalizer-preamp" );
 443     if( f_float < -20.0 )
 444         f_float = -20.0;
 445     else if( f_float > 20.0 )
 446         f_float = 20.0;
 447     p_sys->f_gamp = pow( 10, f_float /20.0);
 448
 449     psz = var_CreateGetString( p_filter, "equalizer-preset" );
 450     if( *psz && p_sys->i_band == 10 )
 451     {
 452         int i;
 453         /* */
 454         for( i = 0; eqz_preset_10b[i] != NULL; i++ )
 455         {
 456             if( !strcasecmp( eqz_preset_10b[i]->psz_name, psz ) )
 457             {
 458                 int j;
 459                 p_sys->f_gamp *= pow( 10, eqz_preset_10b[i]->f_preamp / 20.0 );
 460                 for( j = 0; j < p_sys->i_band; j++ )
 461                     p_sys->f_amp[j] = EqzConvertdB( eqz_preset_10b[i]->f_amp[j] );
 462                 break;
 463             }
 464         }
 465         if( eqz_preset_10b[i] == NULL )
 466         {
 467             msg_Err( p_filter, "equalizer preset '%s' not found", psz );
 468             msg_Dbg( p_filter, "full list:" );
 469             for( i = 0; eqz_preset_10b[i] != NULL; i++ )
 470                 msg_Dbg( p_filter, "  - '%s'", eqz_preset_10b[i]->psz_name );
 471         }
 472     }
 473     free( psz );
 474
 475     psz = var_CreateGetString( p_filter, "equalizer-bands" );
 476     if( *psz )
 477     {
 478         char *p = psz;
 479         int i;
 480         for( i = 0; i < p_sys->i_band; i++ )
 481         {
 482             float f;
 483
 484             /* Read dB -20/20*/
 485             f = strtof( p, &p );
 486
 487             p_sys->f_amp[i] = EqzConvertdB( f );
 488
 489             if( p == NULL )
 490                 break;
 491             p++;
 492             if( *p == '\0' )
 493                 break;
 494         }
 495     }
 496     free( psz );
 497
 498     msg_Dbg( p_filter, "equalizer loaded for %d Hz with %d bands %d pass",
 499              i_rate, p_sys->i_band, p_sys->b_2eqz ? 2 : 1 );
 500     for( i = 0; i < p_sys->i_band; i++ )
 501     {
 502         msg_Dbg( p_filter, "   %d Hz -> factor:%f alpha:%f beta:%f gamma:%f",
 503                  (int)p_cfg->band[i].f_frequency, p_sys->f_amp[i],
 504                  p_sys->f_alpha[i], p_sys->f_beta[i], p_sys->f_gamma[i]);
 505     }
 506     return VLC_SUCCESS;
 507 }
 508
 509 static void EqzFilter( aout_filter_t *p_filter, float *out, float *in,
 510                        int i_samples, int i_channels )
 511 {
 512     aout_filter_sys_t *p_sys = p_filter->p_sys;
 513     int i, ch, j;
 514
 515     for( i = 0; i < i_samples; i++ )
 516     {
 517         for( ch = 0; ch < i_channels; ch++ )
 518         {
 519             const float x = in[ch];
 520             float o = 0.0;
 521
 522             for( j = 0; j < p_sys->i_band; j++ )
 523             {
 524                 float y = p_sys->f_alpha[j] * ( x - p_sys->x[ch][1] ) +
 525                           p_sys->f_gamma[j] * p_sys->y[ch][j][0] -
 526                           p_sys->f_beta[j]  * p_sys->y[ch][j][1];
 527
 528                 p_sys->y[ch][j][1] = p_sys->y[ch][j][0];
 529                 p_sys->y[ch][j][0] = y;
 530
 531                 o += y * p_sys->f_amp[j];
 532             }
 533             p_sys->x[ch][1] = p_sys->x[ch][0];
 534             p_sys->x[ch][0] = x;
 535
 536             /* Second filter */
 537             if( p_sys->b_2eqz )
 538             {
 539                 const float x2 = EQZ_IN_FACTOR * x + o;
 540                 o = 0.0;
 541                 for( j = 0; j < p_sys->i_band; j++ )
 542                 {
 543                     float y = p_sys->f_alpha[j] * ( x2 - p_sys->x2[ch][1] ) +
 544                               p_sys->f_gamma[j] * p_sys->y2[ch][j][0] -
 545                               p_sys->f_beta[j]  * p_sys->y2[ch][j][1];
 546
 547                     p_sys->y2[ch][j][1] = p_sys->y2[ch][j][0];
 548                     p_sys->y2[ch][j][0] = y;
 549
 550                     o += y * p_sys->f_amp[j];
 551                 }
 552                 p_sys->x2[ch][1] = p_sys->x2[ch][0];
 553                 p_sys->x2[ch][0] = x2;
 554
 555                 /* We add source PCM + filtered PCM */
 556                 out[ch] = p_sys->f_gamp *( EQZ_IN_FACTOR * x2 + o );
 557             }
 558             else
 559             {
 560                 /* We add source PCM + filtered PCM */
 561                 out[ch] = p_sys->f_gamp *( EQZ_IN_FACTOR * x + o );
 562             }
 563         }
 564
 565         in  += i_channels;
 566         out += i_channels;
 567     }
 568 }
 569
 570 static void EqzClean( aout_filter_t *p_filter )
 571 {
 572     aout_filter_sys_t *p_sys = p_filter->p_sys;
 573
 574     free( p_sys->f_alpha );
 575     free( p_sys->f_beta );
 576     free( p_sys->f_gamma );
 577
 578     free( p_sys->f_amp );
 579 }