2 * filter_volume.c -- adjust audio volume
3 * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4 * Author: Dan Dennedy <dan@dennedy.org>
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.
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.
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.
21 #include <framework/mlt_filter.h>
22 #include <framework/mlt_frame.h>
30 #define MAX_CHANNELS 6
31 #define EPSILON 0.00001
33 /* The following normalise functions come from the normalize utility:
34 Copyright (C) 1999--2002 Chris Vaill */
39 # define ROUND(x) floor((x) + 0.5)
42 #define DBFSTOAMP(x) pow(10,(x)/20.0)
44 /** Return nonzero if the two strings are equal, ignoring case, up to
45 the first n characters.
47 int strncaseeq(const char *s1
, const char *s2
, size_t n
)
51 if (tolower(*s1
++) != tolower(*s2
++))
59 / tanh((x + lev) / (1-lev)) * (1-lev) - lev (for x < -lev)
61 x' = | x (for |x| <= lev)
63 \ tanh((x - lev) / (1-lev)) * (1-lev) + lev (for x > lev)
65 With limiter level = 0, this is equivalent to a tanh() function;
66 with limiter level = 1, this is equivalent to clipping.
68 static inline double limiter( double x
, double lmtr_lvl
)
73 xp
= tanh((x
+ lmtr_lvl
) / (1-lmtr_lvl
)) * (1-lmtr_lvl
) - lmtr_lvl
;
74 else if (x
> lmtr_lvl
)
75 xp
= tanh((x
- lmtr_lvl
) / (1-lmtr_lvl
)) * (1-lmtr_lvl
) + lmtr_lvl
;
78 // fprintf( stderr, "filter_volume: sample %f limited %f\n", x, xp );
84 /** Takes a full smoothing window, and returns the value of the center
87 Currently, just does a mean filter, but we could do a median or
88 gaussian filter here instead.
90 static inline double get_smoothed_data( double *buf
, int count
)
95 for ( i
= 0, j
= 0; i
< count
; i
++ )
97 if ( buf
[ i
] != -1.0 )
104 // fprintf( stderr, "smoothed over %d values, result %f\n", j, smoothed );
109 /** Get the max power level (using RMS) and peak level of the audio segment.
111 double signal_max_power( int16_t *buffer
, int channels
, int samples
, int16_t *peak
)
113 // Determine numeric limits
114 int bytes_per_samp
= (samp_width
- 1) / 8 + 1;
115 int16_t max
= (1 << (bytes_per_samp
* 8 - 1)) - 1;
116 int16_t min
= -max
- 1;
118 double *sums
= (double *) calloc( channels
, sizeof(double) );
121 double pow
, maxpow
= 0;
123 /* initialize peaks to effectively -inf and +inf */
124 int16_t max_sample
= min
;
125 int16_t min_sample
= max
;
127 for ( i
= 0; i
< samples
; i
++ )
129 for ( c
= 0; c
< channels
; c
++ )
132 sums
[ c
] += (double) sample
* (double) sample
;
135 if ( sample
> max_sample
)
137 else if ( sample
< min_sample
)
141 for ( c
= 0; c
< channels
; c
++ )
143 pow
= sums
[ c
] / (double) samples
;
150 /* scale the pow value to be in the range 0.0 -- 1.0 */
151 maxpow
/= ( (double) min
* (double) min
);
153 if ( -min_sample
> max_sample
)
154 *peak
= min_sample
/ (double) min
;
156 *peak
= max_sample
/ (double) max
;
158 return sqrt( maxpow
);
161 /* ------ End normalize functions --------------------------------------- */
166 static int filter_get_audio( mlt_frame frame
, int16_t **buffer
, mlt_audio_format
*format
, int *frequency
, int *channels
, int *samples
)
168 // Get the properties of the a frame
169 mlt_properties properties
= MLT_FRAME_PROPERTIES( frame
);
170 double gain
= mlt_properties_get_double( properties
, "volume.gain" );
171 double max_gain
= mlt_properties_get_double( properties
, "volume.max_gain" );
172 double limiter_level
= 0.5; /* -6 dBFS */
173 int normalise
= mlt_properties_get_int( properties
, "volume.normalise" );
174 double amplitude
= mlt_properties_get_double( properties
, "volume.amplitude" );
179 // Get the filter from the frame
180 mlt_filter
this = mlt_properties_get_data( properties
, "filter_volume", NULL
);
182 // Get the properties from the filter
183 mlt_properties filter_props
= MLT_FILTER_PROPERTIES( this );
185 if ( mlt_properties_get( properties
, "volume.limiter" ) != NULL
)
186 limiter_level
= mlt_properties_get_double( properties
, "volume.limiter" );
188 // Get the producer's audio
189 mlt_frame_get_audio( frame
, buffer
, format
, frequency
, channels
, samples
);
190 // fprintf( stderr, "filter_volume: frequency %d\n", *frequency );
192 // Determine numeric limits
193 int bytes_per_samp
= (samp_width
- 1) / 8 + 1;
194 int samplemax
= (1 << (bytes_per_samp
* 8 - 1)) - 1;
195 int samplemin
= -samplemax
- 1;
199 int window
= mlt_properties_get_int( filter_props
, "window" );
200 double *smooth_buffer
= mlt_properties_get_data( filter_props
, "smooth_buffer", NULL
);
202 if ( window
> 0 && smooth_buffer
!= NULL
)
204 int smooth_index
= mlt_properties_get_int( filter_props
, "_smooth_index" );
206 // Compute the signal power and put into smoothing buffer
207 smooth_buffer
[ smooth_index
] = signal_max_power( *buffer
, *channels
, *samples
, &peak
);
208 // fprintf( stderr, "filter_volume: raw power %f ", smooth_buffer[ smooth_index ] );
209 if ( smooth_buffer
[ smooth_index
] > EPSILON
)
211 mlt_properties_set_int( filter_props
, "_smooth_index", ( smooth_index
+ 1 ) % window
);
213 // Smooth the data and compute the gain
214 // fprintf( stderr, "smoothed %f over %d frames\n", get_smoothed_data( smooth_buffer, window ), window );
215 gain
*= amplitude
/ get_smoothed_data( smooth_buffer
, window
);
220 gain
*= amplitude
/ signal_max_power( *buffer
, *channels
, *samples
, &peak
);
224 // if ( gain > 1.0 && normalise )
225 // fprintf(stderr, "filter_volume: limiter level %f gain %f\n", limiter_level, gain );
227 if ( max_gain
> 0 && gain
> max_gain
)
230 // Initialise filter's previous gain value to prevent an inadvertant jump from 0
231 mlt_position last_position
= mlt_properties_get_position( filter_props
, "_last_position" );
232 mlt_position current_position
= mlt_frame_get_position( frame
);
233 if ( mlt_properties_get( filter_props
, "_previous_gain" ) == NULL
234 || current_position
!= last_position
+ 1 )
235 mlt_properties_set_double( filter_props
, "_previous_gain", gain
);
237 // Start the gain out at the previous
238 double previous_gain
= mlt_properties_get_double( filter_props
, "_previous_gain" );
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 );
244 // Save the current gain for the next iteration
245 mlt_properties_set_double( filter_props
, "_previous_gain", gain
);
246 mlt_properties_set_position( filter_props
, "_last_position", current_position
);
248 // Ramp from the previous gain to the current
249 gain
= previous_gain
;
251 int16_t *p
= *buffer
;
254 for ( i
= 0; i
< *samples
; i
++ )
256 for ( j
= 0; j
< *channels
; j
++ )
259 *p
= ROUND( sample
);
263 /* use limiter function instead of clipping */
265 *p
= ROUND( samplemax
* limiter( sample
/ (double) samplemax
, limiter_level
) );
267 /* perform clipping */
268 else if ( sample
> samplemax
)
270 else if ( sample
< samplemin
)
281 /** Filter processing.
284 static mlt_frame
filter_process( mlt_filter
this, mlt_frame frame
)
286 mlt_properties properties
= MLT_FRAME_PROPERTIES( frame
);
287 mlt_properties filter_props
= MLT_FILTER_PROPERTIES( this );
289 // Parse the gain property
290 if ( mlt_properties_get( properties
, "gain" ) == NULL
)
292 double gain
= 1.0; // no adjustment
294 if ( mlt_properties_get( filter_props
, "gain" ) != NULL
)
296 char *p
= mlt_properties_get( filter_props
, "gain" );
298 if ( strncaseeq( p
, "normalise", 9 ) )
299 mlt_properties_set( filter_props
, "normalise", "" );
302 if ( strcmp( p
, "" ) != 0 )
303 gain
= fabs( strtod( p
, &p
) );
305 while ( isspace( *p
) )
308 /* check if "dB" is given after number */
309 if ( strncaseeq( p
, "db", 2 ) )
310 gain
= DBFSTOAMP( gain
);
312 // If there is an end adjust gain to the range
313 if ( mlt_properties_get( filter_props
, "end" ) != NULL
)
315 // Determine the time position of this frame in the transition duration
316 mlt_position in
= mlt_filter_get_in( this );
317 mlt_position out
= mlt_filter_get_out( this );
318 mlt_position time
= mlt_frame_get_position( frame
);
319 double position
= ( double )( time
- in
) / ( double )( out
- in
+ 1 );
322 char *p
= mlt_properties_get( filter_props
, "end" );
323 if ( strcmp( p
, "" ) != 0 )
324 end
= fabs( strtod( p
, &p
) );
326 while ( isspace( *p
) )
329 /* check if "dB" is given after number */
330 if ( strncaseeq( p
, "db", 2 ) )
331 end
= DBFSTOAMP( gain
);
334 gain
+= ( end
- gain
) * position
;
338 mlt_properties_set_double( properties
, "volume.gain", gain
);
341 // Parse the maximum gain property
342 if ( mlt_properties_get( filter_props
, "max_gain" ) != NULL
)
344 char *p
= mlt_properties_get( filter_props
, "max_gain" );
345 double gain
= fabs( strtod( p
, &p
) ); // 0 = no max
347 while ( isspace( *p
) )
350 /* check if "dB" is given after number */
351 if ( strncaseeq( p
, "db", 2 ) )
352 gain
= DBFSTOAMP( gain
);
354 mlt_properties_set_double( properties
, "volume.max_gain", gain
);
357 // Parse the limiter property
358 if ( mlt_properties_get( filter_props
, "limiter" ) != NULL
)
360 char *p
= mlt_properties_get( filter_props
, "limiter" );
361 double level
= 0.5; /* -6dBFS */
362 if ( strcmp( p
, "" ) != 0 )
363 level
= strtod( p
, &p
);
365 while ( isspace( *p
) )
368 /* check if "dB" is given after number */
369 if ( strncaseeq( p
, "db", 2 ) )
373 level
= DBFSTOAMP( level
);
380 mlt_properties_set_double( properties
, "volume.limiter", level
);
383 // Parse the normalise property
384 if ( mlt_properties_get( filter_props
, "normalise" ) != NULL
)
386 char *p
= mlt_properties_get( filter_props
, "normalise" );
387 double amplitude
= 0.2511886431509580; /* -12dBFS */
388 if ( strcmp( p
, "" ) != 0 )
389 amplitude
= strtod( p
, &p
);
391 while ( isspace( *p
) )
394 /* check if "dB" is given after number */
395 if ( strncaseeq( p
, "db", 2 ) )
398 amplitude
= -amplitude
;
399 amplitude
= DBFSTOAMP( amplitude
);
404 amplitude
= -amplitude
;
405 if ( amplitude
> 1.0 )
409 // If there is an end adjust gain to the range
410 if ( mlt_properties_get( filter_props
, "end" ) != NULL
)
412 // Determine the time position of this frame in the transition duration
413 mlt_position in
= mlt_filter_get_in( this );
414 mlt_position out
= mlt_filter_get_out( this );
415 mlt_position time
= mlt_frame_get_position( frame
);
416 double position
= ( double )( time
- in
) / ( double )( out
- in
+ 1 );
417 amplitude
*= position
;
419 mlt_properties_set_int( properties
, "volume.normalise", 1 );
420 mlt_properties_set_double( properties
, "volume.amplitude", amplitude
);
423 // Parse the window property and allocate smoothing buffer if needed
424 int window
= mlt_properties_get_int( filter_props
, "window" );
425 if ( mlt_properties_get( filter_props
, "smooth_buffer" ) == NULL
&& window
> 1 )
427 // Create a smoothing buffer for the calculated "max power" of frame of audio used in normalisation
428 double *smooth_buffer
= (double*) calloc( window
, sizeof( double ) );
430 for ( i
= 0; i
< window
; i
++ )
431 smooth_buffer
[ i
] = -1.0;
432 mlt_properties_set_data( filter_props
, "smooth_buffer", smooth_buffer
, 0, free
, NULL
);
435 // Put a filter reference onto the frame
436 mlt_properties_set_data( properties
, "filter_volume", this, 0, NULL
, NULL
);
438 // Override the get_audio method
439 mlt_frame_push_audio( frame
, filter_get_audio
);
444 /** Constructor for the filter.
447 mlt_filter
filter_volume_init( mlt_profile profile
, mlt_service_type type
, const char *id
, char *arg
)
449 mlt_filter
this = calloc( sizeof( struct mlt_filter_s
), 1 );
450 if ( this != NULL
&& mlt_filter_init( this, NULL
) == 0 )
452 mlt_properties properties
= MLT_FILTER_PROPERTIES( this );
453 this->process
= filter_process
;
455 mlt_properties_set( properties
, "gain", arg
);
457 mlt_properties_set_int( properties
, "window", 75 );
458 mlt_properties_set( properties
, "max_gain", "20dB" );