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 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;
}
static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int index )
{
// Get the mutiltrack object
mlt_multitrack self = parent->child;
// Check if we have a track for this index
if ( index >= 0 && index < self->count && self->list[ index ] != NULL )
{
// Get the producer for this track
mlt_producer producer = self->list[ index ]->producer;
// Get the track hide property
int hide = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( mlt_producer_cut_parent( producer ) ), "hide" );
// Obtain the current position
mlt_position position = mlt_producer_frame( parent );
// Get the parent properties
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( parent );
// Get the speed
double speed = mlt_properties_get_double( producer_properties, "_speed" );
// Make sure we're at the same point
mlt_producer_seek( producer, position );
// Get the frame from the producer
mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), frame, 0 );
// Indicate speed of this producer
mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
mlt_properties_set_double( properties, "_speed", speed );
mlt_frame_set_position( *frame, position );
mlt_properties_set_int( properties, "hide", hide );
}
else
{
// Generate a test frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( parent ) );
// Update position on the frame we're creating
mlt_frame_set_position( *frame, mlt_producer_position( parent ) );
// Move on to the next frame
if ( index >= self->count )
{
// Let tractor know if we've reached the end
mlt_properties_set_int( MLT_FRAME_PROPERTIES( *frame ), "last_track", 1 );
// Move to the next frame
mlt_producer_prepare_next( parent );
}
}
return 0;
}
void mlt_profile_from_producer( mlt_profile profile, mlt_producer producer )
{
mlt_frame fr = NULL;
uint8_t *buffer = NULL;
mlt_image_format fmt = mlt_image_none;
mlt_properties p;
int w = profile->width;
int h = profile->height;
if ( ! mlt_service_get_frame( MLT_PRODUCER_SERVICE(producer), &fr, 0 ) && fr )
{
if ( ! mlt_frame_get_image( fr, &buffer, &fmt, &w, &h, 0 ) )
{
// Some source properties are not exposed until after the first get_image call.
mlt_frame_close( fr );
mlt_service_get_frame( MLT_PRODUCER_SERVICE(producer), &fr, 0 );
p = MLT_FRAME_PROPERTIES( fr );
// mlt_properties_dump(p, stderr);
if ( mlt_properties_get_int( p, "meta.media.frame_rate_den" ) &&
mlt_properties_get_int( p, "meta.media.sample_aspect_den" ) )
{
profile->width = mlt_properties_get_int( p, "meta.media.width" );
profile->height = mlt_properties_get_int( p, "meta.media.height" );
profile->progressive = mlt_properties_get_int( p, "meta.media.progressive" );
if ( 1000 > mlt_properties_get_double( p, "meta.media.frame_rate_num" )
/ mlt_properties_get_double( p, "meta.media.frame_rate_den" ) )
{
profile->frame_rate_num = mlt_properties_get_int( p, "meta.media.frame_rate_num" );
profile->frame_rate_den = mlt_properties_get_int( p, "meta.media.frame_rate_den" );
} else {
profile->frame_rate_num = 60;
profile->frame_rate_den = 1;
}
// AVCHD is mis-reported as double frame rate.
if ( profile->progressive == 0 && (
profile->frame_rate_num / profile->frame_rate_den == 50 ||
profile->frame_rate_num / profile->frame_rate_den == 59 ) )
profile->frame_rate_num /= 2;
profile->sample_aspect_num = mlt_properties_get_int( p, "meta.media.sample_aspect_num" );
profile->sample_aspect_den = mlt_properties_get_int( p, "meta.media.sample_aspect_den" );
profile->colorspace = mlt_properties_get_int( p, "meta.media.colorspace" );
profile->display_aspect_num = lrint( (double) profile->sample_aspect_num * profile->width
/ profile->sample_aspect_den );
profile->display_aspect_den = profile->height;
free( profile->description );
profile->description = strdup( "automatic" );
profile->is_explicit = 0;
}
}
}
mlt_frame_close( fr );
mlt_producer_seek( producer, 0 );
}
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 )
{
if ( frame )
{
// Construct a new frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
// Stack the producer and producer's get image
mlt_frame_push_service_int( *frame, index );
mlt_frame_push_service( *frame, producer );
mlt_frame_push_service( *frame, framebuffer_get_image );
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_properties frame_properties = MLT_FRAME_PROPERTIES(*frame);
// Get frame from the real producer
mlt_frame first_frame = mlt_properties_get_data( properties, "first_frame", NULL );
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, mlt_producer_position( producer ) );
// 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_inherit( frame_properties, MLT_FRAME_PROPERTIES(first_frame) );
double force_aspect_ratio = mlt_properties_get_double( properties, "force_aspect_ratio" );
if ( force_aspect_ratio <= 0.0 ) force_aspect_ratio = mlt_properties_get_double( properties, "aspect_ratio" );
mlt_properties_set_double( frame_properties, "aspect_ratio", force_aspect_ratio );
// Give the returned frame temporal identity
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
mlt_properties_set_int( frame_properties, "meta.media.width", mlt_properties_get_int( properties, "width" ) );
mlt_properties_set_int( frame_properties, "meta.media.height", mlt_properties_get_int( properties, "height" ) );
mlt_properties_pass_list( frame_properties, properties, "width, height" );
}
return 0;
}
static int vdpau_get_buffer( AVCodecContext *codec_context, AVFrame *frame )
{
int error = 0;
producer_avformat self = codec_context->opaque;
mlt_log_debug( MLT_PRODUCER_SERVICE(self->parent), "vdpau_get_buffer\n" );
if ( self->vdpau && mlt_deque_count( self->vdpau->deque ) )
{
struct vdpau_render_state *render = mlt_deque_pop_front( self->vdpau->deque );
if ( render )
{
frame->data[0] = (uint8_t*) render;
frame->data[1] = (uint8_t*) render;
frame->data[2] = (uint8_t*) render;
frame->linesize[0] = 0;
frame->linesize[1] = 0;
frame->linesize[2] = 0;
frame->type = FF_BUFFER_TYPE_USER;
render->state = FF_VDPAU_STATE_USED_FOR_REFERENCE;
frame->reordered_opaque = codec_context->reordered_opaque;
if ( frame->reference )
{
self->vdpau->ip_age[0] = self->vdpau->ip_age[1] + 1;
self->vdpau->ip_age[1] = 1;
self->vdpau->b_age++;
}
else
{
self->vdpau->ip_age[0] ++;
self->vdpau->ip_age[1] ++;
self->vdpau->b_age = 1;
}
}
else
{
mlt_log_warning( MLT_PRODUCER_SERVICE(self->parent), "VDPAU surface underrun\n" );
error = -1;
}
}
else
{
mlt_log_warning( MLT_PRODUCER_SERVICE(self->parent), "VDPAU surface underrun\n" );
error = -1;
}
return error;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
/* Obtain properties of frame */
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
/* Obtain the producer for this frame */
producer_ktitle this = mlt_properties_get_data( properties, "producer_kdenlivetitle", NULL );
/* Obtain properties of producer */
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( &this->parent );
*width = mlt_properties_get_int( properties, "rescale_width" );
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( &this->parent ) );
/* Allocate the image */
*format = mlt_image_rgb24a;
mlt_position time = mlt_producer_position( &this->parent ) + mlt_producer_get_in( &this->parent );
if ( mlt_properties_get_int( producer_props, "force_reload" ) ) {
if (mlt_properties_get_int( producer_props, "force_reload" ) > 1) read_xml(producer_props);
mlt_properties_set_int( producer_props, "force_reload", 0 );
drawKdenliveTitle( this, frame, *width, *height, time, 1);
}
else drawKdenliveTitle( this, frame, *width, *height, time, 0);
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
if ( this->current_image )
{
// Clone the image and the alpha
int image_size = this->current_width * ( this->current_height ) * 4;
uint8_t *image_copy = mlt_pool_alloc( image_size );
memcpy( image_copy, this->current_image, image_size );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
mlt_log_debug( MLT_PRODUCER_SERVICE( &this->parent ), "width:%d height:%d %s\n", *width, *height, mlt_image_format_name( *format ) );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( &this->parent ) );
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;
}
static void add_text_to_bg( mlt_producer producer, mlt_frame bg_frame, mlt_frame text_frame )
{
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_transition transition = mlt_properties_get_data( producer_properties, "_transition", NULL );
if( !transition )
{
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
transition = mlt_factory_transition( profile, "composite", NULL );
// Save the transition for future use.
mlt_properties_set_data( producer_properties, "_transition", transition, 0, ( mlt_destructor )mlt_transition_close, NULL );
// Configure the transition.
mlt_properties transition_properties = MLT_TRANSITION_PROPERTIES( transition );
mlt_properties_set( transition_properties, "geometry", "0%/0%:100%x100%:100" );
mlt_properties_set( transition_properties, "halign", "center" );
mlt_properties_set( transition_properties, "valign", "middle" );
}
if( transition && bg_frame && text_frame )
{
// Apply the transition.
mlt_transition_process( transition, bg_frame, text_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 ) );
// Check that we created a frame and initialize it
if ( *frame != NULL )
{
// Obtain properties of frame
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( *frame );
// Update timecode on the frame we're creating
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
// Save the producer to be used in get_audio
mlt_properties_set_data( frame_properties, "_producer_ladspa", producer, 0, NULL, NULL );
// Push the get_audio method
mlt_frame_push_audio( *frame, producer_get_audio );
}
// Calculate the next time code
mlt_producer_prepare_next( producer );
return 0;
}
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;
}
void mlt_producer_close( mlt_producer self )
{
if ( self != NULL && mlt_properties_dec_ref( MLT_PRODUCER_PROPERTIES( self ) ) <= 0 )
{
self->parent.close = NULL;
if ( self->close != NULL )
{
self->close( self->close_object );
}
else
{
int destroy = mlt_producer_is_cut( self );
#if _MLT_PRODUCER_CHECKS_ == 1
// Show debug info
mlt_properties_debug( MLT_PRODUCER_PROPERTIES( self ), "Producer closing", stderr );
#endif
#ifdef _MLT_PRODUCER_CHECKS_
// Show current stats - these should match when the app is closed
mlt_log( MLT_PRODUCER_SERVICE( self ), MLT_LOG_DEBUG, "Producers created %d, destroyed %d\n", producers_created, ++producers_destroyed );
#endif
mlt_service_close( &self->parent );
if ( destroy )
free( self );
}
}
}
static void add_clock_to_frame( mlt_producer producer, mlt_frame frame, time_info* info )
{
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
uint8_t* image = NULL;
mlt_image_format format = mlt_image_rgb24a;
int size = 0;
int width = profile->width;
int height = profile->height;
int line_width = LINE_WIDTH_RATIO * (width > height ? height : width) / 100;
int radius = (width > height ? height : width) / 2;
char* direction = mlt_properties_get( producer_properties, "direction" );
int clock_angle = 0;
mlt_frame_get_image( frame, &image, &format, &width, &height, 1 );
// Calculate the angle for the clock.
int frames = info->frames;
if( !strcmp( direction, "down" ) )
{
frames = info->fps - info->frames - 1;
}
clock_angle = (frames + 1) * 360 / info->fps;
draw_clock( image, profile, clock_angle, line_width );
draw_cross( image, profile, line_width );
draw_ring( image, profile, ( radius * OUTER_RING_RATIO ) / 100, line_width );
draw_ring( image, profile, ( radius * INNER_RING_RATIO ) / 100, line_width );
size = mlt_image_format_size( format, width, height, NULL );
mlt_frame_set_image( frame, image, size, mlt_pool_release );
}
static void producer_close( mlt_producer producer )
{
producer_ktitle self = producer->child;
producer->close = NULL;
mlt_service_cache_purge( MLT_PRODUCER_SERVICE( producer ) );
mlt_producer_close( producer );
free( self );
}
static void producer_close( mlt_producer parent )
{
producer_qimage self = parent->child;
parent->close = NULL;
mlt_service_cache_purge( MLT_PRODUCER_SERVICE(parent) );
mlt_producer_close( parent );
mlt_properties_close( self->filenames );
free( self );
}
virtual HRESULT STDMETHODCALLTYPE VideoInputFormatChanged(
BMDVideoInputFormatChangedEvents events,
IDeckLinkDisplayMode* mode,
BMDDetectedVideoInputFormatFlags flags )
{
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( getProducer() ) );
if ( events & bmdVideoInputDisplayModeChanged )
{
BMDTimeValue duration;
BMDTimeScale timescale;
mode->GetFrameRate( &duration, ×cale );
profile->width = mode->GetWidth();
profile->height = mode->GetHeight() + m_vancLines;
profile->frame_rate_num = timescale;
profile->frame_rate_den = duration;
if ( profile->width == 720 )
{
if ( profile->height == 576 )
{
profile->sample_aspect_num = 16;
profile->sample_aspect_den = 15;
}
else
{
profile->sample_aspect_num = 8;
profile->sample_aspect_den = 9;
}
profile->display_aspect_num = 4;
profile->display_aspect_den = 3;
}
else
{
profile->sample_aspect_num = 1;
profile->sample_aspect_den = 1;
profile->display_aspect_num = 16;
profile->display_aspect_den = 9;
}
free( profile->description );
profile->description = strdup( "decklink" );
mlt_log_verbose( getProducer(), "format changed %dx%d %.3f fps\n",
profile->width, profile->height, (double) profile->frame_rate_num / profile->frame_rate_den );
}
if ( events & bmdVideoInputFieldDominanceChanged )
{
profile->progressive = mode->GetFieldDominance() == bmdProgressiveFrame;
m_topFieldFirst = mode->GetFieldDominance() == bmdUpperFieldFirst;
mlt_log_verbose( getProducer(), "field dominance changed prog %d tff %d\n",
profile->progressive, m_topFieldFirst );
}
if ( events & bmdVideoInputColorspaceChanged )
{
profile->colorspace = m_colorspace =
( mode->GetFlags() & bmdDisplayModeColorspaceRec709 ) ? 709 : 601;
mlt_log_verbose( getProducer(), "colorspace changed %d\n", profile->colorspace );
}
return S_OK;
}
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 int producer_get_image( mlt_frame frame, uint8_t** image, mlt_image_format* format, int* width, int* height, int writable )
{
mlt_producer producer = mlt_frame_pop_service( frame );
mlt_frame bg_frame = NULL;
mlt_frame text_frame = NULL;
int error = 1;
int size = 0;
char* background = mlt_properties_get( MLT_PRODUCER_PROPERTIES( producer ), "background" );
time_info info;
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
get_time_info( producer, frame, &info );
bg_frame = get_background_frame( producer );
if( !strcmp( background, "clock" ) )
{
add_clock_to_frame( producer, bg_frame, &info );
}
text_frame = get_text_frame( producer, &info );
add_text_to_bg( producer, bg_frame, text_frame );
if( bg_frame )
{
// Get the image from the background frame.
error = mlt_frame_get_image( bg_frame, image, format, width, height, writable );
size = mlt_image_format_size( *format, *width, *height, NULL );
// Detach the image from the bg_frame so it is not released.
mlt_frame_set_image( bg_frame, *image, size, NULL );
// Attach the image to the input frame.
mlt_frame_set_image( frame, *image, size, mlt_pool_release );
mlt_frame_close( bg_frame );
}
if( text_frame )
{
mlt_frame_close( text_frame );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return error;
}
static int producer_get_image( mlt_frame frame, uint8_t** buffer, mlt_image_format* format, int* width, int* height, int writable )
{
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = static_cast<mlt_producer>( mlt_properties_get_data( frame_properties, "_producer_qtext", NULL ) );
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
int img_size = 0;
int alpha_size = 0;
uint8_t* alpha = NULL;
QImage* qImg = static_cast<QImage*>( mlt_properties_get_data( producer_properties, "_qimg", NULL ) );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
// Regenerate the qimage if necessary
if( check_qimage( frame_properties ) == true )
{
generate_qimage( frame_properties );
}
*format = mlt_image_rgb24a;
*width = qImg->width();
*height = qImg->height();
// Allocate and fill the image buffer
img_size = mlt_image_format_size( *format, *width, *height, NULL );
*buffer = static_cast<uint8_t*>( mlt_pool_alloc( img_size ) );
copy_qimage_to_mlt_image( qImg, *buffer );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
// Allocate and fill the alpha buffer
alpha_size = *width * *height;
alpha = static_cast<uint8_t*>( mlt_pool_alloc( alpha_size ) );
copy_image_to_alpha( *buffer, alpha, *width, *height );
// Update the frame
mlt_frame_set_image( frame, *buffer, img_size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha, alpha_size, mlt_pool_release );
mlt_properties_set_int( frame_properties, "width", *width );
mlt_properties_set_int( frame_properties, "height", *height );
return 0;
}
int mlt_multitrack_insert( mlt_multitrack self, mlt_producer producer, int track )
{
if ( track >= self->count )
return mlt_multitrack_connect( self, producer, track );
// Connect to the producer to ourselves at the specified track
int result = mlt_service_insert_producer( MLT_MULTITRACK_SERVICE( self ), MLT_PRODUCER_SERVICE( producer ), track );
if ( result == 0 )
{
// Resize the producer list if needed.
if ( self->count + 1 > self->size )
{
int new_size = self->size + 10;
self->list = realloc( self->list, new_size * sizeof( mlt_track ) );
if ( self->list )
{
memset( &self->list[ self->size ], 0, new_size - self->size );
self->size = new_size;
}
}
if ( self->list )
{
// Move all of the list elements following track N down by 1.
memmove( &self->list[ track + 1 ], &self->list[ track ],
( self->count - track ) * sizeof ( mlt_track ) );
self->count ++;
// Assign the track in our list.
self->list[ track ] = malloc( sizeof( struct mlt_track_s ) );
self->list[ track ]->producer = producer;
self->list[ track ]->event = mlt_events_listen( MLT_PRODUCER_PROPERTIES( producer ), self,
"producer-changed", ( mlt_listener )mlt_multitrack_listener );
mlt_properties_inc_ref( MLT_PRODUCER_PROPERTIES( producer ) );
mlt_event_inc_ref( self->list[ track ]->event );
// TODO: Move this into producer_avformat.c when mlt_events broadcasting is available.
if ( self->count > mlt_service_cache_get_size( MLT_MULTITRACK_SERVICE( self ), "producer_avformat" ) )
mlt_service_cache_set_size( MLT_MULTITRACK_SERVICE( self ), "producer_avformat", self->count + 1 );
// Refresh our stats
mlt_multitrack_refresh( self );
}
else
{
result = -1;
}
}
return result;
}
mlt_producer producer_qimage_init( mlt_profile profile, mlt_service_type type, const char *id, char *filename )
{
producer_qimage self = calloc( sizeof( struct producer_qimage_s ), 1 );
if ( self != NULL && mlt_producer_init( &self->parent, self ) == 0 )
{
mlt_producer producer = &self->parent;
// Get the properties interface
mlt_properties properties = MLT_PRODUCER_PROPERTIES( &self->parent );
// Callback registration
#ifdef USE_KDE
init_qimage();
#endif
producer->get_frame = producer_get_frame;
producer->close = ( mlt_destructor )producer_close;
// Set the default properties
mlt_properties_set( properties, "resource", filename );
mlt_properties_set_int( properties, "ttl", 25 );
mlt_properties_set_int( properties, "aspect_ratio", 1 );
mlt_properties_set_int( properties, "progressive", 1 );
mlt_properties_set_int( properties, "seekable", 1 );
// Validate the resource
if ( filename )
load_filenames( self, properties );
if ( self->count )
{
mlt_frame frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
if ( frame )
{
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_properties_set_data( frame_properties, "producer_qimage", self, 0, NULL, NULL );
mlt_frame_set_position( frame, mlt_producer_position( producer ) );
mlt_properties_set_position( frame_properties, "qimage_position", mlt_producer_position( producer ) );
refresh_qimage( self, frame );
mlt_cache_item_close( self->qimage_cache );
mlt_frame_close( frame );
}
}
if ( self->current_width == 0 )
{
producer_close( producer );
producer = NULL;
}
return producer;
}
free( self );
return NULL;
}
int mlt_multitrack_connect( mlt_multitrack self, mlt_producer producer, int track )
{
// Connect to the producer to ourselves at the specified track
int result = mlt_service_connect_producer( MLT_MULTITRACK_SERVICE( self ), MLT_PRODUCER_SERVICE( producer ), track );
if ( result == 0 )
{
mlt_track current_track = ( track < self->count )? self->list[ track ] : NULL;
// Resize the producer list if need be
if ( track >= self->size )
{
int i;
self->list = realloc( self->list, ( track + 10 ) * sizeof( mlt_track ) );
for ( i = self->size; i < track + 10; i ++ )
self->list[ i ] = NULL;
self->size = track + 10;
}
if ( current_track )
{
mlt_event_close( current_track->event );
mlt_producer_close( current_track->producer );
}
else
{
self->list[ track ] = malloc( sizeof( struct mlt_track_s ) );
}
// Assign the track in our list here
self->list[ track ]->producer = producer;
self->list[ track ]->event = mlt_events_listen( MLT_PRODUCER_PROPERTIES( producer ), self,
"producer-changed", ( mlt_listener )mlt_multitrack_listener );
mlt_properties_inc_ref( MLT_PRODUCER_PROPERTIES( producer ) );
mlt_event_inc_ref( self->list[ track ]->event );
// Increment the track count if need be
if ( track >= self->count )
{
self->count = track + 1;
// TODO: Move this into producer_avformat.c when mlt_events broadcasting is available.
if ( self->count > mlt_service_cache_get_size( MLT_MULTITRACK_SERVICE( self ), "producer_avformat" ) )
mlt_service_cache_set_size( MLT_MULTITRACK_SERVICE( self ), "producer_avformat", self->count + 1 );
}
// Refresh our stats
mlt_multitrack_refresh( self );
}
return result;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
// Obtain properties of frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Obtain the producer for this frame
mlt_producer producer = mlt_properties_get_data( properties, "producer_frei0r", NULL );
// Obtain properties of producer
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Choose suitable out values if nothing specific requested
if ( *width <= 0 )
*width = mlt_service_profile( MLT_PRODUCER_SERVICE(producer) )->width;
if ( *height <= 0 )
*height = mlt_service_profile( MLT_PRODUCER_SERVICE(producer) )->height;
// Allocate the image
int size = *width * ( *height + 1 ) * 4;
// Allocate the image
*buffer = mlt_pool_alloc( size );
// Update the frame
mlt_frame_set_image( frame, *buffer, size, mlt_pool_release );
*format = mlt_image_rgb24a;
if ( *buffer != NULL )
{
double position = mlt_frame_get_position( frame );
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
double time = position / mlt_profile_fps( profile );
process_frei0r_item( MLT_PRODUCER_SERVICE(producer), position, time, producer_props, frame, buffer, width, height );
}
return 0;
}
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_profile profile = mlt_service_profile ( MLT_PRODUCER_SERVICE( producer ) ) ;
mlt_properties_set_int( properties, "progressive", ( profile ) ? profile->progressive : 1 );
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 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;
}
static mlt_frame get_background_frame( mlt_producer producer )
{
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_frame bg_frame = NULL;
mlt_producer color_producer = mlt_properties_get_data( producer_properties, "_color_producer", NULL );
if( !color_producer )
{
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
color_producer = mlt_factory_producer( profile, mlt_environment( "MLT_PRODUCER" ), "colour:" );
mlt_properties_set_data( producer_properties, "_color_producer", color_producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
mlt_properties color_properties = MLT_PRODUCER_PROPERTIES( color_producer );
mlt_properties_set( color_properties, "colour", FRAME_BACKGROUND_COLOR );
}
if( color_producer )
{
mlt_producer_seek( color_producer, 0 );
mlt_service_get_frame( MLT_PRODUCER_SERVICE( color_producer ), &bg_frame, 0 );
}
return bg_frame;
}
mlt_service MLTWebVfx::createProducer(mlt_profile profile) {
mlt_producer producer = mlt_producer_new(profile);
if (producer) {
producer->get_frame = getFrame;
producer->close = (mlt_destructor) producer_close;
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_properties_set_int( properties, "meta.media.progressive", 1 );
mlt_properties_set_int( properties, "meta.media.sample_aspect_num", 1 );
mlt_properties_set_int( properties, "meta.media.sample_aspect_den", 1 );
mlt_properties_set_int(properties, "meta.media.width", profile->width);
mlt_properties_set_int(properties, "meta.media.height", profile->height);
return MLT_PRODUCER_SERVICE(producer);
}
return 0;
}
static void vdpau_release_buffer( AVCodecContext *codec_context, AVFrame *frame )
{
producer_avformat self = codec_context->opaque;
if ( self->vdpau )
{
struct vdpau_render_state *render = (struct vdpau_render_state*) frame->data[0];
mlt_log_debug( MLT_PRODUCER_SERVICE(self->parent), "vdpau_release_buffer (%x)\n", render->surface );
int i;
render->state &= ~FF_VDPAU_STATE_USED_FOR_REFERENCE;
for ( i = 0; i < 4; i++ )
frame->data[i] = NULL;
mlt_deque_push_back( self->vdpau->deque, render );
}
}
/** Get the image.
*/
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
mlt_filter filter = mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_producer producer = mlt_properties_get_data( properties, "_producer", NULL );
mlt_transition transition = mlt_properties_get_data( properties, "_transition", NULL );
mlt_frame text_frame = NULL;
mlt_position position = 0;
// Configure this filter
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
setup_producer( filter, producer, frame );
setup_transition( filter, transition );
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
// Make sure the producer is in the correct position
position = mlt_filter_get_position( filter, frame );
mlt_producer_seek( producer, position );
// Get the b frame and process with transition if successful
if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &text_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( text_frame );
// Set the frame and text_frame to be in the same position and have same consumer requirements
mlt_frame_set_position( text_frame, position );
mlt_frame_set_position( frame, position );
mlt_properties_set_int( b_props, "consumer_deinterlace", mlt_properties_get_int( a_props, "consumer_deinterlace" ) );
// Apply all filters that are attached to this filter to the b frame
mlt_service_apply_filters( MLT_FILTER_SERVICE( filter ), text_frame, 0 );
// Process the frame
mlt_transition_process( transition, frame, text_frame );
// Get the image
*format = mlt_image_yuv422;
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Close the b frame
mlt_frame_close( text_frame );
}
return error;
}
