int mlt_service_detach( mlt_service self, mlt_filter filter )
{
int error = self == NULL || filter == NULL;
if ( error == 0 )
{
int i = 0;
mlt_service_base *base = self->local;
mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
for ( i = 0; i < base->filter_count; i ++ )
if ( base->filters[ i ] == filter )
break;
if ( i < base->filter_count )
{
base->filters[ i ] = NULL;
for ( i ++ ; i < base->filter_count; i ++ )
base->filters[ i - 1 ] = base->filters[ i ];
base->filter_count --;
mlt_events_disconnect( MLT_FILTER_PROPERTIES( filter ), self );
mlt_filter_close( filter );
mlt_events_fire( properties, "service-changed", NULL );
}
}
return error;
}
mlt_filter filter_vidstab_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new();
vs_data* data = (vs_data*)calloc( 1, sizeof(vs_data) );
if ( filter && data )
{
data->analyze_data = NULL;
data->apply_data = NULL;
filter->close = filter_close;
filter->child = data;
filter->process = process_filter;
mlt_properties properties = MLT_FILTER_PROPERTIES(filter);
//properties for analyze
mlt_properties_set( properties, "filename", "vidstab.trf" );
mlt_properties_set( properties, "shakiness", "4" );
mlt_properties_set( properties, "accuracy", "4" );
mlt_properties_set( properties, "stepsize", "6" );
mlt_properties_set( properties, "algo", "1" );
mlt_properties_set( properties, "mincontrast", "0.3" );
mlt_properties_set( properties, "show", "0" );
mlt_properties_set( properties, "tripod", "0" );
// properties for apply
mlt_properties_set( properties, "smoothing", "15" );
mlt_properties_set( properties, "maxshift", "-1" );
mlt_properties_set( properties, "maxangle", "-1" );
mlt_properties_set( properties, "crop", "0" );
mlt_properties_set( properties, "invert", "0" );
mlt_properties_set( properties, "relative", "1" );
mlt_properties_set( properties, "zoom", "0" );
mlt_properties_set( properties, "optzoom", "1" );
mlt_properties_set( properties, "zoomspeed", "0.25" );
mlt_properties_set( properties, "reload", "0" );
mlt_properties_set( properties, "vid.stab.version", LIBVIDSTAB_VERSION );
init_vslog();
}
else
{
if( filter )
{
mlt_filter_close( filter );
}
if( data )
{
free( data );
}
filter = NULL;
}
return filter;
}
mlt_filter filter_audiospectrum_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new();
private_data* pdata = (private_data*)calloc( 1, sizeof(private_data) );
if ( filter && pdata && createQApplicationIfNeeded( MLT_FILTER_SERVICE(filter) ) )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_properties_set_int( properties, "_filter_private", 1 );
mlt_properties_set_int( properties, "frequency_low", 20 );
mlt_properties_set_int( properties, "frequency_high", 20000 );
mlt_properties_set( properties, "type", "line" );
mlt_properties_set( properties, "bgcolor", "0x00000000" );
mlt_properties_set( properties, "color.1", "0xffffffff" );
mlt_properties_set( properties, "rect", "0% 0% 100% 100%" );
mlt_properties_set( properties, "thickness", "0" );
mlt_properties_set( properties, "fill", "0" );
mlt_properties_set( properties, "mirror", "0" );
mlt_properties_set( properties, "reverse", "0" );
mlt_properties_set( properties, "tension", "0.4" );
mlt_properties_set( properties, "angle", "0" );
mlt_properties_set( properties, "gorient", "v" );
mlt_properties_set_int( properties, "bands", 31 );
mlt_properties_set_double( properties, "threshold", -60.0 );
mlt_properties_set_int( properties, "window_size", 8192 );
// Create a unique ID for storing data on the frame
pdata->fft_prop_name = (char*)calloc( 1, 20 );
snprintf( pdata->fft_prop_name, 20, "fft.%p", filter );
pdata->fft_prop_name[20 - 1] = '\0';
pdata->fft = 0;
filter->close = filter_close;
filter->process = filter_process;
filter->child = pdata;
}
else
{
mlt_log_error( MLT_FILTER_SERVICE(filter), "Filter audio spectrum failed\n" );
if( filter )
{
mlt_filter_close( filter );
}
if( pdata )
{
free( pdata );
}
filter = NULL;
}
return filter;
}
mlt_filter filter_loudness_meter_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new( );
private_data* pdata = (private_data*)calloc( 1, sizeof(private_data) );
if( filter && pdata )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_properties_set_int( properties, "calc_program", 1 );
mlt_properties_set_int( properties, "calc_shortterm", 1 );
mlt_properties_set_int( properties, "calc_momentary", 1 );
mlt_properties_set_int( properties, "calc_range", 1 );
mlt_properties_set_int( properties, "calc_peak", 1 );
mlt_properties_set_int( properties, "calc_true_peak", 1 );
mlt_properties_set( properties, "program", "-100.0" );
mlt_properties_set( properties, "shortterm", "-100.0" );
mlt_properties_set( properties, "momentary", "-100.0" );
mlt_properties_set( properties, "range", "-1.0" );
mlt_properties_set( properties, "peak", "-100.0" );
mlt_properties_set( properties, "max_peak", "-100.0" );
mlt_properties_set( properties, "true_peak", "-100.0" );
mlt_properties_set( properties, "max_true_peak", "-100.0" );
mlt_properties_set( properties, "reset", "1" );
mlt_properties_set( properties, "reset_count", "0" );
mlt_properties_set( properties, "frames_processed", "0" );
pdata->r128 = 0;
pdata->reset = 1;
pdata->prev_pos = -1;
filter->close = filter_close;
filter->process = filter_process;
filter->child = pdata;
mlt_events_listen( properties, filter, "property-changed", (mlt_listener)property_changed );
}
else
{
if( filter )
{
mlt_filter_close( filter );
filter = NULL;
}
free( pdata );
}
return filter;
}
static void filter_close( mlt_filter filter )
{
private_data* pdata = (private_data*)filter->child;
if ( pdata )
{
mlt_filter_close( pdata->fft );
free( pdata->fft_prop_name );
free( pdata );
}
filter->child = NULL;
filter->close = NULL;
filter->parent.close = NULL;
mlt_service_close( &filter->parent );
}
mlt_filter filter_lift_gamma_gain_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new();
private_data* self = (private_data*)calloc( 1, sizeof(private_data) );
int i = 0;
if ( filter && self )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
// Initialize self data
for( i = 0; i < 256; i++ )
{
self->rlut[i] = i;
self->glut[i] = i;
self->blut[i] = i;
}
self->rlift = self->glift = self->blift = 0.0;
self->rgamma = self->ggamma = self->bgamma = 1.0;
self->rgain = self->ggain = self->bgain = 1.0;
// Initialize filter properties
mlt_properties_set_double( properties, "lift_r", self->rlift );
mlt_properties_set_double( properties, "lift_g", self->glift );
mlt_properties_set_double( properties, "lift_b", self->blift );
mlt_properties_set_double( properties, "gamma_r", self->rgamma );
mlt_properties_set_double( properties, "gamma_g", self->ggamma );
mlt_properties_set_double( properties, "gamma_b", self->bgamma );
mlt_properties_set_double( properties, "gain_r", self->rgain );
mlt_properties_set_double( properties, "gain_g", self->ggain );
mlt_properties_set_double( properties, "gain_b", self->bgain );
filter->close = filter_close;
filter->process = filter_process;
filter->child = self;
}
else
{
mlt_log_error( MLT_FILTER_SERVICE(filter), "Filter lift_gamma_gain init failed\n" );
mlt_filter_close( filter );
filter = NULL;
free( self );
}
return filter;
}
mlt_filter filter_dynamic_loudness_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new( );
private_data* pdata = (private_data*)calloc( 1, sizeof(private_data) );
if( filter && pdata )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_properties_set( properties, "target_loudness", "-23.0" );
mlt_properties_set( properties, "window", "3.0" );
mlt_properties_set( properties, "max_gain", "15.0" );
mlt_properties_set( properties, "min_gain", "-15.0" );
mlt_properties_set( properties, "max_rate", "3.0" );
mlt_properties_set( properties, "in_loudness", "-100.0" );
mlt_properties_set( properties, "out_gain", "0.0" );
mlt_properties_set( properties, "reset_count", "0" );
pdata->target_gain = 0.0;
pdata->start_gain = 0.0;
pdata->end_gain = 0.0;
pdata->r128 = 0;
pdata->reset = 1;
pdata->time_elapsed_ms = 0;
pdata->prev_o_pos = 0;
filter->close = filter_close;
filter->process = filter_process;
filter->child = pdata;
mlt_events_listen( properties, filter, "property-changed", (mlt_listener)property_changed );
}
else
{
if( filter )
{
mlt_filter_close( filter );
filter = NULL;
}
free( pdata );
}
return filter;
}
static void create_filter( mlt_profile profile, mlt_service service, char *effect, int *created )
{
char *id = strdup( effect );
char *arg = strchr( id, ':' );
if ( arg != NULL )
*arg ++ = '\0';
// The swscale and avcolor_space filters require resolution as arg to test compatibility
if ( strncmp( effect, "swscale", 7 ) == 0 || strncmp( effect, "avcolo", 6 ) == 0 )
arg = (char*) mlt_properties_get_int( MLT_SERVICE_PROPERTIES( service ), "meta.media.width" );
mlt_filter filter = mlt_factory_filter( profile, id, arg );
if ( filter != NULL )
{
mlt_properties_set_int( MLT_FILTER_PROPERTIES( filter ), "_loader", 1 );
mlt_service_attach( service, filter );
mlt_filter_close( filter );
*created = 1;
}
free( id );
}
mlt_filter filter_audiowaveform_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new();
if ( !filter ) return NULL;
if ( !createQApplicationIfNeeded( MLT_FILTER_SERVICE(filter) ) ) {
mlt_filter_close( filter );
return NULL;
}
filter->process = filter_process;
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
mlt_properties_set( filter_properties, "bgcolor", "0x00000000" );
mlt_properties_set( filter_properties, "color.1", "0xffffffff" );
mlt_properties_set( filter_properties, "thickness", "0" );
mlt_properties_set( filter_properties, "show_channel", "0" );
mlt_properties_set( filter_properties, "angle", "0" );
mlt_properties_set( filter_properties, "rect", "0 0 100% 100%" );
mlt_properties_set( filter_properties, "fill", "0" );
mlt_properties_set( filter_properties, "gorient", "v" );
return filter;
}
/** Constructor for the filter.
*/
mlt_filter filter_dynamictext_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new();
mlt_transition transition = mlt_factory_transition( profile, "composite", NULL );
mlt_producer producer = mlt_factory_producer( profile, mlt_environment( "MLT_PRODUCER" ), "qtext:" );
// Use pango if qtext is not available.
if( !producer )
producer = mlt_factory_producer( profile, mlt_environment( "MLT_PRODUCER" ), "pango:" );
if ( filter && transition && producer )
{
mlt_properties my_properties = MLT_FILTER_PROPERTIES( filter );
// Register the transition for reuse/destruction
mlt_properties_set_data( my_properties, "_transition", transition, 0, ( mlt_destructor )mlt_transition_close, NULL );
// Register the producer for reuse/destruction
mlt_properties_set_data( my_properties, "_producer", producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
// Ensure that we loop
mlt_properties_set( MLT_PRODUCER_PROPERTIES( producer ), "eof", "loop" );
// Assign default values
mlt_properties_set( my_properties, "argument", arg ? arg: "#timecode#" );
mlt_properties_set( my_properties, "geometry", "0%/0%:100%x100%:100" );
mlt_properties_set( my_properties, "family", "Sans" );
mlt_properties_set( my_properties, "size", "48" );
mlt_properties_set( my_properties, "weight", "400" );
mlt_properties_set( my_properties, "fgcolour", "0x000000ff" );
mlt_properties_set( my_properties, "bgcolour", "0x00000020" );
mlt_properties_set( my_properties, "olcolour", "0x00000000" );
mlt_properties_set( my_properties, "pad", "0" );
mlt_properties_set( my_properties, "halign", "left" );
mlt_properties_set( my_properties, "valign", "top" );
mlt_properties_set( my_properties, "outline", "0" );
mlt_properties_set_int( my_properties, "_filter_private", 1 );
filter->process = filter_process;
}
else
{
if( filter )
{
mlt_filter_close( filter );
}
if( transition )
{
mlt_transition_close( transition );
}
if( producer )
{
mlt_producer_close( producer );
}
filter = NULL;
}
return filter;
}
