void TransitionHandler::deleteTransition(QString tag, int /*a_track*/, int b_track, GenTime in, GenTime out, QDomElement /*xml*/, bool /*do_refresh*/)
{
QScopedPointer<Mlt::Field> field(m_tractor->field());
field->lock();
mlt_service nextservice = mlt_service_get_producer(field->get_service());
mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
QString resource = mlt_properties_get(properties, "mlt_service");
double fps = m_tractor->get_fps();
const int old_pos = (int)((in + out).frames(fps) / 2);
////qDebug() << " del trans pos: " << in.frames(25) << '-' << out.frames(25);
mlt_service_type mlt_type = mlt_service_identify( nextservice );
while (mlt_type == transition_type) {
mlt_transition tr = (mlt_transition) nextservice;
int currentTrack = mlt_transition_get_b_track(tr);
int currentIn = (int) mlt_transition_get_in(tr);
int currentOut = (int) mlt_transition_get_out(tr);
////qDebug() << "// FOUND EXISTING TRANS, IN: " << currentIn << ", OUT: " << currentOut << ", TRACK: " << currentTrack;
if (resource == tag && b_track == currentTrack && currentIn <= old_pos && currentOut >= old_pos) {
mlt_field_disconnect_service(field->get_field(), nextservice);
break;
}
nextservice = mlt_service_producer(nextservice);
if (nextservice == NULL) break;
properties = MLT_SERVICE_PROPERTIES(nextservice);
mlt_type = mlt_service_identify( nextservice );
resource = mlt_properties_get(properties, "mlt_service");
}
field->unlock();
//askForRefresh();
//if (m_isBlocked == 0) m_mltConsumer->set("refresh", 1);
}
bool TransitionHandler::moveTransition(QString type, int startTrack, int newTrack, int newTransitionTrack, GenTime oldIn, GenTime oldOut, GenTime newIn, GenTime newOut)
{
double fps = m_tractor->get_fps();
int new_in = (int)newIn.frames(fps);
int new_out = (int)newOut.frames(fps) - 1;
if (new_in >= new_out) return false;
int old_in = (int)oldIn.frames(fps);
int old_out = (int)oldOut.frames(fps) - 1;
bool doRefresh = true;
// Check if clip is visible in monitor
int position = mlt_producer_position(m_tractor->get_producer());
int diff = old_out - position;
if (diff < 0 || diff > old_out - old_in) doRefresh = false;
if (doRefresh) {
diff = new_out - position;
if (diff < 0 || diff > new_out - new_in) doRefresh = false;
}
QScopedPointer<Mlt::Field> field(m_tractor->field());
field->lock();
mlt_service nextservice = mlt_service_get_producer(field->get_service());
mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
QString resource = mlt_properties_get(properties, "mlt_service");
int old_pos = (int)(old_in + old_out) / 2;
bool found = false;
mlt_service_type mlt_type = mlt_service_identify( nextservice );
while (mlt_type == transition_type) {
Mlt::Transition transition((mlt_transition) nextservice);
nextservice = mlt_service_producer(nextservice);
int currentTrack = transition.get_b_track();
int currentIn = (int) transition.get_in();
int currentOut = (int) transition.get_out();
if (resource == type && startTrack == currentTrack && currentIn <= old_pos && currentOut >= old_pos) {
found = true;
if (newTrack - startTrack != 0) {
Mlt::Properties trans_props(transition.get_properties());
Mlt::Transition new_transition(*m_tractor->profile(), transition.get("mlt_service"));
Mlt::Properties new_trans_props(new_transition.get_properties());
// We cannot use MLT's property inherit because it also clones internal values like _unique_id which messes up the playlist
cloneProperties(new_trans_props, trans_props);
new_transition.set_in_and_out(new_in, new_out);
field->disconnect_service(transition);
plantTransition(field.data(), new_transition, newTransitionTrack, newTrack);
} else transition.set_in_and_out(new_in, new_out);
break;
}
if (nextservice == NULL) break;
properties = MLT_SERVICE_PROPERTIES(nextservice);
mlt_type = mlt_service_identify( nextservice );
resource = mlt_properties_get(properties, "mlt_service");
}
field->unlock();
if (doRefresh) refresh();
//if (m_isBlocked == 0) m_mltConsumer->set("refresh", 1);
return found;
}
static int on_start_producer( mlt_parser self, mlt_producer object )
{
mlt_properties properties = mlt_parser_properties( self );
mlt_properties producers = mlt_properties_get_data( properties, "producers", NULL );
mlt_producer parent = mlt_producer_cut_parent( object );
if ( mlt_service_identify( ( mlt_service )mlt_producer_cut_parent( object ) ) == producer_type && mlt_producer_is_cut( object ) )
{
int ref_count = 0;
clip_references *old_refs = NULL;
clip_references *refs = NULL;
char key[ 50 ];
int count = 0;
track_info *info = peek( self );
sprintf( key, "%p", parent );
mlt_properties_get_data( producers, key, &count );
mlt_properties_set_data( producers, key, parent, ++ count, NULL, NULL );
old_refs = mlt_properties_get_data( properties, key, &ref_count );
refs = malloc( ( ref_count + 1 ) * sizeof( clip_references ) );
if ( old_refs != NULL )
memcpy( refs, old_refs, ref_count * sizeof( clip_references ) );
mlt_properties_set_int( MLT_PRODUCER_PROPERTIES( object ), "_clone", -1 );
refs[ ref_count ].cut = object;
refs[ ref_count ].start = info->position;
refs[ ref_count ].end = info->position + mlt_producer_get_playtime( object ) - 1;
mlt_properties_set_data( properties, key, refs, ++ ref_count, free, NULL );
info->position += mlt_producer_get_playtime( object );
info->length += mlt_producer_get_playtime( object );
}
return 0;
}
void TransitionHandler::deleteTrackTransitions(int ix)
{
QScopedPointer<Mlt::Field> field(m_tractor->field());
mlt_service nextservice = mlt_service_get_producer(field->get_service());
mlt_service_type type = mlt_service_identify( nextservice );
while (type == transition_type) {
Mlt::Transition transition((mlt_transition) nextservice);
nextservice = mlt_service_producer(nextservice);
int currentTrack = transition.get_b_track();
if (ix == currentTrack) {
field->disconnect_service(transition);
}
if (nextservice == NULL) break;
type = mlt_service_identify(nextservice );
}
}
// adds the transition by keeping the instance order from topmost track down to background
void TransitionHandler::plantTransition(Mlt::Field *field, Mlt::Transition &tr, int a_track, int b_track)
{
mlt_service nextservice = mlt_service_get_producer(field->get_service());
mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
QString resource = mlt_properties_get(properties, "mlt_service");
QList <Mlt::Transition *> trList;
mlt_properties insertproperties = tr.get_properties();
QString insertresource = mlt_properties_get(insertproperties, "mlt_service");
bool isMixTransition = insertresource == QLatin1String("mix");
mlt_service_type mlt_type = mlt_service_identify( nextservice );
while (mlt_type == transition_type) {
Mlt::Transition transition((mlt_transition) nextservice);
nextservice = mlt_service_producer(nextservice);
int aTrack = transition.get_a_track();
int bTrack = transition.get_b_track();
int internal = transition.get_int("internal_added");
if ((isMixTransition || resource != QLatin1String("mix")) && (internal > 0 || aTrack < a_track || (aTrack == a_track && bTrack > b_track))) {
Mlt::Properties trans_props(transition.get_properties());
Mlt::Transition *cp = new Mlt::Transition(*m_tractor->profile(), transition.get("mlt_service"));
Mlt::Properties new_trans_props(cp->get_properties());
//new_trans_props.inherit(trans_props);
cloneProperties(new_trans_props, trans_props);
trList.append(cp);
field->disconnect_service(transition);
}
//else qDebug() << "// FOUND TRANS OK, "<<resource<< ", A_: " << aTrack << ", B_ "<<bTrack;
if (nextservice == NULL) break;
properties = MLT_SERVICE_PROPERTIES(nextservice);
mlt_type = mlt_service_identify( nextservice );
resource = mlt_properties_get(properties, "mlt_service");
}
field->plant_transition(tr, a_track, b_track);
// re-add upper transitions
for (int i = trList.count() - 1; i >= 0; --i) {
////qDebug()<< "REPLANT ON TK: "<<trList.at(i)->get_a_track()<<", "<<trList.at(i)->get_b_track();
field->plant_transition(*trList.at(i), trList.at(i)->get_a_track(), trList.at(i)->get_b_track());
}
qDeleteAll(trList);
}
void mlt_field_disconnect_service( mlt_field self, mlt_service service )
{
mlt_service p = mlt_service_producer( service );
mlt_service c = mlt_service_consumer( service);
int i;
switch ( mlt_service_identify(c) )
{
case filter_type:
i = mlt_filter_get_track( MLT_FILTER(c) );
mlt_service_connect_producer( c, p, i );
break;
case transition_type:
i = mlt_transition_get_a_track ( MLT_TRANSITION(c) );
mlt_service_connect_producer( c, p, i );
MLT_TRANSITION(c)->producer = p;
break;
case tractor_type:
self->producer = p;
mlt_tractor_connect( MLT_TRACTOR(c), p );
default:
break;
}
mlt_events_fire( mlt_field_properties( self ), "service-changed", NULL );
}
int mlt_tractor_remove_track( mlt_tractor self, int index )
{
int error = mlt_multitrack_disconnect( mlt_tractor_multitrack( self ), index );
if ( !error )
{
// Update the track indices of transitions and track filters.
mlt_service service = mlt_service_producer( MLT_TRACTOR_SERVICE( self ) );
while ( service )
{
mlt_service_type type = mlt_service_identify( service );
mlt_properties properties = MLT_SERVICE_PROPERTIES( service );
if ( type == transition_type )
{
mlt_transition transition = MLT_TRANSITION( service );
int a_track = mlt_transition_get_a_track( transition );
int b_track = mlt_transition_get_b_track( transition );
if ( a_track >= index || b_track >= index )
{
a_track = MAX( a_track >= index ? a_track - 1 : a_track, 0 );
b_track = MAX( b_track >= index ? b_track - 1 : b_track, 0 );
mlt_transition_set_tracks( transition, a_track, b_track );
}
}
else if ( type == filter_type )
{
int current_track = mlt_properties_get_int( properties, "track" );
if ( current_track >= index )
mlt_properties_set_int( properties, "track", MAX( current_track - 1, 0 ) );
}
service = mlt_service_producer( service );
}
}
return error;
}
int mlt_service_get_frame( mlt_service self, mlt_frame_ptr frame, int index )
{
int result = 0;
// Lock the service
mlt_service_lock( self );
// Ensure that the frame is NULL
*frame = NULL;
// Only process if we have a valid service
if ( self != NULL && self->get_frame != NULL )
{
mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
mlt_position in = mlt_properties_get_position( properties, "in" );
mlt_position out = mlt_properties_get_position( properties, "out" );
mlt_position position = mlt_service_identify( self ) == producer_type ? mlt_producer_position( MLT_PRODUCER( self ) ) : -1;
result = self->get_frame( self, frame, index );
if ( result == 0 )
{
mlt_properties_inc_ref( properties );
properties = MLT_FRAME_PROPERTIES( *frame );
if ( in >=0 && out > 0 )
{
mlt_properties_set_position( properties, "in", in );
mlt_properties_set_position( properties, "out", out );
}
mlt_service_apply_filters( self, *frame, 1 );
mlt_deque_push_back( MLT_FRAME_SERVICE_STACK( *frame ), self );
if ( mlt_service_identify( self ) == producer_type &&
mlt_properties_get_int( MLT_SERVICE_PROPERTIES( self ), "_need_previous_next" ) )
{
// Save the new position from self->get_frame
mlt_position new_position = mlt_producer_position( MLT_PRODUCER( self ) );
// Get the preceding frame, unfiltered
mlt_frame previous_frame;
mlt_producer_seek( MLT_PRODUCER(self), position - 1 );
result = self->get_frame( self, &previous_frame, index );
if ( !result )
mlt_properties_set_data( properties, "previous frame",
previous_frame, 0, ( mlt_destructor ) mlt_frame_close, NULL );
// Get the following frame, unfiltered
mlt_frame next_frame;
mlt_producer_seek( MLT_PRODUCER(self), position + 1 );
result = self->get_frame( self, &next_frame, index );
if ( !result )
{
mlt_properties_set_data( properties, "next frame",
next_frame, 0, ( mlt_destructor ) mlt_frame_close, NULL );
}
// Restore the new position
mlt_producer_seek( MLT_PRODUCER(self), new_position );
}
}
}
// Make sure we return a frame
if ( *frame == NULL )
*frame = mlt_frame_init( self );
// Unlock the service
mlt_service_unlock( self );
return result;
}
bool ServiceManager::initialize(int width, int height)
{
if (effects)
return true;
mlt_properties properties = MLT_SERVICE_PROPERTIES(service);
// Create and initialize Effects
const char* fileName = mlt_properties_get(properties, "resource");
if (!fileName) {
mlt_log(service, MLT_LOG_ERROR, "No 'resource' property found\n");
return false;
}
bool isTransparent = mlt_properties_get_int(properties, "transparent") || mlt_service_identify(service) == filter_type;
parameters = new ServiceParameters(service);
effects = WebVfx::createEffects(fileName, width, height,
parameters, isTransparent);
if (!effects) {
mlt_log(service, MLT_LOG_ERROR,
"Failed to create WebVfx Effects for resource %s\n", fileName);
return false;
}
// Iterate over image map - save source and target image names,
// and create an ImageProducer for each extra image.
char* factory = mlt_properties_get(properties, "factory");
WebVfx::Effects::ImageTypeMapIterator it(effects->getImageTypeMap());
while (it.hasNext()) {
it.next();
const QString& imageName = it.key();
switch (it.value()) {
case WebVfx::Effects::SourceImageType:
sourceImageName = imageName;
break;
case WebVfx::Effects::TargetImageType:
targetImageName = imageName;
break;
case WebVfx::Effects::ExtraImageType:
{
if (!imageProducers)
imageProducers = new std::vector<ImageProducer*>(3);
// Property prefix "producer.<name>."
QString producerPrefix("producer.");
producerPrefix.append(imageName).append(".");
// Find producer.<name>.resource property
QString resourceName(producerPrefix);
resourceName.append("resource");
char* resource = mlt_properties_get(properties, resourceName.toLatin1().constData());
if (resource) {
mlt_producer producer = mlt_factory_producer(mlt_service_profile(service), factory, resource);
if (!producer) {
mlt_log(service, MLT_LOG_ERROR, "WebVfx failed to create extra image producer for %s\n", resourceName.toLatin1().constData());
return false;
}
// Copy producer.<name>.* properties onto producer
mlt_properties_pass(MLT_PRODUCER_PROPERTIES(producer), properties, producerPrefix.toLatin1().constData());
// Append ImageProducer to vector
imageProducers->insert(imageProducers->end(), new ImageProducer(imageName, producer));
}
else
mlt_log(service, MLT_LOG_WARNING, "WebVfx no producer resource property specified for extra image %s\n", resourceName.toLatin1().constData());
break;
}
default:
mlt_log(service, MLT_LOG_ERROR, "Invalid WebVfx image type %d\n", it.value());
break;
}
}
return true;
}
void TransitionHandler::enableMultiTrack(bool enable)
{
int tracks = m_tractor->count();
if (tracks < 3) {
// we need at leas 3 tracks (black bg track + 2 tracks to use this)
return;
}
QScopedPointer<Mlt::Service> service(m_tractor->field());
QScopedPointer<Mlt::Field> field(m_tractor->field());
field->lock();
if (enable) {
// disable track composition (frei0r.cairoblend)
QScopedPointer<Mlt::Field> field(m_tractor->field());
mlt_service nextservice = mlt_service_get_producer(field->get_service());
mlt_service_type type = mlt_service_identify( nextservice );
while (type == transition_type) {
Mlt::Transition transition((mlt_transition) nextservice);
nextservice = mlt_service_producer(nextservice);
int added = transition.get_int("internal_added");
if (added == 237) {
QString mlt_service = transition.get("mlt_service");
if (mlt_service == QLatin1String("frei0r.cairoblend") && transition.get_int("disable") == 0) {
transition.set("disable", 1);
transition.set("split_disable", 1);
}
}
if (nextservice == NULL) break;
type = mlt_service_identify(nextservice);
}
for (int i = 1, screen = 0; i < tracks && screen < 4; ++i) {
Mlt::Producer trackProducer(m_tractor->track(i));
if (QString(trackProducer.get("hide")).toInt() != 1) {
Mlt::Transition transition(*m_tractor->profile(), "composite");
transition.set("mlt_service", "composite");
transition.set("a_track", 0);
transition.set("b_track", i);
transition.set("distort", 0);
transition.set("aligned", 0);
// 200 is an arbitrary number so we can easily remove these transition later
transition.set("internal_added", 200);
QString geometry;
switch (screen) {
case 0:
geometry = QStringLiteral("0/0:50%x50%");
break;
case 1:
geometry = QStringLiteral("50%/0:50%x50%");
break;
case 2:
geometry = QStringLiteral("0/50%:50%x50%");
break;
case 3:
default:
geometry = QStringLiteral("50%/50%:50%x50%");
break;
}
transition.set("geometry", geometry.toUtf8().constData());
transition.set("always_active", 1);
field->plant_transition(transition, 0, i);
screen++;
}
}
} else {
QScopedPointer<Mlt::Field> field(m_tractor->field());
mlt_service nextservice = mlt_service_get_producer(field->get_service());
mlt_service_type type = mlt_service_identify( nextservice );
while (type == transition_type) {
Mlt::Transition transition((mlt_transition) nextservice);
nextservice = mlt_service_producer(nextservice);
int added = transition.get_int("internal_added");
if (added == 200) {
field->disconnect_service(transition);
} else if (added == 237) {
// re-enable track compositing
QString mlt_service = transition.get("mlt_service");
if (mlt_service == QLatin1String("frei0r.cairoblend") && transition.get_int("split_disable") == 1) {
transition.set("disable", 0);
transition.set("split_disable", (char*) NULL);
}
}
if (nextservice == NULL) break;
type = mlt_service_identify(nextservice);
}
}
field->unlock();
emit refresh();
}
void TransitionHandler::updateTransitionParams(QString type, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml)
{
QScopedPointer<Mlt::Field> field(m_tractor->field());
field->lock();
double fps = m_tractor->get_fps();
mlt_service nextservice = mlt_service_get_producer(field->get_service());
mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
QString resource = mlt_properties_get(properties, "mlt_service");
int in_pos = (int) in.frames(fps);
int out_pos = (int) out.frames(fps) - 1;
mlt_service_type mlt_type = mlt_service_identify( nextservice );
while (mlt_type == transition_type) {
mlt_transition tr = (mlt_transition) nextservice;
int currentTrack = mlt_transition_get_b_track(tr);
int currentBTrack = mlt_transition_get_a_track(tr);
int currentIn = (int) mlt_transition_get_in(tr);
int currentOut = (int) mlt_transition_get_out(tr);
// //qDebug()<<"Looking for transition : " << currentIn <<'x'<<currentOut<< ", OLD oNE: "<<in_pos<<'x'<<out_pos;
if (resource == type && b_track == currentTrack && currentIn == in_pos && currentOut == out_pos) {
QMap<QString, QString> map = getTransitionParamsFromXml(xml);
QMap<QString, QString>::Iterator it;
QString key;
mlt_properties transproperties = MLT_TRANSITION_PROPERTIES(tr);
QString currentId = mlt_properties_get(transproperties, "kdenlive_id");
if (currentId != xml.attribute(QStringLiteral("id"))) {
// The transition ID is not the same, so reset all properties
mlt_properties_set(transproperties, "kdenlive_id", xml.attribute(QStringLiteral("id")).toUtf8().constData());
// Cleanup previous properties
QStringList permanentProps;
permanentProps << QStringLiteral("factory") << QStringLiteral("kdenlive_id") << QStringLiteral("mlt_service") << QStringLiteral("mlt_type") << QStringLiteral("in");
permanentProps << QStringLiteral("out") << QStringLiteral("a_track") << QStringLiteral("b_track");
for (int i = 0; i < mlt_properties_count(transproperties); ++i) {
QString propName = mlt_properties_get_name(transproperties, i);
if (!propName.startsWith('_') && ! permanentProps.contains(propName)) {
mlt_properties_set(transproperties, propName.toUtf8().constData(), "");
}
}
}
mlt_properties_set_int(transproperties, "force_track", xml.attribute(QStringLiteral("force_track")).toInt());
mlt_properties_set_int(transproperties, "automatic", xml.attribute(QStringLiteral("automatic"), QStringLiteral("0")).toInt());
if (currentBTrack != a_track) {
mlt_properties_set_int(transproperties, "a_track", a_track);
}
for (it = map.begin(); it != map.end(); ++it) {
key = it.key();
mlt_properties_set(transproperties, key.toUtf8().constData(), it.value().toUtf8().constData());
//qDebug() << " ------ UPDATING TRANS PARAM: " << key.toUtf8().constData() << ": " << it.value().toUtf8().constData();
//filter->set("kdenlive_id", id);
}
break;
}
nextservice = mlt_service_producer(nextservice);
if (nextservice == NULL) break;
properties = MLT_SERVICE_PROPERTIES(nextservice);
mlt_type = mlt_service_identify( nextservice );
resource = mlt_properties_get(properties, "mlt_service");
}
field->unlock();
//askForRefresh();
//if (m_isBlocked == 0) m_mltConsumer->set("refresh", 1);
}
int mlt_parser_start( mlt_parser self, mlt_service object )
{
int error = 0;
mlt_service_type type = mlt_service_identify( object );
switch( type )
{
case invalid_type:
error = self->on_invalid( self, object );
break;
case unknown_type:
error = self->on_unknown( self, object );
break;
case producer_type:
if ( mlt_producer_is_cut( ( mlt_producer )object ) )
error = mlt_parser_start( self, ( mlt_service )mlt_producer_cut_parent( ( mlt_producer )object ) );
error = self->on_start_producer( self, ( mlt_producer )object );
if ( error == 0 )
{
int i = 0;
while ( error == 0 && mlt_producer_filter( ( mlt_producer )object, i ) != NULL )
error = mlt_parser_start( self, ( mlt_service )mlt_producer_filter( ( mlt_producer )object, i ++ ) );
}
error = self->on_end_producer( self, ( mlt_producer )object );
break;
case playlist_type:
error = self->on_start_playlist( self, ( mlt_playlist )object );
if ( error == 0 )
{
int i = 0;
while ( error == 0 && i < mlt_playlist_count( ( mlt_playlist )object ) )
mlt_parser_start( self, ( mlt_service )mlt_playlist_get_clip( ( mlt_playlist )object, i ++ ) );
i = 0;
while ( error == 0 && mlt_producer_filter( ( mlt_producer )object, i ) != NULL )
error = mlt_parser_start( self, ( mlt_service )mlt_producer_filter( ( mlt_producer )object, i ++ ) );
}
error = self->on_end_playlist( self, ( mlt_playlist )object );
break;
case tractor_type:
error = self->on_start_tractor( self, ( mlt_tractor )object );
if ( error == 0 )
{
int i = 0;
mlt_service next = mlt_service_producer( object );
mlt_parser_start( self, ( mlt_service )mlt_tractor_multitrack( ( mlt_tractor )object ) );
while ( next != ( mlt_service )mlt_tractor_multitrack( ( mlt_tractor )object ) )
{
mlt_parser_start( self, next );
next = mlt_service_producer( next );
}
while ( error == 0 && mlt_producer_filter( ( mlt_producer )object, i ) != NULL )
error = mlt_parser_start( self, ( mlt_service )mlt_producer_filter( ( mlt_producer )object, i ++ ) );
}
error = self->on_end_tractor( self, ( mlt_tractor )object );
break;
case multitrack_type:
error = self->on_start_multitrack( self, ( mlt_multitrack )object );
if ( error == 0 )
{
int i = 0;
while ( i < mlt_multitrack_count( ( mlt_multitrack )object ) )
{
self->on_start_track( self );
mlt_parser_start( self, ( mlt_service )mlt_multitrack_track( ( mlt_multitrack )object , i ++ ) );
self->on_end_track( self );
}
i = 0;
while ( error == 0 && mlt_producer_filter( ( mlt_producer )object, i ) != NULL )
error = mlt_parser_start( self, ( mlt_service )mlt_producer_filter( ( mlt_producer )object, i ++ ) );
}
error = self->on_end_multitrack( self, ( mlt_multitrack )object );
break;
case filter_type:
error = self->on_start_filter( self, ( mlt_filter )object );
if ( error == 0 )
{
int i = 0;
while ( error == 0 && mlt_producer_filter( ( mlt_producer )object, i ) != NULL )
error = mlt_parser_start( self, ( mlt_service )mlt_producer_filter( ( mlt_producer )object, i ++ ) );
}
error = self->on_end_filter( self, ( mlt_filter )object );
break;
case transition_type:
error = self->on_start_transition( self, ( mlt_transition )object );
if ( error == 0 )
{
int i = 0;
while ( error == 0 && mlt_producer_filter( ( mlt_producer )object, i ) != NULL )
error = mlt_parser_start( self, ( mlt_service )mlt_producer_filter( ( mlt_producer )object, i ++ ) );
}
error = self->on_end_transition( self, ( mlt_transition )object );
break;
case field_type:
break;
case consumer_type:
break;
}
return error;
}
