X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fmodules%2Fcore%2Ffilter_volume.c;h=04fb9364ec4bbf0e284d1b7a5ce0a779cfe0ef07;hb=bd208d01a2a792e698a9b4884b43602b2f245a8f;hp=719e3ed7abe4130967730f3b3320e541d655024f;hpb=dfcac1bf1428068f68b700d872452d9aa80a8a1d;p=melted

diff --git a/src/modules/core/filter_volume.c b/src/modules/core/filter_volume.c
index 719e3ed..04fb936 100644
--- a/src/modules/core/filter_volume.c
+++ b/src/modules/core/filter_volume.c
@@ -29,9 +29,9 @@
 #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
@@ -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.
 */
 
@@ -165,62 +168,111 @@ 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 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;
@@ -234,18 +286,75 @@ 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
+	// 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" );
@@ -253,10 +362,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,11 +377,10 @@ 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
+	// Parse the normalise property
 	if ( mlt_properties_get( filter_props, "normalise" ) != NULL )
 	{
 		char *p = mlt_properties_get( filter_props, "normalise" );
@@ -280,10 +388,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 )
@@ -297,16 +405,36 @@ static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
 			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 );
 
@@ -324,19 +452,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;
 }
-