git.sesse.net Git - mlt/blob - src/modules/core/filter_volume.c

   1 /*
   2  * filter_volume.c -- adjust audio volume
   3  * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
   4  * Author: Dan Dennedy <dan@dennedy.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "filter_volume.h"
  22
  23 #include <framework/mlt_frame.h>
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <math.h>
  28 #include <ctype.h>
  29 #include <string.h>
  30
  31 #define MAX_CHANNELS 6
  32 #define EPSILON 0.00001
  33
  34 /* The normalise functions come from the normalize utility:
  35    Copyright (C) 1999--2002 Chris Vaill */
  36
  37 #define samp_width 16
  38
  39 #ifndef ROUND
  40 # define ROUND(x) floor((x) + 0.5)
  41 #endif
  42
  43 #define DBFSTOAMP(x) pow(10,(x)/20.0)
  44
  45 /** Return nonzero if the two strings are equal, ignoring case, up to
  46     the first n characters.
  47 */
  48 int strncaseeq(const char *s1, const char *s2, size_t n)
  49 {
  50         for ( ; n > 0; n--)
  51         {
  52                 if (tolower(*s1++) != tolower(*s2++))
  53                         return 0;
  54         }
  55         return 1;
  56 }
  57
  58 /** Limiter function.
  59
  60          / tanh((x + lev) / (1-lev)) * (1-lev) - lev        (for x < -lev)
  61          |
  62     x' = | x                                                (for |x| <= lev)
  63          |
  64          \ tanh((x - lev) / (1-lev)) * (1-lev) + lev        (for x > lev)
  65
  66   With limiter level = 0, this is equivalent to a tanh() function;
  67   with limiter level = 1, this is equivalent to clipping.
  68 */
  69 static inline double limiter( double x, double lmtr_lvl )
  70 {
  71         double xp = x;
  72
  73         if (x < -lmtr_lvl)
  74                 xp = tanh((x + lmtr_lvl) / (1-lmtr_lvl)) * (1-lmtr_lvl) - lmtr_lvl;
  75         else if (x > lmtr_lvl)
  76                 xp = tanh((x - lmtr_lvl) / (1-lmtr_lvl)) * (1-lmtr_lvl) + lmtr_lvl;
  77
  78 //      if ( x != xp )
  79 //              fprintf( stderr, "filter_volume: sample %f limited %f\n", x, xp );
  80
  81         return xp;
  82 }
  83
  84
  85 /** Takes a full smoothing window, and returns the value of the center
  86     element, smoothed.
  87
  88     Currently, just does a mean filter, but we could do a median or
  89     gaussian filter here instead.
  90 */
  91 static inline double get_smoothed_data( double *buf, int count )
  92 {
  93         int i, j;
  94         double smoothed = 0;
  95
  96         for ( i = 0, j = 0; i < count; i++ )
  97         {
  98                 if ( buf[ i ] != -1.0 )
  99                 {
 100                         smoothed += buf[ i ];
 101                         j++;
 102                 }
 103         }
 104         smoothed /= j;
 105 //      fprintf( stderr, "smoothed over %d values, result %f\n", j, smoothed );
 106
 107         return smoothed;
 108 }
 109
 110 /** Get the max power level (using RMS) and peak level of the audio segment.
 111  */
 112 double signal_max_power( int16_t *buffer, int channels, int samples, int16_t *peak )
 113 {
 114         // Determine numeric limits
 115         int bytes_per_samp = (samp_width - 1) / 8 + 1;
 116         int16_t max = (1 << (bytes_per_samp * 8 - 1)) - 1;
 117         int16_t min = -max - 1;
 118
 119         double *sums = (double *) calloc( channels, sizeof(double) );
 120         int c, i;
 121         int16_t sample;
 122         double pow, maxpow = 0;
 123
 124         /* initialize peaks to effectively -inf and +inf */
 125         int16_t max_sample = min;
 126         int16_t min_sample = max;
 127
 128         for ( i = 0; i < samples; i++ )
 129         {
 130                 for ( c = 0; c < channels; c++ )
 131                 {
 132                         sample = *buffer++;
 133                         sums[ c ] += (double) sample * (double) sample;
 134
 135                         /* track peak */
 136                         if ( sample > max_sample )
 137                                 max_sample = sample;
 138                         else if ( sample < min_sample )
 139                                 min_sample = sample;
 140                 }
 141         }
 142         for ( c = 0; c < channels; c++ )
 143         {
 144                 pow = sums[ c ] / (double) samples;
 145                 if ( pow > maxpow )
 146                         maxpow = pow;
 147         }
 148
 149         free( sums );
 150
 151         /* scale the pow value to be in the range 0.0 -- 1.0 */
 152         maxpow /= ( (double) min * (double) min);
 153
 154         if ( -min_sample > max_sample )
 155                 *peak = min_sample / (double) min;
 156         else
 157                 *peak = max_sample / (double) max;
 158
 159         return sqrt( maxpow );
 160 }
 161
 162 /* ------ End normalize functions --------------------------------------- */
 163
 164 /** Get the audio.
 165 */
 166
 167 static int filter_get_audio( mlt_frame frame, int16_t **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
 168 {
 169         // Get the properties of the a frame
 170         mlt_properties properties = mlt_frame_properties( frame );
 171         double gain = mlt_properties_get_double( properties, "volume.gain" );
 172         double max_gain = mlt_properties_get_double( properties, "volume.max_gain" );
 173         double limiter_level = 0.5; /* -6 dBFS */
 174         int normalise =  mlt_properties_get_int( properties, "volume.normalise" );
 175         double amplitude =  mlt_properties_get_double( properties, "volume.amplitude" );
 176         int i, j;
 177         double sample;
 178         int16_t peak;
 179
 180         // Get the filter from the frame
 181         mlt_filter this = mlt_properties_get_data( properties, "filter_volume", NULL );
 182
 183         // Get the properties from the filter
 184         mlt_properties filter_props = mlt_filter_properties( this );
 185
 186         if ( mlt_properties_get( properties, "volume.limiter" ) != NULL )
 187                 limiter_level = mlt_properties_get_double( properties, "volume.limiter" );
 188
 189         // Restore the original get_audio
 190         frame->get_audio = mlt_properties_get_data( properties, "volume.get_audio", NULL );
 191
 192         // Get the producer's audio
 193         mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
 194 //      fprintf( stderr, "filter_volume: frequency %d\n", *frequency );
 195
 196         // Determine numeric limits
 197         int bytes_per_samp = (samp_width - 1) / 8 + 1;
 198         int samplemax = (1 << (bytes_per_samp * 8 - 1)) - 1;
 199         int samplemin = -samplemax - 1;
 200
 201         if ( normalise )
 202         {
 203                 int window = mlt_properties_get_int( filter_props, "window" );
 204                 double *smooth_buffer = mlt_properties_get_data( filter_props, "smooth_buffer", NULL );
 205                 int *smooth_index = mlt_properties_get_data( filter_props, "smooth_index", NULL );
 206
 207                 if ( window > 0 && smooth_buffer != NULL )
 208                 {
 209                         // Compute the signal power and put into smoothing buffer
 210                         smooth_buffer[ *smooth_index ] = signal_max_power( *buffer, *channels, *samples, &peak );
 211 //                      fprintf( stderr, "filter_volume: raw power %f ", smooth_buffer[ *smooth_index ] );
 212                         if ( smooth_buffer[ *smooth_index ] > EPSILON )
 213                         {
 214                                 *smooth_index = ( *smooth_index + 1 ) % window;
 215
 216                                 // Smooth the data and compute the gain
 217 //                              fprintf( stderr, "smoothed %f over %d frames\n", get_smoothed_data( smooth_buffer, window ), window );
 218                                 gain *= amplitude / get_smoothed_data( smooth_buffer, window );
 219                         }
 220                 }
 221                 else
 222                 {
 223                         gain *= amplitude / signal_max_power( *buffer, *channels, *samples, &peak );
 224                 }
 225         }
 226
 227 //      if ( gain > 1.0 && normalise )
 228 //              fprintf(stderr, "filter_volume: limiter level %f gain %f\n", limiter_level, gain );
 229
 230         if ( max_gain > 0 && gain > max_gain )
 231                 gain = max_gain;
 232
 233         // Initialise filter's previous gain value to prevent an inadvertant jump from 0
 234         if ( mlt_properties_get( filter_props, "previous_gain" ) == NULL )
 235                 mlt_properties_set_double( filter_props, "previous_gain", gain );
 236
 237         // Start the gain out at the previous
 238         double previous_gain = mlt_properties_get_double( filter_props, "previous_gain" );
 239
 240         // Determine ramp increment
 241         double gain_step = ( gain - previous_gain ) / *samples;
 242 //      fprintf( stderr, "filter_volume: previous gain %f current gain %f step %f\n", previous_gain, gain, gain_step );
 243
 244         // Save the current gain for the next iteration
 245         mlt_properties_set_double( filter_props, "previous_gain", gain );
 246
 247         // Ramp from the previous gain to the current
 248         gain = previous_gain;
 249
 250         int16_t *p = *buffer;
 251
 252         // Apply the gain
 253         for ( i = 0; i < *samples; i++ )
 254         {
 255                 for ( j = 0; j < *channels; j++ )
 256                 {
 257                         sample = *p * gain;
 258                         *p = ROUND( sample );
 259
 260                         if ( gain > 1.0 )
 261                         {
 262                                 /* use limiter function instead of clipping */
 263                                 if ( normalise )
 264                                         *p = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) );
 265
 266                                 /* perform clipping */
 267                                 else if ( sample > samplemax )
 268                                         *p = samplemax;
 269                                 else if ( sample < samplemin )
 270                                         *p = samplemin;
 271                         }
 272                         p++;
 273                 }
 274                 gain += gain_step;
 275         }
 276
 277         return 0;
 278 }
 279
 280 /** Filter processing.
 281 */
 282
 283 static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
 284 {
 285         mlt_properties properties = mlt_frame_properties( frame );
 286         mlt_properties filter_props = mlt_filter_properties( this );
 287
 288         // Parse the gain property
 289         if ( mlt_properties_get( properties, "gain" ) == NULL )
 290         {
 291                 double gain = 1.0; // no adjustment
 292
 293                 if ( mlt_properties_get( filter_props, "gain" ) != NULL )
 294                 {
 295                         char *p = mlt_properties_get( filter_props, "gain" );
 296
 297                         if ( strncaseeq( p, "normalise", 9 ) )
 298                                 mlt_properties_set( filter_props, "normalise", "" );
 299                         else
 300                         {
 301                                 if ( strcmp( p, "" ) != 0 )
 302                                         gain = fabs( strtod( p, &p) );
 303
 304                                 while ( isspace( *p ) )
 305                                         p++;
 306
 307                                 /* check if "dB" is given after number */
 308                                 if ( strncaseeq( p, "db", 2 ) )
 309                                         gain = DBFSTOAMP( gain );
 310
 311                                 // If there is an end adjust gain to the range
 312                                 if ( mlt_properties_get( filter_props, "end" ) != NULL )
 313                                 {
 314                                         // Determine the time position of this frame in the transition duration
 315                                         mlt_position in = mlt_filter_get_in( this );
 316                                         mlt_position out = mlt_filter_get_out( this );
 317                                         mlt_position time = mlt_frame_get_position( frame );
 318                                         double position = ( double )( time - in ) / ( double )( out - in + 1 );
 319
 320                                         double end = -1;
 321                                         char *p = mlt_properties_get( filter_props, "end" );
 322                                         if ( strcmp( p, "" ) != 0 )
 323                                                 end = fabs( strtod( p, &p) );
 324
 325                                         while ( isspace( *p ) )
 326                                                 p++;
 327
 328                                         /* check if "dB" is given after number */
 329                                         if ( strncaseeq( p, "db", 2 ) )
 330                                                 end = DBFSTOAMP( gain );
 331
 332                                         if ( end != -1 )
 333                                                 gain += ( end - gain ) * position;
 334                                 }
 335                         }
 336                 }
 337                 mlt_properties_set_double( properties, "volume.gain", gain );
 338         }
 339
 340         // Parse the maximum gain property
 341         if ( mlt_properties_get( filter_props, "max_gain" ) != NULL )
 342         {
 343                 char *p = mlt_properties_get( filter_props, "max_gain" );
 344                 double gain = fabs( strtod( p, &p) ); // 0 = no max
 345
 346                 while ( isspace( *p ) )
 347                         p++;
 348
 349                 /* check if "dB" is given after number */
 350                 if ( strncaseeq( p, "db", 2 ) )
 351                         gain = DBFSTOAMP( gain );
 352
 353                 mlt_properties_set_double( properties, "volume.max_gain", gain );
 354         }
 355
 356         // Parse the limiter property
 357         if ( mlt_properties_get( filter_props, "limiter" ) != NULL )
 358         {
 359                 char *p = mlt_properties_get( filter_props, "limiter" );
 360                 double level = 0.5; /* -6dBFS */
 361                 if ( strcmp( p, "" ) != 0 )
 362                         level = strtod( p, &p);
 363
 364                 while ( isspace( *p ) )
 365                         p++;
 366
 367                 /* check if "dB" is given after number */
 368                 if ( strncaseeq( p, "db", 2 ) )
 369                 {
 370                         if ( level > 0 )
 371                                 level = -level;
 372                         level = DBFSTOAMP( level );
 373                 }
 374                 else
 375                 {
 376                         if ( level < 0 )
 377                                 level = -level;
 378                 }
 379                 mlt_properties_set_double( properties, "volume.limiter", level );
 380         }
 381
 382         // Parse the normalise property
 383         if ( mlt_properties_get( filter_props, "normalise" ) != NULL )
 384         {
 385                 char *p = mlt_properties_get( filter_props, "normalise" );
 386                 double amplitude = 0.2511886431509580; /* -12dBFS */
 387                 if ( strcmp( p, "" ) != 0 )
 388                         amplitude = strtod( p, &p);
 389
 390                 while ( isspace( *p ) )
 391                         p++;
 392
 393                 /* check if "dB" is given after number */
 394                 if ( strncaseeq( p, "db", 2 ) )
 395                 {
 396                         if ( amplitude > 0 )
 397                                 amplitude = -amplitude;
 398                         amplitude = DBFSTOAMP( amplitude );
 399                 }
 400                 else
 401                 {
 402                         if ( amplitude < 0 )
 403                                 amplitude = -amplitude;
 404                         if ( amplitude > 1.0 )
 405                                 amplitude = 1.0;
 406                 }
 407
 408                 // If there is an end adjust gain to the range
 409                 if ( mlt_properties_get( filter_props, "end" ) != NULL )
 410                 {
 411                         // Determine the time position of this frame in the transition duration
 412                         mlt_position in = mlt_filter_get_in( this );
 413                         mlt_position out = mlt_filter_get_out( this );
 414                         mlt_position time = mlt_frame_get_position( frame );
 415                         double position = ( double )( time - in ) / ( double )( out - in + 1 );
 416                         amplitude *= position;
 417                 }
 418                 mlt_properties_set_int( properties, "volume.normalise", 1 );
 419                 mlt_properties_set_double( properties, "volume.amplitude", amplitude );
 420         }
 421
 422         // Parse the window property and allocate smoothing buffer if needed
 423         int window = mlt_properties_get_int( filter_props, "window" );
 424         if ( mlt_properties_get( filter_props, "smooth_buffer" ) == NULL && window > 1 )
 425         {
 426                 // Create a smoothing buffer for the calculated "max power" of frame of audio used in normalisation
 427                 double *smooth_buffer = (double*) calloc( window, sizeof( double ) );
 428                 int i;
 429                 for ( i = 0; i < window; i++ )
 430                         smooth_buffer[ i ] = -1.0;
 431                 mlt_properties_set_data( filter_props, "smooth_buffer", smooth_buffer, 0, free, NULL );
 432                 int *smooth_index = calloc( 1, sizeof( int ) );
 433
 434                 mlt_properties_set_data( filter_props, "smooth_index", smooth_index, 0, free, NULL );
 435         }
 436
 437         // Put a filter reference onto the frame
 438         mlt_properties_set_data( properties, "filter_volume", this, 0, NULL, NULL );
 439
 440         // Backup the original get_audio (it's still needed)
 441         mlt_properties_set_data( properties, "volume.get_audio", frame->get_audio, 0, NULL, NULL );
 442
 443         // Override the get_audio method
 444         frame->get_audio = filter_get_audio;
 445
 446         return frame;
 447 }
 448
 449 /** Constructor for the filter.
 450 */
 451
 452 mlt_filter filter_volume_init( char *arg )
 453 {
 454         mlt_filter this = calloc( sizeof( struct mlt_filter_s ), 1 );
 455         if ( this != NULL && mlt_filter_init( this, NULL ) == 0 )
 456         {
 457                 mlt_properties properties = mlt_filter_properties( this );
 458                 this->process = filter_process;
 459                 if ( arg != NULL )
 460                         mlt_properties_set( properties, "gain", arg );
 461
 462                 mlt_properties_set_int( properties, "window", 75 );
 463                 mlt_properties_set( properties, "max_gain", "20dB" );
 464         }
 465         return this;
 466 }
 467