void mlt_service_apply_filters( mlt_service self, mlt_frame frame, int index )
{
int i;
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_properties service_properties = MLT_SERVICE_PROPERTIES( self );
mlt_service_base *base = self->local;
mlt_position position = mlt_frame_get_position( frame );
mlt_position self_in = mlt_properties_get_position( service_properties, "in" );
mlt_position self_out = mlt_properties_get_position( service_properties, "out" );
if ( index == 0 || mlt_properties_get_int( service_properties, "_filter_private" ) == 0 )
{
// Process the frame with the attached filters
for ( i = 0; i < base->filter_count; i ++ )
{
if ( base->filters[ i ] != NULL )
{
mlt_position in = mlt_filter_get_in( base->filters[ i ] );
mlt_position out = mlt_filter_get_out( base->filters[ i ] );
int disable = mlt_properties_get_int( MLT_FILTER_PROPERTIES( base->filters[ i ] ), "disable" );
if ( !disable && ( ( in == 0 && out == 0 ) || ( position >= in && ( position <= out || out == 0 ) ) ) )
{
mlt_properties_set_position( frame_properties, "in", in == 0 ? self_in : in );
mlt_properties_set_position( frame_properties, "out", out == 0 ? self_out : out );
mlt_filter_process( base->filters[ i ], frame );
mlt_service_apply_filters( MLT_FILTER_SERVICE( base->filters[ i ] ), frame, index + 1 );
}
}
}
}
}
mlt_position mlt_filter_get_length( mlt_filter self )
{
mlt_properties properties = MLT_SERVICE_PROPERTIES( &self->parent );
mlt_position in = mlt_properties_get_position( properties, "in" );
mlt_position out = mlt_properties_get_position( properties, "out" );
return ( out > 0 ) ? ( out - in + 1 ) : 0;
}
mlt_position mlt_filter_get_position( mlt_filter self, mlt_frame frame )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( self );
mlt_position in = mlt_properties_get_position( properties, "in" );
const char *unique_id = mlt_properties_get( properties, "_unique_id" );
char name[64];
// Make the properties key from unique id
snprintf( name, sizeof(name), "pos.%s", unique_id );
return mlt_properties_get_position( MLT_FRAME_PROPERTIES( frame ), name ) - in;
}
void mlt_tractor_refresh( mlt_tractor self )
{
mlt_multitrack multitrack = mlt_tractor_multitrack( self );
mlt_properties multitrack_props = MLT_MULTITRACK_PROPERTIES( multitrack );
mlt_properties properties = MLT_TRACTOR_PROPERTIES( self );
mlt_events_block( multitrack_props, properties );
mlt_events_block( properties, properties );
mlt_multitrack_refresh( multitrack );
mlt_properties_set_position( properties, "in", 0 );
mlt_properties_set_position( properties, "out", mlt_properties_get_position( multitrack_props, "out" ) );
mlt_events_unblock( properties, properties );
mlt_events_unblock( multitrack_props, properties );
mlt_properties_set_position( properties, "length", mlt_properties_get_position( multitrack_props, "length" ) );
}
mlt_producer mlt_producer_cut( mlt_producer self, int in, int out )
{
mlt_producer result = mlt_producer_new( mlt_service_profile( MLT_PRODUCER_SERVICE( self ) ) );
mlt_producer parent = mlt_producer_cut_parent( self );
mlt_properties properties = MLT_PRODUCER_PROPERTIES( result );
mlt_properties parent_props = MLT_PRODUCER_PROPERTIES( parent );
mlt_properties_set_lcnumeric( properties,
mlt_properties_get_lcnumeric( MLT_PRODUCER_PROPERTIES( self ) ) );
mlt_events_block( MLT_PRODUCER_PROPERTIES( result ), MLT_PRODUCER_PROPERTIES( result ) );
// Special case - allow for a cut of the entire producer (this will squeeze all other cuts to 0)
if ( in <= 0 )
in = 0;
if ( ( out < 0 || out >= mlt_producer_get_length( parent ) ) && !mlt_producer_is_blank( self ) )
out = mlt_producer_get_length( parent ) - 1;
mlt_properties_inc_ref( parent_props );
mlt_properties_set_int( properties, "_cut", 1 );
mlt_properties_set_data( properties, "_cut_parent", parent, 0, ( mlt_destructor )mlt_producer_close, NULL );
mlt_properties_set_position( properties, "length", mlt_properties_get_position( parent_props, "length" ) );
mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( parent_props, "aspect_ratio" ) );
mlt_producer_set_in_and_out( result, in, out );
return result;
}
mlt_position mlt_filter_get_length2( mlt_filter self, mlt_frame frame )
{
mlt_properties properties = MLT_SERVICE_PROPERTIES( &self->parent );
mlt_position in = mlt_properties_get_position( properties, "in" );
mlt_position out = mlt_properties_get_position( properties, "out" );
if ( out == 0 && frame )
{
// If always active, use the frame's producer
mlt_producer producer = mlt_frame_get_original_producer( frame );
if ( producer )
{
producer = mlt_producer_cut_parent( producer );
in = mlt_producer_get_in( producer );
out = mlt_producer_get_out( producer );
}
}
return ( out > 0 ) ? ( out - in + 1 ) : 0;
}
static int jack_sync( jack_transport_state_t state, jack_position_t *jack_pos, void *arg )
{
mlt_filter filter = (mlt_filter) arg;
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE(filter) );
mlt_position position = mlt_profile_fps( profile ) * jack_pos->frame / jack_pos->frame_rate + 0.5;
int result = 1;
mlt_log_debug( MLT_FILTER_SERVICE(filter), "%s frame %u rate %u pos %d last_pos %d\n",
JACKSTATE(state), jack_pos->frame, jack_pos->frame_rate, position,
mlt_properties_get_position( properties, "_last_pos" ) );
if ( state == JackTransportStopped )
{
mlt_events_fire( properties, "jack-stopped", &position, NULL );
mlt_properties_set_int( properties, "_sync_guard", 0 );
}
else if ( state == JackTransportStarting )
{
result = 0;
if ( !mlt_properties_get_int( properties, "_sync_guard" ) )
{
mlt_properties_set_int( properties, "_sync_guard", 1 );
mlt_events_fire( properties, "jack-started", &position, NULL );
}
else if ( position >= mlt_properties_get_position( properties, "_last_pos" ) - 2 )
{
mlt_properties_set_int( properties, "_sync_guard", 0 );
result = 1;
}
}
else
{
mlt_properties_set_int( properties, "_sync_guard", 0 );
}
return result;
}
static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable ){
if (*format!=mlt_image_yuv422 ){
return -1;
}
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
mlt_transition transition = mlt_frame_pop_service( a_frame );
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
int invert = mlt_properties_get_int( properties, "invert" );
if ( mlt_properties_get( a_props, "rescale.interp" ) == NULL || !strcmp( mlt_properties_get( a_props, "rescale.interp" ), "none" ) )
mlt_properties_set( a_props, "rescale.interp", "nearest" );
// set consumer_aspect_ratio for a and b frame
if ( mlt_properties_get_double( a_props, "aspect_ratio" ) == 0.0 )
mlt_properties_set_double( a_props, "aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
if ( mlt_properties_get_double( b_props, "aspect_ratio" ) == 0.0 )
mlt_properties_set_double( b_props, "aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
mlt_properties_set_double( b_props, "consumer_aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
if ( mlt_properties_get( b_props, "rescale.interp" ) == NULL || !strcmp( mlt_properties_get( b_props, "rescale.interp" ), "none" ) )
mlt_properties_set( b_props, "rescale.interp", "nearest" );
uint8_t *images[]={NULL,NULL,NULL};
mlt_frame_get_image( a_frame, &images[0], format, width, height, 1 );
mlt_frame_get_image( b_frame, &images[1], format, width, height, 1 );
mlt_position in = mlt_transition_get_in( transition );
mlt_position out = mlt_transition_get_out( transition );
// Get the position of the frame
char *name = mlt_properties_get( MLT_TRANSITION_PROPERTIES( transition ), "_unique_id" );
mlt_position position = mlt_properties_get_position( MLT_FRAME_PROPERTIES( a_frame ), name );
float pos=( float )( position - in ) / ( float )( out - in + 1 );
process_frei0r_item( transition_type , pos , properties, !invert ? a_frame : b_frame , images , format, width,height, writable );
*width = mlt_properties_get_int( !invert ? a_props : b_props, "width" );
*height = mlt_properties_get_int( !invert ? a_props : b_props, "height" );
*image = mlt_properties_get_data( !invert ? a_props : b_props , "image", NULL );
return 0;
}
static int producerGetImage(mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int /*writable*/) {
int error = 0;
mlt_properties properties = MLT_FRAME_PROPERTIES(frame);
mlt_producer producer = (mlt_producer)mlt_properties_get_data(properties, kWebVfxProducerPropertyName, NULL);
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES(producer);
int size;
int bpp;
bool hasTransparency = false;
{
MLTWebVfx::ServiceLocker locker(MLT_PRODUCER_SERVICE(producer));
if (!locker.initialize(*width, *height))
return 1;
if (mlt_properties_get_int( producer_props, "transparent") ) {
*format = mlt_image_rgb24a;
hasTransparency = true;
}
else {
*format = mlt_image_rgb24;
}
// Get bpp from image format
mlt_image_format_size(*format, 0, 0, &bpp);
size = *width * *height * bpp;
*buffer = (uint8_t*)mlt_pool_alloc(size);
// When not using transparency, this will make the background black...
memset( *buffer, 255, size );
WebVfx::Image outputImage(*buffer, *width, *height, size, hasTransparency);
locker.getManager()->render(&outputImage,
mlt_properties_get_position(properties, kWebVfxPositionPropertyName),
mlt_producer_get_length(producer), hasTransparency);
}
mlt_frame_set_image(frame, *buffer, size, mlt_pool_release);
if (hasTransparency) {
// Create the alpha channel
int alpha_size = *width * *height;
uint8_t *alpha = (uint8_t *)mlt_pool_alloc( alpha_size );
// Initialise the alpha
memset( alpha, 255, alpha_size );
mlt_frame_set_alpha(frame, alpha, alpha_size, mlt_pool_release);
}
return error;
}
int mlt_producer_seek_time( mlt_producer self, const char* time )
{
mlt_properties_set( MLT_PRODUCER_PROPERTIES(self), "_seek_time", time );
mlt_position position = mlt_properties_get_position( MLT_PRODUCER_PROPERTIES(self), "_seek_time" );
return mlt_producer_seek( self, position );
}
static int transition_get_frame( mlt_service service, mlt_frame_ptr frame, int index )
{
int error = 0;
mlt_transition self = service->child;
mlt_properties properties = MLT_TRANSITION_PROPERTIES( self );
int accepts_blanks = mlt_properties_get_int( properties, "accepts_blanks" );
int a_track = mlt_properties_get_int( properties, "a_track" );
int b_track = mlt_properties_get_int( properties, "b_track" );
mlt_position in = mlt_properties_get_position( properties, "in" );
mlt_position out = mlt_properties_get_position( properties, "out" );
int always_active = mlt_properties_get_int( properties, "always_active" );
int type = mlt_properties_get_int( properties, "_transition_type" );
int reverse_order = 0;
// Ensure that we have the correct order
if ( a_track > b_track )
{
reverse_order = 1;
a_track = b_track;
b_track = mlt_properties_get_int( properties, "a_track" );
}
// Only act on this operation once per multitrack iteration from the tractor
if ( !self->held )
{
int active = 0;
int i = 0;
int a_frame = a_track;
int b_frame = b_track;
mlt_position position;
int ( *invalid )( mlt_frame ) = type == 1 ? mlt_frame_is_test_card : mlt_frame_is_test_audio;
// Initialise temporary store
if ( self->frames == NULL )
self->frames = calloc( b_track + 1, sizeof( mlt_frame ) );
// Get all frames between a and b
for( i = a_track; i <= b_track; i ++ )
mlt_service_get_frame( self->producer, &self->frames[ i ], i );
// We're holding these frames until the last_track frame property is received
self->held = 1;
// When we need to locate the a_frame
switch( type )
{
case 1:
case 2:
// Some transitions (esp. audio) may accept blank frames
active = accepts_blanks;
// If we're not active then...
if ( !active )
{
// Hunt for the a_frame
while( a_frame <= b_frame && invalid( self->frames[ a_frame ] ) )
a_frame ++;
// Determine if we're active now
active = a_frame != b_frame && !invalid( self->frames[ b_frame ] );
}
break;
default:
mlt_log( service, MLT_LOG_ERROR, "invalid transition type\n" );
break;
}
// Now handle the non-always active case
if ( active && !always_active && a_frame <= b_track )
{
// For non-always-active transitions, we need the current position of the a frame
position = mlt_frame_get_position( self->frames[ a_frame ] );
// If a is in range, we're active
active = position >= in && ( out == 0 || position <= out );
}
// Finally, process the a and b frames
if ( active && !mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( self ), "disable" ) )
{
int frame_nb = ( !reverse_order && a_frame <= b_track )? a_frame : b_frame;
mlt_frame a_frame_ptr = self->frames[ frame_nb ];
frame_nb = ( !reverse_order || a_frame > b_track )? b_frame : a_frame;
mlt_frame b_frame_ptr = self->frames[ frame_nb ];
int a_hide = mlt_properties_get_int( MLT_FRAME_PROPERTIES( a_frame_ptr ), "hide" );
int b_hide = mlt_properties_get_int( MLT_FRAME_PROPERTIES( b_frame_ptr ), "hide" );
if ( !( a_hide & type ) && !( b_hide & type ) )
{
// Add hooks for pre-processing frames
mlt_frame_push_service( a_frame_ptr, self );
mlt_frame_push_get_image( a_frame_ptr, get_image_a );
mlt_frame_push_frame( b_frame_ptr, a_frame_ptr );
mlt_frame_push_service( b_frame_ptr, self );
mlt_frame_push_get_image( b_frame_ptr, get_image_b );
// Process the transition
*frame = mlt_transition_process( self, a_frame_ptr, b_frame_ptr );
// We need to ensure that the tractor doesn't consider this frame for output
if ( *frame == a_frame_ptr )
b_hide |= type;
else
a_hide |= type;
mlt_properties_set_int( MLT_FRAME_PROPERTIES( a_frame_ptr ), "hide", a_hide );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( b_frame_ptr ), "hide", b_hide );
}
}
}
// Obtain the frame from the cache or the producer we're attached to
if ( index >= a_track && index <= b_track )
*frame = self->frames[ index ];
else
error = mlt_service_get_frame( self->producer, frame, index );
// Determine if that was the last track
self->held = !mlt_properties_get_int( MLT_FRAME_PROPERTIES( *frame ), "last_track" );
return error;
}
static mlt_frame transition_process( mlt_transition transition, mlt_frame a_frame, mlt_frame b_frame )
{
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// Only if mix is specified, otherwise a producer may set the mix
if ( mlt_properties_get( properties, "start" ) )
{
// Determine the time position of this frame in the transition duration
mlt_properties props = mlt_properties_get_data( MLT_FRAME_PROPERTIES( b_frame ), "_producer", NULL );
mlt_position in = mlt_properties_get_int( props, "in" );
mlt_position out = mlt_properties_get_int( props, "out" );
int length = mlt_properties_get_int( properties, "length" );
mlt_position time = mlt_properties_get_int( props, "_frame" );
double mix = mlt_transition_get_progress( transition, b_frame );
if ( mlt_properties_get_int( properties, "always_active" ) )
mix = ( double ) ( time - in ) / ( double ) ( out - in + 1 );
// TODO: Check the logic here - shouldn't we be computing current and next mixing levels in all cases?
if ( length == 0 )
{
// If there is an end mix level adjust mix to the range
if ( mlt_properties_get( properties, "end" ) )
{
double start = mlt_properties_get_double( properties, "start" );
double end = mlt_properties_get_double( properties, "end" );
mix = start + ( end - start ) * mix;
}
// A negative means total crossfade (uses position)
else if ( mlt_properties_get_double( properties, "start" ) >= 0 )
{
// Otherwise, start/constructor is a constant mix level
mix = mlt_properties_get_double( properties, "start" );
}
// Finally, set the mix property on the frame
mlt_properties_set_double( b_props, "audio.mix", mix );
// Initialise transition previous mix value to prevent an inadvertant jump from 0
mlt_position last_position = mlt_properties_get_position( properties, "_last_position" );
mlt_position current_position = mlt_frame_get_position( b_frame );
mlt_properties_set_position( properties, "_last_position", current_position );
if ( !mlt_properties_get( properties, "_previous_mix" )
|| current_position != last_position + 1 )
mlt_properties_set_double( properties, "_previous_mix", mix );
// Tell b frame what the previous mix level was
mlt_properties_set_double( b_props, "audio.previous_mix", mlt_properties_get_double( properties, "_previous_mix" ) );
// Save the current mix level for the next iteration
mlt_properties_set_double( properties, "_previous_mix", mlt_properties_get_double( b_props, "audio.mix" ) );
mlt_properties_set_double( b_props, "audio.reverse", mlt_properties_get_double( properties, "reverse" ) );
}
else
{
double level = mlt_properties_get_double( properties, "start" );
double mix_start = level;
double mix_end = mix_start;
double mix_increment = 1.0 / length;
if ( time - in < length )
{
mix_start = mix_start * ( ( double )( time - in ) / length );
mix_end = mix_start + mix_increment;
}
else if ( time > out - length )
{
mix_end = mix_start * ( ( double )( out - time - in ) / length );
mix_start = mix_end - mix_increment;
}
mix_start = mix_start < 0 ? 0 : mix_start > level ? level : mix_start;
mix_end = mix_end < 0 ? 0 : mix_end > level ? level : mix_end;
mlt_properties_set_double( b_props, "audio.previous_mix", mix_start );
mlt_properties_set_double( b_props, "audio.mix", mix_end );
}
}
// Override the get_audio method
mlt_frame_push_audio( a_frame, transition );
mlt_frame_push_audio( a_frame, b_frame );
mlt_frame_push_audio( a_frame, transition_get_audio );
return a_frame;
}
static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the b frame from the stack
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
// Get the transition object
mlt_transition transition = mlt_frame_pop_service( a_frame );
// Get the properties of the transition
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
// Get the properties of the b frame
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// Image, format, width, height and image for the b frame
uint8_t *b_image = NULL;
mlt_image_format b_format = mlt_image_rgb24a;
int b_width;
int b_height;
// Assign the current position
mlt_position position = mlt_transition_get_position( transition, a_frame );
int mirror = mlt_properties_get_position( properties, "mirror" );
int length = mlt_transition_get_length( transition );
if ( mlt_properties_get_int( properties, "always_active" ) )
{
mlt_properties props = mlt_properties_get_data( b_props, "_producer", NULL );
mlt_position in = mlt_properties_get_int( props, "in" );
mlt_position out = mlt_properties_get_int( props, "out" );
length = out - in + 1;
}
// Obtain the normalised width and height from the a_frame
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
int normalised_width = profile->width;
int normalised_height = profile->height;
double consumer_ar = mlt_profile_sar( mlt_service_profile( MLT_TRANSITION_SERVICE(transition) ) );
// Structures for geometry
struct mlt_geometry_item_s result;
if ( mirror && position > length / 2 )
position = abs( position - length );
// Fetch the a frame image
*format = mlt_image_rgb24a;
mlt_frame_get_image( a_frame, image, format, width, height, 1 );
// Calculate the region now
mlt_service_lock( MLT_TRANSITION_SERVICE( transition ) );
composite_calculate( transition, &result, normalised_width, normalised_height, ( float )position );
mlt_service_unlock( MLT_TRANSITION_SERVICE( transition ) );
// Fetch the b frame image
result.w = ( result.w * *width / normalised_width );
result.h = ( result.h * *height / normalised_height );
result.x = ( result.x * *width / normalised_width );
result.y = ( result.y * *height / normalised_height );
// Request full resolution of b frame image.
b_width = mlt_properties_get_int( b_props, "meta.media.width" );
b_height = mlt_properties_get_int( b_props, "meta.media.height" );
mlt_properties_set_int( b_props, "rescale_width", b_width );
mlt_properties_set_int( b_props, "rescale_height", b_height );
// Suppress padding and aspect normalization.
char *interps = mlt_properties_get( a_props, "rescale.interp" );
if ( interps )
interps = strdup( interps );
mlt_properties_set( b_props, "rescale.interp", "none" );
// This is not a field-aware transform.
mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
mlt_frame_get_image( b_frame, &b_image, &b_format, &b_width, &b_height, 0 );
// Check that both images are of the correct format and process
if ( *format == mlt_image_rgb24a && b_format == mlt_image_rgb24a )
{
float x, y;
float dx, dy;
float dz;
float sw, sh;
uint8_t *p = *image;
// Get values from the transition
float scale_x = mlt_properties_get_double( properties, "scale_x" );
float scale_y = mlt_properties_get_double( properties, "scale_y" );
int scale = mlt_properties_get_int( properties, "scale" );
int b_alpha = mlt_properties_get_int( properties, "b_alpha" );
float geom_scale_x = (float) b_width / result.w;
float geom_scale_y = (float) b_height / result.h;
float cx = result.x + result.w / 2.0;
float cy = result.y + result.h / 2.0;
float lower_x = - cx;
float lower_y = - cy;
float x_offset = (float) b_width / 2.0;
float y_offset = (float) b_height / 2.0;
affine_t affine;
interpp interp = interpBL_b32;
int i, j; // loop counters
affine_init( affine.matrix );
// Compute the affine transform
get_affine( &affine, transition, ( float )position );
dz = MapZ( affine.matrix, 0, 0 );
if ( ( int )abs( dz * 1000 ) < 25 )
{
if ( interps )
free( interps );
return 0;
}
// Factor scaling into the transformation based on output resolution.
if ( mlt_properties_get_int( properties, "distort" ) )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
}
else
{
// Determine scale with respect to aspect ratio.
double consumer_dar = consumer_ar * normalised_width / normalised_height;
double b_ar = mlt_properties_get_double( b_props, "aspect_ratio" );
double b_dar = b_ar * b_width / b_height;
if ( b_dar > consumer_dar )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_x * ( scale_y == 0 ? 1 : scale_y );
}
else
{
scale_x = geom_scale_y * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
}
scale_x *= consumer_ar / b_ar;
}
if ( scale )
{
affine_max_output( affine.matrix, &sw, &sh, dz, *width, *height );
affine_scale( affine.matrix, sw * MIN( geom_scale_x, geom_scale_y ), sh * MIN( geom_scale_x, geom_scale_y ) );
}
else if ( scale_x != 0 && scale_y != 0 )
{
affine_scale( affine.matrix, scale_x, scale_y );
}
// Set the interpolation function
if ( interps == NULL || strcmp( interps, "nearest" ) == 0 || strcmp( interps, "neighbor" ) == 0 )
interp = interpNN_b32;
else if ( strcmp( interps, "tiles" ) == 0 || strcmp( interps, "fast_bilinear" ) == 0 )
interp = interpNN_b32;
else if ( strcmp( interps, "bilinear" ) == 0 )
interp = interpBL_b32;
else if ( strcmp( interps, "bicubic" ) == 0 )
interp = interpBC_b32;
// TODO: lanczos 8x8
else if ( strcmp( interps, "hyper" ) == 0 || strcmp( interps, "sinc" ) == 0 || strcmp( interps, "lanczos" ) == 0 )
interp = interpBC_b32;
else if ( strcmp( interps, "spline" ) == 0 ) // TODO: spline 4x4 or 6x6
interp = interpBC_b32;
// Do the transform with interpolation
for ( i = 0, y = lower_y; i < *height; i++, y++ )
{
for ( j = 0, x = lower_x; j < *width; j++, x++ )
{
dx = MapX( affine.matrix, x, y ) / dz + x_offset;
dy = MapY( affine.matrix, x, y ) / dz + y_offset;
if ( dx >= 0 && dx < (b_width - 1) && dy >=0 && dy < (b_height - 1) )
interp( b_image, b_width, b_height, dx, dy, result.mix/100.0, p, b_alpha );
p += 4;
}
}
}
if ( interps )
free( interps );
return 0;
}
mlt_position mlt_producer_get_length( mlt_producer self )
{
return mlt_properties_get_position( MLT_PRODUCER_PROPERTIES( self ), "length" );
}
static void analyze_audio( mlt_filter filter, void* buffer, int samples )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
private_data* pdata = (private_data*)filter->child;
int result = -1;
double loudness = 0.0;
ebur128_add_frames_float( pdata->r128, buffer, samples );
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_program" ) )
{
result = ebur128_loudness_global( pdata->r128, &loudness );
if( result == EBUR128_SUCCESS && loudness != HUGE_VAL && loudness != -HUGE_VAL )
{
mlt_properties_set_double( properties, "program", loudness );
}
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_shortterm" ) )
{
result = ebur128_loudness_shortterm( pdata->r128, &loudness );
if( result == EBUR128_SUCCESS && loudness != HUGE_VAL && loudness != -HUGE_VAL )
{
mlt_properties_set_double( properties, "shortterm", loudness );
}
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_momentary" ) )
{
result = ebur128_loudness_momentary( pdata->r128, &loudness );
if( result == EBUR128_SUCCESS && loudness != HUGE_VAL && loudness != -HUGE_VAL )
{
mlt_properties_set_double( properties, "momentary", loudness );
}
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_range" ) )
{
double range = 0;
result = ebur128_loudness_range( pdata->r128, &range );
if( result == EBUR128_SUCCESS && range != HUGE_VAL && range != -HUGE_VAL )
{
mlt_properties_set_double( properties, "range", range );
}
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_peak" ) )
{
double prev_peak = 0.0;
double max_peak = 0.0;
int c = 0;
for( c = 0; c < pdata->r128->channels; c++ )
{
double peak;
result = ebur128_sample_peak( pdata->r128, c, &peak );
if( result == EBUR128_SUCCESS && peak != HUGE_VAL && peak > max_peak )
{
max_peak = peak;
}
result = ebur128_prev_sample_peak( pdata->r128, c, &peak );
if( result == EBUR128_SUCCESS && peak != HUGE_VAL && peak > prev_peak )
{
prev_peak = peak;
}
}
mlt_properties_set_double( properties, "max_peak", 20 * log10(max_peak) );
mlt_properties_set_double( properties, "peak", 20 * log10(prev_peak) );
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_true_peak" ) )
{
double prev_peak = 0.0;
double max_peak = 0.0;
int c = 0;
for( c = 0; c < pdata->r128->channels; c++ )
{
double peak;
result = ebur128_true_peak( pdata->r128, c, &peak );
if( result == EBUR128_SUCCESS && peak != HUGE_VAL && peak > max_peak )
{
max_peak = peak;
}
result = ebur128_prev_true_peak( pdata->r128, c, &peak );
if( result == EBUR128_SUCCESS && peak != HUGE_VAL && peak > prev_peak )
{
prev_peak = peak;
}
}
mlt_properties_set_double( properties, "max_true_peak", 20 * log10(max_peak) );
mlt_properties_set_double( properties, "true_peak", 20 * log10(prev_peak) );
}
mlt_properties_set_position( properties, "frames_processed", mlt_properties_get_position( properties, "frames_processed" ) + 1 );
}
mlt_position mlt_transition_get_out( mlt_transition self )
{
return mlt_properties_get_position( MLT_TRANSITION_PROPERTIES( self ), "out" );
}
static int process_feed( mlt_properties feed, mlt_filter filter, mlt_frame frame )
{
// Error return
int error = 1;
// Get the properties of the data show filter
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Get the type requested by the feeding filter
char *type = mlt_properties_get( feed, "type" );
// Fetch the filter associated to this type
mlt_filter requested = mlt_properties_get_data( filter_properties, type, NULL );
// If it doesn't exist, then create it now
if ( requested == NULL )
{
// Source filter from profile
requested = obtain_filter( filter, type );
// Store it on the properties for subsequent retrieval/destruction
mlt_properties_set_data( filter_properties, type, requested, 0, ( mlt_destructor )mlt_filter_close, NULL );
}
// If we have one, then process it now...
if ( requested != NULL )
{
int i = 0;
mlt_properties properties = MLT_FILTER_PROPERTIES( requested );
static const char *prefix = "properties.";
int len = strlen( prefix );
// Determine if this is an absolute or relative feed
int absolute = mlt_properties_get_int( feed, "absolute" );
// Make do with what we have
int length = !absolute ?
mlt_properties_get_int( feed, "out" ) - mlt_properties_get_int( feed, "in" ) + 1 :
mlt_properties_get_int( feed, "out" ) + 1;
// Repeat period
int period = mlt_properties_get_int( properties, "period" );
period = period == 0 ? 1 : period;
// Pass properties from feed into requested
for ( i = 0; i < mlt_properties_count( properties ); i ++ )
{
char *name = mlt_properties_get_name( properties, i );
char *key = mlt_properties_get_value( properties, i );
if ( !strncmp( name, prefix, len ) )
{
if ( !strncmp( name + len, "length[", 7 ) )
{
mlt_properties_set_position( properties, key, ( length - period ) / period );
}
else
{
char *value = mlt_properties_get( feed, name + len );
if ( value != NULL )
{
// check for metadata keywords in metadata markup if user requested so
if ( mlt_properties_get_int( filter_properties, "dynamic" ) == 1 && !strcmp( name + strlen( name ) - 6, "markup") )
{
// Find keywords which should be surrounded by '#', like: #title#
char* keywords = strtok( value, "#" );
char result[512] = ""; // XXX: how much is enough?
int ct = 0;
int fromStart = ( value[0] == '#' ) ? 1 : 0;
while ( keywords != NULL )
{
if ( ct % 2 == fromStart )
{
// backslash in front of # suppresses substitution
if ( keywords[ strlen( keywords ) -1 ] == '\\' )
{
// keep characters except backslash
strncat( result, keywords, sizeof( result ) - strlen( result ) - 2 );
strcat( result, "#" );
ct++;
}
else
{
strncat( result, keywords, sizeof( result ) - strlen( result ) - 1 );
}
}
else if ( !strcmp( keywords, "timecode" ) )
{
// special case: replace #timecode# with current frame timecode
mlt_position frames = mlt_properties_get_position( feed, "position" );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
char *s = mlt_properties_frames_to_time( properties, frames, mlt_time_smpte_df );
if ( s )
strncat( result, s, sizeof( result ) - strlen( result ) - 1 );
}
else if ( !strcmp( keywords, "frame" ) )
{
// special case: replace #frame# with current frame number
int pos = mlt_properties_get_int( feed, "position" );
char s[12];
snprintf( s, sizeof(s) - 1, "%d", pos );
s[sizeof( s ) - 1] = '\0';
strncat( result, s, sizeof( result ) - strlen( result ) - 1 );
}
else
{
// replace keyword with metadata value
char *metavalue = metadata_value( MLT_FRAME_PROPERTIES( frame ), keywords );
strncat( result, metavalue ? metavalue : "-", sizeof( result ) - strlen( result ) -1 );
}
keywords = strtok( NULL, "#" );
ct++;
}
mlt_properties_set( properties, key, (char*) result );
}
else mlt_properties_set( properties, key, value );
}
}
}
}
// Set the original position on the frame
if ( absolute == 0 )
mlt_frame_set_position( frame, mlt_properties_get_int( feed, "position" ) - mlt_properties_get_int( feed, "in" ) );
else
mlt_frame_set_position( frame, mlt_properties_get_int( feed, "position" ) );
// Process the filter
mlt_filter_process( requested, frame );
// Should be ok...
error = 0;
}
return error;
}
mlt_position mlt_frame_original_position( mlt_frame self )
{
int pos = mlt_properties_get_position( MLT_FRAME_PROPERTIES( self ), "original_position" );
return pos < 0 ? 0 : pos;
}
void drawKdenliveTitle( producer_ktitle self, mlt_frame frame, int width, int height, double position, int force_refresh )
{
// Obtain the producer
mlt_producer producer = &self->parent;
mlt_profile profile = mlt_service_profile ( MLT_PRODUCER_SERVICE( producer ) ) ;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Obtain properties of frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
pthread_mutex_lock( &self->mutex );
// Check if user wants us to reload the image
if ( mlt_properties_get( producer_props, "_animated" ) != NULL || force_refresh == 1 || width != self->current_width || height != self->current_height || mlt_properties_get( producer_props, "_endrect" ) != NULL )
{
//mlt_cache_item_close( self->image_cache );
self->current_image = NULL;
mlt_properties_set_data( producer_props, "cached_image", NULL, 0, NULL, NULL );
mlt_properties_set_int( producer_props, "force_reload", 0 );
}
if (self->current_image == NULL) {
// restore QGraphicsScene
QGraphicsScene *scene = static_cast<QGraphicsScene *> (mlt_properties_get_data( producer_props, "qscene", NULL ));
if ( force_refresh == 1 && scene )
{
scene = NULL;
mlt_properties_set_data( producer_props, "qscene", NULL, 0, NULL, NULL );
}
if ( scene == NULL )
{
int argc = 1;
char* argv[1];
argv[0] = (char*) "xxx";
// Warning: all Qt graphic objects (QRect, ...) must be initialized AFTER
// the QApplication is created, otherwise their will be NULL
if ( app == NULL ) {
if ( qApp ) {
app = qApp;
}
else {
#ifdef linux
if ( getenv("DISPLAY") == 0 )
{
mlt_log_panic( MLT_PRODUCER_SERVICE( producer ), "Error, cannot render titles without an X11 environment.\nPlease either run melt from an X session or use a fake X server like xvfb:\nxvfb-run -a melt (...)\n" );
pthread_mutex_unlock( &self->mutex );
return;
}
#endif
app = new QApplication( argc, argv );
const char *localename = mlt_properties_get_lcnumeric( MLT_SERVICE_PROPERTIES( MLT_PRODUCER_SERVICE( producer ) ) );
QLocale::setDefault( QLocale( localename ) );
}
qRegisterMetaType<QTextCursor>( "QTextCursor" );
}
scene = new QGraphicsScene();
scene->setItemIndexMethod( QGraphicsScene::NoIndex );
scene->setSceneRect(0, 0, mlt_properties_get_int( properties, "width" ), mlt_properties_get_int( properties, "height" ));
if ( mlt_properties_get( producer_props, "resource" ) && mlt_properties_get( producer_props, "resource" )[0] != '\0' )
{
// The title has a resource property, so we read all properties from the resource.
// Do not serialize the xmldata
loadFromXml( producer, scene, mlt_properties_get( producer_props, "_xmldata" ), mlt_properties_get( producer_props, "templatetext" ) );
}
else
{
// The title has no resource, all data should be serialized
loadFromXml( producer, scene, mlt_properties_get( producer_props, "xmldata" ), mlt_properties_get( producer_props, "templatetext" ) );
}
mlt_properties_set_data( producer_props, "qscene", scene, 0, ( mlt_destructor )qscene_delete, NULL );
}
QRectF start = stringToRect( QString( mlt_properties_get( producer_props, "_startrect" ) ) );
QRectF end = stringToRect( QString( mlt_properties_get( producer_props, "_endrect" ) ) );
int originalWidth = mlt_properties_get_int( producer_props, "_original_width" );
int originalHeight= mlt_properties_get_int( producer_props, "_original_height" );
const QRectF source( 0, 0, width, height );
if (start.isNull()) {
start = QRectF( 0, 0, originalWidth, originalHeight );
}
// Effects
QList <QGraphicsItem *> items = scene->items();
QGraphicsTextItem *titem = NULL;
for (int i = 0; i < items.count(); i++) {
titem = static_cast <QGraphicsTextItem*> ( items.at( i ) );
if (titem && !titem->data( 0 ).isNull()) {
QStringList params = titem->data( 0 ).toStringList();
if (params.at( 0 ) == "typewriter" ) {
// typewriter effect has 2 param values:
// the keystroke delay and a start offset, both in frames
QStringList values = params.at( 2 ).split( ";" );
int interval = qMax( 0, ( ( int ) position - values.at( 1 ).toInt()) / values.at( 0 ).toInt() );
QTextCursor cursor = titem->textCursor();
cursor.movePosition(QTextCursor::EndOfBlock);
// get the font format
QTextCharFormat format = cursor.charFormat();
cursor.select(QTextCursor::Document);
QString txt = params.at( 1 ).left( interval );
// If the string to insert is empty, insert a space / linebreak so that we don't loose
// formatting infos for the next iterations
int lines = params.at( 1 ).count( '\n' );
QString empty = " ";
for (int i = 0; i < lines; i++)
empty.append( "\n " );
cursor.insertText( txt.isEmpty() ? empty : txt, format );
if ( !titem->data( 1 ).isNull() )
titem->setTextWidth( titem->data( 1 ).toDouble() );
}
}
}
//must be extracted from kdenlive title
QImage img( width, height, QImage::Format_ARGB32 );
img.fill( 0 );
QPainter p1;
p1.begin( &img );
p1.setRenderHints( QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing );
//| QPainter::SmoothPixmapTransform );
mlt_position anim_out = mlt_properties_get_position( producer_props, "_animation_out" );
if (end.isNull())
{
scene->render( &p1, source, start, Qt::IgnoreAspectRatio );
}
else if ( position > anim_out ) {
scene->render( &p1, source, end, Qt::IgnoreAspectRatio );
}
else {
double percentage = 0;
if ( position && anim_out )
percentage = position / anim_out;
QPointF topleft = start.topLeft() + ( end.topLeft() - start.topLeft() ) * percentage;
QPointF bottomRight = start.bottomRight() + ( end.bottomRight() - start.bottomRight() ) * percentage;
const QRectF r1( topleft, bottomRight );
scene->render( &p1, source, r1, Qt::IgnoreAspectRatio );
if ( profile && !profile->progressive ){
int line=0;
double percentage_next_filed = ( position + 0.5 ) / anim_out;
QPointF topleft_next_field = start.topLeft() + ( end.topLeft() - start.topLeft() ) * percentage_next_filed;
QPointF bottomRight_next_field = start.bottomRight() + ( end.bottomRight() - start.bottomRight() ) * percentage_next_filed;
const QRectF r2( topleft_next_field, bottomRight_next_field );
QImage img1( width, height, QImage::Format_ARGB32 );
img1.fill( 0 );
QPainter p2;
p2.begin(&img1);
p2.setRenderHints( QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing );
scene->render(&p2,source,r2, Qt::IgnoreAspectRatio );
p2.end();
int next_field_line = ( mlt_properties_get_int( producer_props, "top_field_first" ) ? 1 : 0 );
for (line = next_field_line ;line<height;line+=2){
memcpy(img.scanLine(line),img1.scanLine(line),img.bytesPerLine());
}
}
}
p1.end();
int size = width * height * 4;
uint8_t *pointer=img.bits();
QRgb* src = ( QRgb* ) pointer;
self->current_image = ( uint8_t * )mlt_pool_alloc( size );
uint8_t *dst = self->current_image;
for ( int i = 0; i < width * height * 4; i += 4 )
{
*dst++=qRed( *src );
*dst++=qGreen( *src );
*dst++=qBlue( *src );
*dst++=qAlpha( *src );
src++;
}
mlt_properties_set_data( producer_props, "cached_image", self->current_image, size, mlt_pool_release, NULL );
self->current_width = width;
self->current_height = height;
}
pthread_mutex_unlock( &self->mutex );
mlt_properties_set_int( properties, "width", self->current_width );
mlt_properties_set_int( properties, "height", self->current_height );
}
int mlt_service_get_frame( mlt_service self, mlt_frame_ptr frame, int index )
{
int result = 0;
// Lock the service
mlt_service_lock( self );
// Ensure that the frame is NULL
*frame = NULL;
// Only process if we have a valid service
if ( self != NULL && self->get_frame != NULL )
{
mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
mlt_position in = mlt_properties_get_position( properties, "in" );
mlt_position out = mlt_properties_get_position( properties, "out" );
mlt_position position = mlt_service_identify( self ) == producer_type ? mlt_producer_position( MLT_PRODUCER( self ) ) : -1;
result = self->get_frame( self, frame, index );
if ( result == 0 )
{
mlt_properties_inc_ref( properties );
properties = MLT_FRAME_PROPERTIES( *frame );
if ( in >=0 && out > 0 )
{
mlt_properties_set_position( properties, "in", in );
mlt_properties_set_position( properties, "out", out );
}
mlt_service_apply_filters( self, *frame, 1 );
mlt_deque_push_back( MLT_FRAME_SERVICE_STACK( *frame ), self );
if ( mlt_service_identify( self ) == producer_type &&
mlt_properties_get_int( MLT_SERVICE_PROPERTIES( self ), "_need_previous_next" ) )
{
// Save the new position from self->get_frame
mlt_position new_position = mlt_producer_position( MLT_PRODUCER( self ) );
// Get the preceding frame, unfiltered
mlt_frame previous_frame;
mlt_producer_seek( MLT_PRODUCER(self), position - 1 );
result = self->get_frame( self, &previous_frame, index );
if ( !result )
mlt_properties_set_data( properties, "previous frame",
previous_frame, 0, ( mlt_destructor ) mlt_frame_close, NULL );
// Get the following frame, unfiltered
mlt_frame next_frame;
mlt_producer_seek( MLT_PRODUCER(self), position + 1 );
result = self->get_frame( self, &next_frame, index );
if ( !result )
{
mlt_properties_set_data( properties, "next frame",
next_frame, 0, ( mlt_destructor ) mlt_frame_close, NULL );
}
// Restore the new position
mlt_producer_seek( MLT_PRODUCER(self), new_position );
}
}
}
// Make sure we return a frame
if ( *frame == NULL )
*frame = mlt_frame_init( self );
// Unlock the service
mlt_service_unlock( self );
return result;
}
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 transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the b frame from the stack
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
// Get the transition object
mlt_transition transition = mlt_frame_pop_service( a_frame );
// Get the properties of the transition
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
// Get the properties of the b frame
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// Image, format, width, height and image for the b frame
uint8_t *b_image = NULL;
mlt_image_format b_format = mlt_image_rgb24a;
int b_width = mlt_properties_get_int( b_props, "meta.media.width" );
int b_height = mlt_properties_get_int( b_props, "meta.media.height" );
double b_ar = mlt_frame_get_aspect_ratio( b_frame );
double b_dar = b_ar * b_width / b_height;
// Assign the current position
mlt_position position = mlt_transition_get_position( transition, a_frame );
int mirror = mlt_properties_get_position( properties, "mirror" );
int length = mlt_transition_get_length( transition );
if ( mlt_properties_get_int( properties, "always_active" ) )
{
mlt_properties props = mlt_properties_get_data( b_props, "_producer", NULL );
mlt_position in = mlt_properties_get_int( props, "in" );
mlt_position out = mlt_properties_get_int( props, "out" );
length = out - in + 1;
}
// Obtain the normalised width and height from the a_frame
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
int normalised_width = profile->width;
int normalised_height = profile->height;
double consumer_ar = mlt_profile_sar( profile );
if ( mirror && position > length / 2 )
position = abs( position - length );
// Fetch the a frame image
*format = mlt_image_rgb24a;
int error = mlt_frame_get_image( a_frame, image, format, width, height, 1 );
if (error || !image)
return error;
// Calculate the region now
mlt_rect result = {0, 0, normalised_width, normalised_height, 1.0};
mlt_service_lock( MLT_TRANSITION_SERVICE( transition ) );
if (mlt_properties_get(properties, "geometry"))
{
// Structures for geometry
struct mlt_geometry_item_s geometry;
composite_calculate( transition, &geometry, normalised_width, normalised_height, ( double )position );
result.x = geometry.x;
result.y = geometry.y;
result.w = geometry.w;
result.h = geometry.h;
result.o = geometry.mix / 100.0f;
}
else if (mlt_properties_get(properties, "rect"))
{
// Determine length and obtain cycle
double cycle = mlt_properties_get_double( properties, "cycle" );
// Allow a repeat cycle
if ( cycle >= 1 )
length = cycle;
else if ( cycle > 0 )
length *= cycle;
mlt_position anim_pos = repeat_position(properties, "rect", position, length);
result = mlt_properties_anim_get_rect(properties, "rect", anim_pos, length);
if (mlt_properties_get(properties, "rect") && strchr(mlt_properties_get(properties, "rect"), '%')) {
result.x *= normalised_width;
result.y *= normalised_height;
result.w *= normalised_width;
result.h *= normalised_height;
}
result.o = (result.o == DBL_MIN)? 1.0 : MIN(result.o, 1.0);
}
mlt_service_unlock( MLT_TRANSITION_SERVICE( transition ) );
double geometry_w = result.w;
double geometry_h = result.h;
if ( !mlt_properties_get_int( properties, "fill" ) )
{
double geometry_dar = result.w * consumer_ar / result.h;
if ( b_dar > geometry_dar )
{
result.w = MIN( result.w, b_width * b_ar / consumer_ar );
result.h = result.w * consumer_ar / b_dar;
}
else
{
result.h = MIN( result.h, b_height );
result.w = result.h * b_dar / consumer_ar;
}
}
// Fetch the b frame image
result.w = ( result.w * *width / normalised_width );
result.h = ( result.h * *height / normalised_height );
result.x = ( result.x * *width / normalised_width );
result.y = ( result.y * *height / normalised_height );
if (mlt_properties_get_int(properties, "b_scaled")) {
// Request b frame image size just what is needed.
b_width = result.w;
b_height = result.h;
// Set the rescale interpolation to match the frame
mlt_properties_set( b_props, "rescale.interp", mlt_properties_get( a_props, "rescale.interp" ) );
} else {
// Request full resolution of b frame image.
mlt_properties_set_int( b_props, "rescale_width", b_width );
mlt_properties_set_int( b_props, "rescale_height", b_height );
// Suppress padding and aspect normalization.
mlt_properties_set( b_props, "rescale.interp", "none" );
}
// This is not a field-aware transform.
mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
error = mlt_frame_get_image( b_frame, &b_image, &b_format, &b_width, &b_height, 0 );
if (error || !b_image) {
// Remove potentially large image on the B frame.
mlt_frame_set_image( b_frame, NULL, 0, NULL );
return error;
}
// Check that both images are of the correct format and process
if ( *format == mlt_image_rgb24a && b_format == mlt_image_rgb24a )
{
double sw, sh;
// Get values from the transition
double scale_x = mlt_properties_anim_get_double( properties, "scale_x", position, length );
double scale_y = mlt_properties_anim_get_double( properties, "scale_y", position, length );
int scale = mlt_properties_get_int( properties, "scale" );
double geom_scale_x = (double) b_width / result.w;
double geom_scale_y = (double) b_height / result.h;
struct sliced_desc desc = {
.a_image = *image,
.b_image = b_image,
.interp = interpBL_b32,
.a_width = *width,
.a_height = *height,
.b_width = b_width,
.b_height = b_height,
.lower_x = -(result.x + result.w / 2.0), // center
.lower_y = -(result.y + result.h / 2.0), // middle
.mix = result.o,
.x_offset = (double) b_width / 2.0,
.y_offset = (double) b_height / 2.0,
.b_alpha = mlt_properties_get_int( properties, "b_alpha" ),
// Affine boundaries
.minima = 0,
.xmax = b_width - 1,
.ymax = b_height - 1
};
// Recalculate vars if alignment supplied.
if ( mlt_properties_get( properties, "halign" ) || mlt_properties_get( properties, "valign" ) )
{
double halign = alignment_parse( mlt_properties_get( properties, "halign" ) );
double valign = alignment_parse( mlt_properties_get( properties, "valign" ) );
desc.x_offset = halign * b_width / 2.0;
desc.y_offset = valign * b_height / 2.0;
desc.lower_x = -(result.x + geometry_w * halign / 2.0f);
desc.lower_y = -(result.y + geometry_h * valign / 2.0f);
}
affine_init( desc.affine.matrix );
// Compute the affine transform
get_affine( &desc.affine, transition, ( double )position, length );
desc.dz = MapZ( desc.affine.matrix, 0, 0 );
if ( (int) fabs( desc.dz * 1000 ) < 25 )
return 0;
// Factor scaling into the transformation based on output resolution.
if ( mlt_properties_get_int( properties, "distort" ) )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
}
else
{
// Determine scale with respect to aspect ratio.
double consumer_dar = consumer_ar * normalised_width / normalised_height;
if ( b_dar > consumer_dar )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_x * ( scale_y == 0 ? 1 : scale_y );
scale_y *= b_ar / consumer_ar;
}
else
{
scale_x = geom_scale_y * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
scale_x *= consumer_ar / b_ar;
}
}
if ( scale )
{
affine_max_output( desc.affine.matrix, &sw, &sh, desc.dz, *width, *height );
affine_scale( desc.affine.matrix, sw * MIN( geom_scale_x, geom_scale_y ), sh * MIN( geom_scale_x, geom_scale_y ) );
}
else if ( scale_x != 0 && scale_y != 0 )
{
affine_scale( desc.affine.matrix, scale_x, scale_y );
}
char *interps = mlt_properties_get( a_props, "rescale.interp" );
// Copy in case string is changed.
if ( interps )
interps = strdup( interps );
// Set the interpolation function
if ( interps == NULL || strcmp( interps, "nearest" ) == 0 || strcmp( interps, "neighbor" ) == 0 || strcmp( interps, "tiles" ) == 0 || strcmp( interps, "fast_bilinear" ) == 0 )
{
desc.interp = interpNN_b32;
// uses lrintf. Values should be >= -0.5 and < max + 0.5
desc.minima -= 0.5;
desc.xmax += 0.49;
desc.ymax += 0.49;
}
else if ( strcmp( interps, "bilinear" ) == 0 )
{
desc.interp = interpBL_b32;
// uses floorf.
}
else if ( strcmp( interps, "bicubic" ) == 0 || strcmp( interps, "hyper" ) == 0 || strcmp( interps, "sinc" ) == 0 || strcmp( interps, "lanczos" ) == 0 || strcmp( interps, "spline" ) == 0 )
{
// TODO: lanczos 8x8
// TODO: spline 4x4 or 6x6
desc.interp = interpBC_b32;
// uses ceilf. Values should be > -1 and <= max.
desc.minima -= 1;
}
free( interps );
// Do the transform with interpolation
int threads = mlt_properties_get_int(properties, "threads");
threads = CLAMP(threads, 0, mlt_slices_count_normal());
if (threads == 1)
sliced_proc(0, 0, 1, &desc);
else
mlt_slices_run_normal(threads, sliced_proc, &desc);
// Remove potentially large image on the B frame.
mlt_frame_set_image( b_frame, NULL, 0, NULL );
}
return 0;
}
mlt_position mlt_producer_frame( mlt_producer self )
{
return mlt_properties_get_position( MLT_PRODUCER_PROPERTIES( self ), "_frame" );
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Error we will return
int error = 0;
// Get the watermark filter object
mlt_filter this = mlt_frame_pop_service( frame );
// Get the properties of the filter
mlt_properties properties = MLT_FILTER_PROPERTIES( this );
// Get the producer from the filter
mlt_producer producer = mlt_properties_get_data( properties, "producer", NULL );
// Get the composite from the filter
mlt_transition composite = mlt_properties_get_data( properties, "composite", NULL );
// Get the resource to use
char *resource = mlt_properties_get( properties, "resource" );
// Get the old resource
char *old_resource = mlt_properties_get( properties, "_old_resource" );
// Create a composite if we don't have one
if ( composite == NULL )
{
// Create composite via the factory
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( this ) );
composite = mlt_factory_transition( profile, "composite", NULL );
// Register the composite for reuse/destruction
if ( composite != NULL )
mlt_properties_set_data( properties, "composite", composite, 0, ( mlt_destructor )mlt_transition_close, NULL );
}
// If we have one
if ( composite != NULL )
{
// Get the properties
mlt_properties composite_properties = MLT_TRANSITION_PROPERTIES( composite );
// Pass all the composite. properties on the filter down
mlt_properties_pass( composite_properties, properties, "composite." );
if ( mlt_properties_get( properties, "composite.out" ) == NULL )
mlt_properties_set_int( composite_properties, "out", mlt_properties_get_int( properties, "_out" ) );
// Force a refresh
mlt_properties_set_int( composite_properties, "refresh", 1 );
}
// Create a producer if don't have one
if ( producer == NULL || ( old_resource != NULL && strcmp( resource, old_resource ) ) )
{
// Get the factory producer service
char *factory = mlt_properties_get( properties, "factory" );
// Create the producer
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( this ) );
producer = mlt_factory_producer( profile, factory, resource );
// If we have one
if ( producer != NULL )
{
// Register the producer for reuse/destruction
mlt_properties_set_data( properties, "producer", producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
// Ensure that we loop
mlt_properties_set( MLT_PRODUCER_PROPERTIES( producer ), "eof", "loop" );
// Set the old resource
mlt_properties_set( properties, "_old_resource", resource );
}
}
if ( producer != NULL )
{
// Get the producer properties
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
// Now pass all producer. properties on the filter down
mlt_properties_pass( producer_properties, properties, "producer." );
}
// Only continue if we have both producer and composite
if ( composite != NULL && producer != NULL )
{
// Get the service of the producer
mlt_service service = MLT_PRODUCER_SERVICE( producer );
// We will get the 'b frame' from the producer
mlt_frame b_frame = NULL;
// Get the unique id of the filter (used to reacquire the producer position)
char *name = mlt_properties_get( properties, "_unique_id" );
// Get the original producer position
mlt_position position = mlt_properties_get_position( MLT_FRAME_PROPERTIES( frame ), name );
// Make sure the producer is in the correct position
mlt_producer_seek( producer, position );
// Resetting position to appease the composite transition
mlt_frame_set_position( frame, position );
// Get the b frame and process with composite if successful
if ( mlt_service_get_frame( service, &b_frame, 0 ) == 0 )
{
// Get the a and b frame properties
mlt_properties a_props = MLT_FRAME_PROPERTIES( frame );
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// Set the b frame to be in the same position and have same consumer requirements
mlt_frame_set_position( b_frame, position );
mlt_properties_set_double( b_props, "consumer_aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
mlt_properties_set_int( b_props, "consumer_deinterlace", mlt_properties_get_int( a_props, "consumer_deinterlace" ) || mlt_properties_get_int( properties, "deinterlace" ) );
mlt_properties_set_double( b_props, "output_ratio", mlt_properties_get_double( a_props, "output_ratio" ) );
// Check for the special case - no aspect ratio means no problem :-)
if ( mlt_frame_get_aspect_ratio( b_frame ) == 0 )
mlt_properties_set_double( b_props, "aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
if ( mlt_frame_get_aspect_ratio( frame ) == 0 )
mlt_properties_set_double( a_props, "aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
mlt_properties_set_int( b_props, "normalised_width", mlt_properties_get_int( a_props, "normalised_width" ) );
mlt_properties_set_int( b_props, "normalised_height", mlt_properties_get_int( a_props, "normalised_height" ) );
if ( mlt_properties_get_int( properties, "distort" ) )
{
mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( composite ), "distort", 1 );
mlt_properties_set_int( a_props, "distort", 1 );
mlt_properties_set_int( b_props, "distort", 1 );
}
*format = mlt_image_yuv422;
if ( mlt_properties_get_int( properties, "reverse" ) == 0 )
{
// Apply all filters that are attached to this filter to the b frame
mlt_service_apply_filters( MLT_FILTER_SERVICE( this ), b_frame, 0 );
// Process the frame
mlt_transition_process( composite, frame, b_frame );
// Get the image
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
}
else
{
char temp[ 132 ];
int count = 0;
uint8_t *alpha = NULL;
const char *rescale = mlt_properties_get( a_props, "rescale.interp" );
if ( rescale == NULL || !strcmp( rescale, "none" ) )
rescale = "hyper";
mlt_transition_process( composite, b_frame, frame );
mlt_properties_set_int( a_props, "consumer_deinterlace", 1 );
mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
mlt_properties_set( a_props, "rescale.interp", rescale );
mlt_properties_set( b_props, "rescale.interp", rescale );
mlt_service_apply_filters( MLT_FILTER_SERVICE( this ), b_frame, 0 );
error = mlt_frame_get_image( b_frame, image, format, width, height, 1 );
alpha = mlt_frame_get_alpha_mask( b_frame );
mlt_properties_set_data( a_props, "image", *image, *width * *height * 2, NULL, NULL );
mlt_properties_set_data( a_props, "alpha", alpha, *width * *height, NULL, NULL );
mlt_properties_set_int( a_props, "width", *width );
mlt_properties_set_int( a_props, "height", *height );
mlt_properties_set_int( a_props, "progressive", 1 );
mlt_properties_inc_ref( b_props );
strcpy( temp, "_b_frame" );
while( mlt_properties_get_data( a_props, temp, NULL ) != NULL )
sprintf( temp, "_b_frame%d", count ++ );
mlt_properties_set_data( a_props, temp, b_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
}
// Close the b frame
mlt_frame_close( b_frame );
}
else
{
// Get the image from the frame without running fx
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
}
return error;
}
mlt_position mlt_producer_get_out( mlt_producer self )
{
return mlt_properties_get_position( MLT_PRODUCER_PROPERTIES( self ), "out" );
}
static void foreach_consumer_put( mlt_consumer consumer, mlt_frame frame )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
mlt_consumer nested = NULL;
char key[30];
int index = 0;
do {
snprintf( key, sizeof(key), "%d.consumer", index++ );
nested = mlt_properties_get_data( properties, key, NULL );
if ( nested )
{
mlt_properties nested_props = MLT_CONSUMER_PROPERTIES(nested);
double self_fps = mlt_properties_get_double( properties, "fps" );
double nested_fps = mlt_properties_get_double( nested_props, "fps" );
mlt_position nested_pos = mlt_properties_get_position( nested_props, "_multi_position" );
mlt_position self_pos = mlt_frame_get_position( frame );
double self_time = self_pos / self_fps;
double nested_time = nested_pos / nested_fps;
// get the audio for the current frame
uint8_t *buffer = NULL;
mlt_audio_format format = mlt_audio_s16;
int channels = mlt_properties_get_int( properties, "channels" );
int frequency = mlt_properties_get_int( properties, "frequency" );
int current_samples = mlt_sample_calculator( self_fps, frequency, self_pos );
mlt_frame_get_audio( frame, (void**) &buffer, &format, &frequency, &channels, ¤t_samples );
int current_size = mlt_audio_format_size( format, current_samples, channels );
// get any leftover audio
int prev_size = 0;
uint8_t *prev_buffer = mlt_properties_get_data( nested_props, "_multi_audio", &prev_size );
uint8_t *new_buffer = NULL;
if ( prev_size > 0 )
{
new_buffer = mlt_pool_alloc( prev_size + current_size );
memcpy( new_buffer, prev_buffer, prev_size );
memcpy( new_buffer + prev_size, buffer, current_size );
buffer = new_buffer;
}
current_size += prev_size;
current_samples += mlt_properties_get_int( nested_props, "_multi_samples" );
while ( nested_time <= self_time )
{
// put ideal number of samples into cloned frame
int deeply = index > 1 ? 1 : 0;
mlt_frame clone_frame = mlt_frame_clone( frame, deeply );
int nested_samples = mlt_sample_calculator( nested_fps, frequency, nested_pos );
// -10 is an optimization to avoid tiny amounts of leftover samples
nested_samples = nested_samples > current_samples - 10 ? current_samples : nested_samples;
int nested_size = mlt_audio_format_size( format, nested_samples, channels );
if ( nested_size > 0 )
{
prev_buffer = mlt_pool_alloc( nested_size );
memcpy( prev_buffer, buffer, nested_size );
}
else
{
prev_buffer = NULL;
nested_size = 0;
}
mlt_frame_set_audio( clone_frame, prev_buffer, format, nested_size, mlt_pool_release );
mlt_properties_set_int( MLT_FRAME_PROPERTIES(clone_frame), "audio_samples", nested_samples );
mlt_properties_set_int( MLT_FRAME_PROPERTIES(clone_frame), "audio_frequency", frequency );
mlt_properties_set_int( MLT_FRAME_PROPERTIES(clone_frame), "audio_channels", channels );
// chomp the audio
current_samples -= nested_samples;
current_size -= nested_size;
buffer += nested_size;
// send frame to nested consumer
mlt_consumer_put_frame( nested, clone_frame );
mlt_properties_set_position( nested_props, "_multi_position", ++nested_pos );
nested_time = nested_pos / nested_fps;
}
// save any remaining audio
if ( current_size > 0 )
{
prev_buffer = mlt_pool_alloc( current_size );
memcpy( prev_buffer, buffer, current_size );
}
else
{
prev_buffer = NULL;
current_size = 0;
}
mlt_pool_release( new_buffer );
mlt_properties_set_data( nested_props, "_multi_audio", prev_buffer, current_size, mlt_pool_release, NULL );
mlt_properties_set_int( nested_props, "_multi_samples", current_samples );
}
} while ( nested );
}
static int framebuffer_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the filter object and properties
mlt_producer producer = mlt_frame_pop_service( frame );
int index = ( int )mlt_frame_pop_service( frame );
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
// Frame properties objects
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_frame first_frame = mlt_properties_get_data( properties, "first_frame", NULL );
// Get producer parameters
int strobe = mlt_properties_get_int( properties, "strobe" );
int freeze = mlt_properties_get_int( properties, "freeze" );
int freeze_after = mlt_properties_get_int( properties, "freeze_after" );
int freeze_before = mlt_properties_get_int( properties, "freeze_before" );
int in = mlt_properties_get_position( properties, "in" );
// Determine the position
mlt_position first_position = (first_frame != NULL) ? mlt_frame_get_position( first_frame ) : -1;
mlt_position need_first = freeze;
if ( !freeze || freeze_after || freeze_before )
{
double prod_speed = mlt_properties_get_double( properties, "_speed" );
double actual_position = in + prod_speed * (double) mlt_producer_position( producer );
if ( mlt_properties_get_int( properties, "reverse" ) )
actual_position = mlt_producer_get_playtime( producer ) - actual_position;
if ( strobe < 2 )
{
need_first = floor( actual_position );
}
else
{
// Strobe effect wanted, calculate frame position
need_first = floor( actual_position );
need_first -= need_first % strobe;
}
if ( freeze )
{
if ( freeze_after && need_first > freeze ) need_first = freeze;
else if ( freeze_before && need_first < freeze ) need_first = freeze;
}
}
// Determine output buffer size
*width = mlt_properties_get_int( frame_properties, "width" );
*height = mlt_properties_get_int( frame_properties, "height" );
int size = mlt_image_format_size( *format, *width, *height, NULL );
// Get output buffer
int buffersize = 0;
int alphasize = *width * *height;
uint8_t *output = mlt_properties_get_data( properties, "output_buffer", &buffersize );
uint8_t *output_alpha = mlt_properties_get_data( properties, "output_alpha", NULL );
if( buffersize == 0 || buffersize != size )
{
// invalidate cached frame
first_position = -1;
}
if ( need_first != first_position )
{
// invalidate cached frame
first_position = -1;
// Bust the cached frame
mlt_properties_set_data( properties, "first_frame", NULL, 0, NULL, NULL );
first_frame = NULL;
}
if ( output && first_position != -1 ) {
// Using the cached frame
uint8_t *image_copy = mlt_pool_alloc( size );
memcpy( image_copy, output, size );
uint8_t *alpha_copy = mlt_pool_alloc( alphasize );
memcpy( alpha_copy, output_alpha, alphasize );
// Set the output image
*image = image_copy;
mlt_frame_set_image( frame, image_copy, size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha_copy, alphasize, mlt_pool_release );
*width = mlt_properties_get_int( properties, "_output_width" );
*height = mlt_properties_get_int( properties, "_output_height" );
*format = mlt_properties_get_int( properties, "_output_format" );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return 0;
}
// Get the cached frame
if ( first_frame == NULL )
{
// Get the frame to cache from the real producer
mlt_producer real_producer = mlt_properties_get_data( properties, "producer", NULL );
// Seek the producer to the correct place
mlt_producer_seek( real_producer, need_first );
// Get the frame
mlt_service_get_frame( MLT_PRODUCER_SERVICE( real_producer ), &first_frame, index );
// Cache the frame
mlt_properties_set_data( properties, "first_frame", first_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
mlt_properties first_frame_properties = MLT_FRAME_PROPERTIES( first_frame );
// Which frames are buffered?
uint8_t *first_image = mlt_properties_get_data( first_frame_properties, "image", NULL );
uint8_t *first_alpha = mlt_properties_get_data( first_frame_properties, "alpha", NULL );
if ( !first_image )
{
mlt_properties_set( first_frame_properties, "rescale.interp", mlt_properties_get( frame_properties, "rescale.interp" ) );
int error = mlt_frame_get_image( first_frame, &first_image, format, width, height, writable );
if ( error != 0 ) {
mlt_log_error( MLT_PRODUCER_SERVICE( producer ), "first_image == NULL get image died\n" );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return error;
}
output = mlt_pool_alloc( size );
memcpy( output, first_image, size );
// Let someone else clean up
mlt_properties_set_data( properties, "output_buffer", output, size, mlt_pool_release, NULL );
mlt_properties_set_int( properties, "_output_width", *width );
mlt_properties_set_int( properties, "_output_height", *height );
mlt_properties_set_int( properties, "_output_format", *format );
}
if ( !first_alpha )
{
alphasize = *width * *height;
first_alpha = mlt_frame_get_alpha_mask( first_frame );
output_alpha = mlt_pool_alloc( alphasize );
memcpy( output_alpha, first_alpha, alphasize );
mlt_properties_set_data( properties, "output_alpha", output_alpha, alphasize, mlt_pool_release, NULL );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
// Create a copy
uint8_t *image_copy = mlt_pool_alloc( size );
memcpy( image_copy, first_image, size );
uint8_t *alpha_copy = mlt_pool_alloc( alphasize );
memcpy( alpha_copy, first_alpha, alphasize );
// Set the output image
*image = image_copy;
mlt_frame_set_image( frame, *image, size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha_copy, alphasize, 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 )
{
// 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;
}
#include <ctype.h>
#include <string.h>
#include <math.h>
/** Calculate the position for this frame.
*/
static float position_calculate( mlt_transition this, mlt_frame frame )
{
// Get the in and out position
mlt_position in = mlt_transition_get_in( this );
mlt_position out = mlt_transition_get_out( this );
// Get the position of the frame
char *name = mlt_properties_get( MLT_TRANSITION_PROPERTIES( this ), "_unique_id" );
mlt_position position = mlt_properties_get_position( MLT_FRAME_PROPERTIES( frame ), name );
// Now do the calcs
return ( float )( position - in ) / ( float )( out - in + 1 );
}
/** Calculate the field delta for this frame - position between two frames.
*/
static float delta_calculate( mlt_transition this, mlt_frame frame )
{
// Get the in and out position
mlt_position in = mlt_transition_get_in( this );
mlt_position out = mlt_transition_get_out( this );
// Get the position of the frame
mlt_position mlt_filter_get_out( mlt_filter self )
{
mlt_properties properties = MLT_SERVICE_PROPERTIES( &self->parent );
return mlt_properties_get_position( properties, "out" );
}
