static mlt_filter obtain_filter( mlt_filter filter, char *type )
{
// Result to return
mlt_filter result = NULL;
// Miscelaneous variable
int i = 0;
int type_len = strlen( type );
// Get the properties of the data show filter
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Get the profile properties
mlt_properties profile_properties = mlt_properties_get_data( filter_properties, "profile_properties", NULL );
// Obtain the profile_properties if we haven't already
if ( profile_properties == NULL )
{
char temp[ 512 ];
// Get the profile requested
char *profile = mlt_properties_get( filter_properties, "resource" );
// If none is specified, pick up the default for this normalisation
if ( profile == NULL )
sprintf( temp, "%s/feeds/%s/data_fx.properties", mlt_environment( "MLT_DATA" ), mlt_environment( "MLT_NORMALISATION" ) );
else if ( strchr( profile, '%' ) )
sprintf( temp, "%s/feeds/%s/%s", mlt_environment( "MLT_DATA" ), mlt_environment( "MLT_NORMALISATION" ), strchr( profile, '%' ) + 1 );
else
{
strncpy( temp, profile, sizeof( temp ) );
temp[ sizeof( temp ) - 1 ] = '\0';
}
// Load the specified profile or use the default
profile_properties = mlt_properties_load( temp );
// Store for later retrieval
mlt_properties_set_data( filter_properties, "profile_properties", profile_properties, 0, ( mlt_destructor )mlt_properties_close, NULL );
}
if ( profile_properties != NULL )
{
for ( i = 0; i < mlt_properties_count( profile_properties ); i ++ )
{
char *name = mlt_properties_get_name( profile_properties, i );
char *value = mlt_properties_get_value( profile_properties, i );
if ( result == NULL && !strcmp( name, type ) && result == NULL )
result = mlt_factory_filter( mlt_service_profile( MLT_FILTER_SERVICE( filter ) ), value, NULL );
else if ( result != NULL && !strncmp( name, type, type_len ) && name[ type_len ] == '.' )
mlt_properties_set( MLT_FILTER_PROPERTIES( result ), name + type_len + 1, value );
else if ( result != NULL )
break;
}
}
return result;
}
static mlt_filter create_filter( mlt_profile profile, char *effect )
{
mlt_filter filter;
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 ( !strcmp( effect, "avcolor_space" ) )
filter = mlt_factory_filter( profile, id, &profile->width );
else
filter = mlt_factory_filter( profile, id, arg );
if ( filter )
mlt_properties_set_int( MLT_FILTER_PROPERTIES( filter ), "_loader", 1 );
free( id );
return filter;
}
static int filter_get_audio( mlt_frame frame, void** buffer, mlt_audio_format* format, int* frequency, int* channels, int* samples )
{
mlt_filter filter = (mlt_filter)mlt_frame_pop_audio( frame );
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
private_data* pdata = (private_data*)filter->child;
// Create the FFT filter the first time.
if( !pdata->fft )
{
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE(filter) );
pdata->fft = mlt_factory_filter( profile, "fft", NULL );
mlt_properties_set_int( MLT_FILTER_PROPERTIES( pdata->fft ), "window_size",
mlt_properties_get_int( filter_properties, "window_size" ) );
if( !pdata->fft )
{
mlt_log_warning( MLT_FILTER_SERVICE(filter), "Unable to create FFT.\n" );
return 1;
}
}
mlt_properties fft_properties = MLT_FILTER_PROPERTIES( pdata->fft );
// The service must stay locked while using the private data
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
// Perform FFT processing on the frame
mlt_filter_process( pdata->fft, frame );
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
float* bins = (float*)mlt_properties_get_data( fft_properties, "bins", NULL );
if( bins )
{
double window_level = mlt_properties_get_double( fft_properties, "window_level" );
int bin_count = mlt_properties_get_int( fft_properties, "bin_count" );
size_t bins_size = bin_count * sizeof(float);
float* save_bins = (float*)mlt_pool_alloc( bins_size );
if( window_level == 1.0 )
{
memcpy( save_bins, bins, bins_size );
} else {
memset( save_bins, 0, bins_size );
}
// Save the bin data as a property on the frame to be used in get_image()
mlt_properties_set_data( MLT_FRAME_PROPERTIES(frame), pdata->fft_prop_name, save_bins, bins_size, mlt_pool_release, NULL );
}
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
return 0;
}
static void setup_jack_transport( mlt_consumer consumer, mlt_profile profile )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
mlt_filter jack = mlt_factory_filter( profile, "jackrack", NULL );
mlt_properties jack_properties = MLT_FILTER_PROPERTIES(jack);
mlt_service_attach( MLT_CONSUMER_SERVICE(consumer), jack );
mlt_properties_set_int( properties, "audio_off", 1 );
mlt_properties_set_data( properties, "jack_filter", jack, 0, (mlt_destructor) mlt_filter_close, NULL );
// mlt_properties_set( jack_properties, "out_1", "system:playback_1" );
// mlt_properties_set( jack_properties, "out_2", "system:playback_2" );
mlt_events_listen( jack_properties, consumer, "jack-started", (mlt_listener) on_jack_started );
mlt_events_listen( jack_properties, consumer, "jack-stopped", (mlt_listener) on_jack_stopped );
}
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 );
}
static int create_instance( mlt_transition transition, char *name, char *value, int count )
{
// Return from this function
int error = 0;
// Duplicate the value
char *type = strdup( value );
// Pointer to filter argument
char *arg = type == NULL ? NULL : strchr( type, ':' );
// New filter being created
mlt_filter filter = NULL;
// Cleanup type and arg
if ( arg != NULL )
*arg ++ = '\0';
// Create the filter
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
if ( type )
filter = mlt_factory_filter( profile, type, arg );
// If we have a filter, then initialise and store it
if ( filter != NULL )
{
// Properties of transition
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// String to hold the property name
char id[ 256 ];
// String to hold the passdown key
char key[ 256 ];
// Construct id
sprintf( id, "_filter_%d", count );
// Counstruct key
sprintf( key, "%s.", name );
// Just in case, let's assume that the filter here has a composite
//mlt_properties_set( MLT_FILTER_PROPERTIES( filter ), "composite.geometry", "0%/0%:100%x100%" );
//mlt_properties_set_int( MLT_FILTER_PROPERTIES( filter ), "composite.fill", 1 );
// Pass all the key properties on the filter down
mlt_properties_pass( MLT_FILTER_PROPERTIES( filter ), properties, key );
mlt_properties_pass_list( MLT_FILTER_PROPERTIES( filter ), properties, "in, out, length" );
// Ensure that filter is assigned
mlt_properties_set_data( properties, id, filter, 0, ( mlt_destructor )mlt_filter_close, NULL );
}
else
{
// Indicate that an error has occurred
error = 1;
}
// Cleanup
free( type );
// Return error condition
return error;
}
