void mlt_multitrack_close( mlt_multitrack self )
{
if ( self != NULL && mlt_properties_dec_ref( MLT_MULTITRACK_PROPERTIES( self ) ) <= 0 )
{
int i = 0;
for ( i = 0; i < self->count; i ++ )
{
if ( self->list[ i ] != NULL )
{
mlt_event_close( self->list[ i ]->event );
mlt_producer_close( self->list[ i ]->producer );
free( self->list[ i ] );
}
}
// Close the producer
self->parent.close = NULL;
mlt_producer_close( &self->parent );
// Free the list
free( self->list );
// Free the object
free( self );
}
}
mlt_producer producer_consumer_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_producer self = mlt_producer_new( profile );
// Encapsulate the real producer
mlt_profile temp_profile = mlt_profile_clone( profile );
temp_profile->is_explicit = 0;
mlt_producer real_producer = mlt_factory_producer( temp_profile, NULL, arg );
if ( self && real_producer )
{
// Override some producer methods
self->close = ( mlt_destructor )producer_close;
self->get_frame = get_frame;
// Get the properties of this producer
mlt_properties properties = MLT_PRODUCER_PROPERTIES( self );
mlt_properties_set( properties, "resource", arg );
mlt_properties_pass_list( properties, MLT_PRODUCER_PROPERTIES( real_producer ), "out, length" );
// Done with the producer - will re-open later when we have the profile property
mlt_producer_close( real_producer );
}
else
{
if ( self )
mlt_producer_close( self );
if ( real_producer )
mlt_producer_close( real_producer );
self = NULL;
}
mlt_profile_close( temp_profile );
return self;
}
void MltRuntime::init() throw(Exception)
{
stop();
Lock lk(&run_lock);
Status svst = status;
status = StatusCreated;
if ( producer_version != json_version) {
if (producer)mlt_producer_close(producer);
producer = NULL;
}
else {
if (producer && svst == StatusLoaded) {
status = StatusLoaded;
return;
}
else if (producer ){
if (producer)mlt_producer_close(producer);
producer = NULL;
}
}
status = StatusLoadFailed;
if ( json_serialize == NULL)
throw_error_v(ErrorImplError, "running with empty json_serailzed");
producer = (mlt_producer) MltLoader::load_mlt(JsonWrap(json_serialize));
producer_version = json_version;
mlt_producer_optimise(producer);
status = StatusLoaded;
}
mlt_producer producer_vorbis_init( mlt_profile profile, mlt_service_type type, const char *id, char *file )
{
mlt_producer this = NULL;
// Check that we have a non-NULL argument
if ( file != NULL )
{
// Construct the producer
this = calloc( 1, sizeof( struct mlt_producer_s ) );
// Initialise it
if ( mlt_producer_init( this, NULL ) == 0 )
{
// Get the properties
mlt_properties properties = MLT_PRODUCER_PROPERTIES( this );
// Set the resource property (required for all producers)
mlt_properties_set( properties, "resource", file );
// Register our get_frame implementation
this->get_frame = producer_get_frame;
// Open the file
if ( producer_open( this, profile, file ) != 0 )
{
// Clean up
mlt_producer_close( this );
this = NULL;
}
}
}
return this;
}
static void producer_close( mlt_producer producer )
{
/* fprintf(stderr, ":::::::::::::: CLOSING TITLE\n"); */
producer->close = NULL;
mlt_producer_close( producer );
free( producer );
}
static void producer_close( mlt_producer self )
{
context cx = mlt_properties_get_data( MLT_PRODUCER_PROPERTIES( self ), "context", NULL );
// Shut down all the encapsulated services
if ( cx )
{
mlt_consumer_stop( cx->consumer );
mlt_consumer_close( cx->consumer );
mlt_producer_close( cx->producer );
mlt_profile_close( cx->profile );
}
self->close = NULL;
mlt_producer_close( self );
free( self );
}
static void producer_close( mlt_producer parent )
{
// Close the parent
parent->close = NULL;
mlt_producer_close( parent );
// Free the memory
free( parent );
}
static void producer_close( mlt_producer producer )
{
producer_ktitle self = producer->child;
producer->close = NULL;
mlt_service_cache_purge( MLT_PRODUCER_SERVICE( producer ) );
mlt_producer_close( producer );
free( self );
}
static void producer_close( mlt_producer parent )
{
producer_qimage self = parent->child;
parent->close = NULL;
mlt_service_cache_purge( MLT_PRODUCER_SERVICE(parent) );
mlt_producer_close( parent );
mlt_properties_close( self->filenames );
free( self );
}
void mlt_tractor_close( mlt_tractor self )
{
if ( self != NULL && mlt_properties_dec_ref( MLT_TRACTOR_PROPERTIES( self ) ) <= 0 )
{
self->parent.close = NULL;
mlt_producer_close( &self->parent );
free( self );
}
}
MltRuntime::~MltRuntime()
{
try {
stop();
}
catch(const Exception& e) {}
if (producer)mlt_producer_close(producer);
if (consumer)mlt_consumer_close(consumer);
if (json_serialize) json_decref(json_serialize);
}
int mlt_multitrack_connect( mlt_multitrack self, mlt_producer producer, int track )
{
// Connect to the producer to ourselves at the specified track
int result = mlt_service_connect_producer( MLT_MULTITRACK_SERVICE( self ), MLT_PRODUCER_SERVICE( producer ), track );
if ( result == 0 )
{
mlt_track current_track = ( track < self->count )? self->list[ track ] : NULL;
// Resize the producer list if need be
if ( track >= self->size )
{
int i;
self->list = realloc( self->list, ( track + 10 ) * sizeof( mlt_track ) );
for ( i = self->size; i < track + 10; i ++ )
self->list[ i ] = NULL;
self->size = track + 10;
}
if ( current_track )
{
mlt_event_close( current_track->event );
mlt_producer_close( current_track->producer );
}
else
{
self->list[ track ] = malloc( sizeof( struct mlt_track_s ) );
}
// Assign the track in our list here
self->list[ track ]->producer = producer;
self->list[ track ]->event = mlt_events_listen( MLT_PRODUCER_PROPERTIES( producer ), self,
"producer-changed", ( mlt_listener )mlt_multitrack_listener );
mlt_properties_inc_ref( MLT_PRODUCER_PROPERTIES( producer ) );
mlt_event_inc_ref( self->list[ track ]->event );
// Increment the track count if need be
if ( track >= self->count )
{
self->count = track + 1;
// TODO: Move this into producer_avformat.c when mlt_events broadcasting is available.
if ( self->count > mlt_service_cache_get_size( MLT_MULTITRACK_SERVICE( self ), "producer_avformat" ) )
mlt_service_cache_set_size( MLT_MULTITRACK_SERVICE( self ), "producer_avformat", self->count + 1 );
}
// Refresh our stats
mlt_multitrack_refresh( self );
}
return result;
}
static void producer_close( mlt_producer parent )
{
if ( parent != NULL )
{
// Obtain this
producer_kino this = parent->child;
// Close the file
if ( this != NULL )
kino_wrapper_close( this->wrapper );
// Close the parent
parent->close = NULL;
mlt_producer_close( parent );
// Free the memory
free( this );
}
}
int main( int argc, char **argv )
{
// Initialise the factory
if ( mlt_factory_init( NULL ) == 0 )
{
// Create the default consumer
mlt_consumer hello = mlt_factory_consumer( NULL, NULL );
// Create a producer using the default normalising selecter
mlt_producer world = create_tracks( argc, argv );
// Connect the producer to the consumer
mlt_consumer_connect( hello, mlt_producer_service( world ) );
// Start the consumer
mlt_consumer_start( hello );
// Wait for the consumer to terminate
while( !mlt_consumer_is_stopped( hello ) )
sleep( 1 );
// Close the consumer
mlt_consumer_close( hello );
// Close the producer
mlt_producer_close( world );
// Close the factory
mlt_factory_close( );
}
else
{
// Report an error during initialisation
fprintf( stderr, "Unable to locate factory modules\n" );
}
// End of program
return 0;
}
int mlt_multitrack_disconnect( mlt_multitrack self, int track )
{
int error = -1;
if ( self && self->list && track >= 0 && track < self->count )
{
// Disconnect the track producer.
error = mlt_service_disconnect_producer( MLT_MULTITRACK_SERVICE(self), track );
if ( !error )
{
// Release references on track.
if ( self->list[ track ] )
{
mlt_producer_close( self->list[ track ]->producer );
mlt_event_close( self->list[ track ]->event );
if ( track + 1 >= self-> count )
{
free( self->list[ track ] );
self->list[ track ] = NULL;
}
}
// Contract the list of tracks.
for ( ; track + 1 < self->count; track ++ )
{
if ( self->list[ track ] && self->list[ track + 1 ] )
{
self->list[ track ]->producer = self->list[ track + 1 ]->producer;
self->list[ track ]->event = self->list[ track + 1 ]->event;
}
}
self->count --;
// Recalculate the duration.
mlt_multitrack_refresh( self );
}
}
return error;
}
mlt_producer producer_qtext_init( mlt_profile profile, mlt_service_type type, const char *id, char *filename )
{
// Create a new producer object
mlt_producer producer = mlt_producer_new( profile );
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
// Initialize the producer
if ( producer )
{
if ( !createQApplicationIfNeeded( MLT_PRODUCER_SERVICE(producer) ) )
{
mlt_producer_close( producer );
return NULL;
}
mlt_properties_set( producer_properties, "text", "" );
mlt_properties_set( producer_properties, "fgcolour", "0xffffffff" );
mlt_properties_set( producer_properties, "bgcolour", "0x00000000" );
mlt_properties_set( producer_properties, "olcolour", "0x00000000" );
mlt_properties_set( producer_properties, "outline", "0" );
mlt_properties_set( producer_properties, "align", "left" );
mlt_properties_set( producer_properties, "pad", "0" );
mlt_properties_set( producer_properties, "family", "Sans" );
mlt_properties_set( producer_properties, "size", "48" );
mlt_properties_set( producer_properties, "style", "normal" );
mlt_properties_set( producer_properties, "weight", "400" );
mlt_properties_set( producer_properties, "encoding", "UTF-8" );
// Parse the filename argument
if ( filename == NULL ||
!strcmp( filename, "" ) ||
strstr( filename, "<producer>" ) )
{
}
else if( filename[ 0 ] == '+' || strstr( filename, "/+" ) )
{
char *copy = strdup( filename + 1 );
char *tmp = copy;
if ( strstr( tmp, "/+" ) )
tmp = strstr( tmp, "/+" ) + 2;
if ( strrchr( tmp, '.' ) )
( *strrchr( tmp, '.' ) ) = '\0';
while ( strchr( tmp, '~' ) )
( *strchr( tmp, '~' ) ) = '\n';
mlt_properties_set( producer_properties, "text", tmp );
mlt_properties_set( producer_properties, "resource", filename );
free( copy );
}
else
{
// Convert file name string encoding.
mlt_properties_set( producer_properties, "resource", filename );
mlt_properties_from_utf8( producer_properties, "resource", "_resource" );
filename = mlt_properties_get( producer_properties, "_resource" );
FILE *f = fopen( filename, "r" );
if ( f != NULL )
{
char line[81];
char *tmp = NULL;
size_t size = 0;
line[80] = '\0';
while ( fgets( line, 80, f ) )
{
size += strlen( line ) + 1;
if ( tmp )
{
tmp = (char*)realloc( tmp, size );
if ( tmp )
strcat( tmp, line );
}
else
{
tmp = strdup( line );
}
}
fclose( f );
if ( tmp && tmp[ strlen( tmp ) - 1 ] == '\n' )
tmp[ strlen( tmp ) - 1 ] = '\0';
if ( tmp )
mlt_properties_set( producer_properties, "text", tmp );
free( tmp );
}
}
// Create QT objects to be reused.
mlt_properties_set_data( producer_properties, "_qimg", static_cast<void*>( new QImage() ), 0, close_qimg, NULL );
mlt_properties_set_data( producer_properties, "_qpath", static_cast<void*>( new QPainterPath() ), 0, close_qpath, NULL );
// Callback registration
producer->get_frame = producer_get_frame;
producer->close = ( mlt_destructor )producer_close;
}
return producer;
}
SingleResourceLoader::~SingleResourceLoader()
{
if ( producer_tmp ) mlt_producer_close(producer_tmp);
}
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;
}
int main( int argc, char **argv )
{
char temp[ 132 ];
char *file1 = NULL;
char *text = NULL;
mlt_factory_init( "../modules" );
if ( argc < 3 )
{
fprintf( stderr, "usage: pango file.mpeg text_to_display\n" );
return 1;
}
else
{
file1 = argv[ 1 ];
text = argv[ 2 ];
}
// Start the consumer...
mlt_consumer consumer = mlt_factory_consumer( "bluefish", "NTSC" );
// Create the producer(s)
mlt_playlist pl1 = mlt_playlist_init();
mlt_producer dv1 = mlt_factory_producer( "mcmpeg", file1 );
mlt_playlist_append( pl1, dv1 );
mlt_playlist pl2 = mlt_playlist_init();
mlt_producer title = mlt_factory_producer( "pango", NULL ); //"<span font_desc=\"Sans Bold 36\">Mutton <span font_desc=\"Luxi Serif Bold Oblique 36\">Lettuce</span> Tomato</span>" );
mlt_playlist_append( pl2, title );
mlt_properties_set( mlt_producer_properties( title ), "family", "Sans" );
mlt_properties_set( mlt_producer_properties( title ), "size", "36" );
mlt_properties_set( mlt_producer_properties( title ), "weight", "700" );
mlt_properties_set( mlt_producer_properties( title ), "text", text );
mlt_properties_set_int( mlt_producer_properties( title ), "bgcolor", 0x0000007f );
mlt_properties_set_int( mlt_producer_properties( title ), "pad", 8 );
mlt_properties_set_int( mlt_producer_properties( title ), "align", 1 );
mlt_properties_set_int( mlt_producer_properties( title ), "x", 200 );
mlt_properties_set_int( mlt_producer_properties( title ), "y", 40 );
mlt_properties_set_double( mlt_producer_properties( title ), "mix", 0.8 );
// Register producers(s) with a multitrack object
mlt_multitrack multitrack = mlt_multitrack_init( );
mlt_multitrack_connect( multitrack, mlt_playlist_producer( pl1 ), 0 );
mlt_multitrack_connect( multitrack, mlt_playlist_producer( pl2 ), 1 );
// Define a transition
mlt_transition transition = mlt_factory_transition( "composite", NULL );
mlt_transition_connect( transition, mlt_multitrack_service( multitrack ), 0, 1 );
mlt_transition_set_in_and_out( transition, 0.0, 9999.0 );
// Buy a tractor and connect it to the filter
mlt_tractor tractor = mlt_tractor_init( );
mlt_tractor_connect( tractor, mlt_transition_service( transition ) );
// Connect the tractor to the consumer
mlt_consumer_connect( consumer, mlt_tractor_service( tractor ) );
// Do stuff until we're told otherwise...
fprintf( stderr, "Press return to continue\n" );
fgets( temp, 132, stdin );
// Close everything...
mlt_consumer_close( consumer );
mlt_tractor_close( tractor );
mlt_transition_close( transition );
mlt_multitrack_close( multitrack );
mlt_playlist_close( pl1 );
mlt_playlist_close( pl2 );
mlt_producer_close( dv1 );
mlt_producer_close( title );
return 0;
}
~ImageProducer() {
if (producerFrame)
mlt_frame_close(producerFrame);
mlt_producer_close(producer);
}
/** Constructor for the filter.
*/
mlt_filter filter_dynamictext_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new();
mlt_transition transition = mlt_factory_transition( profile, "composite", NULL );
mlt_producer producer = mlt_factory_producer( profile, mlt_environment( "MLT_PRODUCER" ), "qtext:" );
// Use pango if qtext is not available.
if( !producer )
producer = mlt_factory_producer( profile, mlt_environment( "MLT_PRODUCER" ), "pango:" );
if ( filter && transition && producer )
{
mlt_properties my_properties = MLT_FILTER_PROPERTIES( filter );
// Register the transition for reuse/destruction
mlt_properties_set_data( my_properties, "_transition", transition, 0, ( mlt_destructor )mlt_transition_close, NULL );
// Register the producer for reuse/destruction
mlt_properties_set_data( my_properties, "_producer", producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
// Ensure that we loop
mlt_properties_set( MLT_PRODUCER_PROPERTIES( producer ), "eof", "loop" );
// Assign default values
mlt_properties_set( my_properties, "argument", arg ? arg: "#timecode#" );
mlt_properties_set( my_properties, "geometry", "0%/0%:100%x100%:100" );
mlt_properties_set( my_properties, "family", "Sans" );
mlt_properties_set( my_properties, "size", "48" );
mlt_properties_set( my_properties, "weight", "400" );
mlt_properties_set( my_properties, "fgcolour", "0x000000ff" );
mlt_properties_set( my_properties, "bgcolour", "0x00000020" );
mlt_properties_set( my_properties, "olcolour", "0x00000000" );
mlt_properties_set( my_properties, "pad", "0" );
mlt_properties_set( my_properties, "halign", "left" );
mlt_properties_set( my_properties, "valign", "top" );
mlt_properties_set( my_properties, "outline", "0" );
mlt_properties_set_int( my_properties, "_filter_private", 1 );
filter->process = filter_process;
}
else
{
if( filter )
{
mlt_filter_close( filter );
}
if( transition )
{
mlt_transition_close( transition );
}
if( producer )
{
mlt_producer_close( producer );
}
filter = NULL;
}
return filter;
}
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;
}
mlt_producer producer_avformat_init( mlt_profile profile, char *file )
{
int error = 0;
// Report information about available demuxers and codecs as YAML Tiny
if ( file && strstr( file, "f-list" ) )
{
fprintf( stderr, "---\nformats:\n" );
AVInputFormat *format = NULL;
while ( ( format = av_iformat_next( format ) ) )
fprintf( stderr, " - %s\n", format->name );
fprintf( stderr, "...\n" );
error = 1;
}
if ( file && strstr( file, "acodec-list" ) )
{
fprintf( stderr, "---\naudio_codecs:\n" );
AVCodec *codec = NULL;
while ( ( codec = av_codec_next( codec ) ) )
if ( codec->decode && codec->type == CODEC_TYPE_AUDIO )
fprintf( stderr, " - %s\n", codec->name );
fprintf( stderr, "...\n" );
error = 1;
}
if ( file && strstr( file, "vcodec-list" ) )
{
fprintf( stderr, "---\nvideo_codecs:\n" );
AVCodec *codec = NULL;
while ( ( codec = av_codec_next( codec ) ) )
if ( codec->decode && codec->type == CODEC_TYPE_VIDEO )
fprintf( stderr, " - %s\n", codec->name );
fprintf( stderr, "...\n" );
error = 1;
}
if ( error )
return NULL;
mlt_producer this = NULL;
// Check that we have a non-NULL argument
if ( file != NULL )
{
// Construct the producer
this = calloc( 1, sizeof( struct mlt_producer_s ) );
// Initialise it
if ( mlt_producer_init( this, NULL ) == 0 )
{
// Get the properties
mlt_properties properties = MLT_PRODUCER_PROPERTIES( this );
// Set the resource property (required for all producers)
mlt_properties_set( properties, "resource", file );
// Register our get_frame implementation
this->get_frame = producer_get_frame;
// Open the file
if ( producer_open( this, profile, file ) != 0 )
{
// Clean up
mlt_producer_close( this );
this = NULL;
}
else
{
// Close the file to release resources for large playlists - reopen later as needed
mlt_properties_set_data( properties, "dummy_context", NULL, 0, NULL, NULL );
mlt_properties_set_data( properties, "audio_context", NULL, 0, NULL, NULL );
mlt_properties_set_data( properties, "video_context", NULL, 0, NULL, NULL );
// Default the user-selectable indices from the auto-detected indices
mlt_properties_set_int( properties, "audio_index", mlt_properties_get_int( properties, "_audio_index" ) );
mlt_properties_set_int( properties, "video_index", mlt_properties_get_int( properties, "_video_index" ) );
}
}
}
return this;
}
int main( int argc, char **argv )
{
char temp[ 132 ];
char *file1 = NULL;
char *file2 = NULL;
char *wipe = NULL;
mlt_factory_init( "../modules" );
if ( argc < 4 )
{
fprintf( stderr, "usage: luma file1.mpeg file2.mpeg wipe.pgm\n" );
return 1;
}
else
{
file1 = argv[ 1 ];
file2 = argv[ 2 ];
wipe = argv[ 3 ];
}
// Start the consumer...
mlt_consumer consumer = mlt_factory_consumer( "bluefish", "NTSC" );
// Create the producer(s)
mlt_producer dv1 = mlt_factory_producer( "mcmpeg", file1 );
mlt_producer dv2 = mlt_factory_producer( "mcmpeg", file2 );
mlt_playlist playlist1 = mlt_playlist_init();
mlt_playlist_append_io( playlist1, dv1, 0.0, 5.0 );
mlt_playlist playlist2 = mlt_playlist_init();
mlt_playlist_blank( playlist2, 2.9 );
mlt_playlist_append( playlist2, dv2 );
// Register producers(s) with a multitrack object
mlt_multitrack multitrack = mlt_multitrack_init( );
mlt_multitrack_connect( multitrack, mlt_playlist_producer( playlist1 ), 0 );
mlt_multitrack_connect( multitrack, mlt_playlist_producer( playlist2 ), 1 );
// Define a transition
mlt_transition transition = mlt_factory_transition( "luma", wipe );
mlt_properties_set( mlt_transition_properties( transition ), "filename", wipe );
mlt_properties_set_double( mlt_transition_properties( transition ), "softness", 0.1 );
mlt_transition_connect( transition, mlt_multitrack_service( multitrack ), 0, 1 );
mlt_transition_set_in_and_out( transition, 3.0, 5.0 );
// Buy a tractor and connect it to the filter
mlt_tractor tractor = mlt_tractor_init( );
mlt_tractor_connect( tractor, mlt_transition_service( transition ) );
// Connect the tractor to the consumer
mlt_consumer_connect( consumer, mlt_tractor_service( tractor ) );
// Do stuff until we're told otherwise...
fprintf( stderr, "Press return to continue\n" );
fgets( temp, 132, stdin );
// Close everything...
mlt_consumer_close( consumer );
mlt_tractor_close( tractor );
mlt_transition_close( transition );
mlt_multitrack_close( multitrack );
mlt_playlist_close( playlist1 );
mlt_playlist_close( playlist2 );
mlt_producer_close( dv1 );
mlt_producer_close( dv2 );
return 0;
}
int main( int argc, char **argv )
{
int i;
mlt_consumer consumer = NULL;
FILE *store = NULL;
char *name = NULL;
mlt_profile profile = NULL;
int is_progress = 0;
int is_silent = 0;
mlt_profile backup_profile;
// Handle abnormal exit situations.
signal( SIGSEGV, abnormal_exit_handler );
signal( SIGILL, abnormal_exit_handler );
signal( SIGABRT, abnormal_exit_handler );
// Construct the factory
mlt_repository repo = mlt_factory_init( NULL );
#if defined(WIN32) && !defined(MELT_NOSDL)
is_silent = 1;
#endif
for ( i = 1; i < argc; i ++ )
{
// Check for serialisation switch
if ( !strcmp( argv[ i ], "-serialise" ) )
{
name = argv[ ++ i ];
if ( name != NULL && strstr( name, ".melt" ) )
store = fopen( name, "w" );
else
{
if ( name == NULL || name[0] == '-' )
store = stdout;
name = NULL;
}
}
// Look for the profile option
else if ( !strcmp( argv[ i ], "-profile" ) )
{
const char *pname = argv[ ++ i ];
if ( pname && pname[0] != '-' )
profile = mlt_profile_init( pname );
}
else if ( !strcmp( argv[ i ], "-progress" ) )
{
is_progress = 1;
}
else if ( !strcmp( argv[ i ], "-progress2" ) )
{
is_progress = 2;
}
// Look for the query option
else if ( !strcmp( argv[ i ], "-query" ) )
{
const char *pname = argv[ ++ i ];
if ( pname && pname[0] != '-' )
{
if ( !strcmp( pname, "consumers" ) || !strcmp( pname, "consumer" ) )
query_services( repo, consumer_type );
else if ( !strcmp( pname, "filters" ) || !strcmp( pname, "filter" ) )
query_services( repo, filter_type );
else if ( !strcmp( pname, "producers" ) || !strcmp( pname, "producer" ) )
query_services( repo, producer_type );
else if ( !strcmp( pname, "transitions" ) || !strcmp( pname, "transition" ) )
query_services( repo, transition_type );
else if ( !strcmp( pname, "profiles" ) || !strcmp( pname, "profile" ) )
query_profiles();
else if ( !strcmp( pname, "presets" ) || !strcmp( pname, "preset" ) )
query_presets();
else if ( !strncmp( pname, "format", 6 ) )
query_formats();
else if ( !strncmp( pname, "acodec", 6 ) || !strcmp( pname, "audio_codecs" ) )
query_acodecs();
else if ( !strncmp( pname, "vcodec", 6 ) || !strcmp( pname, "video_codecs" ) )
query_vcodecs();
else if ( !strncmp( pname, "consumer=", 9 ) )
query_metadata( repo, consumer_type, "consumer", strchr( pname, '=' ) + 1 );
else if ( !strncmp( pname, "filter=", 7 ) )
query_metadata( repo, filter_type, "filter", strchr( pname, '=' ) + 1 );
else if ( !strncmp( pname, "producer=", 9 ) )
query_metadata( repo, producer_type, "producer", strchr( pname, '=' ) + 1 );
else if ( !strncmp( pname, "transition=", 11 ) )
query_metadata( repo, transition_type, "transition", strchr( pname, '=' ) + 1 );
else if ( !strncmp( pname, "profile=", 8 ) )
query_profile( strchr( pname, '=' ) + 1 );
else if ( !strncmp( pname, "preset=", 7 ) )
query_preset( strchr( pname, '=' ) + 1 );
else
goto query_all;
}
else
{
query_all:
query_services( repo, consumer_type );
query_services( repo, filter_type );
query_services( repo, producer_type );
query_services( repo, transition_type );
fprintf( stdout, "# You can query the metadata for a specific service using:\n"
"# -query <type>=<identifer>\n"
"# where <type> is one of: consumer, filter, producer, or transition.\n" );
}
goto exit_factory;
}
else if ( !strcmp( argv[ i ], "-silent" ) )
{
is_silent = 1;
}
else if ( !strcmp( argv[ i ], "-verbose" ) )
{
mlt_log_set_level( MLT_LOG_VERBOSE );
}
else if ( !strcmp( argv[ i ], "-version" ) || !strcmp( argv[ i ], "--version" ) )
{
fprintf( stdout, "%s " VERSION "\n"
"Copyright (C) 2002-2013 Ushodaya Enterprises Limited\n"
"<http://www.mltframework.org/>\n"
"This is free software; see the source for copying conditions. There is NO\n"
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
basename( argv[0] ) );
goto exit_factory;
}
else if ( !strcmp( argv[ i ], "-debug" ) )
{
mlt_log_set_level( MLT_LOG_DEBUG );
}
}
if ( !is_silent && !isatty( STDIN_FILENO ) && !is_progress )
is_progress = 1;
// Create profile if not set explicitly
if ( getenv( "MLT_PROFILE" ) )
profile = mlt_profile_init( NULL );
if ( profile == NULL )
profile = mlt_profile_init( NULL );
else
profile->is_explicit = 1;
// Look for the consumer option to load profile settings from consumer properties
backup_profile = mlt_profile_clone( profile );
load_consumer( &consumer, profile, argc, argv );
// If the consumer changed the profile, then it is explicit.
if ( backup_profile && !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->frame_rate_den != backup_profile->frame_rate_den ||
profile->frame_rate_num != backup_profile->frame_rate_num ||
profile->colorspace != backup_profile->colorspace ) )
profile->is_explicit = 1;
mlt_profile_close( backup_profile );
// Get melt producer
if ( argc > 1 )
melt = mlt_factory_producer( profile, "melt", &argv[ 1 ] );
if ( melt )
{
// Generate an automatic profile if needed.
if ( ! profile->is_explicit )
{
mlt_profile_from_producer( profile, melt );
mlt_producer_close( melt );
melt = mlt_factory_producer( profile, "melt", &argv[ 1 ] );
}
// Reload the consumer with the fully qualified profile.
// The producer or auto-profile could have changed the profile.
load_consumer( &consumer, profile, argc, argv );
// See if producer has consumer already attached
if ( !store && !consumer )
{
consumer = MLT_CONSUMER( mlt_service_consumer( MLT_PRODUCER_SERVICE( melt ) ) );
if ( consumer )
{
mlt_properties_inc_ref( MLT_CONSUMER_PROPERTIES(consumer) ); // because we explicitly close it
mlt_properties_set_data( MLT_CONSUMER_PROPERTIES(consumer),
"transport_callback", transport_action, 0, NULL, NULL );
}
}
// If we have no consumer, default to sdl
if ( store == NULL && consumer == NULL )
consumer = create_consumer( profile, NULL );
}
// Set transport properties on consumer and produder
if ( consumer != NULL && melt != NULL )
{
mlt_properties_set_data( MLT_CONSUMER_PROPERTIES( consumer ), "transport_producer", melt, 0, NULL, NULL );
mlt_properties_set_data( MLT_PRODUCER_PROPERTIES( melt ), "transport_consumer", consumer, 0, NULL, NULL );
if ( is_progress )
mlt_properties_set_int( MLT_CONSUMER_PROPERTIES( consumer ), "progress", is_progress );
if ( is_silent )
mlt_properties_set_int( MLT_CONSUMER_PROPERTIES( consumer ), "silent", is_silent );
}
if ( argc > 1 && melt != NULL && mlt_producer_get_length( melt ) > 0 )
{
// Parse the arguments
for ( i = 1; i < argc; i ++ )
{
if ( !strcmp( argv[ i ], "-jack" ) )
{
setup_jack_transport( consumer, profile );
}
else if ( !strcmp( argv[ i ], "-serialise" ) )
{
if ( store != stdout )
i ++;
}
else
{
if ( store != NULL )
fprintf( store, "%s\n", argv[ i ] );
i ++;
while ( argv[ i ] != NULL && argv[ i ][ 0 ] != '-' )
{
if ( store != NULL )
fprintf( store, "%s\n", argv[ i ] );
i += 1;
}
i --;
}
}
if ( consumer != NULL && store == NULL )
{
// Get melt's properties
mlt_properties melt_props = MLT_PRODUCER_PROPERTIES( melt );
// Get the last group
mlt_properties group = mlt_properties_get_data( melt_props, "group", 0 );
// Apply group settings
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
mlt_properties_inherit( properties, group );
// Connect consumer to melt
mlt_consumer_connect( consumer, MLT_PRODUCER_SERVICE( melt ) );
// Start the consumer
mlt_events_listen( properties, consumer, "consumer-fatal-error", ( mlt_listener )on_fatal_error );
if ( mlt_consumer_start( consumer ) == 0 )
{
// Try to exit gracefully upon these signals
signal( SIGINT, stop_handler );
signal( SIGTERM, stop_handler );
#ifndef WIN32
signal( SIGHUP, stop_handler );
signal( SIGPIPE, stop_handler );
#endif
// Transport functionality
transport( melt, consumer );
// Stop the consumer
mlt_consumer_stop( consumer );
}
}
else if ( store != NULL && store != stdout && name != NULL )
{
fprintf( stderr, "Project saved as %s.\n", name );
fclose( store );
}
}
else
{
show_usage( argv[0] );
}
// Disconnect producer from consumer to prevent ref cycles from closing services
if ( consumer )
{
mlt_consumer_connect( consumer, NULL );
mlt_events_fire( MLT_CONSUMER_PROPERTIES(consumer), "consumer-cleanup", NULL);
}
// Close the producer
if ( melt != NULL )
mlt_producer_close( melt );
// Close the consumer
if ( consumer != NULL )
mlt_consumer_close( consumer );
// Close the factory
mlt_profile_close( profile );
exit_factory:
// Workaround qmelt on OS X from crashing at exit.
#if !defined(__MACH__) || !defined(QT_GUI_LIB)
mlt_factory_close( );
#endif
return 0;
}
static void producer_close( mlt_producer producer )
{
delete (DeckLinkProducer*) producer->child;
producer->close = NULL;
mlt_producer_close( producer );
}
mlt_producer producer_framebuffer_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
if ( !arg ) return NULL;
mlt_producer producer = NULL;
producer = calloc( 1, sizeof( struct mlt_producer_s ) );
mlt_producer_init( producer, NULL );
// Wrap loader
mlt_producer real_producer;
// Check if a speed was specified.
/**
* Speed must be appended to the filename with '?'. To play your video at 50%:
melt framebuffer:my_video.mpg?0.5
* Stroboscope effect can be obtained by adding a stobe=x parameter, where
x is the number of frames that will be ignored.
* You can play the movie backwards by adding reverse=1
* You can freeze the clip at a determined position by adding freeze=frame_pos
add freeze_after=1 to freeze only paste position or freeze_before to freeze before it
**/
double speed = 0.0;
char *props = strdup( arg );
char *ptr = strrchr( props, '?' );
if ( ptr )
{
speed = atof( ptr + 1 );
if ( speed != 0.0 )
// If speed was valid, then strip it and the delimiter.
// Otherwise, an invalid speed probably means this '?' was not a delimiter.
*ptr = '\0';
}
real_producer = mlt_factory_producer( profile, "abnormal", props );
free( props );
if (speed == 0.0) speed = 1.0;
if ( producer != NULL && real_producer != NULL)
{
// Get the properties of this producer
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_properties_set( properties, "resource", arg);
// Store the producer and fitler
mlt_properties_set_data( properties, "producer", real_producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
// Grab some stuff from the real_producer
mlt_properties_pass_list( properties, MLT_PRODUCER_PROPERTIES( real_producer ), "length, width, height, aspect_ratio" );
if ( speed < 0 )
{
speed = -speed;
mlt_properties_set_int( properties, "reverse", 1 );
}
if ( speed != 1.0 )
{
double real_length = ( (double) mlt_producer_get_length( real_producer ) ) / speed;
mlt_properties_set_position( properties, "length", real_length );
}
mlt_properties_set_position( properties, "out", mlt_producer_get_length( producer ) - 1 );
// Since we control the seeking, prevent it from seeking on its own
mlt_producer_set_speed( real_producer, 0 );
mlt_producer_set_speed( producer, speed );
// Override the get_frame method
producer->get_frame = producer_get_frame;
}
else
{
if ( producer )
mlt_producer_close( producer );
if ( real_producer )
mlt_producer_close( real_producer );
producer = NULL;
}
return producer;
}
int inigo( int argc, char **argv )
{
int i;
mlt_consumer consumer = NULL;
mlt_producer melt = NULL;
FILE *store = NULL;
char *name = NULL;
mlt_profile profile = NULL;
int is_progress = 0;
int is_silent = 0;
// Construct the factory
mlt_repository repo = mlt_factory_init( NULL );
for ( i = 1; i < argc; i ++ )
{
// fprintf(stderr, "argv[%d] = %s\n", i, argv[i]);
// Check for serialisation switch
if ( !strcmp( argv[ i ], "-serialise" ) )
{
name = argv[ ++ i ];
if ( name != NULL && strstr( name, ".melt" ) )
store = fopen( name, "w" );
else
{
if ( name == NULL || name[0] == '-' )
store = stdout;
name = NULL;
}
}
// Look for the profile option
else if ( !strcmp( argv[ i ], "-profile" ) )
{
const char *pname = argv[ ++ i ];
if ( pname && pname[0] != '-' )
profile = mlt_profile_init( pname );
}
else if ( !strcmp( argv[ i ], "-progress" ) )
{
is_progress = 1;
}
// Look for the query option
else if ( !strcmp( argv[ i ], "-query" ) )
{
const char *pname = argv[ ++ i ];
if ( pname && pname[0] != '-' )
{
if ( !strcmp( pname, "consumers" ) || !strcmp( pname, "consumer" ) )
query_services( repo, consumer_type );
else if ( !strcmp( pname, "filters" ) || !strcmp( pname, "filter" ) )
query_services( repo, filter_type );
else if ( !strcmp( pname, "producers" ) || !strcmp( pname, "producer" ) )
query_services( repo, producer_type );
else if ( !strcmp( pname, "transitions" ) || !strcmp( pname, "transition" ) )
query_services( repo, transition_type );
else if ( !strncmp( pname, "consumer=", 9 ) )
query_metadata( repo, consumer_type, "consumer", strchr( pname, '=' ) + 1 );
else if ( !strncmp( pname, "filter=", 7 ) )
query_metadata( repo, filter_type, "filter", strchr( pname, '=' ) + 1 );
else if ( !strncmp( pname, "producer=", 9 ) )
query_metadata( repo, producer_type, "producer", strchr( pname, '=' ) + 1 );
else if ( !strncmp( pname, "transition=", 11 ) )
query_metadata( repo, transition_type, "transition", strchr( pname, '=' ) + 1 );
else
goto query_all;
}
else
{
query_all:
query_services( repo, consumer_type );
query_services( repo, filter_type );
query_services( repo, producer_type );
query_services( repo, transition_type );
fprintf( stderr, "# You can query the metadata for a specific service using:\n"
"# -query <type>=<identifer>\n"
"# where <type> is one of: consumer, filter, producer, or transition.\n" );
}
goto exit_factory;
}
else if ( !strcmp( argv[ i ], "-silent" ) )
{
is_silent = 1;
}
else if ( !strcmp( argv[ i ], "-verbose" ) )
{
mlt_log_set_level( MLT_LOG_VERBOSE );
}
else if ( !strcmp( argv[ i ], "-version" ) || !strcmp( argv[ i ], "--version" ) )
{
fprintf( stderr, "MLT %s 0.5\n"
"Copyright (C) 2002-2009 Ushodaya Enterprises Limited\n"
"<http://www.mltframework.org/>\n"
"This is free software; see the source for copying conditions. There is NO\n"
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
basename( argv[0] ) );
goto exit_factory;
}
else if ( !strcmp( argv[ i ], "-debug" ) )
{
mlt_log_set_level( MLT_LOG_DEBUG );
}
}
// Create profile if not set explicitly
if ( profile == NULL )
profile = mlt_profile_init( NULL );
// Look for the consumer option
for ( i = 1; i < argc; i ++ )
{
if ( !strcmp( argv[ i ], "-consumer" ) )
{
consumer = create_consumer( profile, argv[ ++ i ] );
if ( consumer )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
while ( argv[ i + 1 ] != NULL && strstr( argv[ i + 1 ], "=" ) )
mlt_properties_parse( properties, argv[ ++ i ] );
}
}
}
// If we have no consumer, default to sdl
if ( store == NULL && consumer == NULL )
consumer = create_consumer( profile, NULL );
// Get melt producer
if ( argc > 1 )
melt = mlt_factory_producer( profile, "melt", &argv[ 1 ] );
// Set transport properties on consumer and produder
if ( consumer != NULL && melt != NULL )
{
mlt_properties_set_data( MLT_CONSUMER_PROPERTIES( consumer ), "transport_producer", melt, 0, NULL, NULL );
mlt_properties_set_data( MLT_PRODUCER_PROPERTIES( melt ), "transport_consumer", consumer, 0, NULL, NULL );
if ( is_progress )
mlt_properties_set_int( MLT_CONSUMER_PROPERTIES( consumer ), "progress", is_progress );
if ( is_silent )
mlt_properties_set_int( MLT_CONSUMER_PROPERTIES( consumer ), "silent", is_silent );
}
if ( argc > 1 && melt != NULL && mlt_producer_get_length( melt ) > 0 )
{
// Parse the arguments
for ( i = 1; i < argc; i ++ )
{
if ( !strcmp( argv[ i ], "-serialise" ) )
{
if ( store != stdout )
i ++;
}
else
{
if ( store != NULL )
fprintf( store, "%s\n", argv[ i ] );
i ++;
while ( argv[ i ] != NULL && argv[ i ][ 0 ] != '-' )
{
if ( store != NULL )
fprintf( store, "%s\n", argv[ i ] );
i += 1;
}
i --;
}
}
if ( consumer != NULL && store == NULL )
{
// Get melt's properties
mlt_properties melt_props = MLT_PRODUCER_PROPERTIES( melt );
// Get the last group
mlt_properties group = mlt_properties_get_data( melt_props, "group", 0 );
// Apply group settings
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
mlt_properties_inherit( properties, group );
// Connect consumer to melt
mlt_consumer_connect( consumer, MLT_PRODUCER_SERVICE( melt ) );
// Start the consumer
mlt_consumer_start( consumer );
// Transport functionality
transport( melt, consumer );
// Stop the consumer
mlt_consumer_stop( consumer );
}
else if ( store != NULL && store != stdout && name != NULL )
{
fprintf( stderr, "Project saved as %s.\n", name );
fclose( store );
}
}
else
{
fprintf( stderr,
"Usage: %s [options] [producer [name=value]* ]+\n"
"Options:\n"
" -attach filter[:arg] [name=value]* Attach a filter to the output\n"
" -attach-cut filter[:arg] [name=value]* Attach a filter to a cut\n"
" -attach-track filter[:arg] [name=value]* Attach a filter to a track\n"
" -attach-clip filter[:arg] [name=value]* Attach a filter to a producer\n"
" -audio-track | -hide-video Add an audio-only track\n"
" -blank frames Add blank silence to a track\n"
" -consumer id[:arg] [name=value]* Set the consumer (sink)\n"
" -debug Set the logging level to debug\n"
" -filter filter[:arg] [name=value]* Add a filter to the current track\n"
" -group [name=value]* Apply properties repeatedly\n"
" -help Show this message\n"
" -join clips Join multiple clips into one cut\n"
" -mix length Add a mix between the last two cuts\n"
" -mixer transition Add a transition to the mix\n"
" -null-track | -hide-track Add a hidden track\n"
" -profile name Set the processing settings\n"
" -progress Display progress along with position\n"
" -remove Remove the most recent cut\n"
" -repeat times Repeat the last cut\n"
" -query List all of the registered services\n"
" -query \"consumers\" | \"consumer\"=id List consumers or show info about one\n"
" -query \"filters\" | \"filter\"=id List filters or show info about one\n"
" -query \"producers\" | \"producer\"=id List producers or show info about one\n"
" -query \"transitions\" | \"transition\"=id List transitions, show info about one\n"
" -serialise [filename] Write the commands to a text file\n"
" -silent Do not display position/transport\n"
" -split relative-frame Split the last cut into two cuts\n"
" -swap Rearrange the last two cuts\n"
" -track Add a track\n"
" -transition id[:arg] [name=value]* Add a transition\n"
" -verbose Set the logging level to verbose\n"
" -version Show the version and copyright\n"
" -video-track | -hide-audio Add a video-only track\n"
"For more help: <http://www.mltframework.org/>\n",
basename( argv[0] ) );
}
// Close the producer
if ( melt != NULL )
mlt_producer_close( melt );
// Close the consumer
if ( consumer != NULL )
mlt_consumer_close( consumer );
// Close the factory
mlt_profile_close( profile );
exit_factory:
mlt_factory_close( );
return 0;
}
static void producer_close( mlt_producer producer )
{
producer->close = NULL;
mlt_producer_close( producer );
free( producer );
}
static int get_frame( mlt_producer self, mlt_frame_ptr frame, int index )
{
mlt_properties properties = MLT_PRODUCER_PROPERTIES(self);
context cx = mlt_properties_get_data( properties, "context", NULL );
if ( !cx )
{
// Allocate and initialize our context
cx = mlt_pool_alloc( sizeof( struct context_s ) );
memset( cx, 0, sizeof( *cx ) );
mlt_properties_set_data( properties, "context", cx, 0, mlt_pool_release, NULL );
cx->self = self;
char *profile_name = mlt_properties_get( properties, "profile" );
if ( !profile_name )
profile_name = mlt_properties_get( properties, "mlt_profile" );
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( self ) );
if ( profile_name )
{
cx->profile = mlt_profile_init( profile_name );
cx->profile->is_explicit = 1;
}
else
{
cx->profile = mlt_profile_clone( profile );
cx->profile->is_explicit = 0;
}
// Encapsulate a real producer for the resource
cx->producer = mlt_factory_producer( cx->profile, NULL,
mlt_properties_get( properties, "resource" ) );
if ( ( profile_name && !strcmp( profile_name, "auto" ) ) ||
mlt_properties_get_int( properties, "autoprofile" ) )
{
mlt_profile_from_producer( cx->profile, cx->producer );
mlt_producer_close( cx->producer );
cx->producer = mlt_factory_producer( cx->profile, NULL, mlt_properties_get( properties, "resource" ) );
}
// Since we control the seeking, prevent it from seeking on its own
mlt_producer_set_speed( cx->producer, 0 );
cx->audio_position = -1;
// We will encapsulate a consumer
cx->consumer = mlt_consumer_new( cx->profile );
// Do not use _pass_list on real_time so that it defaults to 0 in the absence of
// an explicit real_time property.
mlt_properties_set_int( MLT_CONSUMER_PROPERTIES( cx->consumer ), "real_time",
mlt_properties_get_int( properties, "real_time" ) );
mlt_properties_pass_list( MLT_CONSUMER_PROPERTIES( cx->consumer ), properties,
"buffer, prefill, deinterlace_method, rescale" );
// Connect it all together
mlt_consumer_connect( cx->consumer, MLT_PRODUCER_SERVICE( cx->producer ) );
mlt_consumer_start( cx->consumer );
}
// Generate a frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( self ) );
if ( *frame )
{
// Seek the producer to the correct place
// Calculate our positions
double actual_position = (double) mlt_producer_frame( self );
if ( mlt_producer_get_speed( self ) != 0 )
actual_position *= mlt_producer_get_speed( self );
mlt_position need_first = floor( actual_position );
mlt_producer_seek( cx->producer,
lrint( need_first * mlt_profile_fps( cx->profile ) / mlt_producer_get_fps( self ) ) );
// Get the nested frame
mlt_frame nested_frame = mlt_consumer_rt_frame( cx->consumer );
// Stack the producer and our methods on the nested frame
mlt_frame_push_service( *frame, nested_frame );
mlt_frame_push_service( *frame, cx );
mlt_frame_push_get_image( *frame, get_image );
mlt_frame_push_audio( *frame, nested_frame );
mlt_frame_push_audio( *frame, cx );
mlt_frame_push_audio( *frame, get_audio );
// Give the returned frame temporal identity
mlt_frame_set_position( *frame, mlt_producer_position( self ) );
// Store the nested frame on the produced frame for destruction
mlt_properties frame_props = MLT_FRAME_PROPERTIES( *frame );
mlt_properties_set_data( frame_props, "_producer_consumer.frame", nested_frame, 0, (mlt_destructor) mlt_frame_close, NULL );
// Inform the normalizers about our video properties
mlt_properties_set_double( frame_props, "aspect_ratio", mlt_profile_sar( cx->profile ) );
mlt_properties_set_int( frame_props, "width", cx->profile->width );
mlt_properties_set_int( frame_props, "height", cx->profile->height );
mlt_properties_set_int( frame_props, "meta.media.width", cx->profile->width );
mlt_properties_set_int( frame_props, "meta.media.height", cx->profile->height );
mlt_properties_set_int( frame_props, "progressive", cx->profile->progressive );
}
// Calculate the next timecode
mlt_producer_prepare_next( self );
return 0;
}
