+ Win32 port - dev studio is required to avoid issues with C++ ABI compatibility

[melted] / mlt++ / src / MltProducer.cpp

diff --git a/mlt++/src/MltProducer.cpp b/mlt++/src/MltProducer.cpp
index f2c0530..1b06e91 100644 (file)
--- a/mlt++/src/MltProducer.cpp
+++ b/mlt++/src/MltProducer.cpp
@@ -19,17 +19,18 @@
  */
 
 #include "MltProducer.h"
+#include "MltFilter.h"
 using namespace Mlt;
 
 Producer::Producer( ) :
-       destroy( false ),
-       instance( NULL )
+       instance( NULL ),
+       parent_( NULL )
 {
 }
 
 Producer::Producer( char *id, char *service ) :
-       destroy( true ),
-       instance( NULL )
+       instance( NULL ),
+       parent_( NULL )
 {
        if ( id != NULL && service != NULL )
                instance = mlt_factory_producer( id, service );
@@ -37,39 +38,81 @@ Producer::Producer( char *id, char *service ) :
                instance = mlt_factory_producer( "fezzik", id != NULL ? id : service );
 }
 
+Producer::Producer( Service &producer ) :
+       instance( NULL ),
+       parent_( NULL )
+{
+       mlt_service_type type = producer.type( );
+       if ( type == producer_type || type == playlist_type || 
+                type == tractor_type || type == multitrack_type )
+       {
+               instance = ( mlt_producer )producer.get_service( );
+               inc_ref( );
+       }
+}
+
 Producer::Producer( mlt_producer producer ) :
-       destroy( false ),
-       instance( producer )
+       instance( producer ),
+       parent_( NULL )
 {
+       inc_ref( );
 }
 
 Producer::Producer( Producer &producer ) :
-       destroy( false ),
-       instance( producer.get_producer( ) )
+       instance( producer.get_producer( ) ),
+       parent_( NULL )
 {
+       inc_ref( );
+}
+
+Producer::Producer( Producer *producer ) :
+       instance( producer != NULL ? producer->get_producer( ) : NULL ),
+       parent_( NULL )
+{
+       if ( is_valid( ) )
+               inc_ref( );
 }
 
 Producer::~Producer( )
 {
-       if ( destroy )
-               mlt_producer_close( instance );
+       delete parent_;
+       mlt_producer_close( instance );
+       instance = NULL;
+}
+
+mlt_producer Producer::get_producer( )
+{
+       return instance;
+}
+
+mlt_producer Producer::get_parent( )
+{
+       return get_producer( ) != NULL && mlt_producer_cut_parent( get_producer( ) ) != NULL ? mlt_producer_cut_parent( get_producer( ) ) : get_producer( );
+}
+
+Producer &Producer::parent( )
+{
+       if ( is_cut( ) && parent_ == NULL )
+               parent_ = new Producer( get_parent( ) );
+       return parent_ == NULL ? *this : *parent_;
 }
+
 mlt_service Producer::get_service( )
 {
        return mlt_producer_service( get_producer( ) );
 }
        
-int Producer::seek( mlt_position position )
+int Producer::seek( int position )
 {
        return mlt_producer_seek( get_producer( ), position );
 }
 
-mlt_position Producer::position( )
+int Producer::position( )
 {
        return mlt_producer_position( get_producer( ) );
 }
 
-mlt_position Producer::frame( )
+int Producer::frame( )
 {
        return mlt_producer_frame( get_producer( ) );
 }
@@ -89,34 +132,60 @@ double Producer::get_fps( )
        return mlt_producer_get_fps( get_producer( ) );
 }
 
-int Producer::set_in_and_out( mlt_position in, mlt_position out )
+int Producer::set_in_and_out( int in, int out )
 {
        return mlt_producer_set_in_and_out( get_producer( ), in, out );
 }
 
-mlt_position Producer::get_in( )
+int Producer::get_in( )
 {
        return mlt_producer_get_in( get_producer( ) );
 }
 
-mlt_position Producer::get_out( )
+int Producer::get_out( )
 {
        return mlt_producer_get_out( get_producer( ) );
 }
 
-mlt_position Producer::get_length( )
+int Producer::get_length( )
 {
        return mlt_producer_get_length( get_producer( ) );
 }
 
-mlt_position Producer::get_playtime( )
+int Producer::get_playtime( )
 {
        return mlt_producer_get_playtime( get_producer( ) );
 }
 
-mlt_producer Producer::get_producer( )
+Producer *Producer::cut( int in, int out )
 {
-       return instance;
+       mlt_producer producer = mlt_producer_cut( get_producer( ), in, out );
+       Producer *result = new Producer( producer );
+       mlt_producer_close( producer );
+       return result;
+}
+
+bool Producer::is_cut( )
+{
+       return mlt_producer_is_cut( get_producer( ) ) != 0;
+}
+
+bool Producer::is_blank( )
+{
+       return mlt_producer_is_blank( get_producer( ) ) != 0;
+}
+
+bool Producer::same_clip( Producer &that )
+{
+       return mlt_producer_cut_parent( get_producer( ) ) == mlt_producer_cut_parent( that.get_producer( ) );
 }
 
+bool Producer::runs_into( Producer &that )
+{
+       return same_clip( that ) && get_out( ) == ( that.get_in( ) - 1 );
+}
 
+void Producer::optimise( )
+{
+       mlt_producer_optimise( get_producer( ) );
+}