static void consumer_work_stop( mlt_consumer self )
{
// Make sure we're running
if ( self->started )
{
// Inform thread to stop
self->ahead = 0;
// Broadcast to the queue condition in case it's waiting
pthread_mutex_lock( &self->queue_mutex );
pthread_cond_broadcast( &self->queue_cond );
pthread_mutex_unlock( &self->queue_mutex );
// Broadcast to the put condition in case it's waiting
pthread_mutex_lock( &self->put_mutex );
pthread_cond_broadcast( &self->put_cond );
pthread_mutex_unlock( &self->put_mutex );
// Broadcast to the done condition in case it's waiting
pthread_mutex_lock( &self->done_mutex );
pthread_cond_broadcast( &self->done_cond );
pthread_mutex_unlock( &self->done_mutex );
// Join the threads
pthread_t *thread;
while ( ( thread = mlt_deque_pop_back( self->worker_threads ) ) )
pthread_join( *thread, NULL );
// Deallocate the array of threads
if ( self->threads )
free( self->threads );
// Indicate that worker threads no longer running
self->started = 0;
// Destroy the mutexes
pthread_mutex_destroy( &self->queue_mutex );
pthread_mutex_destroy( &self->done_mutex );
// Destroy the conditions
pthread_cond_destroy( &self->queue_cond );
pthread_cond_destroy( &self->done_cond );
// Wipe the queues
while ( mlt_deque_count( self->queue ) )
mlt_frame_close( mlt_deque_pop_back( self->queue ) );
// Close the queues
mlt_deque_close( self->queue );
mlt_deque_close( self->worker_threads );
}
}
dv_decoder_t *dv_decoder_alloc( )
{
// We'll return a dv_decoder
dv_decoder_t *this = NULL;
// Lock the mutex
pthread_mutex_lock( &decoder_lock );
// Create the properties if necessary
if ( dv_decoders == NULL )
{
// Create the properties
dv_decoders = mlt_properties_new( );
// Create the stack
mlt_properties_set_data( dv_decoders, "stack", mlt_deque_init( ), 0, ( mlt_destructor )mlt_deque_close, NULL );
// Register the properties for clean up
mlt_factory_register_for_clean_up( dv_decoders, ( mlt_destructor )mlt_properties_close );
}
// Now try to obtain a decoder
if ( dv_decoders != NULL )
{
// Obtain the stack
mlt_deque stack = mlt_properties_get_data( dv_decoders, "stack", NULL );
// Pop the top of the stack
this = mlt_deque_pop_back( stack );
// Create a new decoder if none available
if ( this == NULL )
{
// We'll need a unique property ID for this
char label[ 256 ];
// Configure the decoder
this = dv_decoder_new( FALSE, FALSE, FALSE );
this->quality = DV_QUALITY_COLOR | DV_QUALITY_AC_2;
this->audio->arg_audio_emphasis = 2;
dv_set_audio_correction( this, DV_AUDIO_CORRECT_AVERAGE );
dv_set_error_log( this, NULL );
// Register it with the properties to ensure clean up
sprintf( label, "%p", this );
mlt_properties_set_data( dv_decoders, label, this, 0, ( mlt_destructor )dv_decoder_free, NULL );
}
}
// Unlock the mutex
pthread_mutex_unlock( &decoder_lock );
return this;
}
void mlt_consumer_purge( mlt_consumer self )
{
if ( self && self->ahead )
{
pthread_mutex_lock( &self->queue_mutex );
while ( mlt_deque_count( self->queue ) )
mlt_frame_close( mlt_deque_pop_back( self->queue ) );
pthread_cond_broadcast( &self->queue_cond );
pthread_mutex_unlock( &self->queue_mutex );
}
}
void mlt_frame_replace_image( mlt_frame self, uint8_t *image, mlt_image_format format, int width, int height )
{
// Remove all items from the stack
while( mlt_deque_pop_back( self->stack_image ) ) ;
// Update the information
mlt_properties_set_data( MLT_FRAME_PROPERTIES( self ), "image", image, 0, NULL, NULL );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( self ), "width", width );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( self ), "height", height );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( self ), "format", format );
self->get_alpha_mask = NULL;
}
void consumer_purge( mlt_consumer parent )
{
consumer_sdl self = parent->child;
if ( self->running )
{
pthread_mutex_lock( &self->video_mutex );
while ( mlt_deque_count( self->queue ) )
mlt_frame_close( mlt_deque_pop_back( self->queue ) );
self->is_purge = 1;
pthread_cond_broadcast( &self->video_cond );
pthread_mutex_unlock( &self->video_mutex );
}
}
void mlt_frame_close( mlt_frame self )
{
if ( self != NULL && mlt_properties_dec_ref( MLT_FRAME_PROPERTIES( self ) ) <= 0 )
{
mlt_deque_close( self->stack_image );
mlt_deque_close( self->stack_audio );
while( mlt_deque_peek_back( self->stack_service ) )
mlt_service_close( mlt_deque_pop_back( self->stack_service ) );
mlt_deque_close( self->stack_service );
mlt_properties_close( &self->parent );
free( self );
}
}
static void destroy_data_queue( void *arg )
{
if ( arg != NULL )
{
// Assign the correct type
mlt_deque queue = arg;
// Iterate through each item and destroy them
while ( mlt_deque_peek_front( queue ) != NULL )
mlt_properties_close( mlt_deque_pop_back( queue ) );
// Close the deque
mlt_deque_close( queue );
}
}
void stop()
{
// Stop the audio and video output streams immediately
if ( m_deckLinkOutput )
{
m_deckLinkOutput->StopScheduledPlayback( 0, 0, 0 );
m_deckLinkOutput->DisableAudioOutput();
m_deckLinkOutput->DisableVideoOutput();
}
while ( mlt_deque_count( m_videoFrameQ ) )
{
m_videoFrame = (IDeckLinkMutableVideoFrame*) mlt_deque_pop_back( m_videoFrameQ );
m_videoFrame->Release();
}
m_videoFrame = 0;
if ( m_fifo ) sample_fifo_close( m_fifo );
}
void consumer_purge( mlt_consumer parent )
{
consumer_sdl self = parent->child;
if ( self->running )
{
pthread_mutex_lock( &self->video_mutex );
mlt_frame frame = MLT_FRAME( mlt_deque_peek_back( self->queue ) );
// When playing rewind or fast forward then we need to keep one
// frame in the queue to prevent playback stalling.
double speed = frame? mlt_properties_get_double( MLT_FRAME_PROPERTIES(frame), "_speed" ) : 0;
int n = ( speed == 0.0 || speed == 1.0 ) ? 0 : 1;
while ( mlt_deque_count( self->queue ) > n )
mlt_frame_close( mlt_deque_pop_back( self->queue ) );
self->is_purge = 1;
pthread_cond_broadcast( &self->video_cond );
pthread_mutex_unlock( &self->video_mutex );
}
}
void stop()
{
if ( !m_started )
return;
m_started = false;
// Release the wait in getFrame
pthread_mutex_lock( &m_mutex );
pthread_cond_broadcast( &m_condition );
pthread_mutex_unlock( &m_mutex );
m_decklinkInput->StopStreams();
m_decklinkInput->DisableVideoInput();
m_decklinkInput->DisableAudioInput();
// Cleanup queue
pthread_mutex_lock( &m_mutex );
while ( mlt_frame frame = (mlt_frame) mlt_deque_pop_back( m_queue ) )
mlt_frame_close( frame );
pthread_mutex_unlock( &m_mutex );
}
static void consumer_read_ahead_stop( mlt_consumer self )
{
// Make sure we're running
if ( self->started )
{
// Inform thread to stop
self->ahead = 0;
// Broadcast to the condition in case it's waiting
pthread_mutex_lock( &self->queue_mutex );
pthread_cond_broadcast( &self->queue_cond );
pthread_mutex_unlock( &self->queue_mutex );
// Broadcast to the put condition in case it's waiting
pthread_mutex_lock( &self->put_mutex );
pthread_cond_broadcast( &self->put_cond );
pthread_mutex_unlock( &self->put_mutex );
// Join the thread
pthread_join( self->ahead_thread, NULL );
self->started = 0;
// Destroy the frame queue mutex
pthread_mutex_destroy( &self->queue_mutex );
// Destroy the condition
pthread_cond_destroy( &self->queue_cond );
// Wipe the queue
while ( mlt_deque_count( self->queue ) )
mlt_frame_close( mlt_deque_pop_back( self->queue ) );
// Close the queue
mlt_deque_close( self->queue );
}
}
static void *consumer_thread( void *arg )
{
// Identify the arg
consumer_sdl self = arg;
// Get the consumer
mlt_consumer consumer = &self->parent;
// Get the properties
mlt_properties consumer_props = MLT_CONSUMER_PROPERTIES( consumer );
// Video thread
pthread_t thread;
// internal intialization
int init_audio = 1;
int init_video = 1;
mlt_frame frame = NULL;
mlt_properties properties = NULL;
int duration = 0;
int64_t playtime = 0;
struct timespec tm = { 0, 100000 };
// int last_position = -1;
pthread_mutex_lock( &self->refresh_mutex );
self->refresh_count = 0;
pthread_mutex_unlock( &self->refresh_mutex );
// Loop until told not to
while( self->running )
{
// Get a frame from the attached producer
frame = mlt_consumer_rt_frame( consumer );
// Ensure that we have a frame
if ( frame )
{
// Get the frame properties
properties = MLT_FRAME_PROPERTIES( frame );
// Get the speed of the frame
double speed = mlt_properties_get_double( properties, "_speed" );
// Get refresh request for the current frame
int refresh = mlt_properties_get_int( consumer_props, "refresh" );
// Clear refresh
mlt_events_block( consumer_props, consumer_props );
mlt_properties_set_int( consumer_props, "refresh", 0 );
mlt_events_unblock( consumer_props, consumer_props );
// Play audio
init_audio = consumer_play_audio( self, frame, init_audio, &duration );
// Determine the start time now
if ( self->playing && init_video )
{
// Create the video thread
pthread_create( &thread, NULL, video_thread, self );
// Video doesn't need to be initialised any more
init_video = 0;
}
// Set playtime for this frame
mlt_properties_set_int( properties, "playtime", playtime );
while ( self->running && speed != 0 && mlt_deque_count( self->queue ) > 15 )
nanosleep( &tm, NULL );
// Push this frame to the back of the queue
if ( self->running && speed )
{
pthread_mutex_lock( &self->video_mutex );
mlt_deque_push_back( self->queue, frame );
pthread_cond_broadcast( &self->video_cond );
pthread_mutex_unlock( &self->video_mutex );
// Calculate the next playtime
playtime += ( duration * 1000 );
}
else if ( self->running )
{
pthread_mutex_lock( &self->refresh_mutex );
if ( refresh == 0 && self->refresh_count <= 0 )
{
consumer_play_video( self, frame );
pthread_cond_wait( &self->refresh_cond, &self->refresh_mutex );
}
mlt_frame_close( frame );
self->refresh_count --;
pthread_mutex_unlock( &self->refresh_mutex );
}
else
{
mlt_frame_close( frame );
frame = NULL;
}
// Optimisation to reduce latency
if ( frame && speed == 1.0 )
{
// TODO: disabled due to misbehavior on parallel-consumer
// if ( last_position != -1 && last_position + 1 != mlt_frame_get_position( frame ) )
// mlt_consumer_purge( consumer );
// last_position = mlt_frame_get_position( frame );
}
else
{
mlt_consumer_purge( consumer );
// last_position = -1;
}
}
}
// Kill the video thread
if ( init_video == 0 )
{
pthread_mutex_lock( &self->video_mutex );
pthread_cond_broadcast( &self->video_cond );
pthread_mutex_unlock( &self->video_mutex );
pthread_join( thread, NULL );
}
while( mlt_deque_count( self->queue ) )
mlt_frame_close( mlt_deque_pop_back( self->queue ) );
self->audio_avail = 0;
return NULL;
}
static void *consumer_thread( void *arg )
{
// Identify the arg
consumer_sdl self = arg;
// Get the consumer
mlt_consumer consumer = &self->parent;
// Convenience functionality
int terminate_on_pause = mlt_properties_get_int( MLT_CONSUMER_PROPERTIES( consumer ), "terminate_on_pause" );
int terminated = 0;
// Video thread
pthread_t thread;
// internal intialization
int init_audio = 1;
int init_video = 1;
mlt_frame frame = NULL;
int duration = 0;
int64_t playtime = 0;
struct timespec tm = { 0, 100000 };
// Loop until told not to
while( self->running )
{
// Get a frame from the attached producer
frame = !terminated? mlt_consumer_rt_frame( consumer ) : NULL;
// Check for termination
if ( terminate_on_pause && frame )
terminated = mlt_properties_get_double( MLT_FRAME_PROPERTIES( frame ), "_speed" ) == 0.0;
// Ensure that we have a frame
if ( frame )
{
// Play audio
init_audio = consumer_play_audio( self, frame, init_audio, &duration );
// Determine the start time now
if ( self->playing && init_video )
{
// Create the video thread
pthread_create( &thread, NULL, video_thread, self );
// Video doesn't need to be initialised any more
init_video = 0;
}
// Set playtime for this frame
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "playtime", playtime );
while ( self->running && mlt_deque_count( self->queue ) > 15 )
nanosleep( &tm, NULL );
// Push this frame to the back of the queue
pthread_mutex_lock( &self->video_mutex );
if ( self->is_purge )
{
mlt_frame_close( frame );
frame = NULL;
self->is_purge = 0;
}
else
{
mlt_deque_push_back( self->queue, frame );
pthread_cond_broadcast( &self->video_cond );
}
pthread_mutex_unlock( &self->video_mutex );
// Calculate the next playtime
playtime += ( duration * 1000 );
}
else if ( terminated )
{
if ( init_video || mlt_deque_count( self->queue ) == 0 )
break;
else
nanosleep( &tm, NULL );
}
}
self->running = 0;
// Unblock sdl_preview
if ( mlt_properties_get_int( MLT_CONSUMER_PROPERTIES( consumer ), "put_mode" ) &&
mlt_properties_get_int( MLT_CONSUMER_PROPERTIES( consumer ), "put_pending" ) )
{
frame = mlt_consumer_get_frame( consumer );
if ( frame )
mlt_frame_close( frame );
frame = NULL;
}
// Kill the video thread
if ( init_video == 0 )
{
pthread_mutex_lock( &self->video_mutex );
pthread_cond_broadcast( &self->video_cond );
pthread_mutex_unlock( &self->video_mutex );
pthread_join( thread, NULL );
}
while( mlt_deque_count( self->queue ) )
mlt_frame_close( mlt_deque_pop_back( self->queue ) );
self->audio_avail = 0;
return NULL;
}
HRESULT render( mlt_frame frame )
{
HRESULT result = S_OK;
// Get the audio
double speed = mlt_properties_get_double( MLT_FRAME_PROPERTIES(frame), "_speed" );
if ( speed == 1.0 )
{
mlt_audio_format format = mlt_audio_s16;
int frequency = bmdAudioSampleRate48kHz;
int samples = mlt_sample_calculator( m_fps, frequency, m_count );
int16_t *pcm = 0;
if ( !mlt_frame_get_audio( frame, (void**) &pcm, &format, &frequency, &m_channels, &samples ) )
{
int count = samples;
if ( !m_isPrerolling )
{
uint32_t audioCount = 0;
uint32_t videoCount = 0;
// Check for resync
m_deckLinkOutput->GetBufferedAudioSampleFrameCount( &audioCount );
m_deckLinkOutput->GetBufferedVideoFrameCount( &videoCount );
// Underflow typically occurs during non-normal speed playback.
if ( audioCount < 1 || videoCount < 1 )
{
// Upon switching to normal playback, buffer some frames faster than realtime.
mlt_log_info( &m_consumer, "buffer underrun: audio buf %u video buf %u frames\n", audioCount, videoCount );
m_prerollCounter = 0;
}
// While rebuffering
if ( isBuffering() )
{
// Only append audio to reach the ideal level and not overbuffer.
int ideal = ( m_preroll - 1 ) * bmdAudioSampleRate48kHz / m_fps;
int actual = m_fifo->used / m_channels + audioCount;
int diff = ideal / 2 - actual;
count = diff < 0 ? 0 : diff < count ? diff : count;
}
}
if ( count > 0 )
sample_fifo_append( m_fifo, pcm, count * m_channels );
}
}
// Create video frames while pre-rolling
if ( m_isPrerolling )
{
createFrame();
if ( !m_videoFrame )
{
mlt_log_error( &m_consumer, "failed to create video frame\n" );
return S_FALSE;
}
}
// Get the video
if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES( frame ), "rendered") )
{
mlt_image_format format = mlt_image_yuv422;
uint8_t* image = 0;
uint8_t* buffer = 0;
if ( !mlt_frame_get_image( frame, &image, &format, &m_width, &m_height, 0 ) )
{
m_videoFrame = (IDeckLinkMutableVideoFrame*) mlt_deque_pop_back( m_videoFrameQ );
m_videoFrame->GetBytes( (void**) &buffer );
if ( m_displayMode->GetFieldDominance() == bmdUpperFieldFirst )
// convert lower field first to top field first
swab( image, buffer + m_width * 2, m_width * ( m_height - 1 ) * 2 );
else
swab( image, buffer, m_width * m_height * 2 );
m_deckLinkOutput->ScheduleVideoFrame( m_videoFrame, m_count * m_duration, m_duration, m_timescale );
mlt_deque_push_front( m_videoFrameQ, m_videoFrame );
}
}
else
{
mlt_log_verbose( &m_consumer, "dropped video frame\n" );
}
++m_count;
// Check for end of pre-roll
if ( ++m_prerollCounter > m_preroll && m_isPrerolling )
{
// Start audio and video output
m_deckLinkOutput->EndAudioPreroll();
m_deckLinkOutput->StartScheduledPlayback( 0, m_timescale, 1.0 );
m_isPrerolling = false;
}
return result;
}
static track_info *pop( mlt_parser self )
{
mlt_properties properties = mlt_parser_properties( self );
mlt_deque stack = mlt_properties_get_data( properties, "stack", NULL );
return mlt_deque_pop_back( stack );
}
static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int track )
{
mlt_tractor self = parent->child;
// We only respond to the first track requests
if ( track == 0 && self->producer != NULL )
{
int i = 0;
int done = 0;
mlt_frame temp = NULL;
int count = 0;
int image_count = 0;
// Get the properties of the parent producer
mlt_properties properties = MLT_PRODUCER_PROPERTIES( parent );
// Try to obtain the multitrack associated to the tractor
mlt_multitrack multitrack = mlt_properties_get_data( properties, "multitrack", NULL );
// Or a specific producer
mlt_producer producer = mlt_properties_get_data( properties, "producer", NULL );
// Determine whether this tractor feeds to the consumer or stops here
int global_feed = mlt_properties_get_int( properties, "global_feed" );
// If we don't have one, we're in trouble...
if ( multitrack != NULL )
{
// The output frame will hold the 'global' data feeds (ie: those which are targetted for the final frame)
mlt_deque data_queue = mlt_deque_init( );
// Used to garbage collect all frames
char label[ 30 ];
// Get the id of the tractor
char *id = mlt_properties_get( properties, "_unique_id" );
// Will be used to store the frame properties object
mlt_properties frame_properties = NULL;
// We'll store audio and video frames to use here
mlt_frame audio = NULL;
mlt_frame video = NULL;
mlt_frame first_video = NULL;
// Temporary properties
mlt_properties temp_properties = NULL;
// Get the multitrack's producer
mlt_producer target = MLT_MULTITRACK_PRODUCER( multitrack );
mlt_producer_seek( target, mlt_producer_frame( parent ) );
mlt_producer_set_speed( target, mlt_producer_get_speed( parent ) );
// We will create one frame and attach everything to it
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( parent ) );
// Get the properties of the frame
frame_properties = MLT_FRAME_PROPERTIES( *frame );
// Loop through each of the tracks we're harvesting
for ( i = 0; !done; i ++ )
{
// Get a frame from the producer
mlt_service_get_frame( self->producer, &temp, i );
// Get the temporary properties
temp_properties = MLT_FRAME_PROPERTIES( temp );
// Pass all unique meta properties from the producer's frame to the new frame
mlt_properties_lock( temp_properties );
int props_count = mlt_properties_count( temp_properties );
int j;
for ( j = 0; j < props_count; j ++ )
{
char *name = mlt_properties_get_name( temp_properties, j );
if ( !strncmp( name, "meta.", 5 ) && !mlt_properties_get( frame_properties, name ) )
mlt_properties_set( frame_properties, name, mlt_properties_get_value( temp_properties, j ) );
}
mlt_properties_unlock( temp_properties );
// Copy the format conversion virtual functions
if ( ! (*frame)->convert_image && temp->convert_image )
(*frame)->convert_image = temp->convert_image;
if ( ! (*frame)->convert_audio && temp->convert_audio )
(*frame)->convert_audio = temp->convert_audio;
// Check for last track
done = mlt_properties_get_int( temp_properties, "last_track" );
// Handle fx only tracks
if ( mlt_properties_get_int( temp_properties, "fx_cut" ) )
{
int hide = ( video == NULL ? 1 : 0 ) | ( audio == NULL ? 2 : 0 );
mlt_properties_set_int( temp_properties, "hide", hide );
}
// We store all frames with a destructor on the output frame
sprintf( label, "_%s_%d", id, count ++ );
mlt_properties_set_data( frame_properties, label, temp, 0, ( mlt_destructor )mlt_frame_close, NULL );
// We want to append all 'final' feeds to the global queue
if ( !done && mlt_properties_get_data( temp_properties, "data_queue", NULL ) != NULL )
{
// Move the contents of this queue on to the output frames data queue
mlt_deque sub_queue = mlt_properties_get_data( MLT_FRAME_PROPERTIES( temp ), "data_queue", NULL );
mlt_deque temp = mlt_deque_init( );
while ( global_feed && mlt_deque_count( sub_queue ) )
{
mlt_properties p = mlt_deque_pop_back( sub_queue );
if ( mlt_properties_get_int( p, "final" ) )
mlt_deque_push_back( data_queue, p );
else
mlt_deque_push_back( temp, p );
}
while( mlt_deque_count( temp ) )
mlt_deque_push_front( sub_queue, mlt_deque_pop_back( temp ) );
mlt_deque_close( temp );
}
// Now do the same with the global queue but without the conditional behaviour
if ( mlt_properties_get_data( temp_properties, "global_queue", NULL ) != NULL )
{
mlt_deque sub_queue = mlt_properties_get_data( MLT_FRAME_PROPERTIES( temp ), "global_queue", NULL );
while ( mlt_deque_count( sub_queue ) )
{
mlt_properties p = mlt_deque_pop_back( sub_queue );
mlt_deque_push_back( data_queue, p );
}
}
// Pick up first video and audio frames
if ( !done && !mlt_frame_is_test_audio( temp ) && !( mlt_properties_get_int( temp_properties, "hide" ) & 2 ) )
{
// Order of frame creation is starting to get problematic
if ( audio != NULL )
{
mlt_deque_push_front( MLT_FRAME_AUDIO_STACK( temp ), producer_get_audio );
mlt_deque_push_front( MLT_FRAME_AUDIO_STACK( temp ), audio );
}
audio = temp;
}
if ( !done && !mlt_frame_is_test_card( temp ) && !( mlt_properties_get_int( temp_properties, "hide" ) & 1 ) )
{
if ( video != NULL )
{
mlt_deque_push_front( MLT_FRAME_IMAGE_STACK( temp ), producer_get_image );
mlt_deque_push_front( MLT_FRAME_IMAGE_STACK( temp ), video );
}
video = temp;
if ( first_video == NULL )
first_video = temp;
mlt_properties_set_int( MLT_FRAME_PROPERTIES( temp ), "image_count", ++ image_count );
image_count = 1;
}
}
// Now stack callbacks
if ( audio != NULL )
{
mlt_frame_push_audio( *frame, audio );
mlt_frame_push_audio( *frame, producer_get_audio );
}
if ( video != NULL )
{
mlt_properties video_properties = MLT_FRAME_PROPERTIES( first_video );
mlt_frame_push_service( *frame, video );
mlt_frame_push_service( *frame, producer_get_image );
if ( global_feed )
mlt_properties_set_data( frame_properties, "data_queue", data_queue, 0, NULL, NULL );
mlt_properties_set_data( video_properties, "global_queue", data_queue, 0, destroy_data_queue, NULL );
mlt_properties_set_int( frame_properties, "width", mlt_properties_get_int( video_properties, "width" ) );
mlt_properties_set_int( frame_properties, "height", mlt_properties_get_int( video_properties, "height" ) );
mlt_properties_pass_list( frame_properties, video_properties, "meta.media.width, meta.media.height" );
mlt_properties_set_int( frame_properties, "progressive", mlt_properties_get_int( video_properties, "progressive" ) );
mlt_properties_set_double( frame_properties, "aspect_ratio", mlt_properties_get_double( video_properties, "aspect_ratio" ) );
mlt_properties_set_int( frame_properties, "image_count", image_count );
mlt_properties_set_data( frame_properties, "_producer", mlt_frame_get_original_producer( first_video ), 0, NULL, NULL );
}
else
{
destroy_data_queue( data_queue );
}
mlt_frame_set_position( *frame, mlt_producer_frame( parent ) );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( *frame ), "test_audio", audio == NULL );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( *frame ), "test_image", video == NULL );
}
else if ( producer != NULL )
{
mlt_producer_seek( producer, mlt_producer_frame( parent ) );
mlt_producer_set_speed( producer, mlt_producer_get_speed( parent ) );
mlt_service_get_frame( self->producer, frame, track );
}
else
{
mlt_log( MLT_PRODUCER_SERVICE( parent ), MLT_LOG_ERROR, "tractor without a multitrack!!\n" );
mlt_service_get_frame( self->producer, frame, track );
}
// Prepare the next frame
mlt_producer_prepare_next( parent );
// Indicate our found status
return 0;
}
else
{
// Generate a test card
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( parent ) );
return 0;
}
}
mlt_frame mlt_frame_pop_frame( mlt_frame self )
{
return mlt_deque_pop_back( self->stack_image );
}
void *mlt_frame_pop_audio( mlt_frame self )
{
return mlt_deque_pop_back( self->stack_audio );
}
void *mlt_frame_pop_service( mlt_frame self )
{
return mlt_deque_pop_back( self->stack_image );
}
