static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
mlt_frame_push_service( frame, filter );
mlt_frame_push_get_image( frame, filter_get_image );
return frame;
}
static mlt_frame process( mlt_transition transition, mlt_frame a_frame, mlt_frame b_frame )
{
mlt_service service = MLT_TRANSITION_SERVICE(transition);
if ( !GlslManager::init_chain( service ) ) {
// Create the Movit effect chain
EffectChain* chain = GlslManager::get_chain( service );
mlt_profile profile = mlt_service_profile( service );
Input* b_input = new MltInput( profile->width, profile->height );
ImageFormat output_format;
output_format.color_space = COLORSPACE_sRGB;
output_format.gamma_curve = GAMMA_sRGB;
chain->add_input( b_input );
chain->add_output( output_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED );
chain->set_dither_bits( 8 );
Effect* effect = chain->add_effect( new OverlayEffect(),
GlslManager::get_input( service ), b_input );
// Save these new input on properties for get_image
mlt_properties_set_data( MLT_TRANSITION_PROPERTIES(transition),
"movit input B", b_input, 0, NULL, NULL );
}
// Push the transition on to the frame
mlt_frame_push_service( a_frame, transition );
// Push the b_frame on to the stack
mlt_frame_push_frame( a_frame, b_frame );
// Push the transition method
mlt_frame_push_get_image( a_frame, get_image );
return a_frame;
}
int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Generate a frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
if ( *frame != NULL )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
// Obtain properties of producer
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Set the producer on the frame properties
mlt_properties_set_data( properties, "producer_frei0r", producer, 0, NULL, NULL );
// Update timecode on the frame we're creating
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
// Set producer-specific frame properties
mlt_properties_set_int( properties, "progressive", 1 );
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) );
// Push the get_image method
mlt_frame_push_get_image( *frame, producer_get_image );
}
// Calculate the next timecode
mlt_producer_prepare_next( producer );
return 0;
}
static int getFrame(mlt_producer producer, mlt_frame_ptr frame, int /*index*/) {
// Generate a frame
*frame = mlt_frame_init(MLT_PRODUCER_SERVICE(producer));
if (*frame) {
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES(*frame);
// Set the producer on the frame properties
mlt_properties_set_data(properties, kWebVfxProducerPropertyName, producer, 0, NULL, NULL);
// Update timecode on the frame we're creating
mlt_position position = mlt_producer_position(producer);
mlt_frame_set_position(*frame, position);
mlt_properties_set_position(properties, kWebVfxPositionPropertyName, position);
// Set producer-specific frame properties
mlt_properties_set_int(properties, "progressive", 1);
// Push the get_image method
mlt_frame_push_get_image(*frame, producerGetImage);
}
// Calculate the next timecode
mlt_producer_prepare_next(producer);
return 0;
}
mlt_frame transition_process( mlt_transition transition, mlt_frame a_frame, mlt_frame b_frame )
{
mlt_frame_push_service( a_frame, transition );
mlt_frame_push_frame( a_frame, b_frame );
mlt_frame_push_get_image( a_frame, transition_get_image );
return a_frame;
}
static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Generate a frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
if ( *frame != NULL )
{
// Obtain properties of frame
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( *frame );
// Update time code on the frame
mlt_frame_set_position( *frame, mlt_producer_frame( producer ) );
mlt_properties_set_int( frame_properties, "progressive", 1 );
mlt_properties_set_double( frame_properties, "aspect_ratio", mlt_profile_sar( profile ) );
mlt_properties_set_int( frame_properties, "meta.media.width", profile->width );
mlt_properties_set_int( frame_properties, "meta.media.height", profile->height );
// Configure callbacks
mlt_frame_push_service( *frame, producer );
mlt_frame_push_get_image( *frame, producer_get_image );
mlt_frame_push_audio( *frame, producer );
mlt_frame_push_audio( *frame, producer_get_audio );
}
// Calculate the next time code
mlt_producer_prepare_next( producer );
return 0;
}
mlt_frame transition_process( mlt_transition transition, mlt_frame a_frame, mlt_frame b_frame )
{
char *name = mlt_properties_get( MLT_TRANSITION_PROPERTIES( transition ), "_unique_id" );
mlt_properties_set_position( MLT_FRAME_PROPERTIES( a_frame ), name, mlt_frame_get_position( a_frame ) );
mlt_frame_push_service( a_frame, transition );
mlt_frame_push_frame( a_frame, b_frame );
mlt_frame_push_get_image( a_frame, transition_get_image );
return a_frame;
}
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
// Push this on to the service stack
mlt_frame_push_service( frame, filter );
// Push the get image call
mlt_frame_push_get_image( frame, filter_get_image );
return frame;
}
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
// Push the filter
mlt_frame_push_service( frame, filter );
// Register the get image method
mlt_frame_push_get_image( frame, filter_get_image );
// Return the frame
return frame;
}
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
// Store the aspect ratio reported by the source
mlt_deque_push_back_double( MLT_FRAME_IMAGE_STACK( frame ), mlt_frame_get_aspect_ratio( frame ) );
// Push this on to the service stack
mlt_frame_push_service( frame, filter );
// Push the get_image method on to the stack
mlt_frame_push_get_image( frame, filter_get_image );
return frame;
}
static mlt_frame transition_process( mlt_transition transition, mlt_frame a_frame, mlt_frame b_frame )
{
// Push the transition on to the frame
mlt_frame_push_service( a_frame, transition );
// Push the b_frame on to the stack
mlt_frame_push_frame( a_frame, b_frame );
// Push the transition method
mlt_frame_push_get_image( a_frame, transition_get_image );
return a_frame;
}
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
if( mlt_frame_is_test_card( frame ) ) {
// The producer does not generate video. This filter will create an
// image on the producer's behalf.
mlt_profile profile = mlt_service_profile(
MLT_PRODUCER_SERVICE( mlt_frame_get_original_producer( frame ) ) );
mlt_properties_set_int( frame_properties, "progressive", 1 );
mlt_properties_set_double( frame_properties, "aspect_ratio", mlt_profile_sar( profile ) );
mlt_properties_set_int( frame_properties, "meta.media.width", profile->width );
mlt_properties_set_int( frame_properties, "meta.media.height", profile->height );
// Tell the framework that there really is an image.
mlt_properties_set_int( frame_properties, "test_image", 0 );
// Push a callback to create the image.
mlt_frame_push_get_image( frame, create_image );
}
mlt_frame_push_service( frame, filter );
mlt_frame_push_get_image( frame, filter_get_image );
return frame;
}
static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Get the real structure for this producer
producer_qimage self = producer->child;
// Fetch the producers properties
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
if ( self->filenames == NULL && mlt_properties_get( producer_properties, "resource" ) != NULL )
load_filenames( self, producer_properties );
// Generate a frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
if ( *frame != NULL && self->count > 0 )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
// Set the producer on the frame properties
mlt_properties_set_data( properties, "producer_qimage", self, 0, NULL, NULL );
// Update timecode on the frame we're creating
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
// Ensure that we have a way to obtain the position in the get_image
mlt_properties_set_position( properties, "qimage_position", mlt_producer_position( producer ) );
// Refresh the image
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage = mlt_cache_item_data( self->qimage_cache, NULL );
refresh_qimage( self, *frame );
mlt_cache_item_close( self->qimage_cache );
// Set producer-specific frame properties
mlt_properties_set_int( properties, "progressive", mlt_properties_get_int( producer_properties, "progressive" ) );
double force_ratio = mlt_properties_get_double( producer_properties, "force_aspect_ratio" );
if ( force_ratio > 0.0 )
mlt_properties_set_double( properties, "aspect_ratio", force_ratio );
else
mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( producer_properties, "aspect_ratio" ) );
// Push the get_image method
mlt_frame_push_get_image( *frame, producer_get_image );
}
// Calculate the next timecode
mlt_producer_prepare_next( producer );
return 0;
}
static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Generate a frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
if ( *frame != NULL )
{
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( *frame );
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
// Regenerate the QPainterPath if necessary
if( check_qpath( producer_properties ) )
{
generate_qpath( producer_properties );
}
// Give the frame a copy of the painter path
QPainterPath* prodPath = static_cast<QPainterPath*>( mlt_properties_get_data( producer_properties, "_qpath", NULL ) );
QPainterPath* framePath = new QPainterPath( *prodPath );
mlt_properties_set_data( frame_properties, "_qpath", static_cast<void*>( framePath ), 0, close_qpath, NULL );
// Pass properties to the frame that will be needed to render the path
mlt_properties_set( frame_properties, "_path_sig", mlt_properties_get( producer_properties, "_path_sig" ) );
mlt_properties_set( frame_properties, "_bgcolour", mlt_properties_get( producer_properties, "bgcolour" ) );
mlt_properties_set( frame_properties, "_fgcolour", mlt_properties_get( producer_properties, "fgcolour" ) );
mlt_properties_set( frame_properties, "_olcolour", mlt_properties_get( producer_properties, "olcolour" ) );
mlt_properties_set( frame_properties, "_outline", mlt_properties_get( producer_properties, "outline" ) );
mlt_properties_set_data( frame_properties, "_producer_qtext", static_cast<void*>( producer ), 0, NULL, NULL );
// Set frame properties
mlt_properties_set_int( frame_properties, "progressive", 1 );
double force_ratio = mlt_properties_get_double( producer_properties, "force_aspect_ratio" );
if ( force_ratio > 0.0 )
mlt_properties_set_double( frame_properties, "aspect_ratio", force_ratio );
else
mlt_properties_set_double( frame_properties, "aspect_ratio", 1.0);
// Update time code on the frame
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
// Configure callbacks
mlt_frame_push_get_image( *frame, producer_get_image );
}
// Calculate the next time code
mlt_producer_prepare_next( producer );
return 0;
}
/** Filter processing.
*/
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
// Get the properties of the frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Save the frame out point
mlt_properties_set_int( MLT_FILTER_PROPERTIES( filter ), "_out", mlt_properties_get_int( properties, "out" ) );
// Push the filter on to the stack
mlt_frame_push_service( frame, filter );
// Push the get_image on to the stack
mlt_frame_push_get_image( frame, filter_get_image );
return frame;
}
static int get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
DeckLinkProducer* decklink = (DeckLinkProducer*) producer->child;
mlt_position pos = mlt_producer_position( producer );
mlt_position end = mlt_producer_get_playtime( producer );
end = ( mlt_producer_get_length( producer ) < end ? mlt_producer_get_length( producer ) : end ) - 1;
// Re-open if needed
if ( !decklink && pos < end )
{
producer->child = decklink = new DeckLinkProducer();
decklink->setProducer( producer );
decklink->open( mlt_properties_get_int( MLT_PRODUCER_PROPERTIES(producer), "resource" ) );
}
// Start if needed
if ( decklink )
{
decklink->start( mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) ) );
// Get the next frame from the decklink object
if ( ( *frame = decklink->getFrame() ))
{
// Add audio and video getters
mlt_frame_push_audio( *frame, (void*) get_audio );
mlt_frame_push_get_image( *frame, get_image );
}
}
if ( !*frame )
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE(producer) );
// Calculate the next timecode
mlt_producer_prepare_next( producer );
// Close DeckLink if at end
if ( pos >= end && decklink )
{
decklink->stop();
delete decklink;
producer->child = NULL;
}
return 0;
}
static mlt_frame process(mlt_filter filter, mlt_frame frame)
{
mlt_properties properties = MLT_FILTER_PROPERTIES(filter);
mlt_transition transition = mlt_properties_get_data(properties, "instance", NULL);
char *name = mlt_properties_get(MLT_FILTER_PROPERTIES(filter), "transition");
if (!name || !strcmp("", name))
return frame;
// Create the transition if needed.
if (!transition
|| !mlt_properties_get(MLT_FILTER_PROPERTIES(transition), "mlt_service")
|| strcmp(name, mlt_properties_get(MLT_FILTER_PROPERTIES(transition), "mlt_service"))) {
mlt_profile profile = mlt_service_profile(MLT_FILTER_SERVICE(filter));
transition = mlt_factory_transition(profile, name, NULL);
mlt_properties_set_data(MLT_FILTER_PROPERTIES(filter), "instance", transition, 0, (mlt_destructor) mlt_transition_close, NULL);
}
if (transition) {
mlt_properties transition_props = MLT_TRANSITION_PROPERTIES(transition);
int type = mlt_properties_get_int(transition_props, "_transition_type");
int hide = mlt_properties_get_int(MLT_FRAME_PROPERTIES(frame), "hide");
mlt_properties_pass_list(transition_props, properties, "in out");
mlt_properties_pass(transition_props, properties, "transition." );
// Only if video transition on visible track.
if ((type & 1) && !mlt_frame_is_test_card(frame) && !(hide & 1)) {
mlt_frame_push_service_int(frame,
mlt_image_format_id(mlt_properties_get(properties, "mlt_image_format")));
mlt_frame_push_service(frame, transition);
mlt_frame_push_get_image(frame, get_image);
}
if (type == 0)
mlt_properties_debug(transition_props, "unknown transition type", stderr);
} else {
mlt_properties_debug(properties, "mask_failed to create transition", stderr );
}
return frame;
}
static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Get the real structure for this producer
producer_ktitle this = producer->child;
/* Generate a frame */
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
if ( *frame != NULL )
{
/* Obtain properties of frame and producer */
mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
/* Obtain properties of producer */
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
/* Set the producer on the frame properties */
mlt_properties_set_data( properties, "producer_kdenlivetitle", this, 0, NULL, NULL );
/* Update timecode on the frame we're creating */
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
// Set producer-specific frame properties
mlt_properties_set_int( properties, "progressive", mlt_properties_get_int( producer_props, "progressive" ) );
double force_ratio = mlt_properties_get_double( producer_props, "force_aspect_ratio" );
if ( force_ratio > 0.0 )
mlt_properties_set_double( properties, "aspect_ratio", force_ratio );
else
mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( producer_props, "aspect_ratio" ) );
/* Push the get_image method */
mlt_frame_push_get_image( *frame, producer_get_image );
}
/* Calculate the next timecode */
mlt_producer_prepare_next( producer );
return 0;
}
static int get_image(mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable)
{
mlt_transition transition = mlt_frame_pop_service(frame);
*format = mlt_frame_pop_service_int(frame);
int error = mlt_frame_get_image(frame, image, format, width, height, writable);
if (!error) {
mlt_properties properties = MLT_FRAME_PROPERTIES(frame);
mlt_frame clone = mlt_properties_get_data(properties, "mask frame", NULL);
if (clone) {
mlt_frame_push_get_image(frame, dummy_get_image);
mlt_service_lock(MLT_TRANSITION_SERVICE(transition));
mlt_transition_process(transition, clone, frame);
mlt_service_unlock(MLT_TRANSITION_SERVICE(transition));
error = mlt_frame_get_image(clone, image, format, width, height, writable);
if (!error) {
int size = mlt_image_format_size(*format, *width, *height, NULL);
mlt_frame_set_image(frame, *image, size, NULL);
}
}
}
return error;
}
static mlt_frame process_filter(mlt_filter filter, mlt_frame frame)
{
mlt_frame_push_service(frame, filter);
mlt_frame_push_get_image(frame, get_image_and_detect);
return frame;
}
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 transitionProcess(mlt_transition transition, mlt_frame aFrame, mlt_frame bFrame) {
mlt_frame_push_service(aFrame, transition);
mlt_frame_push_frame(aFrame, bFrame);
mlt_frame_push_get_image(aFrame, transitionGetImage);
return aFrame;
}
static int get_frame( mlt_producer self, mlt_frame_ptr frame, int index )
{
mlt_properties properties = MLT_PRODUCER_PROPERTIES(self);
context cx = mlt_properties_get_data( properties, "context", NULL );
if ( !cx )
{
// Allocate and initialize our context
cx = mlt_pool_alloc( sizeof( struct context_s ) );
memset( cx, 0, sizeof( *cx ) );
mlt_properties_set_data( properties, "context", cx, 0, mlt_pool_release, NULL );
cx->self = self;
char *profile_name = mlt_properties_get( properties, "profile" );
if ( !profile_name )
profile_name = mlt_properties_get( properties, "mlt_profile" );
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( self ) );
if ( profile_name )
{
cx->profile = mlt_profile_init( profile_name );
cx->profile->is_explicit = 1;
}
else
{
cx->profile = mlt_profile_clone( profile );
cx->profile->is_explicit = 0;
}
// Encapsulate a real producer for the resource
cx->producer = mlt_factory_producer( cx->profile, NULL,
mlt_properties_get( properties, "resource" ) );
if ( ( profile_name && !strcmp( profile_name, "auto" ) ) ||
mlt_properties_get_int( properties, "autoprofile" ) )
{
mlt_profile_from_producer( cx->profile, cx->producer );
mlt_producer_close( cx->producer );
cx->producer = mlt_factory_producer( cx->profile, NULL, mlt_properties_get( properties, "resource" ) );
}
// Since we control the seeking, prevent it from seeking on its own
mlt_producer_set_speed( cx->producer, 0 );
cx->audio_position = -1;
// We will encapsulate a consumer
cx->consumer = mlt_consumer_new( cx->profile );
// Do not use _pass_list on real_time so that it defaults to 0 in the absence of
// an explicit real_time property.
mlt_properties_set_int( MLT_CONSUMER_PROPERTIES( cx->consumer ), "real_time",
mlt_properties_get_int( properties, "real_time" ) );
mlt_properties_pass_list( MLT_CONSUMER_PROPERTIES( cx->consumer ), properties,
"buffer, prefill, deinterlace_method, rescale" );
// Connect it all together
mlt_consumer_connect( cx->consumer, MLT_PRODUCER_SERVICE( cx->producer ) );
mlt_consumer_start( cx->consumer );
}
// Generate a frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( self ) );
if ( *frame )
{
// Seek the producer to the correct place
// Calculate our positions
double actual_position = (double) mlt_producer_frame( self );
if ( mlt_producer_get_speed( self ) != 0 )
actual_position *= mlt_producer_get_speed( self );
mlt_position need_first = floor( actual_position );
mlt_producer_seek( cx->producer,
lrint( need_first * mlt_profile_fps( cx->profile ) / mlt_producer_get_fps( self ) ) );
// Get the nested frame
mlt_frame nested_frame = mlt_consumer_rt_frame( cx->consumer );
// Stack the producer and our methods on the nested frame
mlt_frame_push_service( *frame, nested_frame );
mlt_frame_push_service( *frame, cx );
mlt_frame_push_get_image( *frame, get_image );
mlt_frame_push_audio( *frame, nested_frame );
mlt_frame_push_audio( *frame, cx );
mlt_frame_push_audio( *frame, get_audio );
// Give the returned frame temporal identity
mlt_frame_set_position( *frame, mlt_producer_position( self ) );
// Store the nested frame on the produced frame for destruction
mlt_properties frame_props = MLT_FRAME_PROPERTIES( *frame );
mlt_properties_set_data( frame_props, "_producer_consumer.frame", nested_frame, 0, (mlt_destructor) mlt_frame_close, NULL );
// Inform the normalizers about our video properties
mlt_properties_set_double( frame_props, "aspect_ratio", mlt_profile_sar( cx->profile ) );
mlt_properties_set_int( frame_props, "width", cx->profile->width );
mlt_properties_set_int( frame_props, "height", cx->profile->height );
mlt_properties_set_int( frame_props, "meta.media.width", cx->profile->width );
mlt_properties_set_int( frame_props, "meta.media.height", cx->profile->height );
mlt_properties_set_int( frame_props, "progressive", cx->profile->progressive );
}
// Calculate the next timecode
mlt_producer_prepare_next( self );
return 0;
}
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
if ( mlt_properties_get_int( MLT_FILTER_PROPERTIES( filter ), "active" ) )
{
// Push the get_image method on to the stack
mlt_frame_push_service( frame, mlt_service_profile( MLT_FILTER_SERVICE( filter ) ) );
mlt_frame_push_get_image( frame, filter_get_image );
}
else
{
mlt_properties filter_props = MLT_FILTER_PROPERTIES( filter );
mlt_properties frame_props = MLT_FRAME_PROPERTIES( frame );
int left = mlt_properties_get_int( filter_props, "left" );
int right = mlt_properties_get_int( filter_props, "right" );
int top = mlt_properties_get_int( filter_props, "top" );
int bottom = mlt_properties_get_int( filter_props, "bottom" );
int width = mlt_properties_get_int( frame_props, "meta.media.width" );
int height = mlt_properties_get_int( frame_props, "meta.media.height" );
int use_profile = mlt_properties_get_int( filter_props, "use_profile" );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
if ( use_profile )
{
top = top * height / profile->height;
bottom = bottom * height / profile->height;
left = left * width / profile->width;
right = right * width / profile->width;
}
if ( mlt_properties_get_int( filter_props, "center" ) )
{
double aspect_ratio = mlt_frame_get_aspect_ratio( frame );
if ( aspect_ratio == 0.0 )
aspect_ratio = mlt_profile_sar( profile );
double input_ar = aspect_ratio * width / height;
double output_ar = mlt_profile_dar( mlt_service_profile( MLT_FILTER_SERVICE(filter) ) );
int bias = mlt_properties_get_int( filter_props, "center_bias" );
if ( input_ar > output_ar )
{
left = right = ( width - rint( output_ar * height / aspect_ratio ) ) / 2;
if ( abs(bias) > left )
bias = bias < 0 ? -left : left;
else if ( use_profile )
bias = bias * width / profile->width;
left -= bias;
right += bias;
}
else
{
top = bottom = ( height - rint( aspect_ratio * width / output_ar ) ) / 2;
if ( abs(bias) > top )
bias = bias < 0 ? -top : top;
else if ( use_profile )
bias = bias * height / profile->height;
top -= bias;
bottom += bias;
}
}
// Coerce the output to an even width because subsampled YUV with odd widths is too
// risky for downstream processing to handle correctly.
left += ( width - left - right ) & 1;
if ( width - left - right < 8 )
left = right = 0;
if ( height - top - bottom < 8 )
top = bottom = 0;
mlt_properties_set_int( frame_props, "crop.left", left );
mlt_properties_set_int( frame_props, "crop.right", right );
mlt_properties_set_int( frame_props, "crop.top", top );
mlt_properties_set_int( frame_props, "crop.bottom", bottom );
mlt_properties_set_int( frame_props, "crop.original_width", width );
mlt_properties_set_int( frame_props, "crop.original_height", height );
mlt_properties_set_int( frame_props, "meta.media.width", width - left - right );
mlt_properties_set_int( frame_props, "meta.media.height", height - top - bottom );
}
return frame;
}
