static void attach_normalisers( mlt_profile profile, mlt_producer producer )
{
// Loop variable
int i;
// Tokeniser
mlt_tokeniser tokeniser = mlt_tokeniser_init( );
// We only need to load the normalising properties once
if ( normalisers == NULL )
{
char temp[ 1024 ];
sprintf( temp, "%s/core/loader.ini", mlt_environment( "MLT_DATA" ) );
normalisers = mlt_properties_load( temp );
mlt_factory_register_for_clean_up( normalisers, ( mlt_destructor )mlt_properties_close );
}
// Apply normalisers
for ( i = 0; i < mlt_properties_count( normalisers ); i ++ )
{
int j = 0;
int created = 0;
char *value = mlt_properties_get_value( normalisers, i );
mlt_tokeniser_parse_new( tokeniser, value, "," );
for ( j = 0; !created && j < mlt_tokeniser_count( tokeniser ); j ++ )
create_filter( profile, producer, mlt_tokeniser_get_string( tokeniser, j ), &created );
}
// Close the tokeniser
mlt_tokeniser_close( tokeniser );
}
mlt_repository mlt_repository_init( const char *directory )
{
// Safety check
if ( directory == NULL || strcmp( directory, "" ) == 0 )
return NULL;
// Construct the repository
mlt_repository self = calloc( 1, sizeof( struct mlt_repository_s ));
mlt_properties_init( &self->parent, self );
self->consumers = mlt_properties_new();
self->filters = mlt_properties_new();
self->producers = mlt_properties_new();
self->transitions = mlt_properties_new();
// Get the directory list
mlt_properties dir = mlt_properties_new();
int count = mlt_properties_dir_list( dir, directory, NULL, 0 );
int i;
// Iterate over files
for ( i = 0; i < count; i++ )
{
int flags = RTLD_NOW;
const char *object_name = mlt_properties_get_value( dir, i);
// Very temporary hack to allow the quicktime plugins to work
// TODO: extend repository to allow this to be used on a case by case basis
if ( strstr( object_name, "libmltkino" ) )
flags |= RTLD_GLOBAL;
// Open the shared object
void *object = dlopen( object_name, flags );
if ( object != NULL )
{
// Get the registration function
mlt_repository_callback symbol_ptr = dlsym( object, "mlt_register" );
// Call the registration function
if ( symbol_ptr != NULL )
{
symbol_ptr( self );
// Register the object file for closure
mlt_properties_set_data( &self->parent, object_name, object, 0, ( mlt_destructor )dlclose, NULL );
}
else
{
dlclose( object );
}
}
else if ( strstr( object_name, "libmlt" ) )
{
mlt_log( NULL, MLT_LOG_WARNING, "%s: failed to dlopen %s\n (%s)\n", __FUNCTION__, object_name, dlerror() );
}
}
mlt_properties_close( dir );
return self;
}
static mlt_filter obtain_filter( mlt_filter filter, char *type )
{
// Result to return
mlt_filter result = NULL;
// Miscelaneous variable
int i = 0;
int type_len = strlen( type );
// Get the properties of the data show filter
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Get the profile properties
mlt_properties profile_properties = mlt_properties_get_data( filter_properties, "profile_properties", NULL );
// Obtain the profile_properties if we haven't already
if ( profile_properties == NULL )
{
char temp[ 512 ];
// Get the profile requested
char *profile = mlt_properties_get( filter_properties, "resource" );
// If none is specified, pick up the default for this normalisation
if ( profile == NULL )
sprintf( temp, "%s/feeds/%s/data_fx.properties", mlt_environment( "MLT_DATA" ), mlt_environment( "MLT_NORMALISATION" ) );
else if ( strchr( profile, '%' ) )
sprintf( temp, "%s/feeds/%s/%s", mlt_environment( "MLT_DATA" ), mlt_environment( "MLT_NORMALISATION" ), strchr( profile, '%' ) + 1 );
else
{
strncpy( temp, profile, sizeof( temp ) );
temp[ sizeof( temp ) - 1 ] = '\0';
}
// Load the specified profile or use the default
profile_properties = mlt_properties_load( temp );
// Store for later retrieval
mlt_properties_set_data( filter_properties, "profile_properties", profile_properties, 0, ( mlt_destructor )mlt_properties_close, NULL );
}
if ( profile_properties != NULL )
{
for ( i = 0; i < mlt_properties_count( profile_properties ); i ++ )
{
char *name = mlt_properties_get_name( profile_properties, i );
char *value = mlt_properties_get_value( profile_properties, i );
if ( result == NULL && !strcmp( name, type ) && result == NULL )
result = mlt_factory_filter( mlt_service_profile( MLT_FILTER_SERVICE( filter ) ), value, NULL );
else if ( result != NULL && !strncmp( name, type, type_len ) && name[ type_len ] == '.' )
mlt_properties_set( MLT_FILTER_PROPERTIES( result ), name + type_len + 1, value );
else if ( result != NULL )
break;
}
}
return result;
}
static QImage* reorient_with_exif( producer_qimage self, int image_idx, QImage *qimage )
{
#ifdef USE_EXIF
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( &self->parent );
ExifData *d = exif_data_new_from_file( mlt_properties_get_value( self->filenames, image_idx ) );
ExifEntry *entry;
int exif_orientation = 0;
/* get orientation and rotate image accordingly if necessary */
if (d) {
if ( ( entry = exif_content_get_entry ( d->ifd[EXIF_IFD_0], EXIF_TAG_ORIENTATION ) ) )
exif_orientation = exif_get_short (entry->data, exif_data_get_byte_order (d));
/* Free the EXIF data */
exif_data_unref(d);
}
// Remember EXIF value, might be useful for someone
mlt_properties_set_int( producer_props, "_exif_orientation" , exif_orientation );
if ( exif_orientation > 1 )
{
// Rotate image according to exif data
QImage processed;
QMatrix matrix;
switch ( exif_orientation ) {
case 2:
matrix.scale( -1, 1 );
break;
case 3:
matrix.rotate( 180 );
break;
case 4:
matrix.scale( 1, -1 );
break;
case 5:
matrix.rotate( 270 );
matrix.scale( -1, 1 );
break;
case 6:
matrix.rotate( 90 );
break;
case 7:
matrix.rotate( 90 );
matrix.scale( -1, 1 );
break;
case 8:
matrix.rotate( 270 );
break;
}
processed = qimage->transformed( matrix );
delete qimage;
qimage = new QImage( processed );
}
#endif
return qimage;
}
mlt_properties mlt_profile_list( )
{
char *filename = NULL;
const char *prefix = getenv( "MLT_PROFILES_PATH" );
mlt_properties properties = mlt_properties_new();
mlt_properties dir = mlt_properties_new();
int sort = 1;
const char *wildcard = NULL;
int i;
// Load from $datadir/mlt/profiles if no env var
if ( prefix == NULL )
{
prefix = mlt_environment( "MLT_DATA" );
filename = calloc( 1, strlen( prefix ) + strlen( PROFILES_DIR ) + 1 );
strcpy( filename, prefix );
strcat( filename, PROFILES_DIR );
prefix = filename;
}
mlt_properties_dir_list( dir, prefix, wildcard, sort );
for ( i = 0; i < mlt_properties_count( dir ); i++ )
{
char *filename = mlt_properties_get_value( dir, i );
char *profile_name = basename( filename );
if ( profile_name[0] != '.' && strcmp( profile_name, "Makefile" ) &&
profile_name[ strlen( profile_name ) - 1 ] != '~' )
{
mlt_properties profile = mlt_properties_load( filename );
if ( profile )
{
mlt_properties_set_data( properties, profile_name, profile, 0,
(mlt_destructor) mlt_properties_close, NULL );
}
}
}
mlt_properties_close( dir );
if ( filename )
free( filename );
return properties;
}
static int is_service_hidden(mlt_repository repo, mlt_service_type type, const char *service_name )
{
mlt_properties metadata = NULL;
mlt_properties tags = NULL;
metadata = mlt_repository_metadata(repo, type, service_name);
if( metadata )
{
tags = mlt_properties_get_data( metadata, "tags", NULL );
if( tags )
{
int k;
for ( k = 0; k < mlt_properties_count( tags ); k++ )
{
const char* value = mlt_properties_get_value(tags, k);
if( !strcmp("Hidden", value) )
{
return 1;
}
}
}
}
return 0;
}
static int producer_get_frame( mlt_service service, mlt_frame_ptr frame, int index )
{
int result = 1;
mlt_producer self = service != NULL ? service->child : NULL;
if ( self != NULL && !mlt_producer_is_cut( self ) )
{
// Get the properties of this producer
mlt_properties properties = MLT_PRODUCER_PROPERTIES( self );
// Determine eof handling
char *eof = mlt_properties_get( MLT_PRODUCER_PROPERTIES( self ), "eof" );
// Get the speed of the producer
double speed = mlt_producer_get_speed( self );
// We need to use the clone if it's specified
mlt_producer clone = mlt_properties_get_data( properties, "use_clone", NULL );
// If no clone is specified, use self
clone = clone == NULL ? self : clone;
// A properly instatiated producer will have a get_frame method...
if ( self->get_frame == NULL || ( eof && !strcmp( eof, "continue" ) && mlt_producer_position( self ) > mlt_producer_get_out( self ) ) )
{
// Generate a test frame
*frame = mlt_frame_init( service );
// Set the position
result = mlt_frame_set_position( *frame, mlt_producer_position( self ) );
// Mark as a test card
mlt_properties_set_int( MLT_FRAME_PROPERTIES( *frame ), "test_image", 1 );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( *frame ), "test_audio", 1 );
// Calculate the next position
mlt_producer_prepare_next( self );
}
else
{
// Get the frame from the implementation
result = self->get_frame( clone, frame, index );
}
// Copy the fps and speed of the producer onto the frame
properties = MLT_FRAME_PROPERTIES( *frame );
mlt_properties_set_double( properties, "_speed", speed );
mlt_properties_set_int( properties, "test_audio", mlt_frame_is_test_audio( *frame ) );
mlt_properties_set_int( properties, "test_image", mlt_frame_is_test_card( *frame ) );
if ( mlt_properties_get_data( properties, "_producer", NULL ) == NULL )
mlt_properties_set_data( properties, "_producer", service, 0, NULL, NULL );
}
else if ( self != NULL )
{
// Get the speed of the cut
double speed = mlt_producer_get_speed( self );
// Get the parent of the cut
mlt_producer parent = mlt_producer_cut_parent( self );
// Get the properties of the parent
mlt_properties parent_properties = MLT_PRODUCER_PROPERTIES( parent );
// Get the properties of the cut
mlt_properties properties = MLT_PRODUCER_PROPERTIES( self );
// Determine the clone index
int clone_index = mlt_properties_get_int( properties, "_clone" );
// Determine the clone to use
mlt_producer clone = self;
if ( clone_index > 0 )
{
char key[ 25 ];
sprintf( key, "_clone.%d", clone_index - 1 );
clone = mlt_properties_get_data( MLT_PRODUCER_PROPERTIES( mlt_producer_cut_parent( self ) ), key, NULL );
if ( clone == NULL ) mlt_log( service, MLT_LOG_ERROR, "requested clone doesn't exist %d\n", clone_index );
clone = clone == NULL ? self : clone;
}
else
{
clone = parent;
}
// We need to seek to the correct position in the clone
mlt_producer_seek( clone, mlt_producer_get_in( self ) + mlt_properties_get_int( properties, "_position" ) );
// Assign the clone property to the parent
mlt_properties_set_data( parent_properties, "use_clone", clone, 0, NULL, NULL );
// Now get the frame from the parents service
result = mlt_service_get_frame( MLT_PRODUCER_SERVICE( parent ), frame, index );
// We're done with the clone now
mlt_properties_set_data( parent_properties, "use_clone", NULL, 0, NULL, NULL );
// This is useful and required by always_active transitions to determine in/out points of the cut
if ( mlt_properties_get_data( MLT_FRAME_PROPERTIES( *frame ), "_producer", NULL ) == MLT_PRODUCER_SERVICE( parent ) )
mlt_properties_set_data( MLT_FRAME_PROPERTIES( *frame ), "_producer", self, 0, NULL, NULL );
mlt_properties_set_double( MLT_FRAME_PROPERTIES( *frame ), "_speed", speed );
mlt_producer_prepare_next( self );
}
else
{
*frame = mlt_frame_init( service );
result = 0;
}
// Pass on all meta properties from the producer/cut on to the frame
if ( *frame != NULL && self != NULL )
{
int i = 0;
mlt_properties p_props = MLT_PRODUCER_PROPERTIES( self );
mlt_properties f_props = MLT_FRAME_PROPERTIES( *frame );
mlt_properties_lock( p_props );
int count = mlt_properties_count( p_props );
for ( i = 0; i < count; i ++ )
{
char *name = mlt_properties_get_name( p_props, i );
if ( !strncmp( name, "meta.", 5 ) )
mlt_properties_set( f_props, name, mlt_properties_get_value( p_props, i ) );
else if ( !strncmp( name, "set.", 4 ) )
mlt_properties_set( f_props, name + 4, mlt_properties_get_value( p_props, i ) );
}
mlt_properties_unlock( p_props );
}
return result;
}
mlt_producer producer_pango_init( const char *filename )
{
producer_pango this = calloc( sizeof( struct producer_pango_s ), 1 );
if ( this != NULL && mlt_producer_init( &this->parent, this ) == 0 )
{
mlt_producer producer = &this->parent;
pthread_mutex_lock( &pango_mutex );
if ( fontmap == NULL )
fontmap = (PangoFT2FontMap*) pango_ft2_font_map_new();
g_type_init();
pthread_mutex_unlock( &pango_mutex );
producer->get_frame = producer_get_frame;
producer->close = ( mlt_destructor )producer_close;
// Get the properties interface
mlt_properties properties = MLT_PRODUCER_PROPERTIES( &this->parent );
// Set the default properties
mlt_properties_set( properties, "fgcolour", "0xffffffff" );
mlt_properties_set( properties, "bgcolour", "0x00000000" );
mlt_properties_set( properties, "olcolour", "0x00000000" );
mlt_properties_set_int( properties, "align", pango_align_left );
mlt_properties_set_int( properties, "pad", 0 );
mlt_properties_set_int( properties, "outline", 0 );
mlt_properties_set( properties, "text", "" );
mlt_properties_set( properties, "font", NULL );
mlt_properties_set( properties, "family", "Sans" );
mlt_properties_set_int( properties, "size", 48 );
mlt_properties_set( properties, "style", "normal" );
mlt_properties_set( properties, "encoding", "UTF-8" );
mlt_properties_set_int( properties, "weight", PANGO_WEIGHT_NORMAL );
mlt_properties_set_int( properties, "seekable", 1 );
if ( filename == NULL || ( filename && ( !strcmp( filename, "" )
// workaround for old kdenlive countdown generator
|| strstr( filename, "<producer>" ) ) ) )
{
mlt_properties_set( properties, "markup", "" );
}
else if ( filename[ 0 ] == '+' || strstr( filename, "/+" ) )
{
char *copy = strdup( filename + 1 );
char *markup = copy;
if ( strstr( markup, "/+" ) )
markup = strstr( markup, "/+" ) + 2;
( *strrchr( markup, '.' ) ) = '\0';
while ( strchr( markup, '~' ) )
( *strchr( markup, '~' ) ) = '\n';
mlt_properties_set( properties, "resource", filename );
mlt_properties_set( properties, "markup", markup );
free( copy );
}
else if ( strstr( filename, ".mpl" ) )
{
int i = 0;
mlt_properties contents = mlt_properties_load( filename );
mlt_geometry key_frames = mlt_geometry_init( );
struct mlt_geometry_item_s item;
mlt_properties_set( properties, "resource", filename );
mlt_properties_set_data( properties, "contents", contents, 0, ( mlt_destructor )mlt_properties_close, NULL );
mlt_properties_set_data( properties, "key_frames", key_frames, 0, ( mlt_destructor )mlt_geometry_close, NULL );
// Make sure we have at least one entry
if ( mlt_properties_get( contents, "0" ) == NULL )
mlt_properties_set( contents, "0", "" );
for ( i = 0; i < mlt_properties_count( contents ); i ++ )
{
char *name = mlt_properties_get_name( contents, i );
char *value = mlt_properties_get_value( contents, i );
while ( value != NULL && strchr( value, '~' ) )
( *strchr( value, '~' ) ) = '\n';
item.frame = atoi( name );
mlt_geometry_insert( key_frames, &item );
}
mlt_geometry_interpolate( key_frames );
}
else
{
FILE *f = fopen( filename, "r" );
if ( f != NULL )
{
char line[81];
char *markup = NULL;
size_t size = 0;
line[80] = '\0';
while ( fgets( line, 80, f ) )
{
size += strlen( line ) + 1;
if ( markup )
{
markup = realloc( markup, size );
strcat( markup, line );
}
else
{
markup = strdup( line );
}
}
fclose( f );
if ( markup[ strlen( markup ) - 1 ] == '\n' )
markup[ strlen( markup ) - 1 ] = '\0';
mlt_properties_set( properties, "resource", filename );
mlt_properties_set( properties, "markup", ( markup == NULL ? "" : markup ) );
free( markup );
}
else
{
producer->close = NULL;
mlt_producer_close( producer );
producer = NULL;
free( this );
}
}
return producer;
}
free( this );
return NULL;
}
static void foreach_consumer_init( mlt_consumer consumer )
{
const char *resource = mlt_properties_get( MLT_CONSUMER_PROPERTIES(consumer), "resource" );
mlt_properties properties = mlt_properties_parse_yaml( resource );
char key[20];
int index = 0;
if ( mlt_properties_get_data( MLT_CONSUMER_PROPERTIES(consumer), "0", NULL ) )
{
// Properties set directly by application
mlt_properties p;
if ( properties )
mlt_properties_close( properties );
properties = MLT_CONSUMER_PROPERTIES(consumer);
do {
snprintf( key, sizeof(key), "%d", index );
if ( ( p = mlt_properties_get_data( properties, key, NULL ) ) )
generate_consumer( consumer, p, index++ );
} while ( p );
}
else if ( properties && mlt_properties_get_data( properties, "0", NULL ) )
{
// YAML file supplied
mlt_properties p;
do {
snprintf( key, sizeof(key), "%d", index );
if ( ( p = mlt_properties_get_data( properties, key, NULL ) ) )
generate_consumer( consumer, p, index++ );
} while ( p );
mlt_properties_close( properties );
}
else
{
// properties file supplied or properties on this consumer
const char *s;
if ( properties )
mlt_properties_close( properties );
if ( resource )
properties = mlt_properties_load( resource );
else
properties = MLT_CONSUMER_PROPERTIES( consumer );
do {
snprintf( key, sizeof(key), "%d", index );
if ( ( s = mlt_properties_get( properties, key ) ) )
{
mlt_properties p = mlt_properties_new();
int i, count;
if ( !p ) break;
mlt_properties_set( p, "mlt_service", mlt_properties_get( properties, key ) );
snprintf( key, sizeof(key), "%d.", index );
count = mlt_properties_count( properties );
for ( i = 0; i < count; i++ )
{
char *name = mlt_properties_get_name( properties, i );
if ( !strncmp( name, key, strlen(key) ) )
mlt_properties_set( p, name + strlen(key),
mlt_properties_get_value( properties, i ) );
}
generate_consumer( consumer, p, index++ );
mlt_properties_close( p );
}
} while ( s );
if ( resource )
mlt_properties_close( properties );
}
}
static int process_feed( mlt_properties feed, mlt_filter filter, mlt_frame frame )
{
// Error return
int error = 1;
// Get the properties of the data show filter
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Get the type requested by the feeding filter
char *type = mlt_properties_get( feed, "type" );
// Fetch the filter associated to this type
mlt_filter requested = mlt_properties_get_data( filter_properties, type, NULL );
// If it doesn't exist, then create it now
if ( requested == NULL )
{
// Source filter from profile
requested = obtain_filter( filter, type );
// Store it on the properties for subsequent retrieval/destruction
mlt_properties_set_data( filter_properties, type, requested, 0, ( mlt_destructor )mlt_filter_close, NULL );
}
// If we have one, then process it now...
if ( requested != NULL )
{
int i = 0;
mlt_properties properties = MLT_FILTER_PROPERTIES( requested );
static const char *prefix = "properties.";
int len = strlen( prefix );
// Determine if this is an absolute or relative feed
int absolute = mlt_properties_get_int( feed, "absolute" );
// Make do with what we have
int length = !absolute ?
mlt_properties_get_int( feed, "out" ) - mlt_properties_get_int( feed, "in" ) + 1 :
mlt_properties_get_int( feed, "out" ) + 1;
// Repeat period
int period = mlt_properties_get_int( properties, "period" );
period = period == 0 ? 1 : period;
// Pass properties from feed into requested
for ( i = 0; i < mlt_properties_count( properties ); i ++ )
{
char *name = mlt_properties_get_name( properties, i );
char *key = mlt_properties_get_value( properties, i );
if ( !strncmp( name, prefix, len ) )
{
if ( !strncmp( name + len, "length[", 7 ) )
{
mlt_properties_set_position( properties, key, ( length - period ) / period );
}
else
{
char *value = mlt_properties_get( feed, name + len );
if ( value != NULL )
{
// check for metadata keywords in metadata markup if user requested so
if ( mlt_properties_get_int( filter_properties, "dynamic" ) == 1 && !strcmp( name + strlen( name ) - 6, "markup") )
{
// Find keywords which should be surrounded by '#', like: #title#
char* keywords = strtok( value, "#" );
char result[512] = ""; // XXX: how much is enough?
int ct = 0;
int fromStart = ( value[0] == '#' ) ? 1 : 0;
while ( keywords != NULL )
{
if ( ct % 2 == fromStart )
{
// backslash in front of # suppresses substitution
if ( keywords[ strlen( keywords ) -1 ] == '\\' )
{
// keep characters except backslash
strncat( result, keywords, sizeof( result ) - strlen( result ) - 2 );
strcat( result, "#" );
ct++;
}
else
{
strncat( result, keywords, sizeof( result ) - strlen( result ) - 1 );
}
}
else if ( !strcmp( keywords, "timecode" ) )
{
// special case: replace #timecode# with current frame timecode
mlt_position frames = mlt_properties_get_position( feed, "position" );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
char *s = mlt_properties_frames_to_time( properties, frames, mlt_time_smpte_df );
if ( s )
strncat( result, s, sizeof( result ) - strlen( result ) - 1 );
}
else if ( !strcmp( keywords, "frame" ) )
{
// special case: replace #frame# with current frame number
int pos = mlt_properties_get_int( feed, "position" );
char s[12];
snprintf( s, sizeof(s) - 1, "%d", pos );
s[sizeof( s ) - 1] = '\0';
strncat( result, s, sizeof( result ) - strlen( result ) - 1 );
}
else
{
// replace keyword with metadata value
char *metavalue = metadata_value( MLT_FRAME_PROPERTIES( frame ), keywords );
strncat( result, metavalue ? metavalue : "-", sizeof( result ) - strlen( result ) -1 );
}
keywords = strtok( NULL, "#" );
ct++;
}
mlt_properties_set( properties, key, (char*) result );
}
else mlt_properties_set( properties, key, value );
}
}
}
}
// Set the original position on the frame
if ( absolute == 0 )
mlt_frame_set_position( frame, mlt_properties_get_int( feed, "position" ) - mlt_properties_get_int( feed, "in" ) );
else
mlt_frame_set_position( frame, mlt_properties_get_int( feed, "position" ) );
// Process the filter
mlt_filter_process( requested, frame );
// Should be ok...
error = 0;
}
return error;
}
static int refresh_pixbuf( producer_pixbuf self, mlt_frame frame )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Check if user wants us to reload the image
if ( mlt_properties_get_int( producer_props, "force_reload" ) )
{
self->pixbuf = NULL;
self->image = NULL;
mlt_properties_set_int( producer_props, "force_reload", 0 );
}
// Get the time to live for each frame
double ttl = mlt_properties_get_int( producer_props, "ttl" );
// Get the original position of this frame
mlt_position position = mlt_frame_original_position( frame );
position += mlt_producer_get_in( producer );
// Image index
int loop = mlt_properties_get_int( producer_props, "loop" );
int current_idx;
if (loop) {
current_idx = ( int )floor( ( double )position / ttl ) % self->count;
} else {
current_idx = MIN(( double )position / ttl, self->count - 1);
}
// Key for the cache
char image_key[ 10 ];
sprintf( image_key, "%d", current_idx );
int disable_exif = mlt_properties_get_int( producer_props, "disable_exif" );
if ( current_idx != self->pixbuf_idx )
self->pixbuf = NULL;
if ( !self->pixbuf || mlt_properties_get_int( producer_props, "_disable_exif" ) != disable_exif )
{
GError *error = NULL;
self->image = NULL;
pthread_mutex_lock( &g_mutex );
self->pixbuf = gdk_pixbuf_new_from_file( mlt_properties_get_value( self->filenames, current_idx ), &error );
if ( self->pixbuf )
{
// Read the exif value for this file
if ( !disable_exif )
self->pixbuf = reorient_with_exif( self, current_idx, self->pixbuf );
// Register this pixbuf for destruction and reuse
mlt_cache_item_close( self->pixbuf_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.pixbuf", self->pixbuf, 0, ( mlt_destructor )g_object_unref );
self->pixbuf_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.pixbuf" );
self->pixbuf_idx = current_idx;
// Store the width/height of the pixbuf temporarily
self->width = gdk_pixbuf_get_width( self->pixbuf );
self->height = gdk_pixbuf_get_height( self->pixbuf );
mlt_events_block( producer_props, NULL );
mlt_properties_set_int( producer_props, "meta.media.width", self->width );
mlt_properties_set_int( producer_props, "meta.media.height", self->height );
mlt_properties_set_int( producer_props, "_disable_exif", disable_exif );
mlt_events_unblock( producer_props, NULL );
}
pthread_mutex_unlock( &g_mutex );
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->width );
mlt_properties_set_int( properties, "height", self->height );
return current_idx;
}
static int transition_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Error we will return
int error = 0;
// We will get the 'b frame' from the frame stack
mlt_frame b_frame = mlt_frame_pop_frame( frame );
// Get the watermark transition object
mlt_transition transition = mlt_frame_pop_service( frame );
// Get the properties of the transitionfin
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( frame );
mlt_service_lock( MLT_TRANSITION_SERVICE( transition ) );
// Get the composite from the transition
mlt_transition composite = mlt_properties_get_data( properties, "composite", NULL );
// Look for the first filter
mlt_filter filter = mlt_properties_get_data( properties, "_filter_0", NULL );
// Get the position
mlt_position position = mlt_transition_get_position( transition, frame );
// Create a composite if we don't have one
if ( composite == NULL )
{
// Create composite via the factory
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
composite = mlt_factory_transition( profile, "composite", NULL );
// If we have one
if ( composite != NULL )
{
// Get the properties
mlt_properties composite_properties = MLT_TRANSITION_PROPERTIES( composite );
// We want to ensure that we don't get a wobble...
//mlt_properties_set_int( composite_properties, "distort", 1 );
mlt_properties_set_int( composite_properties, "progressive", 1 );
// Pass all the composite. properties on the transition down
mlt_properties_pass( composite_properties, properties, "composite." );
// Register the composite for reuse/destruction
mlt_properties_set_data( properties, "composite", composite, 0, ( mlt_destructor )mlt_transition_close, NULL );
}
}
else
{
// Pass all current properties down
mlt_properties composite_properties = MLT_TRANSITION_PROPERTIES( composite );
mlt_properties_pass( composite_properties, properties, "composite." );
}
// Create filters
if ( filter == NULL )
{
// Loop Variable
int i = 0;
// Number of filters created
int count = 0;
// Loop for all properties
for ( i = 0; i < mlt_properties_count( properties ); i ++ )
{
// Get the name of this property
char *name = mlt_properties_get_name( properties, i );
// If the name does not contain a . and matches filter
if ( strchr( name, '.' ) == NULL && !strncmp( name, "filter", 6 ) )
{
// Get the filter constructor
char *value = mlt_properties_get_value( properties, i );
// Create an instance
if ( create_instance( transition, name, value, count ) == 0 )
count ++;
}
}
// Look for the first filter again
filter = mlt_properties_get_data( properties, "_filter_0", NULL );
}
else
{
// Pass all properties down
mlt_filter temp = NULL;
// Loop Variable
int i = 0;
// Number of filters found
int count = 0;
// Loop for all properties
for ( i = 0; i < mlt_properties_count( properties ); i ++ )
{
// Get the name of this property
char *name = mlt_properties_get_name( properties, i );
// If the name does not contain a . and matches filter
if ( strchr( name, '.' ) == NULL && !strncmp( name, "filter", 6 ) )
{
// Strings to hold the id and pass down key
char id[ 256 ];
char key[ 256 ];
// Construct id and key
sprintf( id, "_filter_%d", count );
sprintf( key, "%s.", name );
// Get the filter
temp = mlt_properties_get_data( properties, id, NULL );
if ( temp != NULL )
{
mlt_properties_pass( MLT_FILTER_PROPERTIES( temp ), properties, key );
count ++;
}
}
}
}
mlt_properties_set_int( a_props, "width", *width );
mlt_properties_set_int( a_props, "height", *height );
// Only continue if we have both filter and composite
if ( composite != NULL )
{
// Get the resource of this filter (could be a shape [rectangle/circle] or an alpha provider of choice
const char *resource = mlt_properties_get( properties, "resource" );
// Get the old resource in case it's changed
char *old_resource = mlt_properties_get( properties, "_old_resource" );
// String to hold the filter to query on
char id[ 256 ];
// Index to hold the count
int i = 0;
// We will get the 'b frame' from the composite only if it's NULL (region filter)
if ( b_frame == NULL )
{
// Copy the region
b_frame = composite_copy_region( composite, frame, position );
// Ensure a destructor
char *name = mlt_properties_get( properties, "_unique_id" );
mlt_properties_set_data( a_props, name, b_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
// Properties of the B framr
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// filter_only prevents copying the alpha channel of the shape to the output frame
// by compositing filtered frame over itself
if ( mlt_properties_get_int( properties, "filter_only" ) )
{
char *name = mlt_properties_get( properties, "_unique_id" );
frame = composite_copy_region( composite, b_frame, position );
mlt_properties_set_data( b_props, name, frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
// Make sure the filter is in the correct position
while ( filter != NULL )
{
// Stack this filter
if ( mlt_properties_get_int( MLT_FILTER_PROPERTIES( filter ), "off" ) == 0 )
mlt_filter_process( filter, b_frame );
// Generate the key for the next
sprintf( id, "_filter_%d", ++ i );
// Get the next filter
filter = mlt_properties_get_data( properties, id, NULL );
}
// Allow filters to be attached to a region filter
filter = mlt_properties_get_data( properties, "_region_filter", NULL );
if ( filter != NULL )
mlt_service_apply_filters( MLT_FILTER_SERVICE( filter ), b_frame, 0 );
// Hmm - this is probably going to go wrong....
mlt_frame_set_position( frame, position );
// Get the b frame and process with composite if successful
mlt_transition_process( composite, frame, b_frame );
// If we have a shape producer copy the alpha mask from the shape frame to the b_frame
if ( strcmp( resource, "rectangle" ) != 0 )
{
// Get the producer from the transition
mlt_producer producer = mlt_properties_get_data( properties, "producer", NULL );
// If We have no producer then create one
if ( producer == NULL || ( old_resource != NULL && strcmp( resource, old_resource ) ) )
{
// Get the factory producer service
char *factory = mlt_properties_get( properties, "factory" );
// Store the old resource
mlt_properties_set( properties, "_old_resource", resource );
// Special case circle resource
if ( strcmp( resource, "circle" ) == 0 )
resource = "pixbuf:<svg width='100' height='100'><circle cx='50' cy='50' r='50' fill='black'/></svg>";
// Create the producer
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
producer = mlt_factory_producer( profile, factory, resource );
// If we have one
if ( producer != NULL )
{
// Get the producer properties
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
// Ensure that we loop
mlt_properties_set( producer_properties, "eof", "loop" );
// Now pass all producer. properties on the transition down
mlt_properties_pass( producer_properties, properties, "producer." );
// Register the producer for reuse/destruction
mlt_properties_set_data( properties, "producer", producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
}
}
// Now use the shape producer
if ( producer != NULL )
{
// We will get the alpha frame from the producer
mlt_frame shape_frame = NULL;
// Make sure the producer is in the correct position
mlt_producer_seek( producer, position );
// Get the shape frame
if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &shape_frame, 0 ) == 0 )
{
// Ensure that the shape frame will be closed
mlt_properties_set_data( b_props, "shape_frame", shape_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
if ( mlt_properties_get_int(properties, "holecolor") ) {
mlt_properties_set_int(b_props, "holecolor", mlt_properties_get_int(properties,"holecolor"));
}
// Specify the callback for evaluation
b_frame->get_alpha_mask = filter_get_alpha_mask;
}
}
}
// Get the image
error = mlt_frame_get_image( frame, image, format, width, height, 0 );
}
mlt_service_unlock( MLT_TRANSITION_SERVICE( transition ) );
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 pos = mlt_filter_get_position( filter, frame );
mlt_position len = mlt_filter_get_length2( filter, frame );
int maxdia = mlt_properties_anim_get_int( properties, "maxdiameter", pos, len );
int maxcount = mlt_properties_anim_get_int( properties, "maxcount", pos, len );
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Load svg
char *factory = mlt_properties_get( properties, "factory" );
char temp[1204] = "";
sprintf( temp, "%s/oldfilm/", mlt_environment( "MLT_DATA" ) );
mlt_properties direntries = mlt_properties_new();
mlt_properties_dir_list( direntries, temp,"dust*.svg",1 );
if (!maxcount)
return 0;
double position = mlt_filter_get_progress( filter, frame );
srand( position * 10000 );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
int im = rand() % maxcount;
int piccount = mlt_properties_count( direntries );
while ( im-- && piccount )
{
int picnum = rand() % piccount;
int y1 = rand() % *height;
int x1 = rand() % *width;
char resource[1024] = "";
char savename[1024] = "", savename1[1024] = "", cachedy[100];
int dx = ( *width * maxdia / 100);
int luma_width, luma_height;
uint8_t *luma_image = NULL;
uint8_t *alpha = NULL;
int updown = rand() % 2;
int mirror = rand() % 2;
sprintf( resource, "%s", mlt_properties_get_value(direntries,picnum) );
sprintf( savename, "cache-%d-%d", picnum,dx );
sprintf( savename1, "cache-alpha-%d-%d", picnum, dx );
sprintf( cachedy, "cache-dy-%d-%d", picnum,dx );
luma_image = mlt_properties_get_data( properties , savename , NULL );
alpha = mlt_properties_get_data( properties , savename1 , NULL );
if ( luma_image == NULL || alpha == NULL )
{
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
mlt_producer producer = mlt_factory_producer( profile, factory, resource );
if ( producer != NULL )
{
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_properties_set( producer_properties, "eof", "loop" );
mlt_frame luma_frame = NULL;
if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &luma_frame, 0 ) == 0 )
{
mlt_image_format luma_format = mlt_image_yuv422;
luma_width = dx;
luma_height = luma_width * mlt_properties_get_int( MLT_FRAME_PROPERTIES ( luma_frame ) , "height" ) / mlt_properties_get_int( MLT_FRAME_PROPERTIES ( luma_frame ) , "width" );
mlt_properties_set( MLT_FRAME_PROPERTIES( luma_frame ), "rescale.interp", "best" );// none/nearest/tiles/hyper
mlt_frame_get_image( luma_frame, &luma_image, &luma_format, &luma_width, &luma_height, 0 );
alpha = mlt_frame_get_alpha_mask (luma_frame );
uint8_t* savealpha = mlt_pool_alloc( luma_width * luma_height );
uint8_t* savepic = mlt_pool_alloc( luma_width * luma_height * 2);
if ( savealpha && savepic )
{
memcpy( savealpha, alpha , luma_width * luma_height );
memcpy( savepic, luma_image , luma_width * luma_height * 2 );
mlt_properties_set_data( properties, savename, savepic, luma_width * luma_height * 2, mlt_pool_release, NULL );
mlt_properties_set_data( properties, savename1, savealpha, luma_width * luma_height, mlt_pool_release, NULL );
mlt_properties_set_int( properties, cachedy, luma_height );
overlay_image( *image, *width, *height, luma_image, luma_width, luma_height, alpha, x1, y1, updown, mirror );
}
else
{
if ( savealpha )
mlt_pool_release( savealpha );
if ( savepic )
mlt_pool_release( savepic );
}
mlt_frame_close( luma_frame );
}
mlt_producer_close( producer );
}
}
else
{
overlay_image ( *image, *width, *height, luma_image, dx, mlt_properties_get_int ( properties, cachedy ), alpha, x1, y1, updown, mirror );
}
}
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
if (piccount>0 )
return 0;
if ( error == 0 && *image )
{
int h = *height;
int w = *width;
int im = rand() % maxcount;
while ( im-- )
{
int type = im % 2;
int y1 = rand() % h;
int x1 = rand() % w;
int dx = rand() % maxdia;
int dy = rand() % maxdia;
int x=0, y=0;
double v = 0.0;
for ( x = -dx ; x < dx ; x++ )
{
for ( y = -dy ; y < dy ; y++ )
{
if ( x1 + x < w && x1 + x > 0 && y1 + y < h && y1 + y > 0 ){
uint8_t *pix = *image + (y+y1) * w * 2 + (x + x1) * 2;
v=pow((double) x /(double)dx * 5.0, 2.0) + pow((double)y / (double)dy * 5.0, 2.0);
if (v>10)
v=10;
v = 1.0 - ( v / 10.0 );
switch(type)
{
case 0:
*pix -= (*pix) * v;
break;
case 1:
*pix += ( 255-*pix ) * v;
break;
}
}
}
}
}
}
return error;
}
int refresh_qimage( producer_qimage self, mlt_frame frame )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Check if user wants us to reload the image
if ( mlt_properties_get_int( producer_props, "force_reload" ) )
{
self->qimage = NULL;
self->current_image = NULL;
mlt_properties_set_int( producer_props, "force_reload", 0 );
}
// Get the time to live for each frame
double ttl = mlt_properties_get_int( producer_props, "ttl" );
// Get the original position of this frame
mlt_position position = mlt_frame_original_position( frame );
position += mlt_producer_get_in( producer );
// Image index
int image_idx = ( int )floor( ( double )position / ttl ) % self->count;
int disable_exif = mlt_properties_get_int( producer_props, "disable_exif" );
if ( !createQApplicationIfNeeded( MLT_PRODUCER_SERVICE(producer) ) )
return -1;
if ( image_idx != self->qimage_idx )
self->qimage = NULL;
if ( !self->qimage || mlt_properties_get_int( producer_props, "_disable_exif" ) != disable_exif )
{
self->current_image = NULL;
QImage *qimage = new QImage( QString::fromUtf8( mlt_properties_get_value( self->filenames, image_idx ) ) );
self->qimage = qimage;
if ( !qimage->isNull( ) )
{
// Read the exif value for this file
if ( !disable_exif )
qimage = reorient_with_exif( self, image_idx, qimage );
// Register qimage for destruction and reuse
mlt_cache_item_close( self->qimage_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage", qimage, 0, ( mlt_destructor )qimage_delete );
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage_idx = image_idx;
// Store the width/height of the qimage
self->current_width = qimage->width( );
self->current_height = qimage->height( );
mlt_events_block( producer_props, NULL );
mlt_properties_set_int( producer_props, "meta.media.width", self->current_width );
mlt_properties_set_int( producer_props, "meta.media.height", self->current_height );
mlt_properties_set_int( producer_props, "_disable_exif", disable_exif );
mlt_events_unblock( producer_props, NULL );
}
else
{
delete qimage;
self->qimage = NULL;
}
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->current_width );
mlt_properties_set_int( properties, "height", self->current_height );
return image_idx;
}
static mlt_producer create_producer( mlt_profile profile, char *file )
{
mlt_producer result = NULL;
// 1st Line - check for service:resource handling
if ( strchr( file, ':' ) )
{
char *temp = strdup( file );
char *service = temp;
char *resource = strchr( temp, ':' );
*resource ++ = '\0';
result = mlt_factory_producer( profile, service, resource );
free( temp );
}
// 2nd Line preferences
if ( result == NULL )
{
int i = 0;
char *lookup = strdup( file );
char *p = lookup;
// Make backup of profile for determining if we need to use 'consumer' producer.
mlt_profile backup_profile = mlt_profile_clone( profile );
// We only need to load the dictionary once
if ( dictionary == NULL )
{
char temp[ 1024 ];
sprintf( temp, "%s/core/loader.dict", mlt_environment( "MLT_DATA" ) );
dictionary = mlt_properties_load( temp );
mlt_factory_register_for_clean_up( dictionary, ( mlt_destructor )mlt_properties_close );
}
// Convert the lookup string to lower case
while ( *p )
{
*p = tolower( *p );
p ++;
}
// Iterate through the dictionary
for ( i = 0; result == NULL && i < mlt_properties_count( dictionary ); i ++ )
{
char *name = mlt_properties_get_name( dictionary, i );
if ( fnmatch( name, lookup, 0 ) == 0 )
result = create_from( profile, file, mlt_properties_get_value( dictionary, i ) );
}
// Check if the producer changed the profile - xml does this.
// The consumer producer does not handle frame rate differences.
if ( result && backup_profile->is_explicit && (
profile->width != backup_profile->width ||
profile->height != backup_profile->height ||
profile->sample_aspect_num != backup_profile->sample_aspect_num ||
profile->sample_aspect_den != backup_profile->sample_aspect_den ||
profile->colorspace != backup_profile->colorspace ) )
{
// Restore the original profile attributes.
profile->display_aspect_den = backup_profile->display_aspect_den;
profile->display_aspect_num = backup_profile->display_aspect_num;
profile->frame_rate_den = backup_profile->frame_rate_den;
profile->frame_rate_num = backup_profile->frame_rate_num;
profile->height = backup_profile->height;
profile->progressive = backup_profile->progressive;
profile->sample_aspect_den = backup_profile->sample_aspect_den;
profile->sample_aspect_num = backup_profile->sample_aspect_num;
profile->width = backup_profile->width;
// Use the 'consumer' producer.
mlt_producer_close( result );
result = mlt_factory_producer( profile, "consumer", file );
}
mlt_profile_close( backup_profile );
free( lookup );
}
// Finally, try just loading as service
if ( result == NULL )
result = mlt_factory_producer( profile, file, NULL );
return result;
}
int refresh_qimage( producer_qimage self, mlt_frame frame )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Check if user wants us to reload the image
if ( mlt_properties_get_int( producer_props, "force_reload" ) )
{
self->qimage = NULL;
self->current_image = NULL;
mlt_properties_set_int( producer_props, "force_reload", 0 );
}
// Get the time to live for each frame
double ttl = mlt_properties_get_int( producer_props, "ttl" );
// Get the original position of this frame
mlt_position position = mlt_frame_original_position( frame );
position += mlt_producer_get_in( producer );
// Image index
int image_idx = ( int )floor( ( double )position / ttl ) % self->count;
// Key for the cache
char image_key[ 10 ];
sprintf( image_key, "%d", image_idx );
int disable_exif = mlt_properties_get_int( producer_props, "disable_exif" );
if ( app == NULL )
{
if ( qApp )
{
app = qApp;
}
else
{
#ifdef linux
if ( getenv("DISPLAY") == 0 )
{
mlt_log_panic( MLT_PRODUCER_SERVICE( producer ), "Error, cannot render titles without an X11 environment.\nPlease either run melt from an X session or use a fake X server like xvfb:\nxvfb-run -a melt (...)\n" );
return -1;
}
#endif
int argc = 1;
char* argv[1];
argv[0] = (char*) "xxx";
app = new QApplication( argc, argv );
const char *localename = mlt_properties_get_lcnumeric( MLT_SERVICE_PROPERTIES( MLT_PRODUCER_SERVICE( producer ) ) );
QLocale::setDefault( QLocale( localename ) );
}
}
if ( image_idx != self->qimage_idx )
self->qimage = NULL;
if ( !self->qimage || mlt_properties_get_int( producer_props, "_disable_exif" ) != disable_exif )
{
self->current_image = NULL;
QImage *qimage = new QImage( QString::fromUtf8( mlt_properties_get_value( self->filenames, image_idx ) ) );
self->qimage = qimage;
if ( !qimage->isNull( ) )
{
// Read the exif value for this file
if ( !disable_exif )
qimage = reorient_with_exif( self, image_idx, qimage );
// Register qimage for destruction and reuse
mlt_cache_item_close( self->qimage_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage", qimage, 0, ( mlt_destructor )qimage_delete );
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage_idx = image_idx;
// Store the width/height of the qimage
self->current_width = qimage->width( );
self->current_height = qimage->height( );
mlt_events_block( producer_props, NULL );
mlt_properties_set_int( producer_props, "meta.media.width", self->current_width );
mlt_properties_set_int( producer_props, "meta.media.height", self->current_height );
mlt_properties_set_int( producer_props, "_disable_exif", disable_exif );
mlt_events_unblock( producer_props, NULL );
}
else
{
delete qimage;
self->qimage = NULL;
}
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->current_width );
mlt_properties_set_int( properties, "height", self->current_height );
return image_idx;
}
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;
}
}
static GdkPixbuf* reorient_with_exif( producer_pixbuf self, int image_idx, GdkPixbuf *pixbuf )
{
#ifdef USE_EXIF
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( &self->parent );
ExifData *d = exif_data_new_from_file( mlt_properties_get_value( self->filenames, image_idx ) );
ExifEntry *entry;
int exif_orientation = 0;
/* get orientation and rotate image accordingly if necessary */
if (d)
{
if ( ( entry = exif_content_get_entry ( d->ifd[EXIF_IFD_0], EXIF_TAG_ORIENTATION ) ) )
exif_orientation = exif_get_short (entry->data, exif_data_get_byte_order (d));
/* Free the EXIF data */
exif_data_unref(d);
}
// Remember EXIF value, might be useful for someone
mlt_properties_set_int( producer_props, "_exif_orientation" , exif_orientation );
if ( exif_orientation > 1 )
{
GdkPixbuf *processed = NULL;
GdkPixbufRotation matrix = GDK_PIXBUF_ROTATE_NONE;
// Rotate image according to exif data
switch ( exif_orientation ) {
case 2:
processed = gdk_pixbuf_flip ( pixbuf, TRUE );
break;
case 3:
matrix = GDK_PIXBUF_ROTATE_UPSIDEDOWN;
processed = pixbuf;
break;
case 4:
processed = gdk_pixbuf_flip ( pixbuf, FALSE );
break;
case 5:
matrix = GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE;
processed = gdk_pixbuf_flip ( pixbuf, TRUE );
break;
case 6:
matrix = GDK_PIXBUF_ROTATE_CLOCKWISE;
processed = pixbuf;
break;
case 7:
matrix = GDK_PIXBUF_ROTATE_CLOCKWISE;
processed = gdk_pixbuf_flip ( pixbuf, TRUE );
break;
case 8:
matrix = GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE;
processed = pixbuf;
break;
}
if ( processed )
{
pixbuf = gdk_pixbuf_rotate_simple( processed, matrix );
g_object_unref( processed );
}
}
#endif
return pixbuf;
}
