static int transition_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the b frame from the stack
mlt_frame b_frame = mlt_frame_pop_audio( frame );
// Get the effect
mlt_transition effect = mlt_frame_pop_audio( frame );
// Get the properties of the b frame
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// We can only mix s16
*format = mlt_audio_s16;
if ( mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( effect ), "combine" ) == 0 )
{
double mix_start = 0.5, mix_end = 0.5;
if ( mlt_properties_get( b_props, "audio.previous_mix" ) != NULL )
mix_start = mlt_properties_get_double( b_props, "audio.previous_mix" );
if ( mlt_properties_get( b_props, "audio.mix" ) != NULL )
mix_end = mlt_properties_get_double( b_props, "audio.mix" );
if ( mlt_properties_get_int( b_props, "audio.reverse" ) )
{
mix_start = 1 - mix_start;
mix_end = 1 - mix_end;
}
mix_audio( frame, b_frame, mix_start, mix_end, buffer, format, frequency, channels, samples );
}
else
{
combine_audio( frame, b_frame, buffer, format, frequency, channels, samples );
}
return 0;
}
static int ladspa_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the filter properties
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Get the producer's audio
*format = mlt_audio_float;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
// Initialise LADSPA if needed
jack_rack_t *jackrack = mlt_properties_get_data( filter_properties, "jackrack", NULL );
if ( jackrack == NULL )
{
sample_rate = *frequency; // global inside jack_rack
jackrack = initialise_jack_rack( filter_properties, *channels );
}
// Get the filter-specific properties
LADSPA_Data **input_buffers = mlt_pool_alloc( sizeof( LADSPA_Data* ) * *channels );
LADSPA_Data **output_buffers = mlt_pool_alloc( sizeof( LADSPA_Data* ) * *channels );
int i;
for ( i = 0; i < *channels; i++ )
{
input_buffers[i] = (LADSPA_Data*) *buffer + i * *samples;
output_buffers[i] = (LADSPA_Data*) *buffer + i * *samples;
}
// Do LADSPA processing
int error = jackrack && process_ladspa( jackrack->procinfo, *samples, input_buffers, output_buffers );
mlt_pool_release( input_buffers );
mlt_pool_release( output_buffers );
return error;
}
static int resample_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the filter properties
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Get the resample information
int output_rate = mlt_properties_get_int( filter_properties, "frequency" );
// If no resample frequency is specified, default to requested value
if ( output_rate == 0 )
output_rate = *frequency;
// Get the producer's audio
int error = mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
if ( error ) return error;
// Return now if no work to do
if ( output_rate != *frequency && *frequency > 0 && *channels > 0 )
{
mlt_log_debug( MLT_FILTER_SERVICE(filter), "channels %d samples %d frequency %d -> %d\n",
*channels, *samples, *frequency, output_rate );
// Do not convert to float unless we need to change the rate
if ( *format != mlt_audio_f32le )
frame->convert_audio( frame, buffer, format, mlt_audio_f32le );
mlt_service_lock( MLT_FILTER_SERVICE(filter) );
SRC_DATA data;
data.data_in = *buffer;
data.data_out = mlt_properties_get_data( filter_properties, "output_buffer", NULL );
data.src_ratio = ( float ) output_rate / ( float ) *frequency;
data.input_frames = *samples;
data.output_frames = BUFFER_LEN / *channels;
data.end_of_input = 0;
SRC_STATE *state = mlt_properties_get_data( filter_properties, "state", NULL );
if ( !state || mlt_properties_get_int( filter_properties, "channels" ) != *channels )
{
// Recreate the resampler if the number of channels changed
state = src_new( RESAMPLE_TYPE, *channels, &error );
mlt_properties_set_data( filter_properties, "state", state, 0, (mlt_destructor) src_delete, NULL );
mlt_properties_set_int( filter_properties, "channels", *channels );
}
// Resample the audio
error = src_process( state, &data );
if ( !error )
{
// Update output variables
*samples = data.output_frames_gen;
*frequency = output_rate;
*buffer = data.data_out;
}
else
{
mlt_log_error( MLT_FILTER_SERVICE( filter ), "%s %d,%d,%d\n", src_strerror( error ), *frequency, *samples, output_rate );
}
mlt_service_unlock( MLT_FILTER_SERVICE(filter) );
}
return error;
}
static int transition_get_audio( mlt_frame frame_a, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
int error = 0;
// Get the b frame from the stack
mlt_frame frame_b = mlt_frame_pop_audio( frame_a );
// Get the effect
mlt_transition transition = mlt_frame_pop_audio( frame_a );
// Get the properties of the b frame
mlt_properties b_props = MLT_FRAME_PROPERTIES( frame_b );
transition_mix self = transition->child;
int16_t *buffer_b, *buffer_a;
int frequency_b = *frequency, frequency_a = *frequency;
int channels_b = *channels, channels_a = *channels;
int samples_b = *samples, samples_a = *samples;
// We can only mix s16
*format = mlt_audio_s16;
mlt_frame_get_audio( frame_b, (void**) &buffer_b, format, &frequency_b, &channels_b, &samples_b );
mlt_frame_get_audio( frame_a, (void**) &buffer_a, format, &frequency_a, &channels_a, &samples_a );
if ( buffer_b == buffer_a )
{
*samples = samples_b;
*channels = channels_b;
*buffer = buffer_b;
*frequency = frequency_b;
return error;
}
int silent = mlt_properties_get_int( MLT_FRAME_PROPERTIES( frame_a ), "silent_audio" );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame_a ), "silent_audio", 0 );
if ( silent )
memset( buffer_a, 0, samples_a * channels_a * sizeof( int16_t ) );
silent = mlt_properties_get_int( b_props, "silent_audio" );
mlt_properties_set_int( b_props, "silent_audio", 0 );
if ( silent )
memset( buffer_b, 0, samples_b * channels_b * sizeof( int16_t ) );
// determine number of samples to process
*samples = MIN( self->src_buffer_count + samples_b, self->dest_buffer_count + samples_a );
*channels = MIN( MIN( channels_b, channels_a ), MAX_CHANNELS );
*frequency = frequency_a;
// Prevent src buffer overflow by discarding oldest samples.
samples_b = MIN( samples_b, MAX_SAMPLES * MAX_CHANNELS / channels_b );
size_t bytes = PCM16_BYTES( samples_b, channels_b );
if ( PCM16_BYTES( self->src_buffer_count + samples_b, channels_b ) > MAX_BYTES ) {
mlt_log_verbose( MLT_TRANSITION_SERVICE(transition), "buffer overflow: src_buffer_count %d\n",
self->src_buffer_count );
self->src_buffer_count = MAX_SAMPLES * MAX_CHANNELS / channels_b - samples_b;
memmove( self->src_buffer, &self->src_buffer[MAX_SAMPLES * MAX_CHANNELS - samples_b * channels_b],
PCM16_BYTES( samples_b, channels_b ) );
}
// Buffer new src samples.
memcpy( &self->src_buffer[self->src_buffer_count * channels_b], buffer_b, bytes );
self->src_buffer_count += samples_b;
buffer_b = self->src_buffer;
// Prevent dest buffer overflow by discarding oldest samples.
samples_a = MIN( samples_a, MAX_SAMPLES * MAX_CHANNELS / channels_a );
bytes = PCM16_BYTES( samples_a, channels_a );
if ( PCM16_BYTES( self->dest_buffer_count + samples_a, channels_a ) > MAX_BYTES ) {
mlt_log_verbose( MLT_TRANSITION_SERVICE(transition), "buffer overflow: dest_buffer_count %d\n",
self->dest_buffer_count );
self->dest_buffer_count = MAX_SAMPLES * MAX_CHANNELS / channels_a - samples_a;
memmove( self->dest_buffer, &self->dest_buffer[MAX_SAMPLES * MAX_CHANNELS - samples_a * channels_a],
PCM16_BYTES( samples_a, channels_a ) );
}
// Buffer the new dest samples.
memcpy( &self->dest_buffer[self->dest_buffer_count * channels_a], buffer_a, bytes );
self->dest_buffer_count += samples_a;
buffer_a = self->dest_buffer;
// Do the mixing.
if ( mlt_properties_get_int( MLT_TRANSITION_PROPERTIES(transition), "combine" ) )
{
double weight = 1.0;
if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES( frame_a ), "meta.mixdown" ) )
weight = 1.0 - mlt_properties_get_double( MLT_FRAME_PROPERTIES( frame_a ), "meta.volume" );
combine_audio( weight, buffer_a, buffer_b, channels_a, channels_b, *channels, *samples );
}
else
{
double mix_start = 0.5, mix_end = 0.5;
if ( mlt_properties_get( b_props, "audio.previous_mix" ) )
mix_start = mlt_properties_get_double( b_props, "audio.previous_mix" );
if ( mlt_properties_get( b_props, "audio.mix" ) )
mix_end = mlt_properties_get_double( b_props, "audio.mix" );
if ( mlt_properties_get_int( b_props, "audio.reverse" ) )
{
mix_start = 1.0 - mix_start;
mix_end = 1.0 - mix_end;
}
mix_audio( mix_start, mix_end, buffer_a, buffer_b, channels_a, channels_b, *channels, *samples );
}
// Copy the audio into the frame.
bytes = PCM16_BYTES( *samples, *channels );
*buffer = mlt_pool_alloc( bytes );
memcpy( *buffer, buffer_a, bytes );
mlt_frame_set_audio( frame_a, *buffer, *format, bytes, mlt_pool_release );
if ( mlt_properties_get_int( b_props, "_speed" ) == 0 )
{
// Flush the buffer when paused and scrubbing.
samples_b = self->src_buffer_count;
samples_a = self->dest_buffer_count;
}
else
{
// Determine the maximum amount of latency permitted in the buffer.
int max_latency = CLAMP( *frequency / 1000, 0, MAX_SAMPLES ); // samples in 1ms
// samples_b becomes the new target src buffer count.
samples_b = CLAMP( self->src_buffer_count - *samples, 0, max_latency );
// samples_b becomes the number of samples to consume: difference between actual and the target.
samples_b = self->src_buffer_count - samples_b;
// samples_a becomes the new target dest buffer count.
samples_a = CLAMP( self->dest_buffer_count - *samples, 0, max_latency );
// samples_a becomes the number of samples to consume: difference between actual and the target.
samples_a = self->dest_buffer_count - samples_a;
}
// Consume the src buffer.
self->src_buffer_count -= samples_b;
if ( self->src_buffer_count ) {
memmove( self->src_buffer, &self->src_buffer[samples_b * channels_b],
PCM16_BYTES( self->src_buffer_count, channels_b ));
}
// Consume the dest buffer.
self->dest_buffer_count -= samples_a;
if ( self->dest_buffer_count ) {
memmove( self->dest_buffer, &self->dest_buffer[samples_a * channels_a],
PCM16_BYTES( self->dest_buffer_count, channels_a ));
}
return error;
}
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 int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the properties of the a frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
int from = mlt_properties_get_int( properties, "channelcopy.from" );
int to = mlt_properties_get_int( properties, "channelcopy.to" );
int swap = mlt_properties_get_int( properties, "channelcopy.swap" );
// Get the producer's audio
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
// Copy channels as necessary
if ( from != to)
switch ( *format )
{
case mlt_audio_u8:
{
uint8_t *f = (uint8_t*) *buffer + from;
uint8_t *t = (uint8_t*) *buffer + to;
uint8_t x;
int i;
if ( swap )
for ( i = 0; i < *samples; i++, f += *channels, t += *channels )
{
x = *t;
*t = *f;
*f = x;
}
else
for ( i = 0; i < *samples; i++, f += *channels, t += *channels )
*t = *f;
break;
}
case mlt_audio_s16:
{
int16_t *f = (int16_t*) *buffer + from;
int16_t *t = (int16_t*) *buffer + to;
int16_t x;
int i;
if ( swap )
for ( i = 0; i < *samples; i++, f += *channels, t += *channels )
{
x = *t;
*t = *f;
*f = x;
}
else
for ( i = 0; i < *samples; i++, f += *channels, t += *channels )
*t = *f;
break;
}
case mlt_audio_s32:
{
int32_t *f = (int32_t*) *buffer + from * *samples;
int32_t *t = (int32_t*) *buffer + to * *samples;
if ( swap )
{
int32_t *x = malloc( *samples * sizeof(int32_t) );
memcpy( x, t, *samples * sizeof(int32_t) );
memcpy( t, f, *samples * sizeof(int32_t) );
memcpy( f, x, *samples * sizeof(int32_t) );
free( x );
}
else
{
memcpy( t, f, *samples * sizeof(int32_t) );
}
break;
}
case mlt_audio_s32le:
case mlt_audio_f32le:
{
int32_t *f = (int32_t*) *buffer + from;
int32_t *t = (int32_t*) *buffer + to;
int32_t x;
int i;
if ( swap )
for ( i = 0; i < *samples; i++, f += *channels, t += *channels )
{
x = *t;
*t = *f;
*f = x;
}
else
for ( i = 0; i < *samples; i++, f += *channels, t += *channels )
*t = *f;
break;
}
case mlt_audio_float:
{
float *f = (float*) *buffer + from * *samples;
float *t = (float*) *buffer + to * *samples;
if ( swap )
{
float *x = malloc( *samples * sizeof(float) );
memcpy( x, t, *samples * sizeof(float) );
memcpy( t, f, *samples * sizeof(float) );
memcpy( f, x, *samples * sizeof(float) );
free( x );
}
else
{
memcpy( t, f, *samples * sizeof(float) );
}
break;
}
default:
mlt_log_error( MLT_FILTER_SERVICE( filter ), "Invalid audio format\n" );
break;
}
return 0;
}
static int ladspa_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
int error = 0;
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the filter properties
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Check if the channel configuration has changed
int prev_channels = mlt_properties_get_int( filter_properties, "_prev_channels" );
if ( prev_channels != *channels )
{
if( prev_channels )
{
mlt_log_info( MLT_FILTER_SERVICE(filter), "Channel configuration changed. Old: %d New: %d.\n", prev_channels, *channels );
mlt_properties_set_data( filter_properties, "jackrack", NULL, 0, (mlt_destructor) NULL, NULL );
}
mlt_properties_set_int( filter_properties, "_prev_channels", *channels );
}
// Initialise LADSPA if needed
jack_rack_t *jackrack = mlt_properties_get_data( filter_properties, "jackrack", NULL );
if ( jackrack == NULL )
{
sample_rate = *frequency; // global inside jack_rack
jackrack = initialise_jack_rack( filter_properties, *channels );
}
if ( jackrack && jackrack->procinfo && jackrack->procinfo->chain &&
mlt_properties_get_int64( filter_properties, "_pluginid" ) )
{
plugin_t *plugin = jackrack->procinfo->chain;
LADSPA_Data value;
int i, c;
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
// Get the producer's audio
*format = mlt_audio_float;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
// Resize the buffer if necessary.
if ( *channels < jackrack->channels )
{
// Add extra channels to satisfy the plugin.
// Extra channels in the buffer will be ignored by downstream services.
int old_size = mlt_audio_format_size( *format, *samples, *channels );
int new_size = mlt_audio_format_size( *format, *samples, jackrack->channels );
uint8_t* new_buffer = mlt_pool_alloc( new_size );
memcpy( new_buffer, *buffer, old_size );
// Put silence in extra channels.
memset( new_buffer + old_size, 0, new_size - old_size );
mlt_frame_set_audio( frame, new_buffer, *format, new_size, mlt_pool_release );
*buffer = new_buffer;
}
for ( i = 0; i < plugin->desc->control_port_count; i++ )
{
// Apply the control port values
char key[20];
value = plugin_desc_get_default_control_value( plugin->desc, i, sample_rate );
snprintf( key, sizeof(key), "%d", i );
if ( mlt_properties_get( filter_properties, key ) )
value = mlt_properties_anim_get_double( filter_properties, key, position, length );
for ( c = 0; c < plugin->copies; c++ )
plugin->holders[c].control_memory[i] = value;
}
plugin->wet_dry_enabled = mlt_properties_get( filter_properties, "wetness" ) != NULL;
if ( plugin->wet_dry_enabled )
{
value = mlt_properties_anim_get_double( filter_properties, "wetness", position, length );
for ( c = 0; c < jackrack->channels; c++ )
plugin->wet_dry_values[c] = value;
}
// Configure the buffers
LADSPA_Data **input_buffers = mlt_pool_alloc( sizeof( LADSPA_Data* ) * jackrack->channels );
LADSPA_Data **output_buffers = mlt_pool_alloc( sizeof( LADSPA_Data* ) * jackrack->channels );
// Some plugins crash with too many frames (samples).
// So, feed the plugin with N samples per loop iteration.
int samples_offset = 0;
int sample_count = MIN(*samples, MAX_SAMPLE_COUNT);
for (i = 0; samples_offset < *samples; i++) {
int j = 0;
for (; j < jackrack->channels; j++)
output_buffers[j] = input_buffers[j] = (LADSPA_Data*) *buffer + j * (*samples) + samples_offset;
sample_count = MIN(*samples - samples_offset, MAX_SAMPLE_COUNT);
// Do LADSPA processing
error = process_ladspa( jackrack->procinfo, sample_count, input_buffers, output_buffers );
samples_offset += MAX_SAMPLE_COUNT;
}
mlt_pool_release( input_buffers );
mlt_pool_release( output_buffers );
// read the status port values
for ( i = 0; i < plugin->desc->status_port_count; i++ )
{
char key[20];
int p = plugin->desc->status_port_indicies[i];
for ( c = 0; c < plugin->copies; c++ )
{
snprintf( key, sizeof(key), "%d[%d]", p, c );
value = plugin->holders[c].status_memory[i];
mlt_properties_set_double( filter_properties, key, value );
}
}
}
else
{
// Nothing to do.
error = mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
}
return error;
}
int mlt_frame_get_audio( mlt_frame self, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
mlt_get_audio get_audio = mlt_frame_pop_audio( self );
mlt_properties properties = MLT_FRAME_PROPERTIES( self );
int hide = mlt_properties_get_int( properties, "test_audio" );
mlt_audio_format requested_format = *format;
if ( hide == 0 && get_audio != NULL )
{
get_audio( self, buffer, format, frequency, channels, samples );
mlt_properties_set_int( properties, "audio_frequency", *frequency );
mlt_properties_set_int( properties, "audio_channels", *channels );
mlt_properties_set_int( properties, "audio_samples", *samples );
mlt_properties_set_int( properties, "audio_format", *format );
if ( self->convert_audio && *buffer && requested_format != mlt_audio_none )
self->convert_audio( self, buffer, format, requested_format );
}
else if ( mlt_properties_get_data( properties, "audio", NULL ) )
{
*buffer = mlt_properties_get_data( properties, "audio", NULL );
*format = mlt_properties_get_int( properties, "audio_format" );
*frequency = mlt_properties_get_int( properties, "audio_frequency" );
*channels = mlt_properties_get_int( properties, "audio_channels" );
*samples = mlt_properties_get_int( properties, "audio_samples" );
if ( self->convert_audio && *buffer && requested_format != mlt_audio_none )
self->convert_audio( self, buffer, format, requested_format );
}
else
{
int size = 0;
*samples = *samples <= 0 ? 1920 : *samples;
*channels = *channels <= 0 ? 2 : *channels;
*frequency = *frequency <= 0 ? 48000 : *frequency;
mlt_properties_set_int( properties, "audio_frequency", *frequency );
mlt_properties_set_int( properties, "audio_channels", *channels );
mlt_properties_set_int( properties, "audio_samples", *samples );
mlt_properties_set_int( properties, "audio_format", *format );
switch( *format )
{
case mlt_image_none:
size = 0;
*buffer = NULL;
break;
case mlt_audio_s16:
size = *samples * *channels * sizeof( int16_t );
break;
case mlt_audio_s32:
size = *samples * *channels * sizeof( int32_t );
break;
case mlt_audio_float:
size = *samples * *channels * sizeof( float );
break;
default:
break;
}
if ( size )
*buffer = mlt_pool_alloc( size );
if ( *buffer )
memset( *buffer, 0, size );
mlt_properties_set_data( properties, "audio", *buffer, size, ( mlt_destructor )mlt_pool_release, NULL );
mlt_properties_set_int( properties, "test_audio", 1 );
}
// TODO: This does not belong here
if ( *format == mlt_audio_s16 && mlt_properties_get( properties, "meta.volume" ) )
{
double value = mlt_properties_get_double( properties, "meta.volume" );
if ( value == 0.0 )
{
memset( *buffer, 0, *samples * *channels * 2 );
}
else if ( value != 1.0 )
{
int total = *samples * *channels;
int16_t *p = *buffer;
while ( total -- )
{
*p = *p * value;
p ++;
}
}
mlt_properties_set( properties, "meta.volume", NULL );
}
return 0;
}
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;
}
static int ladspa_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
int error = 0;
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the filter properties
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Initialise LADSPA if needed
jack_rack_t *jackrack = mlt_properties_get_data( filter_properties, "jackrack", NULL );
if ( jackrack == NULL )
{
sample_rate = *frequency; // global inside jack_rack
jackrack = initialise_jack_rack( filter_properties, *channels );
}
if ( jackrack && jackrack->procinfo && jackrack->procinfo->chain &&
mlt_properties_get_int64( filter_properties, "_pluginid" ) )
{
plugin_t *plugin = jackrack->procinfo->chain;
LADSPA_Data value;
int i, c;
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
// Get the producer's audio
*channels = jackrack->channels;
*format = mlt_audio_float;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
for ( i = 0; i < plugin->desc->control_port_count; i++ )
{
// Apply the control port values
char key[20];
value = plugin_desc_get_default_control_value( plugin->desc, i, sample_rate );
snprintf( key, sizeof(key), "%d", i );
if ( mlt_properties_get( filter_properties, key ) )
value = mlt_properties_anim_get_double( filter_properties, key, position, length );
for ( c = 0; c < plugin->copies; c++ )
plugin->holders[c].control_memory[i] = value;
}
plugin->wet_dry_enabled = mlt_properties_get( filter_properties, "wetness" ) != NULL;
if ( plugin->wet_dry_enabled )
{
value = mlt_properties_anim_get_double( filter_properties, "wetness", position, length );
for ( c = 0; c < *channels; c++ )
plugin->wet_dry_values[c] = value;
}
// Configure the buffers
LADSPA_Data **input_buffers = mlt_pool_alloc( sizeof( LADSPA_Data* ) * *channels );
LADSPA_Data **output_buffers = mlt_pool_alloc( sizeof( LADSPA_Data* ) * *channels );
for ( i = 0; i < *channels; i++ )
{
input_buffers[i] = (LADSPA_Data*) *buffer + i * *samples;
output_buffers[i] = (LADSPA_Data*) *buffer + i * *samples;
}
// Do LADSPA processing
error = process_ladspa( jackrack->procinfo, *samples, input_buffers, output_buffers );
mlt_pool_release( input_buffers );
mlt_pool_release( output_buffers );
// read the status port values
for ( i = 0; i < plugin->desc->status_port_count; i++ )
{
char key[20];
int p = plugin->desc->status_port_indicies[i];
for ( c = 0; c < plugin->copies; c++ )
{
snprintf( key, sizeof(key), "%d[%d]", p, c );
value = plugin->holders[c].status_memory[i];
mlt_properties_set_double( filter_properties, key, value );
}
}
}
else
{
// Nothing to do.
error = mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
}
return error;
}
static int resample_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the filter properties
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
// Get the resample information
int output_rate = mlt_properties_get_int( filter_properties, "frequency" );
int16_t *sample_buffer = mlt_properties_get_data( filter_properties, "buffer", NULL );
// Obtain the resample context if it exists
ReSampleContext *resample = mlt_properties_get_data( filter_properties, "audio_resample", NULL );
// If no resample frequency is specified, default to requested value
if ( output_rate == 0 )
output_rate = *frequency;
// Get the producer's audio
int error = mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
if ( error ) return error;
// Return now if no work to do
if ( output_rate != *frequency )
{
// Will store number of samples created
int used = 0;
mlt_log_debug( MLT_FILTER_SERVICE(filter), "channels %d samples %d frequency %d -> %d\n",
*channels, *samples, *frequency, output_rate );
// Do not convert to s16 unless we need to change the rate
if ( *format != mlt_audio_s16 )
{
*format = mlt_audio_s16;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
}
// Create a resampler if nececessary
if ( resample == NULL || *frequency != mlt_properties_get_int( filter_properties, "last_frequency" ) )
{
// Create the resampler
resample = av_audio_resample_init( *channels, *channels, output_rate, *frequency,
AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16, 16, 10, 0, 0.8 );
// And store it on properties
mlt_properties_set_data( filter_properties, "audio_resample", resample, 0, ( mlt_destructor )audio_resample_close, NULL );
// And remember what it was created for
mlt_properties_set_int( filter_properties, "last_frequency", *frequency );
}
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
// Resample the audio
used = audio_resample( resample, sample_buffer, *buffer, *samples );
int size = used * *channels * sizeof( int16_t );
// Resize if necessary
if ( used > *samples )
{
*buffer = mlt_pool_realloc( *buffer, size );
mlt_frame_set_audio( frame, *buffer, *format, size, mlt_pool_release );
}
// Copy samples
memcpy( *buffer, sample_buffer, size );
// Update output variables
*samples = used;
*frequency = output_rate;
}
else
{
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
}
return error;
}
static int producer_get_audio( mlt_frame frame, int16_t** buffer, mlt_audio_format* format, int* frequency, int* channels, int* samples )
{
mlt_producer producer = (mlt_producer)mlt_frame_pop_audio( frame );
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
char* sound = mlt_properties_get( producer_properties, "sound" );
double fps = mlt_producer_get_fps( producer );
mlt_position position = mlt_frame_original_position( frame );
int size = 0;
int do_beep = 0;
time_info info;
if( fps == 0 ) fps = 25;
// Correct the returns if necessary
*format = mlt_audio_float;
*frequency = *frequency <= 0 ? 48000 : *frequency;
*channels = *channels <= 0 ? 2 : *channels;
*samples = *samples <= 0 ? mlt_sample_calculator( fps, *frequency, position ) : *samples;
// Allocate the buffer
size = *samples * *channels * sizeof( float );
*buffer = mlt_pool_alloc( size );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
get_time_info( producer, frame, &info );
// Determine if this should be a tone or silence.
if( strcmp( sound, "none") )
{
if( !strcmp( sound, "2pop" ) )
{
mlt_position out = mlt_properties_get_int( producer_properties, "out" );
mlt_position frames = out - position;
if( frames == ( info.fps * 2 ) )
{
do_beep = 1;
}
}
else if( !strcmp( sound, "frame0" ) )
{
if( info.frames == 0 )
{
do_beep = 1;
}
}
}
if( do_beep )
{
fill_beep( producer_properties, (float*)*buffer, *frequency, *channels, *samples );
}
else
{
// Fill silence.
memset( *buffer, 0, size );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
// Set the buffer for destruction
mlt_frame_set_audio( frame, *buffer, *format, size, mlt_pool_release );
return 0;
}
static int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
mlt_properties properties = mlt_frame_pop_audio( frame );
mlt_filter filter = mlt_frame_pop_audio( frame );
mlt_properties filter_props = MLT_FILTER_PROPERTIES( filter );
mlt_properties frame_props = MLT_FRAME_PROPERTIES( frame );
// We can only mix s16
*format = mlt_audio_s16;
mlt_frame_get_audio( frame, (void**) buffer, format, frequency, channels, samples );
// Apply silence
int silent = mlt_properties_get_int( frame_props, "silent_audio" );
mlt_properties_set_int( frame_props, "silent_audio", 0 );
if ( silent )
memset( *buffer, 0, *samples * *channels * sizeof( int16_t ) );
int src_size = 0;
int16_t *src = mlt_properties_get_data( filter_props, "scratch_buffer", &src_size );
int16_t *dest = *buffer;
double v; // sample accumulator
int i, out, in;
double factors[6][6]; // mixing weights [in][out]
double mix_start = 0.5, mix_end = 0.5;
if ( mlt_properties_get( properties, "previous_mix" ) != NULL )
mix_start = mlt_properties_get_double( properties, "previous_mix" );
if ( mlt_properties_get( properties, "mix" ) != NULL )
mix_end = mlt_properties_get_double( properties, "mix" );
double weight = mix_start;
double weight_step = ( mix_end - mix_start ) / *samples;
int active_channel = mlt_properties_get_int( properties, "channel" );
int gang = mlt_properties_get_int( properties, "gang" ) ? 2 : 1;
// Use an inline low-pass filter to help avoid clipping
double Fc = 0.5;
double B = exp(-2.0 * M_PI * Fc);
double A = 1.0 - B;
double vp[6];
// Setup or resize a scratch buffer
if ( !src || src_size < *samples * *channels * sizeof(int16_t) )
{
// We allocate 4 more samples than we need to deal with jitter in the sample count per frame.
src_size = ( *samples + 4 ) * *channels * sizeof(int16_t);
src = mlt_pool_alloc( src_size );
if ( !src )
return 0;
mlt_properties_set_data( filter_props, "scratch_buffer", src, src_size, mlt_pool_release, NULL );
}
// We must use a pristine copy as the source
memcpy( src, *buffer, *samples * *channels * sizeof(int16_t) );
// Initialize the mix factors
for ( i = 0; i < 6; i++ )
for ( out = 0; out < 6; out++ )
factors[i][out] = 0.0;
for ( out = 0; out < *channels; out++ )
vp[out] = (double) dest[out];
for ( i = 0; i < *samples; i++ )
{
// Recompute the mix factors
switch ( active_channel )
{
case -1: // Front L/R balance
case -2: // Rear L/R balance
{
// Gang front/rear balance if requested
int g, active = active_channel;
for ( g = 0; g < gang; g++, active-- )
{
int left = active == -1 ? 0 : 2;
int right = left + 1;
if ( weight < 0.0 )
{
factors[left][left] = 1.0;
factors[right][right] = weight + 1.0 < 0.0 ? 0.0 : weight + 1.0;
}
else
{
factors[left][left] = 1.0 - weight < 0.0 ? 0.0 : 1.0 - weight;
factors[right][right] = 1.0;
}
}
break;
}
case -3: // Left fade
case -4: // right fade
{
// Gang left/right fade if requested
int g, active = active_channel;
for ( g = 0; g < gang; g++, active-- )
{
int front = active == -3 ? 0 : 1;
int rear = front + 2;
if ( weight < 0.0 )
{
factors[front][front] = 1.0;
factors[rear][rear] = weight + 1.0 < 0.0 ? 0.0 : weight + 1.0;
}
else
{
factors[front][front] = 1.0 - weight < 0.0 ? 0.0 : 1.0 - weight;
factors[rear][rear] = 1.0;
}
}
break;
}
case 0: // left
case 2:
{
int left = active_channel;
int right = left + 1;
factors[right][right] = 1.0;
if ( weight < 0.0 ) // output left toward left
{
factors[left][left] = 0.5 - weight * 0.5;
factors[left][right] = ( 1.0 + weight ) * 0.5;
}
else // output left toward right
{
factors[left][left] = ( 1.0 - weight ) * 0.5;
factors[left][right] = 0.5 + weight * 0.5;
}
break;
}
case 1: // right
case 3:
{
int right = active_channel;
int left = right - 1;
factors[left][left] = 1.0;
if ( weight < 0.0 ) // output right toward left
{
factors[right][left] = 0.5 - weight * 0.5;
factors[right][right] = ( 1.0 + weight ) * 0.5;
}
else // output right toward right
{
factors[right][left] = ( 1.0 - weight ) * 0.5;
factors[right][right] = 0.5 + weight * 0.5;
}
break;
}
}
// Do the mixing
for ( out = 0; out < *channels && out < 6; out++ )
{
v = 0;
for ( in = 0; in < *channels && in < 6; in++ )
v += factors[in][out] * src[ i * *channels + in ];
v = v < -32767 ? -32767 : v > 32768 ? 32768 : v;
vp[out] = dest[ i * *channels + out ] = (int16_t) ( v * A + vp[ out ] * B );
}
weight += weight_step;
}
return 0;
}