#include <string.h>
#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
*/
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;
}
return sqrt( maxpow );
}
+/* ------ End normalize functions --------------------------------------- */
+
/** Get the audio.
*/
{
// 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 gain = mlt_properties_get_double( properties, "volume.gain" );
+ 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;
+ int i, j;
double sample;
int16_t peak;
+ // Get the filter from the frame
+ mlt_filter this = mlt_properties_get_data( properties, "filter_volume", NULL );
+
+ // Get the properties from the filter
+ mlt_properties filter_props = mlt_filter_properties( this );
+
+ 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 );
// 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 )
{
- double *smooth_buffer = mlt_properties_get_data( properties, "volume.smooth_buffer", NULL );
- int *smooth_index = mlt_properties_get_data( properties, "volume.smooth_index", NULL );
+ int window = mlt_properties_get_int( filter_props, "window" );
+ double *smooth_buffer = mlt_properties_get_data( filter_props, "smooth_buffer", 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 )
+ {
+ int smooth_index = mlt_properties_get_int( filter_props, "_smooth_index" );
+
+ // 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 )
+ {
+ mlt_properties_set_int( filter_props, "_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;
+
+ // Initialise filter's previous gain value to prevent an inadvertant jump from 0
+ if ( mlt_properties_get( filter_props, "previous_gain" ) == NULL )
+ mlt_properties_set_double( filter_props, "previous_gain", gain );
+
+ // Start the gain out at the previous
+ double previous_gain = mlt_properties_get_double( filter_props, "previous_gain" );
+
+ // Determine ramp increment
+ double gain_step = ( gain - previous_gain ) / *samples;
+// fprintf( stderr, "filter_volume: previous gain %f current gain %f step %f\n", previous_gain, gain, gain_step );
+
+ // Save the current gain for the next iteration
+ mlt_properties_set_double( filter_props, "previous_gain", gain );
+
+ // Ramp from the previous gain to the current
+ gain = previous_gain;
+
+ int16_t *p = *buffer;
+
// Apply the gain
- for ( i = 0; i < ( *channels * *samples ); i++ )
+ for ( i = 0; i < *samples; i++ )
{
- sample = (*buffer)[i] * gain;
- (*buffer)[i] = ROUND( sample );
-
- if ( gain > 1.0 )
+ for ( j = 0; j < *channels; j++ )
{
- /* use limiter function instead of clipping */
- if ( use_limiter != 0 )
- (*buffer)[i] = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) );
+ sample = *p * gain;
+ *p = ROUND( sample );
+
+ if ( gain > 1.0 )
+ {
+ /* use limiter function instead of clipping */
+ if ( normalise )
+ *p = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) );
- /* perform clipping */
- else if ( sample > samplemax )
- (*buffer)[i] = samplemax;
- else if ( sample < samplemin )
- (*buffer)[i] = samplemin;
+ /* perform clipping */
+ else if ( sample > samplemax )
+ *p = samplemax;
+ else if ( sample < samplemin )
+ *p = samplemin;
+ }
+ p++;
}
+ gain += gain_step;
}
return 0;
mlt_properties properties = mlt_frame_properties( frame );
mlt_properties filter_props = mlt_filter_properties( this );
- // Propogate the volume/gain property
+ // Parse 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" );
- mlt_properties_set_double( properties, "gain", 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 );
+
+ // If there is an end adjust gain to the range
+ if ( mlt_properties_get( filter_props, "end" ) != NULL )
+ {
+ // Determine the time position of this frame in the transition duration
+ mlt_position in = mlt_filter_get_in( this );
+ mlt_position out = mlt_filter_get_out( this );
+ mlt_position time = mlt_frame_get_position( frame );
+ double position = ( double )( time - in ) / ( double )( out - in + 1 );
+
+ double end = -1;
+ char *p = mlt_properties_get( filter_props, "end" );
+ if ( strcmp( p, "" ) != 0 )
+ end = fabs( strtod( p, &p) );
+
+ while ( isspace( *p ) )
+ p++;
+
+ /* check if "dB" is given after number */
+ if ( strncaseeq( p, "db", 2 ) )
+ end = DBFSTOAMP( gain );
+
+ if ( end != -1 )
+ gain += ( end - gain ) * position;
+ }
+ }
+ }
+ mlt_properties_set_double( properties, "volume.gain", gain );
}
- // Parse and propogate the limiter property
+ // Parse 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 the limiter property
if ( mlt_properties_get( filter_props, "limiter" ) != NULL )
{
char *p = mlt_properties_get( filter_props, "limiter" );
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 )
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
+ // Parse the normalise property
if ( mlt_properties_get( filter_props, "normalise" ) != NULL )
{
char *p = mlt_properties_get( filter_props, "normalise" );
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 )
if ( amplitude > 1.0 )
amplitude = 1.0;
}
+
+ // If there is an end adjust gain to the range
+ if ( mlt_properties_get( filter_props, "end" ) != NULL )
+ {
+ // Determine the time position of this frame in the transition duration
+ mlt_position in = mlt_filter_get_in( this );
+ mlt_position out = mlt_filter_get_out( this );
+ mlt_position time = mlt_frame_get_position( frame );
+ double position = ( double )( time - in ) / ( double )( out - in + 1 );
+ amplitude *= position;
+ }
mlt_properties_set_int( properties, "volume.normalise", 1 );
mlt_properties_set_double( properties, "volume.amplitude", amplitude );
}
- // Propogate the smoothing buffer properties
- 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 );
-
+ // Parse the window property and allocate smoothing buffer if needed
+ 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 );
+ }
+
+ // Put a filter reference onto the frame
+ mlt_properties_set_data( properties, "filter_volume", this, 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 );
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;
}
-
projects / melted / blobdiff