static int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples ) { // Get the filter from the frame mlt_filter this = mlt_frame_pop_audio( frame ); // Get the properties from the filter mlt_properties filter_props = MLT_FILTER_PROPERTIES( this ); // Get the frame's filter instance properties mlt_properties instance_props = mlt_frame_unique_properties( frame, MLT_FILTER_SERVICE( this ) ); // Get the parameters double gain = mlt_properties_get_double( instance_props, "gain" ); double max_gain = mlt_properties_get_double( instance_props, "max_gain" ); double limiter_level = 0.5; /* -6 dBFS */ int normalise = mlt_properties_get_int( instance_props, "normalise" ); double amplitude = mlt_properties_get_double( instance_props, "amplitude" ); int i, j; double sample; int16_t peak; if ( mlt_properties_get( instance_props, "limiter" ) != NULL ) limiter_level = mlt_properties_get_double( instance_props, "limiter" ); // Get the producer's audio *format = mlt_audio_s16; 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; mlt_service_lock( MLT_FILTER_SERVICE( this ) ); if ( normalise ) { int window = mlt_properties_get_int( filter_props, "window" ); double *smooth_buffer = mlt_properties_get_data( filter_props, "smooth_buffer", NULL ); 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( (int16_t*) *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 mlt_position last_position = mlt_properties_get_position( filter_props, "_last_position" ); mlt_position current_position = mlt_frame_get_position( frame ); if ( mlt_properties_get( filter_props, "_previous_gain" ) == NULL || current_position != last_position + 1 ) 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 ); mlt_properties_set_position( filter_props, "_last_position", current_position ); mlt_service_unlock( MLT_FILTER_SERVICE( this ) ); // Ramp from the previous gain to the current gain = previous_gain; int16_t *p = (int16_t*) *buffer; // Apply the gain for ( i = 0; i < *samples; i++ ) { for ( j = 0; j < *channels; j++ ) { 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 ) *p = samplemax; else if ( sample < samplemin ) *p = samplemin; } p++; } gain += gain_step; } return 0; }
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame ) { mlt_properties filter_props = MLT_FILTER_PROPERTIES( filter ); mlt_properties instance_props = mlt_frame_unique_properties( frame, MLT_FILTER_SERVICE( filter ) ); double gain = 1.0; // no adjustment // Parse the gain property if ( mlt_properties_get( filter_props, "gain" ) != NULL ) { 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 = strtod( p, &p ); while ( isspace( *p ) ) p++; /* check if "dB" is given after number */ if ( strncaseeq( p, "db", 2 ) ) gain = DBFSTOAMP( gain ); else gain = fabs( gain ); // If there is an end adjust gain to the range if ( mlt_properties_get( filter_props, "end" ) != NULL ) { double end = -1; char *p = mlt_properties_get( filter_props, "end" ); if ( strcmp( p, "" ) != 0 ) end = strtod( p, &p ); while ( isspace( *p ) ) p++; /* check if "dB" is given after number */ if ( strncaseeq( p, "db", 2 ) ) end = DBFSTOAMP( end ); else end = fabs( end ); if ( end != -1 ) gain += ( end - gain ) * mlt_filter_get_progress( filter, frame ); } } } mlt_properties_set_double( instance_props, "gain", gain ); // 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 = 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 ); else gain = fabs( gain ); mlt_properties_set_double( instance_props, "max_gain", gain ); } // Parse the limiter property if ( mlt_properties_get( filter_props, "limiter" ) != NULL ) { char *p = mlt_properties_get( filter_props, "limiter" ); double level = 0.5; /* -6dBFS */ if ( strcmp( p, "" ) != 0 ) level = strtod( p, &p); while ( isspace( *p ) ) p++; /* check if "dB" is given after number */ if ( strncaseeq( p, "db", 2 ) ) { if ( level > 0 ) level = -level; level = DBFSTOAMP( level ); } else { if ( level < 0 ) level = -level; } mlt_properties_set_double( instance_props, "limiter", level ); } // Parse the normalise property if ( mlt_properties_get( filter_props, "normalise" ) != NULL ) { char *p = mlt_properties_get( filter_props, "normalise" ); double amplitude = 0.2511886431509580; /* -12dBFS */ if ( strcmp( p, "" ) != 0 ) amplitude = strtod( p, &p); while ( isspace( *p ) ) p++; /* check if "dB" is given after number */ if ( strncaseeq( p, "db", 2 ) ) { if ( amplitude > 0 ) amplitude = -amplitude; amplitude = DBFSTOAMP( amplitude ); } else { if ( amplitude < 0 ) amplitude = -amplitude; 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 ) { amplitude *= mlt_filter_get_progress( filter, frame ); } mlt_properties_set_int( instance_props, "normalise", 1 ); mlt_properties_set_double( instance_props, "amplitude", amplitude ); } // 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 ); } // Push the filter onto the stack mlt_frame_push_audio( frame, filter ); // Override the get_audio method mlt_frame_push_audio( frame, filter_get_audio ); return frame; }
} p++; } gain += gain_step; } return 0; } /** Filter processing. */ static mlt_frame filter_process( mlt_filter this, mlt_frame frame ) { mlt_properties filter_props = MLT_FILTER_PROPERTIES( this ); mlt_properties instance_props = mlt_frame_unique_properties( frame, MLT_FILTER_SERVICE( this ) ); double gain = 1.0; // no adjustment // Parse the gain property if ( mlt_properties_get( filter_props, "gain" ) != NULL ) { 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 = strtod( p, &p );
static int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples ) { // Get the filter from the frame mlt_filter filter = mlt_frame_pop_audio( frame ); // Get the properties from the filter mlt_properties filter_props = MLT_FILTER_PROPERTIES( filter ); // Get the frame's filter instance properties mlt_properties instance_props = mlt_frame_unique_properties( frame, MLT_FILTER_SERVICE( filter ) ); // Get the parameters double gain = mlt_properties_get_double( instance_props, "gain" ); double max_gain = mlt_properties_get_double( instance_props, "max_gain" ); double limiter_level = 0.5; /* -6 dBFS */ int normalise = mlt_properties_get_int( instance_props, "normalise" ); double amplitude = mlt_properties_get_double( instance_props, "amplitude" ); int i, j; double sample; int16_t peak; // Use animated value for gain if "level" property is set char* level_property = mlt_properties_get( filter_props, "level" ); if ( level_property != NULL ) { mlt_position position = mlt_filter_get_position( filter, frame ); mlt_position length = mlt_filter_get_length2( filter, frame ); gain = mlt_properties_anim_get_double( filter_props, "level", position, length ); gain = DBFSTOAMP( gain ); } if ( mlt_properties_get( instance_props, "limiter" ) != NULL ) limiter_level = mlt_properties_get_double( instance_props, "limiter" ); // Get the producer's audio *format = normalise? mlt_audio_s16 : mlt_audio_f32le; mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples ); mlt_service_lock( MLT_FILTER_SERVICE( filter ) ); if ( normalise ) { int window = mlt_properties_get_int( filter_props, "window" ); double *smooth_buffer = mlt_properties_get_data( filter_props, "smooth_buffer", NULL ); 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 ); 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 gain *= amplitude / get_smoothed_data( smooth_buffer, window ); } } else { gain *= amplitude / signal_max_power( *buffer, *channels, *samples, &peak ); } } if ( max_gain > 0 && gain > max_gain ) gain = max_gain; // Initialise filter's previous gain value to prevent an inadvertant jump from 0 mlt_position last_position = mlt_properties_get_position( filter_props, "_last_position" ); mlt_position current_position = mlt_frame_get_position( frame ); if ( mlt_properties_get( filter_props, "_previous_gain" ) == NULL || current_position != last_position + 1 ) 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; // Save the current gain for the next iteration mlt_properties_set_double( filter_props, "_previous_gain", gain ); mlt_properties_set_position( filter_props, "_last_position", current_position ); mlt_service_unlock( MLT_FILTER_SERVICE( filter ) ); // Ramp from the previous gain to the current gain = previous_gain; // Apply the gain if ( normalise ) { int16_t *p = *buffer; // Determine numeric limits int bytes_per_samp = (samp_width - 1) / 8 + 1; int samplemax = (1 << (bytes_per_samp * 8 - 1)) - 1; for ( i = 0; i < *samples; i++, gain += gain_step ) { for ( j = 0; j < *channels; j++ ) { sample = *p * gain; *p = ROUND( sample ); if ( gain > 1.0 && normalise ) { /* use limiter function instead of clipping */ *p = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) ); } p++; } } } else { float *p = *buffer; for ( i = 0; i < *samples; i++, gain += gain_step ) { for ( j = 0; j < *channels; j++, p++ ) { p[0] *= gain; } } } return 0; }