X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fmodules%2Fcore%2Ffilter_volume.c;h=891d63a60097a80fe03dd77818d4eed9b7439081;hb=dc57bd7b4020663b49149f44f1607c4d78c4d2d5;hp=719e3ed7abe4130967730f3b3320e541d655024f;hpb=dfcac1bf1428068f68b700d872452d9aa80a8a1d;p=melted diff --git a/src/modules/core/filter_volume.c b/src/modules/core/filter_volume.c index 719e3ed..891d63a 100644 --- a/src/modules/core/filter_volume.c +++ b/src/modules/core/filter_volume.c @@ -29,9 +29,9 @@ #include #define MAX_CHANNELS 6 -#define SMOOTH_BUFFER_SIZE 50 +#define EPSILON 0.00001 -/* This utilities and limiter function comes from the normalize utility: +/* The normalise functions come from the normalize utility: Copyright (C) 1999--2002 Chris Vaill */ #define samp_width 16 @@ -68,15 +68,16 @@ int strncaseeq(const char *s1, const char *s2, size_t n) */ static inline double limiter( double x, double lmtr_lvl ) { - double xp; + double xp = x; if (x < -lmtr_lvl) xp = tanh((x + lmtr_lvl) / (1-lmtr_lvl)) * (1-lmtr_lvl) - lmtr_lvl; - else if (x <= lmtr_lvl) - xp = x; - else + else if (x > lmtr_lvl) xp = tanh((x - lmtr_lvl) / (1-lmtr_lvl)) * (1-lmtr_lvl) + lmtr_lvl; +// if ( x != xp ) +// fprintf( stderr, "filter_volume: sample %f limited %f\n", x, xp ); + return xp; } @@ -158,6 +159,8 @@ double signal_max_power( int16_t *buffer, int channels, int samples, int16_t *pe return sqrt( maxpow ); } +/* ------ End normalize functions --------------------------------------- */ + /** Get the audio. */ @@ -166,43 +169,62 @@ static int filter_get_audio( mlt_frame frame, int16_t **buffer, mlt_audio_format // Get the properties of the a frame mlt_properties properties = mlt_frame_properties( frame ); double gain = mlt_properties_get_double( properties, "gain" ); - int use_limiter = mlt_properties_get_int( properties, "volume.use_limiter" ); - double limiter_level = mlt_properties_get_double( properties, "volume.limiter_level" ); + double max_gain = mlt_properties_get_double( properties, "volume.max_gain" ); + double limiter_level = 0.5; /* -6 dBFS */ int normalise = mlt_properties_get_int( properties, "volume.normalise" ); double amplitude = mlt_properties_get_double( properties, "volume.amplitude" ); int i; double sample; int16_t peak; + if ( mlt_properties_get( properties, "volume.limiter" ) != NULL ) + limiter_level = mlt_properties_get_double( properties, "volume.limiter" ); + // Restore the original get_audio frame->get_audio = mlt_properties_get_data( properties, "volume.get_audio", NULL ); // Get the producer's audio mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples ); + //fprintf( stderr, "filter_volume: frequency %d\n", *frequency ); + return 0; // Determine numeric limits int bytes_per_samp = (samp_width - 1) / 8 + 1; int samplemax = (1 << (bytes_per_samp * 8 - 1)) - 1; int samplemin = -samplemax - 1; -#if 0 - if ( gain > 1.0 && use_limiter != 0 ) - fprintf(stderr, "filter_volume: limiting samples greater than %f\n", limiter_level ); -#endif - if ( normalise ) { + int window = mlt_properties_get_int( properties, "volume.window" ); double *smooth_buffer = mlt_properties_get_data( properties, "volume.smooth_buffer", NULL ); int *smooth_index = mlt_properties_get_data( properties, "volume.smooth_index", NULL ); - // Compute the signal power and put into smoothing buffer - smooth_buffer[ *smooth_index ] = signal_max_power( *buffer, *channels, *samples, &peak ); - *smooth_index = ( *smooth_index + 1 ) % SMOOTH_BUFFER_SIZE; - - // Smooth the data and compute the gain - gain *= amplitude / get_smoothed_data( smooth_buffer, SMOOTH_BUFFER_SIZE ); + if ( window > 0 && smooth_buffer != NULL ) + { + // Compute the signal power and put into smoothing buffer + smooth_buffer[ *smooth_index ] = signal_max_power( *buffer, *channels, *samples, &peak ); +// fprintf( stderr, "filter_volume: raw power %f ", smooth_buffer[ *smooth_index ] ); + if ( smooth_buffer[ *smooth_index ] > EPSILON ) + { + *smooth_index = ( *smooth_index + 1 ) % window; + + // Smooth the data and compute the gain + //fprintf( stderr, "smoothed %f over %d frames\n", get_smoothed_data( smooth_buffer, window ), window ); + gain *= amplitude / get_smoothed_data( smooth_buffer, window ); + } + } + else + { + gain = amplitude / signal_max_power( *buffer, *channels, *samples, &peak ); + } } +// if ( gain > 1.0 && normalise ) +// fprintf(stderr, "filter_volume: limiter level %f gain %f\n", limiter_level, gain ); + + if ( max_gain > 0 && gain > max_gain ) + gain = max_gain; + // Apply the gain for ( i = 0; i < ( *channels * *samples ); i++ ) { @@ -212,7 +234,7 @@ static int filter_get_audio( mlt_frame frame, int16_t **buffer, mlt_audio_format if ( gain > 1.0 ) { /* use limiter function instead of clipping */ - if ( use_limiter != 0 ) + if ( normalise ) (*buffer)[i] = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) ); /* perform clipping */ @@ -234,17 +256,49 @@ static mlt_frame filter_process( mlt_filter this, mlt_frame frame ) mlt_properties properties = mlt_frame_properties( frame ); mlt_properties filter_props = mlt_filter_properties( this ); - // Propogate the volume/gain property + // Propogate the gain property if ( mlt_properties_get( properties, "gain" ) == NULL ) { - double gain = 1.0; // none - if ( mlt_properties_get( filter_props, "volume" ) != NULL ) - gain = mlt_properties_get_double( filter_props, "volume" ); + double gain = 1.0; // no adjustment + if ( mlt_properties_get( filter_props, "gain" ) != NULL ) - gain = mlt_properties_get_double( filter_props, "gain" ); + { + char *p = mlt_properties_get( filter_props, "gain" ); + + if ( strncaseeq( p, "normalise", 9 ) ) + mlt_properties_set( filter_props, "normalise", "" ); + else + { + if ( strcmp( p, "" ) != 0 ) + gain = fabs( strtod( p, &p) ); + + while ( isspace( *p ) ) + p++; + + /* check if "dB" is given after number */ + if ( strncaseeq( p, "db", 2 ) ) + gain = DBFSTOAMP( gain ); + } + } mlt_properties_set_double( properties, "gain", gain ); } + // Propogate the maximum gain property + if ( mlt_properties_get( filter_props, "max_gain" ) != NULL ) + { + char *p = mlt_properties_get( filter_props, "max_gain" ); + double gain = fabs( strtod( p, &p) ); // 0 = no max + + while ( isspace( *p ) ) + p++; + + /* check if "dB" is given after number */ + if ( strncaseeq( p, "db", 2 ) ) + gain = DBFSTOAMP( gain ); + + mlt_properties_set_double( properties, "volume.max_gain", gain ); + } + // Parse and propogate the limiter property if ( mlt_properties_get( filter_props, "limiter" ) != NULL ) { @@ -253,10 +307,10 @@ static mlt_frame filter_process( mlt_filter this, mlt_frame frame ) if ( strcmp( p, "" ) != 0 ) level = strtod( p, &p); - /* check if "dB" is given after number */ while ( isspace( *p ) ) p++; + /* check if "dB" is given after number */ if ( strncaseeq( p, "db", 2 ) ) { if ( level > 0 ) @@ -268,8 +322,7 @@ static mlt_frame filter_process( mlt_filter this, mlt_frame frame ) if ( level < 0 ) level = -level; } - mlt_properties_set_int( properties, "volume.use_limiter", 1 ); - mlt_properties_set_double( properties, "volume.limiter_level", level ); + mlt_properties_set_double( properties, "volume.limiter", level ); } // Parse and propogate the normalise property @@ -280,10 +333,10 @@ static mlt_frame filter_process( mlt_filter this, mlt_frame frame ) if ( strcmp( p, "" ) != 0 ) amplitude = strtod( p, &p); - /* check if "dB" is given after number */ while ( isspace( *p ) ) p++; + /* check if "dB" is given after number */ if ( strncaseeq( p, "db", 2 ) ) { if ( amplitude > 0 ) @@ -301,12 +354,27 @@ static mlt_frame filter_process( mlt_filter this, mlt_frame frame ) mlt_properties_set_double( properties, "volume.amplitude", amplitude ); } + int window = mlt_properties_get_int( filter_props, "window" ); + if ( mlt_properties_get( filter_props, "smooth_buffer" ) == NULL && window > 1 ) + { + // Create a smoothing buffer for the calculated "max power" of frame of audio used in normalisation + double *smooth_buffer = (double*) calloc( window, sizeof( double ) ); + int i; + for ( i = 0; i < window; i++ ) + smooth_buffer[ i ] = -1.0; + mlt_properties_set_data( filter_props, "smooth_buffer", smooth_buffer, 0, free, NULL ); + int *smooth_index = calloc( 1, sizeof( int ) ); + + mlt_properties_set_data( filter_props, "smooth_index", smooth_index, 0, free, NULL ); + } + // Propogate the smoothing buffer properties + mlt_properties_set_int( properties, "volume.window", window ); mlt_properties_set_data( properties, "volume.smooth_buffer", mlt_properties_get_data( filter_props, "smooth_buffer", NULL ), 0, NULL, NULL ); mlt_properties_set_data( properties, "volume.smooth_index", mlt_properties_get_data( filter_props, "smooth_index", NULL ), 0, NULL, NULL ); - + // Backup the original get_audio (it's still needed) mlt_properties_set_data( properties, "volume.get_audio", frame->get_audio, 0, NULL, NULL ); @@ -324,18 +392,13 @@ mlt_filter filter_volume_init( char *arg ) mlt_filter this = calloc( sizeof( struct mlt_filter_s ), 1 ); if ( this != NULL && mlt_filter_init( this, NULL ) == 0 ) { + mlt_properties properties = mlt_filter_properties( this ); this->process = filter_process; if ( arg != NULL ) - mlt_properties_set_double( mlt_filter_properties( this ), "volume", atof( arg ) ); + mlt_properties_set( properties, "gain", arg ); - // Create a smoothing buffer for the calculated "max power" of frame of audio used in normalisation - double *smooth_buffer = (double*) calloc( SMOOTH_BUFFER_SIZE, sizeof( double ) ); - int i; - for ( i = 0; i < SMOOTH_BUFFER_SIZE; i++ ) - smooth_buffer[ i ] = -1.0; - mlt_properties_set_data( mlt_filter_properties( this ), "smooth_buffer", smooth_buffer, 0, free, NULL ); - int *smooth_index = calloc( 1, sizeof( int ) ); - mlt_properties_set_data( mlt_filter_properties( this ), "smooth_index", smooth_index, 0, free, NULL ); + mlt_properties_set_int( properties, "window", 75 ); + mlt_properties_set( properties, "max_gain", "20dB" ); } return this; }