2 * \file mlt_multitrack.c
3 * \brief multitrack service class
5 * Copyright (C) 2003-2008 Ushodaya Enterprises Limited
6 * \author Charles Yates <charles.yates@pandora.be>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "mlt_multitrack.h"
24 #include "mlt_playlist.h"
25 #include "mlt_frame.h"
30 /* Forward reference. */
32 static int producer_get_frame( mlt_producer producer
, mlt_frame_ptr frame
, int index
);
34 /** Construct and initialize a new multitrack.
36 * Sets the resource property to "<multitrack>".
38 * \public \memberof mlt_multitrack_s
39 * \return a new multitrack
42 mlt_multitrack
mlt_multitrack_init( )
44 // Allocate the multitrack object
45 mlt_multitrack
this = calloc( sizeof( struct mlt_multitrack_s
), 1 );
49 mlt_producer producer
= &this->parent
;
50 if ( mlt_producer_init( producer
, this ) == 0 )
52 mlt_properties properties
= MLT_MULTITRACK_PROPERTIES( this );
53 producer
->get_frame
= producer_get_frame
;
54 mlt_properties_set_data( properties
, "multitrack", this, 0, NULL
, NULL
);
55 mlt_properties_set( properties
, "log_id", "multitrack" );
56 mlt_properties_set( properties
, "resource", "<multitrack>" );
57 mlt_properties_set_int( properties
, "in", 0 );
58 mlt_properties_set_int( properties
, "out", -1 );
59 mlt_properties_set_int( properties
, "length", 0 );
60 producer
->close
= ( mlt_destructor
)mlt_multitrack_close
;
72 /** Get the producer associated to this multitrack.
74 * \public \memberof mlt_multitrack_s
75 * \param this a multitrack
76 * \return the producer object
77 * \see MLT_MULTITRACK_PRODUCER
80 mlt_producer
mlt_multitrack_producer( mlt_multitrack
this )
82 return this != NULL ?
&this->parent
: NULL
;
85 /** Get the service associated this multitrack.
87 * \public \memberof mlt_multitrack_s
88 * \param this a multitrack
89 * \return the service object
90 * \see MLT_MULTITRACK_SERVICE
93 mlt_service
mlt_multitrack_service( mlt_multitrack
this )
95 return MLT_MULTITRACK_SERVICE( this );
98 /** Get the properties associated this multitrack.
100 * \public \memberof mlt_multitrack_s
101 * \param this a multitrack
102 * \return the multitrack's property list
103 * \see MLT_MULTITRACK_PROPERTIES
106 mlt_properties
mlt_multitrack_properties( mlt_multitrack
this )
108 return MLT_MULTITRACK_PROPERTIES( this );
111 /** Initialize position related information.
113 * \public \memberof mlt_multitrack_s
114 * \param this a multitrack
117 void mlt_multitrack_refresh( mlt_multitrack
this )
121 // Obtain the properties of this multitrack
122 mlt_properties properties
= MLT_MULTITRACK_PROPERTIES( this );
124 // We need to ensure that the multitrack reports the longest track as its length
125 mlt_position length
= 0;
127 // Obtain stats on all connected services
128 for ( i
= 0; i
< this->count
; i
++ )
130 // Get the producer from this index
131 mlt_track track
= this->list
[ i
];
132 mlt_producer producer
= track
->producer
;
134 // If it's allocated then, update our stats
135 if ( producer
!= NULL
)
137 // If we have more than 1 track, we must be in continue mode
138 if ( this->count
> 1 )
139 mlt_properties_set( MLT_PRODUCER_PROPERTIES( producer
), "eof", "continue" );
141 // Determine the longest length
142 //if ( !mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( producer ), "hide" ) )
143 length
= mlt_producer_get_playtime( producer
) > length ?
mlt_producer_get_playtime( producer
) : length
;
147 // Update multitrack properties now - we'll not destroy the in point here
148 mlt_events_block( properties
, properties
);
149 mlt_properties_set_position( properties
, "length", length
);
150 mlt_events_unblock( properties
, properties
);
151 mlt_properties_set_position( properties
, "out", length
- 1 );
154 /** Listener for producers on the playlist.
156 * \private \memberof mlt_multitrack_s
157 * \param producer a producer
158 * \param this a multitrack
161 static void mlt_multitrack_listener( mlt_producer producer
, mlt_multitrack
this )
163 mlt_multitrack_refresh( this );
166 /** Connect a producer to a given track.
168 * Note that any producer can be connected here, but see special case treatment
169 * of playlist in clip point determination below.
171 * \public \memberof mlt_multitrack_s
172 * \param this a multitrack
173 * \param producer the producer to connect to the multitrack producer
174 * \param track the 0-based index of the track on which to connect the multitrack
175 * \return true on error
178 int mlt_multitrack_connect( mlt_multitrack
this, mlt_producer producer
, int track
)
180 // Connect to the producer to ourselves at the specified track
181 int result
= mlt_service_connect_producer( MLT_MULTITRACK_SERVICE( this ), MLT_PRODUCER_SERVICE( producer
), track
);
185 // Resize the producer list if need be
186 if ( track
>= this->size
)
189 this->list
= realloc( this->list
, ( track
+ 10 ) * sizeof( mlt_track
) );
190 for ( i
= this->size
; i
< track
+ 10; i
++ )
191 this->list
[ i
] = NULL
;
192 this->size
= track
+ 10;
195 if ( this->list
[ track
] != NULL
)
197 mlt_event_close( this->list
[ track
]->event
);
198 mlt_producer_close( this->list
[ track
]->producer
);
202 this->list
[ track
] = malloc( sizeof( struct mlt_track_s
) );
205 // Assign the track in our list here
206 this->list
[ track
]->producer
= producer
;
207 this->list
[ track
]->event
= mlt_events_listen( MLT_PRODUCER_PROPERTIES( producer
), this,
208 "producer-changed", ( mlt_listener
)mlt_multitrack_listener
);
209 mlt_properties_inc_ref( MLT_PRODUCER_PROPERTIES( producer
) );
210 mlt_event_inc_ref( this->list
[ track
]->event
);
212 // Increment the track count if need be
213 if ( track
>= this->count
)
214 this->count
= track
+ 1;
217 mlt_multitrack_refresh( this );
223 /** Get the number of tracks.
225 * \public \memberof mlt_multitrack_s
226 * \param this a multitrack
227 * \return the number of tracks
230 int mlt_multitrack_count( mlt_multitrack
this )
235 /** Get an individual track as a producer.
237 * \public \memberof mlt_multitrack_s
238 * \param this a multitrack
239 * \param track the 0-based index of the producer to get
240 * \return the producer or NULL if not valid
243 mlt_producer
mlt_multitrack_track( mlt_multitrack
this, int track
)
245 mlt_producer producer
= NULL
;
247 if ( this->list
!= NULL
&& track
< this->count
)
248 producer
= this->list
[ track
]->producer
;
253 /** Position comparison function for sorting.
255 * \private \memberof mlt_multitrack_s
256 * \param p1 a position
257 * \param p2 another position
258 * \return <0 if \p p1 is less than \p p2, 0 if equal, >0 if greater
261 static int position_compare( const void *p1
, const void *p2
)
263 return *( mlt_position
* )p1
- *( mlt_position
* )p2
;
266 /** Add a position to a set.
268 * \private \memberof mlt_multitrack_s
269 * \param array an array of positions (the set)
270 * \param size the current number of positions in the array (not the capacity of the array)
271 * \param position the position to add
272 * \return the new size of the array
275 static int add_unique( mlt_position
*array
, int size
, mlt_position position
)
278 for ( i
= 0; i
< size
; i
++ )
279 if ( array
[ i
] == position
)
282 array
[ size
++ ] = position
;
286 /** Determine the clip point.
289 * Special case here: a 'producer' has no concept of multiple clips - only the
290 * playlist and multitrack producers have clip functionality. Further to that a
291 * multitrack determines clip information from any connected tracks that happen
294 * Additionally, it must locate clips in the correct order, for example, consider
295 * the following track arrangement:
297 * playlist1 |0.0 |b0.0 |0.1 |0.1 |0.2 |
298 * playlist2 |b1.0 |1.0 |b1.1 |1.1 |
300 * Note - b clips represent blanks. They are also reported as clip positions.
302 * When extracting clip positions from these playlists, we should get a sequence of:
304 * 0.0, 1.0, b0.0, 0.1, b1.1, 1.1, 0.1, 0.2, [out of playlist2], [out of playlist1]
307 * \public \memberof mlt_multitrack_s
308 * \param this a multitrack
309 * \param whence from where to extract
310 * \param index the 0-based index of which clip to extract
311 * \return the position of clip \p index relative to \p whence
314 mlt_position
mlt_multitrack_clip( mlt_multitrack
this, mlt_whence whence
, int index
)
316 mlt_position position
= 0;
319 mlt_position
*map
= malloc( 1000 * sizeof( mlt_position
) );
322 for ( i
= 0; i
< this->count
; i
++ )
324 // Get the producer for this track
325 mlt_producer producer
= this->list
[ i
]->producer
;
327 // If it's assigned and not a hidden track
328 if ( producer
!= NULL
)
330 // Get the properties of this producer
331 mlt_properties properties
= MLT_PRODUCER_PROPERTIES( producer
);
333 // Determine if it's a playlist
334 mlt_playlist playlist
= mlt_properties_get_data( properties
, "playlist", NULL
);
336 // Special case consideration of playlists
337 if ( playlist
!= NULL
)
339 for ( j
= 0; j
< mlt_playlist_count( playlist
); j
++ )
340 count
= add_unique( map
, count
, mlt_playlist_clip( playlist
, mlt_whence_relative_start
, j
) );
341 count
= add_unique( map
, count
, mlt_producer_get_out( producer
) + 1 );
345 count
= add_unique( map
, count
, 0 );
346 count
= add_unique( map
, count
, mlt_producer_get_out( producer
) + 1 );
352 qsort( map
, count
, sizeof( mlt_position
), position_compare
);
354 // Now locate the requested index
357 case mlt_whence_relative_start
:
359 position
= map
[ index
];
361 position
= map
[ count
- 1 ];
364 case mlt_whence_relative_current
:
365 position
= mlt_producer_position( MLT_MULTITRACK_PRODUCER( this ) );
366 for ( i
= 0; i
< count
- 2; i
++ )
367 if ( position
>= map
[ i
] && position
< map
[ i
+ 1 ] )
370 if ( index
>= 0 && index
< count
)
371 position
= map
[ index
];
372 else if ( index
< 0 )
375 position
= map
[ count
- 1 ];
378 case mlt_whence_relative_end
:
380 position
= map
[ count
- index
- 1 ];
392 /** Get frame method.
395 * Special case here: The multitrack must be used in a conjunction with a downstream
396 * tractor-type service, ie:
399 * Producer2 - multitrack - { filters/transitions } - tractor - consumer
402 * The get_frame of a tractor pulls frames from it's connected service on all tracks and
403 * will terminate as soon as it receives a test card with a last_track property. The
404 * important case here is that the mulitrack does not move to the next frame until all
405 * tracks have been pulled.
407 * Reasoning: In order to seek on a network such as above, the multitrack needs to ensure
408 * that all producers are positioned on the same frame. It uses the 'last track' logic
409 * to determine when to move to the next frame.
411 * Flaw: if a transition is configured to read from a b-track which happens to trigger
412 * the last frame logic (ie: it's configured incorrectly), then things are going to go
415 * See playlist logic too.
418 * \private \memberof mlt_multitrack_s
419 * \param parent the producer interface to a mulitrack
420 * \param[out] frame a frame by reference
421 * \param index the 0-based track index
422 * \return true if there was an error
425 static int producer_get_frame( mlt_producer parent
, mlt_frame_ptr frame
, int index
)
427 // Get the mutiltrack object
428 mlt_multitrack
this = parent
->child
;
430 // Check if we have a track for this index
431 if ( index
< this->count
&& this->list
[ index
] != NULL
)
433 // Get the producer for this track
434 mlt_producer producer
= this->list
[ index
]->producer
;
436 // Get the track hide property
437 int hide
= mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( mlt_producer_cut_parent( producer
) ), "hide" );
439 // Obtain the current position
440 mlt_position position
= mlt_producer_frame( parent
);
442 // Get the parent properties
443 mlt_properties producer_properties
= MLT_PRODUCER_PROPERTIES( parent
);
446 double speed
= mlt_properties_get_double( producer_properties
, "_speed" );
448 // Make sure we're at the same point
449 mlt_producer_seek( producer
, position
);
451 // Get the frame from the producer
452 mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer
), frame
, 0 );
454 // Indicate speed of this producer
455 mlt_properties properties
= MLT_FRAME_PROPERTIES( *frame
);
456 mlt_properties_set_double( properties
, "_speed", speed
);
457 mlt_properties_set_position( properties
, "_position", position
);
458 mlt_properties_set_int( properties
, "hide", hide
);
462 // Generate a test frame
463 *frame
= mlt_frame_init( MLT_PRODUCER_SERVICE( parent
) );
465 // Update position on the frame we're creating
466 mlt_frame_set_position( *frame
, mlt_producer_position( parent
) );
468 // Move on to the next frame
469 if ( index
>= this->count
)
471 // Let tractor know if we've reached the end
472 mlt_properties_set_int( MLT_FRAME_PROPERTIES( *frame
), "last_track", 1 );
474 // Move to the next frame
475 mlt_producer_prepare_next( parent
);
482 /** Close this instance and free its resources.
484 * \public \memberof mlt_multitrack_s
485 * \param this a multitrack
488 void mlt_multitrack_close( mlt_multitrack
this )
490 if ( this != NULL
&& mlt_properties_dec_ref( MLT_MULTITRACK_PROPERTIES( this ) ) <= 0 )
493 for ( i
= 0; i
< this->count
; i
++ )
495 if ( this->list
[ i
] != NULL
)
497 mlt_event_close( this->list
[ i
]->event
);
498 mlt_producer_close( this->list
[ i
]->producer
);
499 free( this->list
[ i
] );
503 // Close the producer
504 this->parent
.close
= NULL
;
505 mlt_producer_close( &this->parent
);