projects / melted / blob
? search:


609df04b35c6679a522aa5f238f1301ad190b9fc
[melted] / src / modules / core / filter_volume.c
1 /*
2 * filter_volume.c -- adjust audio volume
3 * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4 * Author: Dan Dennedy <dan@dennedy.org>
5 *
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.
10 *
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.
15 *
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.
19 */
20
21 #include "filter_volume.h"
22
23 #include <framework/mlt_frame.h>
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <math.h>
28 #include <ctype.h>
29 #include <string.h>
30
31 #define MAX_CHANNELS 6
32 #define EPSILON 0.00001
33
34 /* The normalise functions come from the normalize utility:
35 Copyright (C) 1999--2002 Chris Vaill */
36
37 #define samp_width 16
38
39 #ifndef ROUND
40 # define ROUND(x) floor((x) + 0.5)
41 #endif
42
43 #define DBFSTOAMP(x) pow(10,(x)/20.0)
44
45 /** Return nonzero if the two strings are equal, ignoring case, up to
46 the first n characters.
47 */
48 int strncaseeq(const char *s1, const char *s2, size_t n)
49 {
50 for ( ; n > 0; n--)
51 {
52 if (tolower(*s1++) != tolower(*s2++))
53 return 0;
54 }
55 return 1;
56 }
57
58 /** Limiter function.
59
60 / tanh((x + lev) / (1-lev)) * (1-lev) - lev (for x < -lev)
61 |
62 x' = | x (for |x| <= lev)
63 |
64 \ tanh((x - lev) / (1-lev)) * (1-lev) + lev (for x > lev)
65
66 With limiter level = 0, this is equivalent to a tanh() function;
67 with limiter level = 1, this is equivalent to clipping.
68 */
69 static inline double limiter( double x, double lmtr_lvl )
70 {
71 double xp = x;
72
73 if (x < -lmtr_lvl)
74 xp = tanh((x + lmtr_lvl) / (1-lmtr_lvl)) * (1-lmtr_lvl) - lmtr_lvl;
75 else if (x > lmtr_lvl)
76 xp = tanh((x - lmtr_lvl) / (1-lmtr_lvl)) * (1-lmtr_lvl) + lmtr_lvl;
77
78 // if ( x != xp )
79 // fprintf( stderr, "filter_volume: sample %f limited %f\n", x, xp );
80
81 return xp;
82 }
83
84
85 /** Takes a full smoothing window, and returns the value of the center
86 element, smoothed.
87
88 Currently, just does a mean filter, but we could do a median or
89 gaussian filter here instead.
90 */
91 static inline double get_smoothed_data( double *buf, int count )
92 {
93 int i, j;
94 double smoothed = 0;
95
96 for ( i = 0, j = 0; i < count; i++ )
97 {
98 if ( buf[ i ] != -1.0 )
99 {
100 smoothed += buf[ i ];
101 j++;
102 }
103 }
104 smoothed /= j;
105 // fprintf( stderr, "smoothed over %d values, result %f\n", j, smoothed );
106
107 return smoothed;
108 }
109
110 /** Get the max power level (using RMS) and peak level of the audio segment.
111 */
112 double signal_max_power( int16_t *buffer, int channels, int samples, int16_t *peak )
113 {
114 // Determine numeric limits
115 int bytes_per_samp = (samp_width - 1) / 8 + 1;
116 int16_t max = (1 << (bytes_per_samp * 8 - 1)) - 1;
117 int16_t min = -max - 1;
118
119 double *sums = (double *) calloc( channels, sizeof(double) );
120 int c, i;
121 int16_t sample;
122 double pow, maxpow = 0;
123
124 /* initialize peaks to effectively -inf and +inf */
125 int16_t max_sample = min;
126 int16_t min_sample = max;
127
128 for ( i = 0; i < samples; i++ )
129 {
130 for ( c = 0; c < channels; c++ )
131 {
132 sample = *buffer++;
133 sums[ c ] += (double) sample * (double) sample;
134
135 /* track peak */
136 if ( sample > max_sample )
137 max_sample = sample;
138 else if ( sample < min_sample )
139 min_sample = sample;
140 }
141 }
142 for ( c = 0; c < channels; c++ )
143 {
144 pow = sums[ c ] / (double) samples;
145 if ( pow > maxpow )
146 maxpow = pow;
147 }
148
149 free( sums );
150
151 /* scale the pow value to be in the range 0.0 -- 1.0 */
152 maxpow /= ( (double) min * (double) min);
153
154 if ( -min_sample > max_sample )
155 *peak = min_sample / (double) min;
156 else
157 *peak = max_sample / (double) max;
158
159 return sqrt( maxpow );
160 }
161
162 /* ------ End normalize functions --------------------------------------- */
163
164 /** Get the audio.
165 */
166
167 static int filter_get_audio( mlt_frame frame, int16_t **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
168 {
169 // Get the properties of the a frame
170 mlt_properties properties = mlt_frame_properties( frame );
171 double gain = mlt_properties_get_double( properties, "volume.gain" );
172 double max_gain = mlt_properties_get_double( properties, "volume.max_gain" );
173 double limiter_level = 0.5; /* -6 dBFS */
174 int normalise = mlt_properties_get_int( properties, "volume.normalise" );
175 double amplitude = mlt_properties_get_double( properties, "volume.amplitude" );
176 int i, j;
177 double sample;
178 int16_t peak;
179
180 // Get the filter from the frame
181 mlt_filter this = mlt_properties_get_data( properties, "filter_volume", NULL );
182
183 // Get the properties from the filter
184 mlt_properties filter_props = mlt_filter_properties( this );
185
186 if ( mlt_properties_get( properties, "volume.limiter" ) != NULL )
187 limiter_level = mlt_properties_get_double( properties, "volume.limiter" );
188
189 // Restore the original get_audio
190 frame->get_audio = mlt_properties_get_data( properties, "volume.get_audio", NULL );
191
192 // Get the producer's audio
193 mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
194 // fprintf( stderr, "filter_volume: frequency %d\n", *frequency );
195
196 // Determine numeric limits
197 int bytes_per_samp = (samp_width - 1) / 8 + 1;
198 int samplemax = (1 << (bytes_per_samp * 8 - 1)) - 1;
199 int samplemin = -samplemax - 1;
200
201 if ( normalise )
202 {
203 int window = mlt_properties_get_int( filter_props, "window" );
204 double *smooth_buffer = mlt_properties_get_data( filter_props, "smooth_buffer", NULL );
205 int *smooth_index = mlt_properties_get_data( filter_props, "smooth_index", NULL );
206
207 if ( window > 0 && smooth_buffer != NULL )
208 {
209 // Compute the signal power and put into smoothing buffer
210 smooth_buffer[ *smooth_index ] = signal_max_power( *buffer, *channels, *samples, &peak );
211 // fprintf( stderr, "filter_volume: raw power %f ", smooth_buffer[ *smooth_index ] );
212 if ( smooth_buffer[ *smooth_index ] > EPSILON )
213 {
214 *smooth_index = ( *smooth_index + 1 ) % window;
215
216 // Smooth the data and compute the gain
217 // fprintf( stderr, "smoothed %f over %d frames\n", get_smoothed_data( smooth_buffer, window ), window );
218 gain *= amplitude / get_smoothed_data( smooth_buffer, window );
219 }
220 }
221 else
222 {
223 gain *= amplitude / signal_max_power( *buffer, *channels, *samples, &peak );
224 }
225 }
226
227 // if ( gain > 1.0 && normalise )
228 // fprintf(stderr, "filter_volume: limiter level %f gain %f\n", limiter_level, gain );
229
230 if ( max_gain > 0 && gain > max_gain )
231 gain = max_gain;
232
233 // Initialise filter's previous gain value to prevent an inadvertant jump from 0
234 if ( mlt_properties_get( filter_props, "previous_gain" ) == NULL )
235 mlt_properties_set_double( filter_props, "previous_gain", gain );
236
237 // Start the gain out at the previous
238 double previous_gain = mlt_properties_get_double( filter_props, "previous_gain" );
239
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 );
243
244 // Save the current gain for the next iteration
245 mlt_properties_set_double( filter_props, "previous_gain", gain );
246
247 // Ramp from the previous gain to the current
248 gain = previous_gain;
249
250 int16_t *p = *buffer;
251
252 // Apply the gain
253 for ( i = 0; i < *samples; i++ )
254 {
255 for ( j = 0; j < *channels; j++ )
256 {
257 sample = *p * gain;
258 *p = ROUND( sample );
259
260 if ( gain > 1.0 )
261 {
262 /* use limiter function instead of clipping */
263 if ( normalise )
264 *p = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) );
265
266 /* perform clipping */
267 else if ( sample > samplemax )
268 *p = samplemax;
269 else if ( sample < samplemin )
270 *p = samplemin;
271 }
272 p++;
273 }
274 gain += gain_step;
275 }
276
277 return 0;
278 }
279
280 /** Filter processing.
281 */
282
283 static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
284 {
285 mlt_properties properties = mlt_frame_properties( frame );
286 mlt_properties filter_props = mlt_filter_properties( this );
287
288 // Parse the gain property
289 if ( mlt_properties_get( properties, "gain" ) == NULL )
290 {
291 double gain = 1.0; // no adjustment
292
293 if ( mlt_properties_get( filter_props, "gain" ) != NULL )
294 {
295 char *p = mlt_properties_get( filter_props, "gain" );
296
297 if ( strncaseeq( p, "normalise", 9 ) )
298 mlt_properties_set( filter_props, "normalise", "" );
299 else
300 {
301 if ( strcmp( p, "" ) != 0 )
302 gain = fabs( strtod( p, &p) );
303
304 while ( isspace( *p ) )
305 p++;
306
307 /* check if "dB" is given after number */
308 if ( strncaseeq( p, "db", 2 ) )
309 gain = DBFSTOAMP( gain );
310
311 // If there is an end adjust gain to the range
312 if ( mlt_properties_get( filter_props, "end" ) != NULL )
313 {
314 // Determine the time position of this frame in the transition duration
315 mlt_position in = mlt_filter_get_in( this );
316 mlt_position out = mlt_filter_get_out( this );
317 mlt_position time = mlt_frame_get_position( frame );
318 double position = ( double )( time - in ) / ( double )( out - in + 1 );
319
320 double end = -1;
321 char *p = mlt_properties_get( filter_props, "end" );
322 if ( strcmp( p, "" ) != 0 )
323 end = fabs( strtod( p, &p) );
324
325 while ( isspace( *p ) )
326 p++;
327
328 /* check if "dB" is given after number */
329 if ( strncaseeq( p, "db", 2 ) )
330 end = DBFSTOAMP( gain );
331
332 if ( end != -1 )
333 gain += ( end - gain ) * position;
334 }
335 }
336 }
337 mlt_properties_set_double( properties, "volume.gain", gain );
338 }
339
340 // Parse the maximum gain property
341 if ( mlt_properties_get( filter_props, "max_gain" ) != NULL )
342 {
343 char *p = mlt_properties_get( filter_props, "max_gain" );
344 double gain = fabs( strtod( p, &p) ); // 0 = no max
345
346 while ( isspace( *p ) )
347 p++;
348
349 /* check if "dB" is given after number */
350 if ( strncaseeq( p, "db", 2 ) )
351 gain = DBFSTOAMP( gain );
352
353 mlt_properties_set_double( properties, "volume.max_gain", gain );
354 }
355
356 // Parse the limiter property
357 if ( mlt_properties_get( filter_props, "limiter" ) != NULL )
358 {
359 char *p = mlt_properties_get( filter_props, "limiter" );
360 double level = 0.5; /* -6dBFS */
361 if ( strcmp( p, "" ) != 0 )
362 level = strtod( p, &p);
363
364 while ( isspace( *p ) )
365 p++;
366
367 /* check if "dB" is given after number */
368 if ( strncaseeq( p, "db", 2 ) )
369 {
370 if ( level > 0 )
371 level = -level;
372 level = DBFSTOAMP( level );
373 }
374 else
375 {
376 if ( level < 0 )
377 level = -level;
378 }
379 mlt_properties_set_double( properties, "volume.limiter", level );
380 }
381
382 // Parse the normalise property
383 if ( mlt_properties_get( filter_props, "normalise" ) != NULL )
384 {
385 char *p = mlt_properties_get( filter_props, "normalise" );
386 double amplitude = 0.2511886431509580; /* -12dBFS */
387 if ( strcmp( p, "" ) != 0 )
388 amplitude = strtod( p, &p);
389
390 while ( isspace( *p ) )
391 p++;
392
393 /* check if "dB" is given after number */
394 if ( strncaseeq( p, "db", 2 ) )
395 {
396 if ( amplitude > 0 )
397 amplitude = -amplitude;
398 amplitude = DBFSTOAMP( amplitude );
399 }
400 else
401 {
402 if ( amplitude < 0 )
403 amplitude = -amplitude;
404 if ( amplitude > 1.0 )
405 amplitude = 1.0;
406 }
407
408 // If there is an end adjust gain to the range
409 if ( mlt_properties_get( filter_props, "end" ) != NULL )
410 {
411 // Determine the time position of this frame in the transition duration
412 mlt_position in = mlt_filter_get_in( this );
413 mlt_position out = mlt_filter_get_out( this );
414 mlt_position time = mlt_frame_get_position( frame );
415 double position = ( double )( time - in ) / ( double )( out - in + 1 );
416 amplitude *= position;
417 }
418 mlt_properties_set_int( properties, "volume.normalise", 1 );
419 mlt_properties_set_double( properties, "volume.amplitude", amplitude );
420 }
421
422 // Parse the window property and allocate smoothing buffer if needed
423 int window = mlt_properties_get_int( filter_props, "window" );
424 if ( mlt_properties_get( filter_props, "smooth_buffer" ) == NULL && window > 1 )
425 {
426 // Create a smoothing buffer for the calculated "max power" of frame of audio used in normalisation
427 double *smooth_buffer = (double*) calloc( window, sizeof( double ) );
428 int i;
429 for ( i = 0; i < window; i++ )
430 smooth_buffer[ i ] = -1.0;
431 mlt_properties_set_data( filter_props, "smooth_buffer", smooth_buffer, 0, free, NULL );
432 int *smooth_index = calloc( 1, sizeof( int ) );
433
434 mlt_properties_set_data( filter_props, "smooth_index", smooth_index, 0, free, NULL );
435 }
436
437 // Put a filter reference onto the frame
438 mlt_properties_set_data( properties, "filter_volume", this, 0, NULL, NULL );
439
440 // Backup the original get_audio (it's still needed)
441 mlt_properties_set_data( properties, "volume.get_audio", frame->get_audio, 0, NULL, NULL );
442
443 // Override the get_audio method
444 frame->get_audio = filter_get_audio;
445
446 return frame;
447 }
448
449 /** Constructor for the filter.
450 */
451
452 mlt_filter filter_volume_init( char *arg )
453 {
454 mlt_filter this = calloc( sizeof( struct mlt_filter_s ), 1 );
455 if ( this != NULL && mlt_filter_init( this, NULL ) == 0 )
456 {
457 mlt_properties properties = mlt_filter_properties( this );
458 this->process = filter_process;
459 if ( arg != NULL )
460 mlt_properties_set( properties, "gain", arg );
461
462 mlt_properties_set_int( properties, "window", 75 );
463 mlt_properties_set( properties, "max_gain", "20dB" );
464 }
465 return this;
466 }
467
my melted branch