git.sesse.net Git - mlt/blob - src/modules/plus/filter_loudness.c

   1 /*
   2  * filter_ebur128.c -- normalize audio according to EBU R128
   3  * Copyright (C) 2014 Brian Matherly <pez4brian@yahoo.com>
   4  * Author: Brian Matherly <pez4brian@yahoo.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library 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 GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <framework/mlt.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <math.h>
  25 #include "ebur128/ebur128.h"
  26
  27 #define MAX_RESULT_SIZE 512
  28
  29 typedef struct
  30 {
  31         ebur128_state* state;
  32 } analyze_data;
  33
  34 typedef struct
  35 {
  36         double in_loudness;
  37         double in_range;
  38         double in_peak;
  39 } apply_data;
  40
  41 typedef struct
  42 {
  43         analyze_data* analyze;
  44         apply_data* apply;
  45         mlt_position last_position;
  46 } private_data;
  47
  48 static void destroy_analyze_data( mlt_filter filter )
  49 {
  50         private_data* private = (private_data*)filter->child;
  51         ebur128_destroy( &private->analyze->state );
  52         free( private->analyze );
  53         private->analyze = NULL;
  54 }
  55
  56 static void init_analyze_data( mlt_filter filter, int channels, int samplerate )
  57 {
  58         private_data* private = (private_data*)filter->child;
  59         private->analyze = (analyze_data*)calloc( 1, sizeof(analyze_data) );
  60         private->analyze->state = ebur128_init( (unsigned int)channels, (unsigned long)samplerate, EBUR128_MODE_I | EBUR128_MODE_LRA | EBUR128_MODE_SAMPLE_PEAK );
  61         private->last_position = 0;
  62 }
  63
  64 static void destroy_apply_data( mlt_filter filter )
  65 {
  66         private_data* private = (private_data*)filter->child;
  67         free( private->apply );
  68         private->apply = NULL;
  69 }
  70
  71 static void init_apply_data( mlt_filter filter )
  72 {
  73         private_data* private = (private_data*)filter->child;
  74         mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
  75         char* results = mlt_properties_get( properties, "results" );
  76         int scan_return = 0;
  77
  78         private->apply = (apply_data*)calloc( 1, sizeof(apply_data) );
  79
  80         scan_return = sscanf( results,"L: %lf\tR: %lf\tP %lf", &private->apply->in_loudness, &private->apply->in_range, &private->apply->in_peak );
  81         if( scan_return != 3 )
  82         {
  83                 mlt_log_error( MLT_FILTER_SERVICE( filter ), "Unable to load results: %s\n", results );
  84                 destroy_apply_data( filter );
  85                 return;
  86         }
  87         else
  88         {
  89                 mlt_log_info( MLT_FILTER_SERVICE( filter ), "Loaded Results: L: %lf\tR: %lf\tP %lf\n", private->apply->in_loudness, private->apply->in_range, private->apply->in_peak );
  90         }
  91 }
  92
  93 static void analyze( mlt_filter filter, mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
  94 {
  95         private_data* private = (private_data*)filter->child;
  96         mlt_position pos = mlt_filter_get_position( filter, frame );
  97
  98         // If any frames are skipped, analysis data will be incomplete.
  99         if( private->analyze && pos != private->last_position + 1 )
 100         {
 101                 mlt_log_error( MLT_FILTER_SERVICE(filter), "Analysis Failed: Bad frame sequence\n" );
 102                 destroy_analyze_data( filter );
 103         }
 104
 105         // Analyze Audio
 106         if( !private->analyze && pos == 0 )
 107         {
 108                 init_analyze_data( filter, *channels, *frequency );
 109         }
 110
 111         if( private->analyze )
 112         {
 113                 ebur128_add_frames_float( private->analyze->state, *buffer, *samples );
 114
 115                 if ( pos + 1 == mlt_filter_get_length2( filter, frame ) )
 116                 {
 117                         mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
 118                         double loudness = 0.0;
 119                         double range = 0.0;
 120                         double tmpPeak = 0.0;
 121                         double peak = 0.0;
 122                         int i = 0;
 123                         char result[MAX_RESULT_SIZE];
 124                         ebur128_loudness_global( private->analyze->state, &loudness );
 125                         ebur128_loudness_range( private->analyze->state, &range );
 126
 127                         for ( i = 0; i < *channels; i++ )
 128                         {
 129                                 ebur128_sample_peak( private->analyze->state, i, &tmpPeak );
 130                                 if( tmpPeak > peak )
 131                                 {
 132                                         peak = tmpPeak;
 133                                 }
 134                         }
 135
 136                         snprintf( result, MAX_RESULT_SIZE, "L: %lf\tR: %lf\tP %lf", loudness, range, peak );
 137                         result[ MAX_RESULT_SIZE - 1 ] = '\0';
 138                         mlt_log_info( MLT_FILTER_SERVICE( filter ), "Stored results: %s", result );
 139                         mlt_properties_set( properties, "results", result );
 140                         destroy_analyze_data( filter );
 141                 }
 142
 143                 private->last_position = pos;
 144         }
 145 }
 146
 147 static void apply( mlt_filter filter, mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
 148 {
 149         private_data* private = (private_data*)filter->child;
 150         mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
 151
 152         // Analyze Audio
 153         if( !private->apply )
 154         {
 155                 init_apply_data( filter );
 156         }
 157
 158         if( private->apply )
 159         {
 160                 double target_db = mlt_properties_get_double( properties, "program" );
 161                 double delta_db = target_db - private->apply->in_loudness;
 162                 double coeff = delta_db > -90.0f ? powf(10.0f, delta_db * 0.05f) : 0.0f;
 163                 float* p = *buffer;
 164                 int count = *samples * *channels;
 165                 while( count-- )
 166                 {
 167                         *p = *p * coeff;
 168                         p++;
 169                 }
 170         }
 171 }
 172
 173 /** Get the audio.
 174 */
 175
 176 static int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
 177 {
 178         mlt_filter filter = mlt_frame_pop_audio( frame );
 179         mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
 180
 181         mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
 182
 183         // Get the producer's audio
 184         *format = mlt_audio_f32le;
 185         mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
 186
 187         char* results = mlt_properties_get( properties, "results" );
 188         if( results && strcmp( results, "" ) )
 189         {
 190                 apply( filter, frame, buffer, format, frequency, channels, samples );
 191         }
 192         else
 193         {
 194                 analyze( filter, frame, buffer, format, frequency, channels, samples );
 195         }
 196
 197         mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
 198
 199         return 0;
 200 }
 201
 202 /** Filter processing.
 203 */
 204
 205 static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
 206 {
 207         mlt_frame_push_audio( frame, filter );
 208         mlt_frame_push_audio( frame, filter_get_audio );
 209         return frame;
 210 }
 211
 212 /** Destructor for the filter.
 213 */
 214
 215 static void filter_close( mlt_filter filter )
 216 {
 217         private_data* private = (private_data*)filter->child;
 218
 219         if ( private )
 220         {
 221                 if ( private->analyze )
 222                 {
 223                         destroy_analyze_data( filter );
 224                 }
 225                 free( private );
 226         }
 227         filter->child = NULL;
 228         filter->close = NULL;
 229         filter->parent.close = NULL;
 230         mlt_service_close( &filter->parent );
 231 }
 232
 233 /** Constructor for the filter.
 234 */
 235
 236 mlt_filter filter_loudness_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
 237 {
 238         mlt_filter filter = mlt_filter_new( );
 239         private_data* data = (private_data*)calloc( 1, sizeof(private_data) );
 240
 241         if ( filter && data )
 242         {
 243                 mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
 244                 mlt_properties_set( properties, "program", "-23.0" );
 245
 246                 data->analyze = NULL;
 247
 248                 filter->close = filter_close;
 249                 filter->process = filter_process;
 250                 filter->child = data;
 251         }
 252         else
 253         {
 254                 if( filter )
 255                 {
 256                         mlt_filter_close( filter );
 257                         filter = NULL;
 258                 }
 259
 260                 if( data )
 261                 {
 262                         free( data );
 263                 }
 264         }
 265
 266         return filter;
 267 }