static int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
mlt_filter filter = mlt_frame_pop_audio( frame );
private_data* pdata = (private_data*)filter->child;
mlt_position pos = mlt_frame_get_position( frame );
// Get the producer's audio
*format = mlt_audio_f32le;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
check_for_reset( filter, *channels, *frequency );
if( pos != pdata->prev_pos )
{
// Only analyze the audio if the producer is not paused.
analyze_audio( filter, *buffer, *samples );
}
pdata->prev_pos = pos;
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
return 0;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
int error = 0;
// Regenerate the LUT if necessary
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
refresh_lut( filter, frame );
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
// Make sure the format is acceptable
if( *format != mlt_image_rgb24 && *format != mlt_image_rgb24a )
{
*format = mlt_image_rgb24;
}
// Get the image
writable = 1;
error = mlt_frame_get_image( frame, image, format, width, height, writable );
// Apply the LUT
if( !error )
{
apply_lut( filter, *image, *format, *width, *height );
}
return error;
}
static int attach_boundry_to_frame( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the filter object
mlt_filter filter = mlt_frame_pop_service( frame );
// Get the filter's property object
mlt_properties filter_properties = MLT_FILTER_PROPERTIES(filter);
// Get the frame properties
mlt_properties frame_properties = MLT_FRAME_PROPERTIES(frame);
// Get the frame position
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
// Get the geometry object
mlt_geometry geometry = mlt_properties_get_data(filter_properties, "filter_geometry", NULL);
if (geometry == NULL) {
mlt_geometry geom = mlt_geometry_init();
char *arg = mlt_properties_get(filter_properties, "geometry");
// Initialize with the supplied geometry
struct mlt_geometry_item_s item;
mlt_geometry_parse_item( geom, &item, arg );
item.frame = 0;
item.key = 1;
item.mix = 100;
mlt_geometry_insert( geom, &item );
mlt_geometry_interpolate( geom );
mlt_properties_set_data( filter_properties, "filter_geometry", geom, 0, (mlt_destructor)mlt_geometry_close, (mlt_serialiser)mlt_geometry_serialise );
geometry = mlt_properties_get_data(filter_properties, "filter_geometry", NULL);
}
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
// Get the current geometry item
mlt_geometry_item geometry_item = mlt_pool_alloc( sizeof( struct mlt_geometry_item_s ) );
mlt_geometry_fetch(geometry, geometry_item, position);
// Cleanse the geometry item
geometry_item->w = geometry_item->x < 0 ? geometry_item->w + geometry_item->x : geometry_item->w;
geometry_item->h = geometry_item->y < 0 ? geometry_item->h + geometry_item->y : geometry_item->h;
geometry_item->x = geometry_item->x < 0 ? 0 : geometry_item->x;
geometry_item->y = geometry_item->y < 0 ? 0 : geometry_item->y;
geometry_item->w = geometry_item->w < 0 ? 0 : geometry_item->w;
geometry_item->h = geometry_item->h < 0 ? 0 : geometry_item->h;
mlt_properties_set_data( frame_properties, "bounds", geometry_item, sizeof( struct mlt_geometry_item_s ), mlt_pool_release, NULL );
// Get the new image
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
if( error != 0 )
mlt_properties_debug( frame_properties, "error after mlt_frame_get_image() in autotrack_rectangle attach_boundry_to_frame", stderr );
return error;
}
static void analyze_image( mlt_filter filter, mlt_frame frame, uint8_t* vs_image, VSPixelFormat vs_format, int width, int height )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
vs_data* data = (vs_data*)filter->child;
mlt_position pos = mlt_filter_get_position( filter, frame );
// If any frames are skipped, analysis data will be incomplete.
if( data->analyze_data && pos != data->analyze_data->last_position + 1 )
{
mlt_log_error( MLT_FILTER_SERVICE(filter), "Bad frame sequence\n" );
destory_analyze_data( data->analyze_data );
data->analyze_data = NULL;
}
if ( !data->analyze_data && pos == 0 )
{
// Analysis must start on the first frame
init_analyze_data( filter, frame, vs_format, width, height );
}
if( data->analyze_data )
{
// Initialize the VSFrame to be analyzed.
VSMotionDetect* md = &data->analyze_data->md;
LocalMotions localmotions;
VSFrame vsFrame;
vsFrameFillFromBuffer( &vsFrame, vs_image, &md->fi );
// Detect and save motions.
if( vsMotionDetection( md, &localmotions, &vsFrame ) == VS_OK )
{
vsWriteToFile( md, data->analyze_data->results, &localmotions);
vs_vector_del( &localmotions );
}
else
{
mlt_log_error( MLT_FILTER_SERVICE(filter), "Motion detection failed\n" );
destory_analyze_data( data->analyze_data );
data->analyze_data = NULL;
}
// Publish the motions if this is the last frame.
if ( pos + 1 == mlt_filter_get_length2( filter, frame ) )
{
mlt_log_info( MLT_FILTER_SERVICE(filter), "Analysis complete\n" );
destory_analyze_data( data->analyze_data );
data->analyze_data = NULL;
mlt_properties_set( properties, "results", mlt_properties_get( properties, "filename" ) );
}
else
{
data->analyze_data->last_position = pos;
}
}
}
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;
}
static void on_jack_seek( mlt_properties owner, mlt_filter filter, mlt_position *position )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_log_verbose( MLT_FILTER_SERVICE(filter), "%s: %d\n", __FUNCTION__, *position );
mlt_properties_set_int( properties, "_sync_guard", 1 );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
jack_client_t *jack_client = mlt_properties_get_data( properties, "jack_client", NULL );
jack_nframes_t jack_frame = jack_get_sample_rate( jack_client );
jack_frame *= *position / mlt_profile_fps( profile );
jack_transport_locate( jack_client, jack_frame );
}
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 int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
mlt_filter filter = mlt_frame_pop_audio( frame );
private_data* pdata = (private_data*)filter->child;
mlt_position o_pos = mlt_frame_original_position( frame );
// Get the producer's audio
*format = mlt_audio_f32le;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
if( abs( o_pos - pdata->prev_o_pos ) > 1 )
{
// Assume this is a new clip and restart
// Use original position so that transitions between clips are detected.
pdata->reset = 1;
mlt_log_info( MLT_FILTER_SERVICE( filter ), "Reset. Old Pos: %d\tNew Pos: %d\n", pdata->prev_o_pos, o_pos );
}
check_for_reset( filter, *channels, *frequency );
if( o_pos != pdata->prev_o_pos )
{
// Only analyze the audio is the producer is not paused.
analyze_audio( filter, *buffer, *samples, *frequency );
}
double start_coeff = pdata->start_gain > -90.0 ? pow(10.0, pdata->start_gain / 20.0) : 0.0;
double end_coeff = pdata->end_gain > -90.0 ? pow(10.0, pdata->end_gain / 20.0) : 0.0;
double coeff_factor = pow( (end_coeff / start_coeff), 1.0 / (double)*samples );
double coeff = start_coeff;
float* p = *buffer;
int s = 0;
int c = 0;
for( s = 0; s < *samples; s++ )
{
coeff = coeff * coeff_factor;
for ( c = 0; c < *channels; c++ )
{
*p = *p * coeff;
p++;
}
}
pdata->prev_o_pos = o_pos;
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
return 0;
}
static void apply_lut( mlt_filter filter, uint8_t* image, mlt_image_format format, int width, int height )
{
private_data* self = (private_data*)filter->child;
uint8_t* rlut = malloc( sizeof(self->rlut) );
uint8_t* glut = malloc( sizeof(self->glut) );
uint8_t* blut = malloc( sizeof(self->blut) );
int total = width * height + 1;
uint8_t* sample = image;
// Copy the LUT so that we can be frame-thread safe.
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
memcpy( rlut, self->rlut, sizeof(self->rlut) );
memcpy( glut, self->glut, sizeof(self->glut) );
memcpy( blut, self->blut, sizeof(self->blut) );
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
switch( format )
{
case mlt_image_rgb24:
while( --total )
{
*sample = rlut[ *sample ];
sample++;
*sample = glut[ *sample ];
sample++;
*sample = blut[ *sample ];
sample++;
}
break;
case mlt_image_rgb24a:
while( --total )
{
*sample = rlut[ *sample ];
sample++;
*sample = glut[ *sample ];
sample++;
*sample = blut[ *sample ];
sample++;
sample++; // Skip alpha
}
break;
default:
mlt_log_error( MLT_FILTER_SERVICE( filter ), "Invalid image format: %s\n", mlt_image_format_name( format ) );
break;
}
free( rlut );
free( glut );
free( blut );
}
/** Get the image.
*/
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
mlt_filter filter = mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_producer producer = mlt_properties_get_data( properties, "_producer", NULL );
mlt_transition transition = mlt_properties_get_data( properties, "_transition", NULL );
mlt_frame text_frame = NULL;
mlt_position position = 0;
// Configure this filter
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
setup_producer( filter, producer, frame );
setup_transition( filter, transition );
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
// Make sure the producer is in the correct position
position = mlt_filter_get_position( filter, frame );
mlt_producer_seek( producer, position );
// Get the b frame and process with transition if successful
if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &text_frame, 0 ) == 0 )
{
// Get the a and b frame properties
mlt_properties a_props = MLT_FRAME_PROPERTIES( frame );
mlt_properties b_props = MLT_FRAME_PROPERTIES( text_frame );
// Set the frame and text_frame to be in the same position and have same consumer requirements
mlt_frame_set_position( text_frame, position );
mlt_frame_set_position( frame, position );
mlt_properties_set_int( b_props, "consumer_deinterlace", mlt_properties_get_int( a_props, "consumer_deinterlace" ) );
// Apply all filters that are attached to this filter to the b frame
mlt_service_apply_filters( MLT_FILTER_SERVICE( filter ), text_frame, 0 );
// Process the frame
mlt_transition_process( transition, frame, text_frame );
// Get the image
*format = mlt_image_yuv422;
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Close the b frame
mlt_frame_close( text_frame );
}
return error;
}
void mlt_service_apply_filters( mlt_service self, mlt_frame frame, int index )
{
int i;
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_properties service_properties = MLT_SERVICE_PROPERTIES( self );
mlt_service_base *base = self->local;
mlt_position position = mlt_frame_get_position( frame );
mlt_position self_in = mlt_properties_get_position( service_properties, "in" );
mlt_position self_out = mlt_properties_get_position( service_properties, "out" );
if ( index == 0 || mlt_properties_get_int( service_properties, "_filter_private" ) == 0 )
{
// Process the frame with the attached filters
for ( i = 0; i < base->filter_count; i ++ )
{
if ( base->filters[ i ] != NULL )
{
mlt_position in = mlt_filter_get_in( base->filters[ i ] );
mlt_position out = mlt_filter_get_out( base->filters[ i ] );
int disable = mlt_properties_get_int( MLT_FILTER_PROPERTIES( base->filters[ i ] ), "disable" );
if ( !disable && ( ( in == 0 && out == 0 ) || ( position >= in && ( position <= out || out == 0 ) ) ) )
{
mlt_properties_set_position( frame_properties, "in", in == 0 ? self_in : in );
mlt_properties_set_position( frame_properties, "out", out == 0 ? self_out : out );
mlt_filter_process( base->filters[ i ], frame );
mlt_service_apply_filters( MLT_FILTER_SERVICE( base->filters[ i ] ), frame, index + 1 );
}
}
}
}
}
static void deserialize_vectors( videostab self, char *vectors, mlt_position length )
{
mlt_geometry g = mlt_geometry_init();
// Parse the property as a geometry
if ( g && !mlt_geometry_parse( g, vectors, length, -1, -1 ) )
{
struct mlt_geometry_item_s item;
int i;
// Copy the geometry items to a vc array for interp()
for ( i = 0; i < length; i++ )
{
mlt_geometry_fetch( g, &item, i );
self->pos_h[i].x = item.x;
self->pos_h[i].y = item.y;
}
}
else
{
mlt_log_warning( MLT_FILTER_SERVICE(self->parent), "failed to parse vectors\n" );
}
// We are done with this mlt_geometry
if ( g ) mlt_geometry_close( g );
}
static int jackrack_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the filter properties
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
int jack_frequency = mlt_properties_get_int( filter_properties, "_sample_rate" );
// Get the producer's audio
*format = mlt_audio_float;
mlt_frame_get_audio( frame, buffer, format, &jack_frequency, channels, samples );
// TODO: Deal with sample rate differences
if ( *frequency != jack_frequency )
mlt_log_error( MLT_FILTER_SERVICE( filter ), "mismatching frequencies JACK = %d actual = %d\n",
jack_frequency, *frequency );
*frequency = jack_frequency;
// Initialise Jack ports and connections if needed
if ( mlt_properties_get_int( filter_properties, "_samples" ) == 0 )
mlt_properties_set_int( filter_properties, "_samples", *samples );
// Get the filter-specific properties
jack_ringbuffer_t **output_buffers = mlt_properties_get_data( filter_properties, "output_buffers", NULL );
jack_ringbuffer_t **input_buffers = mlt_properties_get_data( filter_properties, "input_buffers", NULL );
// pthread_mutex_t *output_lock = mlt_properties_get_data( filter_properties, "output_lock", NULL );
// pthread_cond_t *output_ready = mlt_properties_get_data( filter_properties, "output_ready", NULL );
// Process the audio
float *q = (float*) *buffer;
size_t size = *samples * sizeof(float);
int j;
// struct timespec tm = { 0, 0 };
// Write into output ringbuffer
for ( j = 0; j < *channels; j++ )
{
if ( jack_ringbuffer_write_space( output_buffers[j] ) >= size )
jack_ringbuffer_write( output_buffers[j], (char*)( q + j * *samples ), size );
}
// Synchronization phase - wait for signal from Jack process
while ( jack_ringbuffer_read_space( input_buffers[ *channels - 1 ] ) < size ) ;
//pthread_cond_wait( output_ready, output_lock );
// Read from input ringbuffer
for ( j = 0; j < *channels; j++, q++ )
{
if ( jack_ringbuffer_read_space( input_buffers[j] ) >= size )
jack_ringbuffer_read( input_buffers[j], (char*)( q + j * *samples ), size );
}
// help jack_sync() indicate when we are rolling
mlt_position pos = mlt_frame_get_position( frame );
mlt_properties_set_position( filter_properties, "_last_pos", pos );
return 0;
}
/** Get the image.
*/
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
mlt_filter filter = (mlt_filter)mlt_frame_pop_service( frame );
private_data* pdata = (private_data*)filter->child;
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
if( mlt_properties_get_data( frame_properties, pdata->fft_prop_name, NULL ) )
{
// Get the current image
*format = mlt_image_rgb24a;
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Draw the spectrum
if( !error ) {
QImage qimg( *width, *height, QImage::Format_ARGB32 );
copy_mlt_to_qimage_rgba( *image, &qimg );
draw_spectrum( filter, frame, &qimg );
copy_qimage_to_mlt_rgba( &qimg, *image );
}
} else {
if ( pdata->preprocess_warned++ == 2 )
{
// This filter depends on the consumer processing the audio before
// the video.
mlt_log_warning( MLT_FILTER_SERVICE(filter), "Audio not preprocessed.\n" );
}
mlt_frame_get_image( frame, image, format, width, height, writable );
}
return error;
}
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 int get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter)mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
uint8_t* vs_image = NULL;
VSPixelFormat vs_format = PF_NONE;
// VS only works on progressive frames
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "consumer_deinterlace", 1 );
*format = validate_format( *format );
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Convert the received image to a format vid.stab can handle
if ( !error )
{
vs_format = mltimage_to_vsimage( *format, *width, *height, *image, &vs_image );
}
if( vs_image )
{
mlt_service_lock( MLT_FILTER_SERVICE(filter) );
char* results = mlt_properties_get( properties, "results" );
if( results && strcmp( results, "" ) )
{
apply_results( filter, frame, vs_image, vs_format, *width, *height );
vsimage_to_mltimage( vs_image, *image, *format, *width, *height );
}
else
{
analyze_image( filter, frame, vs_image, vs_format, *width, *height );
if( mlt_properties_get_int( properties, "show" ) == 1 )
{
vsimage_to_mltimage( vs_image, *image, *format, *width, *height );
}
}
mlt_service_unlock( MLT_FILTER_SERVICE(filter) );
free_vsimage( vs_image, vs_format );
}
return error;
}
static void analyze_audio( mlt_filter filter, void* buffer, int samples, int frequency )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
private_data* pdata = (private_data*)filter->child;
int result = -1;
double in_loudness = 0.0;
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE(filter) );
double fps = mlt_profile_fps( profile );
ebur128_add_frames_float( pdata->r128, buffer, samples );
if( pdata->time_elapsed_ms < 400 )
{
// Waiting for first program loudness measurement.
// Use window loudness as initial guess.
result = ebur128_loudness_window( pdata->r128, pdata->time_elapsed_ms, &in_loudness );
pdata->time_elapsed_ms += samples * 1000 / frequency;
}
else
{
result = ebur128_loudness_global( pdata->r128, &in_loudness );
}
if( result == EBUR128_SUCCESS && in_loudness != HUGE_VAL && in_loudness != -HUGE_VAL )
{
mlt_properties_set_double( properties, "in_loudness", in_loudness );
double target_loudness = mlt_properties_get_double( properties, "target_loudness" );
pdata->target_gain = target_loudness - in_loudness;
// Make sure gain limits are not exceeded.
double max_gain = mlt_properties_get_double( properties, "max_gain" );
double min_gain = mlt_properties_get_double( properties, "min_gain" );
if( pdata->target_gain > max_gain )
{
pdata->target_gain = max_gain;
}
else if ( pdata->target_gain < min_gain )
{
pdata->target_gain = min_gain;
}
}
// Make sure gain does not change too quickly.
pdata->start_gain = pdata->end_gain;
pdata->end_gain = pdata->target_gain;
double max_frame_gain = mlt_properties_get_double( properties, "max_rate" ) / fps;
if( pdata->start_gain - pdata->end_gain > max_frame_gain )
{
pdata->end_gain = pdata->start_gain - max_frame_gain;
}
else if( pdata->end_gain - pdata->start_gain > max_frame_gain )
{
pdata->end_gain = pdata->start_gain + max_frame_gain;
}
mlt_properties_set_double( properties, "out_gain", pdata->end_gain );
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = mlt_frame_pop_service( frame );
*format = mlt_image_rgb24a;
mlt_log_debug( MLT_FILTER_SERVICE( filter ), "frei0r %dx%d\n", *width, *height );
int error = mlt_frame_get_image( frame, image, format, width, height, 0 );
if ( error == 0 && *image )
{
double position = mlt_filter_get_position( filter, frame );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
double time = position / mlt_profile_fps( profile );
int length = mlt_filter_get_length2( filter, frame );
process_frei0r_item( MLT_FILTER_SERVICE(filter), position, time, length, frame, image, width, height );
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *image_format, int *width, int *height, int writable )
{
int error = 0;
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_filter filter = (mlt_filter)mlt_frame_pop_service( frame );
int samples = 0;
int channels = 0;
int frequency = 0;
mlt_audio_format audio_format = mlt_audio_s16;
int16_t* audio = (int16_t*)mlt_properties_get_data( frame_properties, "audio", NULL );
if ( !audio && !preprocess_warned ) {
// This filter depends on the consumer processing the audio before the
// video. If the audio is not preprocessed, this filter will process it.
// If this filter processes the audio, it could cause confusion for the
// consumer if it needs different audio properties.
mlt_log_warning( MLT_FILTER_SERVICE(filter), "Audio not preprocessed. Potential audio distortion.\n" );
preprocess_warned = true;
}
*image_format = mlt_image_rgb24a;
// Get the current image
error = mlt_frame_get_image( frame, image, image_format, width, height, writable );
// Get the audio
if( !error ) {
frequency = mlt_properties_get_int( frame_properties, "audio_frequency" );
if (!frequency) {
frequency = 48000;
}
channels = mlt_properties_get_int( frame_properties, "audio_channels" );
if (!channels) {
channels = 2;
}
samples = mlt_properties_get_int( frame_properties, "audio_samples" );
if (!samples) {
mlt_producer producer = mlt_frame_get_original_producer( frame );
double fps = mlt_producer_get_fps( mlt_producer_cut_parent( producer ) );
samples = mlt_sample_calculator( fps, frequency, mlt_frame_get_position( frame ) );
}
error = mlt_frame_get_audio( frame, (void**)&audio, &audio_format, &frequency, &channels, &samples );
}
// Draw the waveforms
if( !error ) {
QImage qimg( *width, *height, QImage::Format_ARGB32 );
convert_mlt_to_qimage_rgba( *image, &qimg, *width, *height );
draw_waveforms( filter, frame, &qimg, audio, channels, samples );
convert_qimage_to_mlt_rgba( &qimg, *image, *width, *height );
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Pop the service
mlt_filter filter = mlt_frame_pop_service( frame );
// Get the frame properties
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
// Track specific
process_queue( mlt_properties_get_data( frame_properties, "data_queue", NULL ), frame, filter );
// Global
process_queue( mlt_properties_get_data( frame_properties, "global_queue", NULL ), frame, filter );
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
// Need to get the image
return mlt_frame_get_image( frame, image, format, width, height, 1 );
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the filter
mlt_filter filter = mlt_frame_pop_service( frame );
// Get the properties of the filter
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
// Get the region transition
mlt_transition transition = mlt_properties_get_data( properties, "_transition", NULL );
// Create the transition if not available
if ( transition == NULL )
{
// Create the transition
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
transition = mlt_factory_transition( profile, "region", NULL );
// Register with the filter
mlt_properties_set_data( properties, "_transition", transition, 0, ( mlt_destructor )mlt_transition_close, NULL );
// Pass a reference to this filter down
mlt_properties_set_data( MLT_TRANSITION_PROPERTIES( transition ), "_region_filter", filter, 0, NULL, NULL );
}
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
// Pass all properties down
mlt_properties_inherit( MLT_TRANSITION_PROPERTIES( transition ), properties );
// Make the frame's position relative to this filter's in point
mlt_frame_set_position( frame, mlt_filter_get_position( filter, frame ) );
// Process the frame
mlt_transition_process( transition, frame, NULL );
return mlt_frame_get_image( frame, image, format, width, height, writable );
}
static int jack_sync( jack_transport_state_t state, jack_position_t *jack_pos, void *arg )
{
mlt_filter filter = (mlt_filter) arg;
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE(filter) );
mlt_position position = mlt_profile_fps( profile ) * jack_pos->frame / jack_pos->frame_rate + 0.5;
int result = 1;
mlt_log_debug( MLT_FILTER_SERVICE(filter), "%s frame %u rate %u pos %d last_pos %d\n",
JACKSTATE(state), jack_pos->frame, jack_pos->frame_rate, position,
mlt_properties_get_position( properties, "_last_pos" ) );
if ( state == JackTransportStopped )
{
mlt_events_fire( properties, "jack-stopped", &position, NULL );
mlt_properties_set_int( properties, "_sync_guard", 0 );
}
else if ( state == JackTransportStarting )
{
result = 0;
if ( !mlt_properties_get_int( properties, "_sync_guard" ) )
{
mlt_properties_set_int( properties, "_sync_guard", 1 );
mlt_events_fire( properties, "jack-started", &position, NULL );
}
else if ( position >= mlt_properties_get_position( properties, "_last_pos" ) - 2 )
{
mlt_properties_set_int( properties, "_sync_guard", 0 );
result = 1;
}
}
else
{
mlt_properties_set_int( properties, "_sync_guard", 0 );
}
return result;
}
int get_image_and_detect(mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable)
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service(frame);
mlt_properties properties = MLT_FILTER_PROPERTIES(filter);
*format = mlt_image_yuv420p;
writable = writable || mlt_properties_get_int(properties, "show") ? 1 : 0;
int error = mlt_frame_get_image(frame, image, format, width, height, writable);
if (!error)
{
// Service locks are for concurrency control
mlt_service_lock(MLT_FILTER_SERVICE(filter));
StabData *data = static_cast<StabData*>(mlt_properties_get_data(properties, "_stab_data", NULL));
if (!data)
{
data = init_detect(properties, format, width, height);
mlt_properties_set_data(properties, "_stab_data", data, 0, (mlt_destructor) destroy_detect, NULL);
}
VSMotionDetect* md = &data->md;
LocalMotions localmotions;
VSFrame vsFrame;
vsFrameFillFromBuffer(&vsFrame, *image, &md->fi);
// detect and save motions
vsMotionDetection(md, &localmotions, &vsFrame);
mlt_position pos = mlt_filter_get_position( filter, frame );
serialize_localmotions(data, localmotions, pos);
mlt_service_unlock(MLT_FILTER_SERVICE(filter));
}
return error;
}
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;
}
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
// Set a default colorspace on the frame if not yet set by the producer.
// The producer may still change it during get_image.
// This way we do not have to modify each producer to set a valid colorspace.
mlt_properties properties = MLT_FRAME_PROPERTIES(frame);
if ( mlt_properties_get_int( properties, "colorspace" ) <= 0 )
mlt_properties_set_int( properties, "colorspace", mlt_service_profile( MLT_FILTER_SERVICE(filter) )->colorspace );
if ( !frame->convert_image )
frame->convert_image = convert_image;
// Not working yet - see comment for get_image() above.
// mlt_frame_push_service( frame, mlt_service_profile( MLT_FILTER_SERVICE( filter ) ) );
// mlt_frame_push_get_image( frame, get_image );
return frame;
}
static mlt_frame process( mlt_filter filter, mlt_frame frame )
{
// Set a default colorspace on the frame if not yet set by the producer.
// The producer may still change it during get_image.
// This way we do not have to modify each producer to set a valid colorspace.
mlt_properties properties = MLT_FRAME_PROPERTIES(frame);
if ( mlt_properties_get_int( properties, "colorspace" ) <= 0 )
mlt_properties_set_int( properties, "colorspace", mlt_service_profile( MLT_FILTER_SERVICE(filter) )->colorspace );
frame->convert_image = convert_image;
mlt_filter cpu_csc = (mlt_filter) mlt_properties_get_data( MLT_FILTER_PROPERTIES( filter ), "cpu_csc", NULL );
mlt_properties_inc_ref( MLT_FILTER_PROPERTIES(cpu_csc) );
mlt_properties_set_data( properties, "cpu_csc", cpu_csc, 0,
(mlt_destructor) mlt_filter_close, NULL );
return frame;
}
static mlt_frame process(mlt_filter filter, mlt_frame frame)
{
mlt_properties properties = MLT_FILTER_PROPERTIES(filter);
mlt_transition transition = mlt_properties_get_data(properties, "instance", NULL);
char *name = mlt_properties_get(MLT_FILTER_PROPERTIES(filter), "transition");
if (!name || !strcmp("", name))
return frame;
// Create the transition if needed.
if (!transition
|| !mlt_properties_get(MLT_FILTER_PROPERTIES(transition), "mlt_service")
|| strcmp(name, mlt_properties_get(MLT_FILTER_PROPERTIES(transition), "mlt_service"))) {
mlt_profile profile = mlt_service_profile(MLT_FILTER_SERVICE(filter));
transition = mlt_factory_transition(profile, name, NULL);
mlt_properties_set_data(MLT_FILTER_PROPERTIES(filter), "instance", transition, 0, (mlt_destructor) mlt_transition_close, NULL);
}
if (transition) {
mlt_properties transition_props = MLT_TRANSITION_PROPERTIES(transition);
int type = mlt_properties_get_int(transition_props, "_transition_type");
int hide = mlt_properties_get_int(MLT_FRAME_PROPERTIES(frame), "hide");
mlt_properties_pass_list(transition_props, properties, "in out");
mlt_properties_pass(transition_props, properties, "transition." );
// Only if video transition on visible track.
if ((type & 1) && !mlt_frame_is_test_card(frame) && !(hide & 1)) {
mlt_frame_push_service_int(frame,
mlt_image_format_id(mlt_properties_get(properties, "mlt_image_format")));
mlt_frame_push_service(frame, transition);
mlt_frame_push_get_image(frame, get_image);
}
if (type == 0)
mlt_properties_debug(transition_props, "unknown transition type", stderr);
} else {
mlt_properties_debug(properties, "mask_failed to create transition", stderr );
}
return frame;
}
int mlt_field_plant_filter( mlt_field self, mlt_filter that, int track )
{
// Connect the filter to the last producer
int result = mlt_filter_connect( that, self->producer, track );
// If successful, then we'll use this for connecting in the future
if ( result == 0 )
{
// This is now the new producer
self->producer = MLT_FILTER_SERVICE( that );
// Reconnect tractor to new producer
mlt_tractor_connect( self->tractor, self->producer );
// Fire an event
mlt_events_fire( mlt_field_properties( self ), "service-changed", NULL );
}
return result;
}
static void get_timecode_str( mlt_filter filter, mlt_frame frame, char* text )
{
int frames = mlt_frame_get_position( frame );
double fps = mlt_profile_fps( mlt_service_profile( MLT_FILTER_SERVICE( filter ) ) );
char tc[12] = "";
if (fps == 0)
{
strncat( text, "-", MAX_TEXT_LEN - strlen( text ) - 1 );
}
else
{
int seconds = frames / fps;
frames = frames % lrint( fps );
int minutes = seconds / 60;
seconds = seconds % 60;
int hours = minutes / 60;
minutes = minutes % 60;
sprintf(tc, "%.2d:%.2d:%.2d:%.2d", hours, minutes, seconds, frames);
strncat( text, tc, MAX_TEXT_LEN - strlen( text ) - 1 );
}
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Pop the top of stack now
mlt_filter filter = mlt_frame_pop_service( frame );
// Get the image from the frame
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Get the image from the frame
if ( error == 0 )
{
if ( filter != NULL )
{
// Get the filter properties
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
// Structures for geometry
struct geometry_s result;
struct geometry_s start;
struct geometry_s end;
// Retrieve the position
float position = mlt_filter_get_progress( filter, frame );
// Now parse the geometries
geometry_parse( &start, NULL, mlt_properties_get( properties, "start" ), profile->width, profile->height );
geometry_parse( &end, &start, mlt_properties_get( properties, "end" ), profile->width, profile->height );
// Do the calculation
geometry_calculate( &result, &start, &end, position, *width, *height );
// Now actually render it
obscure_render( *image, *width, *height, result );
}
}
return error;
}
