An example of use is as follows:
- #include <time.h>
- #include <mlt++/Mlt.h>
- using namespace Mlt;
-
- int main( void )
- {
- Factory::init( );
- Producer p( "pango:" );
- p.set( "text", "Hello World" );
- Consumer c( "sdl" );
- Event *e = Consumer.setup_wait_for( "consumer-stopped" );
- c.connect( p );
- c.start( );
- c.wait_for( e );
- delete e;
- return 0;
- }
-
- This is a fairly typical example of use of mlt++ - create a 'producer' (an
+ #include <mlt++/Mlt.h>
+ using namespace Mlt;
+
+ int main( void )
+ {
+ Factory::init( );
+ Producer p( "pango:", "Hello World" );
+ Consumer c( "sdl" );
+ c.connect( p );
+ c.run( );
+ return 0;
+ }
+
+ This is a fairly typical example of mlt++ usage - create a 'producer' (an
object which produces 'frames'), create a 'consumer' (an object which consumes
frames), connect them together, start the consumer and wait until done (here
we just wait for the user to close the window).
As a simple example of the Playlist in action, we'll convert the example
above into an application which plays multiple video or audio files.
- #include <time.h>
- #include <mlt++/Mlt.h>
- using namespace Mlt;
-
- int main( int argc, char **argv )
- {
- Factory::init( );
- Playlist list;
- for ( int i = 1; i < argc; i ++ )
- {
- Producer p( argv[i] );
- if ( p.is_valid( ) )
- list.append( p );
- }
- Consumer c( "sdl" );
- c.connect( list );
- Event *e = Consumer.setup_wait_for( "consumer-stopped" );
- c.start( );
- c.wait_for( e );
- delete e;
- return 0;
- }
+ #include <mlt++/Mlt.h>
+ using namespace Mlt;
+
+ int main( int argc, char **argv )
+ {
+ Factory::init( );
+ Playlist list;
+ for ( int i = 1; i < argc; i ++ )
+ {
+ Producer p( argv[i] );
+ if ( p.is_valid( ) )
+ list.append( p );
+ }
+ Consumer c( "sdl" );
+ c.connect( list );
+ c.run( );
+ return 0;
+ }
Now you can run the program as:
- ./player *.avi *.mp3 *.jpg etc
+ ./player *.avi *.mp3 *.jpg etc
In this case, we construct a playlist by simply appending producers to it.
Notice that although the scope of the Producer is limited to the inner
logo of some sort. We'll just use some black text on a partially
transparent red background.
- #include <time.h>
#include <mlt++/Mlt.h>
using namespace Mlt;
int main( int argc, char **argv )
{
- Factory::init( );
- Playlist list;
- for ( int i = 1; i < argc; i ++ )
- {
- Producer p( argv[i] );
- if ( p.is_valid( ) )
- list.append( p );
- }
- Filter f( "watermark", "pango:" );
- f.set( "producer.text", "MLT++" );
- f.set( "producer.fgcolour", "0x000000ff" );
- f.set( "producer.bgcolour", "0xff000080" );
- list.attach( f );
- Consumer c( "sdl" );
- c.connect( list );
- Event *e = Consumer.setup_wait_for( "consumer-stopped" );
- c.start( );
- c.wait_for( e );
- delete e;
- return 0;
+ Factory::init( );
+ Playlist list;
+ for ( int i = 1; i < argc; i ++ )
+ {
+ Producer p( argv[i] );
+ if ( p.is_valid( ) )
+ list.append( p );
+ }
+ Filter f( "watermark", "pango:" );
+ f.set( "producer.text", "MLT++" );
+ f.set( "producer.fgcolour", "0x000000ff" );
+ f.set( "producer.bgcolour", "0xff000080" );
+ list.attach( f );
+ Consumer c( "sdl" );
+ c.connect( list );
+ c.run( );
+ return 0;
}
Notice that the watermark filter reuses the 'pango' producer we showed in the
that are obtained from the playlist are watermarked.
+Cuts
+----
+
+ When you add a clip to a playlist, the a cut object is created - this is merely a
+ wrapper for the producer, spanning the specified in and out points.
+
+ Whenever you retrieve a clip from a playlist, you will always get a cut object.
+ This allows you to attach filters to a specific part of a producer and should
+ the position of the cut in the playlist change, then the filter will remain
+ correctly associated to it.
+
+ A producer and a cut are generally identical in behaviour, but should you need to
+ distinguish between them, you can use:
+
+ if ( producer.is_cut( ) )
+
+ and to retrieve the parent of a cut, you can use:
+
+ Producer parent = producer.parent_cut( );
+
+ Filters that are attached directly to a parent are executed before any filters
+ attached to the cut.
+
+
Tractor
-------
tracks.
Stepping away from the player example we've been tinkering with for a minute,
- let's assume we want to do something like dubbing a video with some audio. This
+ let's assume we want to do something like dub a video with some audio. This
a very trivial thing to do:
Tractor *dub( char *video_file, char *audio_file )
{
- Tractor *tractor = new Tractor( );
- Producer video( video_file );
- Producer audio( audio_file );
- tractor->set_track( video, 0 );
- tractor->set_track( audio, 1 );
- return tractor;
+ Tractor *tractor = new Tractor( );
+ Producer video( video_file );
+ Producer audio( audio_file );
+ tractor->set_track( video, 0 );
+ tractor->set_track( audio, 1 );
+ return tractor;
}
That's all that needs to be done - you can now connect the returned object to a
Tractor *mix( char *video_file, char *audio_file )
{
- Tractor *tractor = new Tractor( );
- Transition mix( "mix" );
- Producer video( video_file );
- Producer audio( audio_file );
- tractor.set_track( video, 0 );
- tractor.set_track( audio, 1 );
- tractor.field.plant_transition( mix, 0, 1 );
- return tractor;
+ Tractor *tractor = new Tractor( );
+ Transition mix( "mix" );
+ Producer video( video_file );
+ Producer audio( audio_file );
+ tractor.set_track( video, 0 );
+ tractor.set_track( audio, 1 );
+ tractor.field.plant_transition( mix, 0, 1 );
+ return tractor;
}
- The tractor returned will now mix the audio from the original video and the audio.
+ The tractor returned will now mix the audio from the original video and the
+ audio.
+
+
+Mix
+---
+
+ There is a convenience function which simplifies the process of applying
+ transitions betwee adjacent cuts on a playlist. This is often preferable
+ to use over the constuction of your own tractor and transition set up.
+
+ To apply a 25 frame luma transition between the first and second cut on
+ the playlist, you could use:
+
+ Transition luma;
+ playlist.mix( 0, 25, luma );
+
+
+Events
+------
+
+ Typically, applications need to be informed when changes occur in an mlt++ object.
+ This facilitates application services such as undo/redo management, or project
+ rendering in a timeline type widget and many other types of operations which an
+ application needs.
+
+ As an example, consider the following:
+
+ class Westley
+ {
+ private:
+ Consumer consumer;
+ Tractor &tractor;
+ public:
+ Westley( MltTractor &tractor ) :
+ tractor( tractor ),
+ consumer( "westley" )
+ {
+ consumer.connect( tractor );
+ tractor.listen( tractor, "producer-changed",
+ ( mlt_listener )Westley::listener );
+ }
+
+ static void listener( Properties *tractor, Westley *object )
+ {
+ object->activate( );
+ }
+
+ void activate( )
+ {
+ consumer.start( );
+ }
+ };
+
+ Now, each time the tractor is changed, the westley representation is output to
+ stderr.
+
+
+Servers and Westley Docs
+------------------------
+
+ One of the key features of MLT is its server capabilities. This feature
+ allows you to pass westley documents seamlessly from one process to
+ another and even to different computers on your network.
+
+ The miracle playout server is one such example of an application which
+ uses this functionality - you can build your own servers into your own
+ processes with ease.
+
+ A server process would be running as follows:
+
+ #include <mlt++/Miracle>
+ using namespace Mlt;
+
+ int main( void )
+ {
+ Miracle miracle( "miracle", 5250 );
+ miracle.start( );
+ miracle.execute( "uadd sdl" );
+ miracle.execute( "play u0" );
+ miracle.wait_for_shutdown( );
+ return 0;
+ }
+
+ Typically, when you have an MLT object such as a producer or a playlist,
+ you can send a westley representation of this to a running server with:
+
+ Conumser valerie( "valerie", "localhost:5250" );
+ valerie.connect( producer );
+ valerie.start( );
+
+ The effect of the push will be to append the producer on to the first
+ unit (u0).
+
+ You can completely customise the miracle server - an example of this
+ is shown below.
That's All Folks...
void dump( Properties &properties )
{
- for ( int i = 0; i < properties.count( ); i ++ )
- cout << Properties.get_name( i ) << " = " << Properties.get( i ) << endl;
+ for ( int i = 0; i < properties.count( ); i ++ )
+ cout << Properties.get_name( i ) << " = " << Properties.get( i ) << endl;
}
Note that the properties object handles type conversion, so the following
bool do_we_have_a_producer( Service &service )
{
- Producer producer( service );
- return producer.is_valid( );
+ Producer producer( service );
+ return producer.is_valid( );
}
Events
------
+
+
+Servers and Westley Docs
+------------------------
+
+ For various reasons, you might want to serialise a producer to a string.
+ To do this, you just need to specify a property to write to:
+
+ Consumer westley( "westley", "buffer" );
+ westley.connect( producer );
+ westley.start( );
+ buffer = westley.get( "buffer" );
+
+ You can use any name you want, and you can change it using the "resource"
+ property. Any name with a '.' in it is considered to be a file. Hence, you
+ can use a westley consumer to store multiple instances of the same MLT
+ object - useful if you want to provide undo/redo capabilities in an
+ editing application.
+
+ Should you receive an xml document as a string, and you want to send it
+ on to a server, you can use:
+
+ Conumser valerie( "valerie", "localhost:5250" );
+ valerie.set( "westley", buffer );
+ valerie.start( );
+
+ If you need to obtain an MLT object from a string:
+
+ Producer producer( "westley-xml", buffer );
+
+ The following shows a working example of an extended server:
+
+ class ShotcutServer : public Miracle
+ {
+ public:
+ ShotcutServer( char *id, int port ) :
+ Miracle( id, port )
+ {
+ }
+
+ void set_receive_doc( bool doc )
+ {
+ set( "push-parser-off", doc );
+ }
+
+ // Reject all commands other than push/receive
+ Response *execute( char *command )
+ {
+ valerie_response response = valerie_response_init( );
+ valerie_response_set_error( response, 400, "Not OK" );
+ return new Response( response );
+ }
+
+ // Push document handler
+ Response *received( char *command, char *doc )
+ {
+ valerie_response response = valerie_response_init( );
+ // Use doc in some way and assign Response
+ if ( doc != NULL )
+ valerie_response_set_error( response, 200, "OK" );
+ return new Response( response );
+ }
+
+ // Push service handler
+ Response *push( char *command, Service *service )
+ {
+ valerie_response response = valerie_response_init( );
+ // Use service in some way and assign Response
+ if ( service != NULL )
+ valerie_response_set_error( response, 200, "OK" );
+ return new Response( response );
+ }
+ };
+
+ NB: Should you be incorporating this into a GUI application, remember that the
+ execute, received and push methods are invoked from a thread - make sure that
+ you honour the locking requirements of your GUI toolkit before interacting with
+ the UI.
+
+