static int get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
context cx = mlt_frame_pop_audio( frame );
mlt_frame nested_frame = mlt_frame_pop_audio( frame );
int result = 0;
// if not repeating last frame
if ( mlt_frame_get_position( nested_frame ) != cx->audio_position )
{
double fps = mlt_profile_fps( cx->profile );
if ( mlt_producer_get_fps( cx->self ) < fps )
fps = mlt_producer_get_fps( cx->self );
*samples = mlt_sample_calculator( fps, *frequency, cx->audio_counter++ );
result = mlt_frame_get_audio( nested_frame, buffer, format, frequency, channels, samples );
int size = mlt_audio_format_size( *format, *samples, *channels );
int16_t *new_buffer = mlt_pool_alloc( size );
mlt_frame_set_audio( frame, new_buffer, *format, size, mlt_pool_release );
memcpy( new_buffer, *buffer, size );
*buffer = new_buffer;
cx->audio_position = mlt_frame_get_position( nested_frame );
}
else
{
// otherwise return no samples
*samples = 0;
*buffer = NULL;
}
return result;
}
static int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
mlt_filter filter = mlt_frame_pop_audio( frame );
private_data* pdata = (private_data*)filter->child;
mlt_position pos = mlt_frame_get_position( frame );
// Get the producer's audio
*format = mlt_audio_f32le;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
check_for_reset( filter, *channels, *frequency );
if( pos != pdata->prev_pos )
{
// Only analyze the audio if the producer is not paused.
analyze_audio( filter, *buffer, *samples );
}
pdata->prev_pos = pos;
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
return 0;
}
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 );
}
}
}
}
}
static int filter_get_frame( mlt_service service, mlt_frame_ptr frame, int index )
{
mlt_filter self = service->child;
// Get coords in/out/track
int track = mlt_filter_get_track( self );
int in = mlt_filter_get_in( self );
int out = mlt_filter_get_out( self );
// Get the producer this is connected to
mlt_service producer = mlt_service_producer( &self->parent );
// If the frame request is for this filters track, we need to process it
if ( index == track || track == -1 )
{
int ret = mlt_service_get_frame( producer, frame, index );
if ( ret == 0 )
{
mlt_position position = mlt_frame_get_position( *frame );
if ( position >= in && ( out == 0 || position <= out ) )
*frame = mlt_filter_process( self, *frame );
return 0;
}
else
{
*frame = mlt_frame_init( service );
return 0;
}
}
else
{
return mlt_service_get_frame( producer, frame, index );
}
}
static void get_frame_str( mlt_filter filter, mlt_frame frame, char* text )
{
int pos = mlt_frame_get_position( frame );
char s[12];
snprintf( s, sizeof( s ) - 1, "%d", pos );
strncat( text, s, MAX_TEXT_LEN - strlen( text ) - 1 );
}
double mlt_transition_get_progress_delta( mlt_transition self, mlt_frame frame )
{
double progress = 0;
mlt_position in = mlt_transition_get_in( self );
mlt_position out = mlt_transition_get_out( self );
if ( out == 0 )
{
// If always active, use the frame's producer
mlt_producer producer = mlt_frame_get_original_producer( frame );
if ( producer )
{
in = mlt_producer_get_in( producer );
out = mlt_producer_get_out( producer );
}
}
if ( out != 0 )
{
mlt_position position = mlt_frame_get_position( frame );
double length = out - in + 1;
double x = ( double ) ( position - in ) / length;
double y = ( double ) ( position + 1 - in ) / length;
progress = ( y - x ) / 2.0;
}
return progress;
}
static int jackrack_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the filter properties
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
int jack_frequency = mlt_properties_get_int( filter_properties, "_sample_rate" );
// Get the producer's audio
*format = mlt_audio_float;
mlt_frame_get_audio( frame, buffer, format, &jack_frequency, channels, samples );
// TODO: Deal with sample rate differences
if ( *frequency != jack_frequency )
mlt_log_error( MLT_FILTER_SERVICE( filter ), "mismatching frequencies JACK = %d actual = %d\n",
jack_frequency, *frequency );
*frequency = jack_frequency;
// Initialise Jack ports and connections if needed
if ( mlt_properties_get_int( filter_properties, "_samples" ) == 0 )
mlt_properties_set_int( filter_properties, "_samples", *samples );
// Get the filter-specific properties
jack_ringbuffer_t **output_buffers = mlt_properties_get_data( filter_properties, "output_buffers", NULL );
jack_ringbuffer_t **input_buffers = mlt_properties_get_data( filter_properties, "input_buffers", NULL );
// pthread_mutex_t *output_lock = mlt_properties_get_data( filter_properties, "output_lock", NULL );
// pthread_cond_t *output_ready = mlt_properties_get_data( filter_properties, "output_ready", NULL );
// Process the audio
float *q = (float*) *buffer;
size_t size = *samples * sizeof(float);
int j;
// struct timespec tm = { 0, 0 };
// Write into output ringbuffer
for ( j = 0; j < *channels; j++ )
{
if ( jack_ringbuffer_write_space( output_buffers[j] ) >= size )
jack_ringbuffer_write( output_buffers[j], (char*)( q + j * *samples ), size );
}
// Synchronization phase - wait for signal from Jack process
while ( jack_ringbuffer_read_space( input_buffers[ *channels - 1 ] ) < size ) ;
//pthread_cond_wait( output_ready, output_lock );
// Read from input ringbuffer
for ( j = 0; j < *channels; j++, q++ )
{
if ( jack_ringbuffer_read_space( input_buffers[j] ) >= size )
jack_ringbuffer_read( input_buffers[j], (char*)( q + j * *samples ), size );
}
// help jack_sync() indicate when we are rolling
mlt_position pos = mlt_frame_get_position( frame );
mlt_properties_set_position( filter_properties, "_last_pos", pos );
return 0;
}
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 );
// Allocate the image
int size = *width * ( *height + 1 ) * 2;
// Allocate the image
*buffer = mlt_pool_alloc( size );
// Update the frame
mlt_properties_set_data( properties, "image", *buffer, size, mlt_pool_release, NULL );
mlt_properties_set_int( properties, "width", *width );
mlt_properties_set_int( properties, "height", *height );
*format = mlt_image_yuv422;
if ( *buffer != NULL )
{
mlt_position in = mlt_producer_get_in( producer );
mlt_position out = mlt_producer_get_out( producer );
mlt_position time = mlt_frame_get_position( frame );
double position = ( double )( time - in ) / ( double )( out - in + 1 );
process_frei0r_item( producer_type , position, producer_props, frame , buffer, format , width , height , writable );
}
return 0;
}
mlt_frame mlt_filter_process( mlt_filter self, mlt_frame frame )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( self );
int disable = mlt_properties_get_int( properties, "disable" );
const char *unique_id = mlt_properties_get( properties, "_unique_id" );
mlt_position position = mlt_frame_get_position( frame );
char name[30];
// Make the properties key from unique id
snprintf( name, sizeof(name), "pos.%s", unique_id );
name[sizeof(name) -1] = '\0';
// Save the position on the frame
mlt_properties_set_position( MLT_FRAME_PROPERTIES( frame ), name, position );
if ( disable || self->process == NULL )
{
return frame;
}
else
{
// Add a reference to this filter on the frame
mlt_properties_inc_ref( MLT_FILTER_PROPERTIES(self) );
snprintf( name, sizeof(name), "filter.%s", unique_id );
name[sizeof(name) -1] = '\0';
mlt_properties_set_data( MLT_FRAME_PROPERTIES(frame), name, self, 0,
(mlt_destructor) mlt_filter_close, NULL );
return self->process( self, frame );
}
}
void consumer_frame_show_cb( mlt_consumer sdl, mlt_consumer parent, mlt_frame frame )
{
consumer_sdl self = parent->child;
self->last_speed = mlt_properties_get_double( MLT_FRAME_PROPERTIES( frame ), "_speed" );
self->last_position = mlt_frame_get_position( frame );
mlt_events_fire( MLT_CONSUMER_PROPERTIES( parent ), "consumer-frame-show", frame, NULL );
}
static void *consumer_thread( void *arg )
{
// Map the argument to the object
mlt_consumer consumer = arg;
// Get the properties
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
// Convenience functionality
int terminate_on_pause = mlt_properties_get_int( properties, "terminate_on_pause" );
int terminated = 0;
// Frame and size
mlt_frame frame = NULL;
// Loop while running
while( !terminated && mlt_properties_get_int( properties, "_running" ) )
{
// Get the frame
frame = mlt_consumer_rt_frame( consumer );
// Check for termination
if ( terminate_on_pause && frame != NULL )
terminated = mlt_properties_get_double( MLT_FRAME_PROPERTIES( frame ), "_speed" ) == 0.0;
// Check that we have a frame to work with
if ( frame )
{
avsync_stats* stats = mlt_properties_get_data( properties, "_stats", NULL );
double fps = mlt_properties_get_double( properties, "fps" );
mlt_position pos = mlt_frame_get_position( frame );
if( !strcmp( mlt_properties_get( properties, "report" ), "frame" ) )
{
stats->report_frames = 1;
}
else
{
stats->report_frames = 0;
}
detect_flash( frame, pos, fps, stats );
detect_blip( frame, pos, fps, stats );
calculate_sync( stats );
report_results( stats, pos );
// Close the frame
mlt_events_fire( properties, "consumer-frame-show", frame, NULL );
mlt_frame_close( frame );
}
}
// Indicate that the consumer is stopped
mlt_properties_set_int( properties, "_running", 0 );
mlt_consumer_stopped( consumer );
return NULL;
}
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;
}
void AudioEnvelope::loadEnvelope()
{
Q_ASSERT(m_envelope == NULL);
std::cout << "Loading envelope ..." << std::endl;
int samplingRate = m_info->info(0)->samplingRate();
mlt_audio_format format_s16 = mlt_audio_s16;
int channels = 1;
Mlt::Frame *frame;
int64_t position;
int samples;
m_envelope = new int64_t[m_envelopeSize];
m_envelopeMax = 0;
m_envelopeMean = 0;
QTime t;
t.start();
int count = 0;
m_producer->seek(m_offset);
m_producer->set_speed(1.0); // This is necessary, otherwise we don't get any new frames in the 2nd run.
for (int i = 0; i < m_envelopeSize; i++) {
frame = m_producer->get_frame(i);
position = mlt_frame_get_position(frame->get_frame());
samples = mlt_sample_calculator(m_producer->get_fps(), samplingRate, position);
int16_t *data = static_cast<int16_t*>(frame->get_audio(format_s16, samplingRate, channels, samples));
int64_t sum = 0;
for (int k = 0; k < samples; k++) {
sum += fabs(data[k]);
}
m_envelope[i] = sum;
m_envelopeMean += sum;
if (sum > m_envelopeMax) {
m_envelopeMax = sum;
}
// std::cout << position << "|" << m_producer->get_playtime()
// << "-" << m_producer->get_in() << "+" << m_producer->get_out() << " ";
delete frame;
count++;
if (m_length > 0 && count > m_length) {
break;
}
}
m_envelopeMean /= m_envelopeSize;
std::cout << "Calculating the envelope (" << m_envelopeSize << " frames) took "
<< t.elapsed() << " ms." << std::endl;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *image_format, int *width, int *height, int writable )
{
int error = 0;
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_filter filter = (mlt_filter)mlt_frame_pop_service( frame );
int samples = 0;
int channels = 0;
int frequency = 0;
mlt_audio_format audio_format = mlt_audio_s16;
int16_t* audio = (int16_t*)mlt_properties_get_data( frame_properties, "audio", NULL );
if ( !audio && !preprocess_warned ) {
// This filter depends on the consumer processing the audio before the
// video. If the audio is not preprocessed, this filter will process it.
// If this filter processes the audio, it could cause confusion for the
// consumer if it needs different audio properties.
mlt_log_warning( MLT_FILTER_SERVICE(filter), "Audio not preprocessed. Potential audio distortion.\n" );
preprocess_warned = true;
}
*image_format = mlt_image_rgb24a;
// Get the current image
error = mlt_frame_get_image( frame, image, image_format, width, height, writable );
// Get the audio
if( !error ) {
frequency = mlt_properties_get_int( frame_properties, "audio_frequency" );
if (!frequency) {
frequency = 48000;
}
channels = mlt_properties_get_int( frame_properties, "audio_channels" );
if (!channels) {
channels = 2;
}
samples = mlt_properties_get_int( frame_properties, "audio_samples" );
if (!samples) {
mlt_producer producer = mlt_frame_get_original_producer( frame );
double fps = mlt_producer_get_fps( mlt_producer_cut_parent( producer ) );
samples = mlt_sample_calculator( fps, frequency, mlt_frame_get_position( frame ) );
}
error = mlt_frame_get_audio( frame, (void**)&audio, &audio_format, &frequency, &channels, &samples );
}
// Draw the waveforms
if( !error ) {
QImage qimg( *width, *height, QImage::Format_ARGB32 );
convert_mlt_to_qimage_rgba( *image, &qimg, *width, *height );
draw_waveforms( filter, frame, &qimg, audio, channels, samples );
convert_qimage_to_mlt_rgba( &qimg, *image, *width, *height );
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_position position = mlt_frame_get_position( frame );
// Get the image
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 0 );
// Only process if we have no error and a valid colour space
if ( error == 0 )
{
double factor = mlt_properties_get_double( properties, "start" );
mlt_position f_pos = mlt_filter_get_position( filter, frame );
mlt_position f_len = mlt_filter_get_length2( filter, frame );
int speed = mlt_properties_anim_get_int( properties, "speed", f_pos, f_len );
int deformX = mlt_properties_anim_get_int( properties, "deformX", f_pos, f_len );
int deformY = mlt_properties_anim_get_int( properties, "deformY", f_pos, f_len );
if ( mlt_properties_get( properties, "end" ) )
{
// Determine the time position of this frame in the transition duration
double end = fabs( mlt_properties_get_double( MLT_FILTER_PROPERTIES( filter ), "end" ) );
factor += ( end - factor ) * mlt_filter_get_progress( filter, frame );
}
// If animated property "wave" is set, use its value.
char* wave_property = mlt_properties_get( properties, "wave" );
if ( wave_property )
{
factor = mlt_properties_anim_get_double( properties, "wave", f_pos, f_len );
}
if (factor != 0)
{
int image_size = *width * (*height) * 2;
uint8_t *dst = mlt_pool_alloc (image_size);
DoWave(*image, *width, (*height), dst, position, speed, factor, deformX, deformY);
*image = dst;
mlt_frame_set_image( frame, *image, image_size, mlt_pool_release );
}
}
return error;
}
mlt_frame mlt_filter_process( mlt_filter self, mlt_frame frame )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( self );
int disable = mlt_properties_get_int( properties, "disable" );
const char *unique_id = mlt_properties_get( properties, "_unique_id" );
mlt_position position = mlt_frame_get_position( frame );
char name[20];
// Make the properties key from unique id
strcpy( name, "pos." );
strcat( name, unique_id );
// Save the position on the frame
mlt_properties_set_position( MLT_FRAME_PROPERTIES( frame ), name, position );
if ( disable || self->process == NULL )
return frame;
else
return self->process( self, frame );
}
static void get_timecode_str( mlt_filter filter, mlt_frame frame, char* text )
{
int frames = mlt_frame_get_position( frame );
double fps = mlt_profile_fps( mlt_service_profile( MLT_FILTER_SERVICE( filter ) ) );
char tc[12] = "";
if (fps == 0)
{
strncat( text, "-", MAX_TEXT_LEN - strlen( text ) - 1 );
}
else
{
int seconds = frames / fps;
frames = frames % lrint( fps );
int minutes = seconds / 60;
seconds = seconds % 60;
int hours = minutes / 60;
minutes = minutes % 60;
sprintf(tc, "%.2d:%.2d:%.2d:%.2d", hours, minutes, seconds, frames);
strncat( text, tc, MAX_TEXT_LEN - strlen( text ) - 1 );
}
}
void mlt_frame_write_ppm( mlt_frame frame )
{
int width = 0;
int height = 0;
mlt_image_format format = mlt_image_rgb24;
uint8_t *image;
if ( mlt_frame_get_image( frame, &image, &format, &width, &height, 0 ) == 0 )
{
FILE *file;
char filename[16];
sprintf( filename, "frame-%05d.ppm", (int)mlt_frame_get_position( frame ) );
file = fopen( filename, "wb" );
if ( !file )
return;
fprintf( file, "P6\n%d %d\n255\n", width, height);
fwrite( image, width * height * 3, 1, file );
fclose( file );
}
}
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;
}
double mlt_transition_get_progress( mlt_transition self, mlt_frame frame )
{
double progress = 0;
mlt_position in = mlt_transition_get_in( self );
mlt_position out = mlt_transition_get_out( self );
if ( out == 0 )
{
// If always active, use the frame's producer
mlt_producer producer = mlt_frame_get_original_producer( frame );
if ( producer )
{
in = mlt_producer_get_in( producer );
out = mlt_producer_get_out( producer );
}
}
if ( out != 0 )
{
mlt_position position = mlt_frame_get_position( frame );
progress = ( double ) ( position - in ) / ( double ) ( out - in + 1 );
}
return progress;
}
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 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 filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the filter from the frame
mlt_filter this = mlt_frame_pop_audio( frame );
// Get the properties from the filter
mlt_properties filter_props = MLT_FILTER_PROPERTIES( this );
// Get the frame's filter instance properties
mlt_properties instance_props = mlt_frame_unique_properties( frame, MLT_FILTER_SERVICE( this ) );
// Get the parameters
double gain = mlt_properties_get_double( instance_props, "gain" );
double max_gain = mlt_properties_get_double( instance_props, "max_gain" );
double limiter_level = 0.5; /* -6 dBFS */
int normalise = mlt_properties_get_int( instance_props, "normalise" );
double amplitude = mlt_properties_get_double( instance_props, "amplitude" );
int i, j;
double sample;
int16_t peak;
if ( mlt_properties_get( instance_props, "limiter" ) != NULL )
limiter_level = mlt_properties_get_double( instance_props, "limiter" );
// Get the producer's audio
*format = mlt_audio_s16;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
// fprintf( stderr, "filter_volume: frequency %d\n", *frequency );
// Determine numeric limits
int bytes_per_samp = (samp_width - 1) / 8 + 1;
int samplemax = (1 << (bytes_per_samp * 8 - 1)) - 1;
int samplemin = -samplemax - 1;
mlt_service_lock( MLT_FILTER_SERVICE( this ) );
if ( normalise )
{
int window = mlt_properties_get_int( filter_props, "window" );
double *smooth_buffer = mlt_properties_get_data( filter_props, "smooth_buffer", NULL );
if ( window > 0 && smooth_buffer != NULL )
{
int smooth_index = mlt_properties_get_int( filter_props, "_smooth_index" );
// Compute the signal power and put into smoothing buffer
smooth_buffer[ smooth_index ] = signal_max_power( *buffer, *channels, *samples, &peak );
// fprintf( stderr, "filter_volume: raw power %f ", smooth_buffer[ smooth_index ] );
if ( smooth_buffer[ smooth_index ] > EPSILON )
{
mlt_properties_set_int( filter_props, "_smooth_index", ( smooth_index + 1 ) % window );
// Smooth the data and compute the gain
// fprintf( stderr, "smoothed %f over %d frames\n", get_smoothed_data( smooth_buffer, window ), window );
gain *= amplitude / get_smoothed_data( smooth_buffer, window );
}
}
else
{
gain *= amplitude / signal_max_power( (int16_t*) *buffer, *channels, *samples, &peak );
}
}
// if ( gain > 1.0 && normalise )
// fprintf(stderr, "filter_volume: limiter level %f gain %f\n", limiter_level, gain );
if ( max_gain > 0 && gain > max_gain )
gain = max_gain;
// Initialise filter's previous gain value to prevent an inadvertant jump from 0
mlt_position last_position = mlt_properties_get_position( filter_props, "_last_position" );
mlt_position current_position = mlt_frame_get_position( frame );
if ( mlt_properties_get( filter_props, "_previous_gain" ) == NULL
|| current_position != last_position + 1 )
mlt_properties_set_double( filter_props, "_previous_gain", gain );
// Start the gain out at the previous
double previous_gain = mlt_properties_get_double( filter_props, "_previous_gain" );
// Determine ramp increment
double gain_step = ( gain - previous_gain ) / *samples;
// fprintf( stderr, "filter_volume: previous gain %f current gain %f step %f\n", previous_gain, gain, gain_step );
// Save the current gain for the next iteration
mlt_properties_set_double( filter_props, "_previous_gain", gain );
mlt_properties_set_position( filter_props, "_last_position", current_position );
mlt_service_unlock( MLT_FILTER_SERVICE( this ) );
// Ramp from the previous gain to the current
gain = previous_gain;
int16_t *p = (int16_t*) *buffer;
// Apply the gain
for ( i = 0; i < *samples; i++ )
{
for ( j = 0; j < *channels; j++ )
{
sample = *p * gain;
*p = ROUND( sample );
if ( gain > 1.0 )
{
/* use limiter function instead of clipping */
if ( normalise )
*p = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) );
/* perform clipping */
else if ( sample > samplemax )
*p = samplemax;
else if ( sample < samplemin )
*p = samplemin;
}
p++;
}
gain += gain_step;
}
return 0;
}
static 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 );
}
/** Filter processing.
*/
static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
{
// Get the properties of the frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Get a unique name to store the frame position
char *name = mlt_properties_get( MLT_FILTER_PROPERTIES( this ), "_unique_id" );
// Assign the frame out point to the filter (just in case we need it later)
mlt_properties_set_int( MLT_FILTER_PROPERTIES( this ), "_out", mlt_properties_get_int( properties, "out" ) );
// Assign the current position to the name
mlt_properties_set_position( properties, name, mlt_frame_get_position( frame ) - mlt_filter_get_in( this ) );
// Push the filter on to the stack
mlt_frame_push_service( frame, this );
// Push the get_image on to the stack
mlt_frame_push_get_image( frame, filter_get_image );
return frame;
}
/** Constructor for the filter.
*/
mlt_filter filter_watermark_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
static void *consumer_worker_thread( void *arg )
{
// The argument is the consumer
mlt_consumer self = arg;
// Get the properties of the consumer
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
// Get the width and height
int width = mlt_properties_get_int( properties, "width" );
int height = mlt_properties_get_int( properties, "height" );
mlt_image_format format = self->format;
// See if video is turned off
int video_off = mlt_properties_get_int( properties, "video_off" );
int preview_off = mlt_properties_get_int( properties, "preview_off" );
int preview_format = mlt_properties_get_int( properties, "preview_format" );
// General frame variable
mlt_frame frame = NULL;
uint8_t *image = NULL;
if ( preview_off && preview_format != 0 )
format = preview_format;
// Continue to read ahead
while ( self->ahead )
{
// Get the next unprocessed frame from the work queue
pthread_mutex_lock( &self->queue_mutex );
int index = first_unprocessed_frame( self );
while ( self->ahead && index >= mlt_deque_count( self->queue ) )
{
mlt_log_debug( MLT_CONSUMER_SERVICE(self), "waiting in worker index = %d queue count = %d\n",
index, mlt_deque_count( self->queue ) );
pthread_cond_wait( &self->queue_cond, &self->queue_mutex );
index = first_unprocessed_frame( self );
}
// Mark the frame for processing
frame = mlt_deque_peek( self->queue, index );
if ( frame )
{
mlt_log_debug( MLT_CONSUMER_SERVICE(self), "worker processing index = %d frame %d queue count = %d\n",
index, mlt_frame_get_position(frame), mlt_deque_count( self->queue ) );
frame->is_processing = 1;
mlt_properties_inc_ref( MLT_FRAME_PROPERTIES( frame ) );
}
pthread_mutex_unlock( &self->queue_mutex );
// If there's no frame, we're probably stopped...
if ( frame == NULL )
continue;
#ifdef DEINTERLACE_ON_NOT_NORMAL_SPEED
// All non normal playback frames should be shown
if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES( frame ), "_speed" ) != 1 )
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "consumer_deinterlace", 1 );
#endif
// Get the image
if ( !video_off )
{
// Fetch width/height again
width = mlt_properties_get_int( properties, "width" );
height = mlt_properties_get_int( properties, "height" );
mlt_events_fire( MLT_CONSUMER_PROPERTIES( self ), "consumer-frame-render", frame, NULL );
mlt_frame_get_image( frame, &image, &format, &width, &height, 0 );
}
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "rendered", 1 );
mlt_frame_close( frame );
// Tell a waiting thread (non-realtime main consumer thread) that we are done.
pthread_mutex_lock( &self->done_mutex );
pthread_cond_broadcast( &self->done_cond );
pthread_mutex_unlock( &self->done_mutex );
}
return NULL;
}
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 properties = MLT_CONSUMER_PROPERTIES( consumer );
// internal intialization
mlt_frame frame = NULL;
int last_position = -1;
int eos = 0;
int eos_threshold = 20;
if ( self->play )
eos_threshold = eos_threshold + mlt_properties_get_int( MLT_CONSUMER_PROPERTIES( self->play ), "buffer" );
// Determine if the application is dealing with the preview
int preview_off = mlt_properties_get_int( properties, "preview_off" );
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_get_frame( consumer );
// Ensure that we have a frame
if ( self->running && frame != NULL )
{
// Get the speed of the frame
double speed = mlt_properties_get_double( MLT_FRAME_PROPERTIES( frame ), "_speed" );
// Lock during the operation
mlt_service_lock( MLT_CONSUMER_SERVICE( consumer ) );
// Get refresh request for the current frame
int refresh = mlt_properties_get_int( properties, "refresh" );
// Decrement refresh and clear changed
mlt_events_block( properties, properties );
mlt_properties_set_int( properties, "refresh", 0 );
mlt_events_unblock( properties, properties );
// Unlock after the operation
mlt_service_unlock( MLT_CONSUMER_SERVICE( consumer ) );
// Set the changed property on this frame for the benefit of still
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "refresh", refresh );
// Make sure the recipient knows that this frame isn't really rendered
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "rendered", 0 );
// Optimisation to reduce latency
if ( speed == 1.0 )
{
if ( last_position != -1 && last_position + 1 != mlt_frame_get_position( frame ) )
mlt_consumer_purge( self->play );
last_position = mlt_frame_get_position( frame );
}
else
{
//mlt_consumer_purge( self->play );
last_position = -1;
}
// If we aren't playing normally, then use the still
if ( speed != 1 )
{
mlt_producer producer = MLT_PRODUCER( mlt_service_get_producer( MLT_CONSUMER_SERVICE( consumer ) ) );
mlt_position duration = producer? mlt_producer_get_playtime( producer ) : -1;
int pause = 0;
#ifndef SKIP_WAIT_EOS
if ( self->active == self->play )
{
// Do not interrupt the play consumer near the end
if ( duration - self->last_position > eos_threshold )
{
// Get a new frame at the sought position
mlt_frame_close( frame );
if ( producer )
mlt_producer_seek( producer, self->last_position );
frame = mlt_consumer_get_frame( consumer );
pause = 1;
}
else
{
// Send frame with speed 0 to stop it
if ( frame && !mlt_consumer_is_stopped( self->play ) )
{
mlt_consumer_put_frame( self->play, frame );
frame = NULL;
eos = 1;
}
// Check for end of stream
if ( mlt_consumer_is_stopped( self->play ) )
{
// Stream has ended
mlt_log_verbose( MLT_CONSUMER_SERVICE( consumer ), "END OF STREAM\n" );
pause = 1;
eos = 0; // reset eos indicator
}
else
{
// Prevent a tight busy loop
struct timespec tm = { 0, 100000L }; // 100 usec
nanosleep( &tm, NULL );
}
}
}
#else
pause = self->active == self->play;
#endif
if ( pause )
{
// Start the still consumer
if ( !mlt_consumer_is_stopped( self->play ) )
mlt_consumer_stop( self->play );
self->last_speed = speed;
self->active = self->still;
self->ignore_change = 0;
mlt_consumer_start( self->still );
}
// Send the frame to the active child
if ( frame && !eos )
{
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "refresh", 1 );
if ( self->active )
mlt_consumer_put_frame( self->active, frame );
}
if ( pause && speed == 0.0 )
{
mlt_events_fire( properties, "consumer-sdl-paused", NULL );
}
}
// Allow a little grace time before switching consumers on speed changes
else if ( self->ignore_change -- > 0 && self->active != NULL && !mlt_consumer_is_stopped( self->active ) )
{
mlt_consumer_put_frame( self->active, frame );
}
// Otherwise use the normal player
else
{
if ( !mlt_consumer_is_stopped( self->still ) )
mlt_consumer_stop( self->still );
if ( mlt_consumer_is_stopped( self->play ) )
{
self->last_speed = speed;
self->active = self->play;
self->ignore_change = 0;
mlt_consumer_start( self->play );
}
if ( self->play )
mlt_consumer_put_frame( self->play, frame );
}
// Copy the rectangle info from the active consumer
if ( self->running && preview_off == 0 && self->active )
{
mlt_properties active = MLT_CONSUMER_PROPERTIES( self->active );
mlt_service_lock( MLT_CONSUMER_SERVICE( consumer ) );
mlt_properties_set_int( properties, "rect_x", mlt_properties_get_int( active, "rect_x" ) );
mlt_properties_set_int( properties, "rect_y", mlt_properties_get_int( active, "rect_y" ) );
mlt_properties_set_int( properties, "rect_w", mlt_properties_get_int( active, "rect_w" ) );
mlt_properties_set_int( properties, "rect_h", mlt_properties_get_int( active, "rect_h" ) );
mlt_service_unlock( MLT_CONSUMER_SERVICE( consumer ) );
}
if ( self->active == self->still )
{
pthread_mutex_lock( &self->refresh_mutex );
if ( self->running && speed == 0 && self->refresh_count <= 0 )
{
mlt_events_fire( properties, "consumer-sdl-paused", NULL );
pthread_cond_wait( &self->refresh_cond, &self->refresh_mutex );
}
self->refresh_count --;
pthread_mutex_unlock( &self->refresh_mutex );
}
}
else
{
if ( frame ) mlt_frame_close( frame );
mlt_consumer_put_frame( self->active, NULL );
self->running = 0;
}
}
if ( self->play ) mlt_consumer_stop( self->play );
if ( self->still ) mlt_consumer_stop( self->still );
return NULL;
}
static void on_consumer_frame_show( mlt_properties owner, mlt_consumer consumer, mlt_frame frame )
{
if ( frame )
consumer->position = mlt_frame_get_position( frame );
}
static int get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
mlt_properties properties = MLT_FRAME_PROPERTIES( a_frame );
mlt_transition transition = MLT_TRANSITION( mlt_frame_pop_service( a_frame ) );
uint8_t *b_image;
int window_size = mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( transition ), "window_size" );
double psnr[3], ssim[3];
*format = mlt_image_yuv422;
mlt_frame_get_image( b_frame, &b_image, format, width, height, writable );
mlt_frame_get_image( a_frame, image, format, width, height, writable );
psnr[0] = calc_psnr( *image, b_image, *width * *height, 2 );
psnr[1] = calc_psnr( *image + 1, b_image + 1, *width * *height / 2, 4 );
psnr[2] = calc_psnr( *image + 3, b_image + 3, *width * *height / 2, 4 );
ssim[0] = calc_ssim( *image, b_image, *width, *height, window_size, 2 );
ssim[1] = calc_ssim( *image + 1, b_image + 1, *width / 2, *height, window_size, 4 );
ssim[2] = calc_ssim( *image + 3, b_image + 3, *width / 2, *height, window_size, 4 );
mlt_properties_set_double( properties, "meta.vqm.psnr.y", psnr[0] );
mlt_properties_set_double( properties, "meta.vqm.psnr.cb", psnr[1] );
mlt_properties_set_double( properties, "meta.vqm.psnr.cr", psnr[2] );
mlt_properties_set_double( properties, "meta.vqm.ssim.y", ssim[0] );
mlt_properties_set_double( properties, "meta.vqm.ssim.cb", ssim[1] );
mlt_properties_set_double( properties, "meta.vqm.ssim.cr", ssim[2] );
printf( "%05d %05.2f %05.2f %05.2f %5.3f %5.3f %5.3f\n",
mlt_frame_get_position( a_frame ), psnr[0], psnr[1], psnr[2],
ssim[0], ssim[1], ssim[2] );
// copy the B frame to the bottom of the A frame for comparison
window_size = mlt_image_format_size( *format, *width, *height, NULL ) / 2;
memcpy( *image + window_size, b_image + window_size, window_size );
if ( !mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( transition ), "render" ) )
return 0;
// get RGBA image for Qt drawing
*format = mlt_image_rgb24a;
mlt_frame_get_image( a_frame, image, format, width, height, 1 );
// convert mlt image to qimage
QImage img( *width, *height, QImage::Format_ARGB32 );
int y = *height + 1;
uint8_t *src = *image;
while ( --y )
{
QRgb *dst = (QRgb*) img.scanLine( *height - y );
int x = *width + 1;
while ( --x )
{
*dst++ = qRgba( src[0], src[1], src[2], 255 );
src += 4;
}
}
// setup Qt drawing
QPainter painter;
painter.begin( &img );
painter.setRenderHints( QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing );
// draw some stuff with Qt
QPalette palette;
QFont font;
QString s;
font.setBold( true );
font.setPointSize( 30 * *height / 1080 );
painter.setPen( QColor("black") );
painter.drawLine( 0, *height/2 + 1, *width, *height/2 );
painter.setPen( QColor("white") );
painter.drawLine( 0, *height/2 - 1, *width, *height/2 );
painter.setFont( font );
s.sprintf( "Frame: %05d\nPSNR: %05.2f (Y) %05.2f (Cb) %05.2f (Cr)\nSSIM: %5.3f (Y) %5.3f (Cb) %5.3f (Cr)",
mlt_frame_get_position( a_frame ), psnr[0], psnr[1], psnr[2],
ssim[0], ssim[1], ssim[2] );
painter.setPen( QColor("black") );
painter.drawText( 52, *height * 8 / 10 + 2, *width, *height, 0, s );
painter.setPen( QColor("white") );
painter.drawText( 50, *height * 8 / 10, *width, *height, 0, s );
// finish Qt drawing
painter.end();
window_size = mlt_image_format_size( *format, *width, *height, NULL );
uint8_t *dst = (uint8_t *) mlt_pool_alloc( window_size );
mlt_properties_set_data( MLT_FRAME_PROPERTIES(a_frame), "image", dst, window_size, mlt_pool_release, NULL );
*image = dst;
// convert qimage to mlt
y = *height + 1;
while ( --y )
{
QRgb *src = (QRgb*) img.scanLine( *height - y );
int x = *width + 1;
while ( --x )
{
*dst++ = qRed( *src );
*dst++ = qGreen( *src );
*dst++ = qBlue( *src );
*dst++ = qAlpha( *src );
src++;
}
}
return 0;
}
static void *consumer_read_ahead_thread( void *arg )
{
// The argument is the consumer
mlt_consumer self = arg;
// Get the properties of the consumer
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
// Get the width and height
int width = mlt_properties_get_int( properties, "width" );
int height = mlt_properties_get_int( properties, "height" );
// See if video is turned off
int video_off = mlt_properties_get_int( properties, "video_off" );
int preview_off = mlt_properties_get_int( properties, "preview_off" );
int preview_format = mlt_properties_get_int( properties, "preview_format" );
// Get the audio settings
mlt_audio_format afmt = mlt_audio_s16;
const char *format = mlt_properties_get( properties, "mlt_audio_format" );
if ( format )
{
if ( !strcmp( format, "none" ) )
afmt = mlt_audio_none;
else if ( !strcmp( format, "s32" ) )
afmt = mlt_audio_s32;
else if ( !strcmp( format, "s32le" ) )
afmt = mlt_audio_s32le;
else if ( !strcmp( format, "float" ) )
afmt = mlt_audio_float;
else if ( !strcmp( format, "f32le" ) )
afmt = mlt_audio_f32le;
else if ( !strcmp( format, "u8" ) )
afmt = mlt_audio_u8;
}
int counter = 0;
double fps = mlt_properties_get_double( properties, "fps" );
int channels = mlt_properties_get_int( properties, "channels" );
int frequency = mlt_properties_get_int( properties, "frequency" );
int samples = 0;
void *audio = NULL;
// See if audio is turned off
int audio_off = mlt_properties_get_int( properties, "audio_off" );
// Get the maximum size of the buffer
int buffer = mlt_properties_get_int( properties, "buffer" ) + 1;
// General frame variable
mlt_frame frame = NULL;
uint8_t *image = NULL;
// Time structures
struct timeval ante;
// Average time for get_frame and get_image
int count = 0;
int skipped = 0;
int64_t time_process = 0;
int skip_next = 0;
mlt_position pos = 0;
mlt_position start_pos = 0;
mlt_position last_pos = 0;
int frame_duration = mlt_properties_get_int( properties, "frame_duration" );
int drop_max = mlt_properties_get_int( properties, "drop_max" );
if ( preview_off && preview_format != 0 )
self->format = preview_format;
// Get the first frame
frame = mlt_consumer_get_frame( self );
if ( frame )
{
// Get the image of the first frame
if ( !video_off )
{
mlt_events_fire( MLT_CONSUMER_PROPERTIES( self ), "consumer-frame-render", frame, NULL );
mlt_frame_get_image( frame, &image, &self->format, &width, &height, 0 );
}
if ( !audio_off )
{
samples = mlt_sample_calculator( fps, frequency, counter++ );
mlt_frame_get_audio( frame, &audio, &afmt, &frequency, &channels, &samples );
}
// Mark as rendered
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "rendered", 1 );
last_pos = start_pos = pos = mlt_frame_get_position( frame );
}
// Get the starting time (can ignore the times above)
gettimeofday( &ante, NULL );
// Continue to read ahead
while ( self->ahead )
{
// Put the current frame into the queue
pthread_mutex_lock( &self->queue_mutex );
while( self->ahead && mlt_deque_count( self->queue ) >= buffer )
pthread_cond_wait( &self->queue_cond, &self->queue_mutex );
mlt_deque_push_back( self->queue, frame );
pthread_cond_broadcast( &self->queue_cond );
pthread_mutex_unlock( &self->queue_mutex );
// Get the next frame
frame = mlt_consumer_get_frame( self );
// If there's no frame, we're probably stopped...
if ( frame == NULL )
continue;
pos = mlt_frame_get_position( frame );
// Increment the counter used for averaging processing cost
count ++;
// All non-normal playback frames should be shown
if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES( frame ), "_speed" ) != 1 )
{
#ifdef DEINTERLACE_ON_NOT_NORMAL_SPEED
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "consumer_deinterlace", 1 );
#endif
// Indicate seeking or trick-play
start_pos = pos;
}
// If skip flag not set or frame-dropping disabled
if ( !skip_next || self->real_time == -1 )
{
if ( !video_off )
{
// Reset width/height - could have been changed by previous mlt_frame_get_image
width = mlt_properties_get_int( properties, "width" );
height = mlt_properties_get_int( properties, "height" );
// Get the image
mlt_events_fire( MLT_CONSUMER_PROPERTIES( self ), "consumer-frame-render", frame, NULL );
mlt_frame_get_image( frame, &image, &self->format, &width, &height, 0 );
}
// Indicate the rendered image is available.
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "rendered", 1 );
// Reset consecutively-skipped counter
skipped = 0;
}
else // Skip image processing
{
// Increment the number of consecutively-skipped frames
skipped++;
// If too many (1 sec) consecutively-skipped frames
if ( skipped > drop_max )
{
// Reset cost tracker
time_process = 0;
count = 1;
mlt_log_verbose( self, "too many frames dropped - forcing next frame\n" );
}
}
// Always process audio
if ( !audio_off )
{
samples = mlt_sample_calculator( fps, frequency, counter++ );
mlt_frame_get_audio( frame, &audio, &afmt, &frequency, &channels, &samples );
}
// Get the time to process this frame
int64_t time_current = time_difference( &ante );
// If the current time is not suddenly some large amount
if ( time_current < time_process / count * 20 || !time_process || count < 5 )
{
// Accumulate the cost for processing this frame
time_process += time_current;
}
else
{
mlt_log_debug( self, "current %"PRId64" threshold %"PRId64" count %d\n",
time_current, (int64_t) (time_process / count * 20), count );
// Ignore the cost of this frame's time
count--;
}
// Determine if we started, resumed, or seeked
if ( pos != last_pos + 1 )
start_pos = pos;
last_pos = pos;
// Do not skip the first 20% of buffer at start, resume, or seek
if ( pos - start_pos <= buffer / 5 + 1 )
{
// Reset cost tracker
time_process = 0;
count = 1;
}
// Reset skip flag
skip_next = 0;
// Only consider skipping if the buffer level is low (or really small)
if ( mlt_deque_count( self->queue ) <= buffer / 5 + 1 )
{
// Skip next frame if average cost exceeds frame duration.
if ( time_process / count > frame_duration )
skip_next = 1;
if ( skip_next )
mlt_log_debug( self, "avg usec %"PRId64" (%"PRId64"/%d) duration %d\n",
time_process/count, time_process, count, frame_duration);
}
}
// Remove the last frame
mlt_frame_close( frame );
return NULL;
}
