Behavioural change - tracks with hide properties now affect length (might be problematic)
[melted] / src / framework / mlt_multitrack.c
index b357546..d274dbc 100644 (file)
 #include <stdio.h>
 #include <stdlib.h>
 
+struct mlt_track_s
+{
+       mlt_producer producer;
+       mlt_event event;
+};
+
+typedef struct mlt_track_s *mlt_track;
+
 /** Private definition.
 */
 
@@ -34,7 +42,7 @@ struct mlt_multitrack_s
 {
        // We're extending producer here
        struct mlt_producer_s parent;
-       mlt_producer *list;
+       mlt_track *list;
        int size;
        int count;
 };
@@ -61,6 +69,7 @@ mlt_multitrack mlt_multitrack_init( )
                        producer->get_frame = producer_get_frame;
                        mlt_properties_set_data( properties, "multitrack", this, 0, NULL, NULL );
                        mlt_properties_set( properties, "log_id", "multitrack" );
+                       mlt_properties_set( properties, "resource", "<multitrack>" );
                }
                else
                {
@@ -77,7 +86,7 @@ mlt_multitrack mlt_multitrack_init( )
 
 mlt_producer mlt_multitrack_producer( mlt_multitrack this )
 {
-       return &this->parent;
+       return this != NULL ? &this->parent : NULL;
 }
 
 /** Get the service associated this multitrack.
@@ -96,7 +105,7 @@ mlt_properties mlt_multitrack_properties( mlt_multitrack this )
        return mlt_service_properties( mlt_multitrack_service( this ) );
 }
 
-/** Initialise timecode related information.
+/** Initialise position related information.
 */
 
 void mlt_multitrack_refresh( mlt_multitrack this )
@@ -107,7 +116,7 @@ void mlt_multitrack_refresh( mlt_multitrack this )
        mlt_properties properties = mlt_multitrack_properties( this );
 
        // We need to ensure that the multitrack reports the longest track as its length
-       mlt_timecode length = 0;
+       mlt_position length = 0;
 
        // We need to ensure that fps are the same on all services
        double fps = 0;
@@ -116,13 +125,19 @@ void mlt_multitrack_refresh( mlt_multitrack this )
        for ( i = 0; i < this->count; i ++ )
        {
                // Get the producer from this index
-               mlt_producer producer = this->list[ i ];
+               mlt_track track = this->list[ i ];
+               mlt_producer producer = track->producer;
 
                // If it's allocated then, update our stats
                if ( producer != NULL )
                {
+                       // If we have more than 1 track, we must be in continue mode
+                       if ( this->count > 1 )
+                               mlt_properties_set( mlt_producer_properties( producer ), "eof", "continue" );
+                       
                        // Determine the longest length
-                       length = mlt_producer_get_playtime( producer ) > length ? mlt_producer_get_playtime( producer ) : length;
+                       //if ( !mlt_properties_get_int( mlt_producer_properties( producer ), "hide" ) )
+                               length = mlt_producer_get_playtime( producer ) > length ? mlt_producer_get_playtime( producer ) : length;
                        
                        // Handle fps
                        if ( fps == 0 )
@@ -142,11 +157,21 @@ void mlt_multitrack_refresh( mlt_multitrack this )
        }
 
        // Update multitrack properties now - we'll not destroy the in point here
-       mlt_properties_set_timecode( properties, "length", length );
-       mlt_properties_set_timecode( properties, "out", length );
+       mlt_events_block( properties, properties );
+       mlt_properties_set_position( properties, "length", length );
+       mlt_events_unblock( properties, properties );
+       mlt_properties_set_position( properties, "out", length - 1 );
        mlt_properties_set_double( properties, "fps", fps );
 }
 
+/** Listener for producers on the playlist.
+*/
+
+static void mlt_multitrack_listener( mlt_producer producer, mlt_multitrack this )
+{
+       mlt_multitrack_refresh( this );
+}
+
 /** Connect a producer to a given track.
 
        Note that any producer can be connected here, but see special case treatment
@@ -160,22 +185,32 @@ int mlt_multitrack_connect( mlt_multitrack this, mlt_producer producer, int trac
 
        if ( result == 0 )
        {
-               // If it's a playlist, we need to make sure it doesn't pause at end
-               mlt_properties properties = mlt_producer_properties( producer );
-               mlt_properties_set( properties, "eof", "continue" );
-
                // Resize the producer list if need be
                if ( track >= this->size )
                {
                        int i;
-                       this->list = realloc( this->list, ( track + 10 ) * sizeof( mlt_producer ) );
+                       this->list = realloc( this->list, ( track + 10 ) * sizeof( mlt_track ) );
                        for ( i = this->size; i < track + 10; i ++ )
                                this->list[ i ] = NULL;
                        this->size = track + 10;
                }
-               
+
+               if ( this->list[ track ] != NULL )
+               {
+                       mlt_event_close( this->list[ track ]->event );
+                       mlt_producer_close( this->list[ track ]->producer );
+               }
+               else
+               {
+                       this->list[ track ] = malloc( sizeof( struct mlt_track_s ) );
+               }
+
                // Assign the track in our list here
-               this->list[ track ] = producer;
+               this->list[ track ]->producer = producer;
+               this->list[ track ]->event = mlt_events_listen( mlt_producer_properties( producer ), this, 
+                                                                        "producer-changed", ( mlt_listener )mlt_multitrack_listener );
+               mlt_properties_inc_ref( mlt_producer_properties( producer ) );
+               mlt_event_inc_ref( this->list[ track ]->event );
                
                // Increment the track count if need be
                if ( track >= this->count )
@@ -188,6 +223,43 @@ int mlt_multitrack_connect( mlt_multitrack this, mlt_producer producer, int trac
        return result;
 }
 
+/** Get the number of tracks.
+*/
+
+int mlt_multitrack_count( mlt_multitrack this )
+{
+       return this->count;     
+}
+
+/** Get an individual track as a producer.
+*/
+
+mlt_producer mlt_multitrack_track( mlt_multitrack this, int track )
+{
+       mlt_producer producer = NULL;
+       
+       if ( this->list != NULL && track < this->count )
+               producer = this->list[ track ]->producer;
+
+       return producer;
+}
+
+static int position_compare( const void *p1, const void *p2 )
+{
+       return *( mlt_position * )p1 - *( mlt_position * )p2;
+}
+
+static int add_unique( mlt_position *array, int size, mlt_position position )
+{
+       int i = 0;
+       for ( i = 0; i < size; i ++ )
+               if ( array[ i ] == position )
+                       break;
+       if ( i == size )
+               array[ size ++ ] = position;
+       return size;
+}
+
 /** Determine the clip point.
 
        Special case here: a 'producer' has no concept of multiple clips - only the 
@@ -208,19 +280,20 @@ int mlt_multitrack_connect( mlt_multitrack this, mlt_producer producer, int trac
        0.0, 1.0, b0.0, 0.1, b1.1, 1.1, 0.1, 0.2, [out of playlist2], [out of playlist1]
 */
 
-mlt_timecode mlt_multitrack_clip( mlt_multitrack this, mlt_whence whence, int index )
+mlt_position mlt_multitrack_clip( mlt_multitrack this, mlt_whence whence, int index )
 {
-       int first = 1;
-       mlt_timecode position = 0;
+       mlt_position position = 0;
        int i = 0;
+       int j = 0;
+       mlt_position *map = malloc( 1000 * sizeof( mlt_position ) );
+       int count = 0;
 
-       // Loop through each of the tracks
        for ( i = 0; i < this->count; i ++ )
        {
                // Get the producer for this track
-               mlt_producer producer = this->list[ i ];
+               mlt_producer producer = this->list[ i ]->producer;
 
-               // If it's assigned...
+               // If it's assigned and not a hidden track
                if ( producer != NULL )
                {
                        // Get the properties of this producer
@@ -229,31 +302,59 @@ mlt_timecode mlt_multitrack_clip( mlt_multitrack this, mlt_whence whence, int in
                        // Determine if it's a playlist
                        mlt_playlist playlist = mlt_properties_get_data( properties, "playlist", NULL );
 
-                       // We only consider playlists
+                       // Special case consideration of playlists
                        if ( playlist != NULL )
                        {
-                               // Locate the smallest timecode
-                               if ( first )
-                               {
-                                       // First position found
-                                       position = mlt_playlist_clip( playlist, whence, index );
-       
-                                       // We're no longer first
-                                       first = 0;
-                               }
-                               else
-                               {
-                                       // Obtain the clip position in this playlist
-                                       mlt_timecode position2 = mlt_playlist_clip( playlist, whence, index );
-
-                                       // If this position is prior to the first, then use it
-                                       if ( position2 < position )
-                                               position = position2;
-                               }
+                               for ( j = 0; j < mlt_playlist_count( playlist ); j ++ )
+                                       count = add_unique( map, count, mlt_playlist_clip( playlist, mlt_whence_relative_start, j ) );
+                               count = add_unique( map, count, mlt_producer_get_out( producer ) + 1 );
+                       }
+                       else
+                       {
+                               count = add_unique( map, count, 0 );
+                               count = add_unique( map, count, mlt_producer_get_out( producer ) + 1 );
                        }
                }
        }
 
+       // Now sort the map
+       qsort( map, count, sizeof( mlt_position ), position_compare );
+
+       // Now locate the requested index
+       switch( whence )
+       {
+               case mlt_whence_relative_start:
+                       if ( index < count )
+                               position = map[ index ];
+                       else
+                               position = map[ count - 1 ];
+                       break;
+
+               case mlt_whence_relative_current:
+                       position = mlt_producer_position( mlt_multitrack_producer( this ) );
+                       for ( i = 0; i < count - 2; i ++ ) 
+                               if ( position >= map[ i ] && position < map[ i + 1 ] )
+                                       break;
+                       index += i;
+                       if ( index >= 0 && index < count )
+                               position = map[ index ];
+                       else if ( index < 0 )
+                               position = map[ 0 ];
+                       else
+                               position = map[ count - 1 ];
+                       break;
+
+               case mlt_whence_relative_end:
+                       if ( index < count )
+                               position = map[ count - index - 1 ];
+                       else
+                               position = map[ 0 ];
+                       break;
+       }
+
+       // Free the map
+       free( map );
+
        return position;
 }
 
@@ -291,30 +392,39 @@ static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int ind
        if ( index < this->count && this->list[ index ] != NULL )
        {
                // Get the producer for this track
-               mlt_producer producer = this->list[ index ];
+               mlt_producer producer = this->list[ index ]->producer;
 
-               // Obtain the current timecode
-               uint64_t position = mlt_producer_frame( parent );
+               // Get the track hide property
+               int hide = mlt_properties_get_int( mlt_producer_properties( mlt_producer_cut_parent( producer ) ), "hide" );
+
+               // Obtain the current position
+               mlt_position position = mlt_producer_frame( parent );
+
+               // Get the parent properties
+               mlt_properties producer_properties = mlt_producer_properties( parent );
+
+               // Get the speed
+               double speed = mlt_properties_get_double( producer_properties, "_speed" );
 
                // Make sure we're at the same point
-               mlt_producer_seek_frame( producer, position );
+               mlt_producer_seek( producer, position );
 
                // Get the frame from the producer
                mlt_service_get_frame( mlt_producer_service( producer ), frame, 0 );
 
                // Indicate speed of this producer
-               mlt_properties producer_properties = mlt_producer_properties( parent );
-               double speed = mlt_properties_get_double( producer_properties, "speed" );
                mlt_properties properties = mlt_frame_properties( *frame );
-               mlt_properties_set_double( properties, "speed", speed );
+               mlt_properties_set_double( properties, "_speed", speed );
+               mlt_properties_set_position( properties, "_position", position );
+               mlt_properties_set_int( properties, "hide", hide );
        }
        else
        {
                // Generate a test frame
                *frame = mlt_frame_init( );
 
-               // Update timecode on the frame we're creating
-               mlt_frame_set_timecode( *frame, mlt_producer_position( parent ) );
+               // Update position on the frame we're creating
+               mlt_frame_set_position( *frame, mlt_producer_position( parent ) );
 
                // Move on to the next frame
                if ( index >= this->count )
@@ -325,9 +435,6 @@ static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int ind
                        // Move to the next frame
                        mlt_producer_prepare_next( parent );
                }
-
-               // Refresh our stats
-               mlt_multitrack_refresh( this );
        }
 
        return 0;
@@ -338,12 +445,26 @@ static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int ind
 
 void mlt_multitrack_close( mlt_multitrack this )
 {
-       // Close the producer
-       mlt_producer_close( &this->parent );
+       if ( this != NULL && mlt_properties_dec_ref( mlt_multitrack_properties( this ) ) <= 0 )
+       {
+               int i = 0;
+               for ( i = 0; i < this->count; i ++ )
+               {
+                       if ( this->list[ i ] != NULL )
+                       {
+                               mlt_event_close( this->list[ i ]->event );
+                               mlt_producer_close( this->list[ i ]->producer );
+                               free( this->list[ i ] );
+                       }
+               }
+
+               // Close the producer
+               mlt_producer_close( &this->parent );
 
-       // Free the list
-       free( this->list );
+               // Free the list
+               free( this->list );
 
-       // Free the object
-       free( this );
+               // Free the object
+               free( this );
+       }
 }