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 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;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
/* Obtain properties of frame */
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
/* Obtain the producer for this frame */
producer_ktitle this = mlt_properties_get_data( properties, "producer_kdenlivetitle", NULL );
/* Obtain properties of producer */
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( &this->parent );
*width = mlt_properties_get_int( properties, "rescale_width" );
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( &this->parent ) );
/* Allocate the image */
*format = mlt_image_rgb24a;
mlt_position time = mlt_producer_position( &this->parent ) + mlt_producer_get_in( &this->parent );
if ( mlt_properties_get_int( producer_props, "force_reload" ) ) {
if (mlt_properties_get_int( producer_props, "force_reload" ) > 1) read_xml(producer_props);
mlt_properties_set_int( producer_props, "force_reload", 0 );
drawKdenliveTitle( this, frame, *width, *height, time, 1);
}
else drawKdenliveTitle( this, frame, *width, *height, time, 0);
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
if ( this->current_image )
{
// Clone the image and the alpha
int image_size = this->current_width * ( this->current_height ) * 4;
uint8_t *image_copy = mlt_pool_alloc( image_size );
memcpy( image_copy, this->current_image, image_size );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
mlt_log_debug( MLT_PRODUCER_SERVICE( &this->parent ), "width:%d height:%d %s\n", *width, *height, mlt_image_format_name( *format ) );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( &this->parent ) );
return 0;
}
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 int producer_get_image( mlt_frame frame, uint8_t** image, mlt_image_format* format, int* width, int* height, int writable )
{
mlt_producer producer = mlt_frame_pop_service( frame );
mlt_frame bg_frame = NULL;
mlt_frame text_frame = NULL;
int error = 1;
int size = 0;
char* background = mlt_properties_get( MLT_PRODUCER_PROPERTIES( producer ), "background" );
time_info info;
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
get_time_info( producer, frame, &info );
bg_frame = get_background_frame( producer );
if( !strcmp( background, "clock" ) )
{
add_clock_to_frame( producer, bg_frame, &info );
}
text_frame = get_text_frame( producer, &info );
add_text_to_bg( producer, bg_frame, text_frame );
if( bg_frame )
{
// Get the image from the background frame.
error = mlt_frame_get_image( bg_frame, image, format, width, height, writable );
size = mlt_image_format_size( *format, *width, *height, NULL );
// Detach the image from the bg_frame so it is not released.
mlt_frame_set_image( bg_frame, *image, size, NULL );
// Attach the image to the input frame.
mlt_frame_set_image( frame, *image, size, mlt_pool_release );
mlt_frame_close( bg_frame );
}
if( text_frame )
{
mlt_frame_close( text_frame );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return error;
}
static int producer_get_image( mlt_frame frame, uint8_t** buffer, mlt_image_format* format, int* width, int* height, int writable )
{
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = static_cast<mlt_producer>( mlt_properties_get_data( frame_properties, "_producer_qtext", NULL ) );
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
int img_size = 0;
int alpha_size = 0;
uint8_t* alpha = NULL;
QImage* qImg = static_cast<QImage*>( mlt_properties_get_data( producer_properties, "_qimg", NULL ) );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
// Regenerate the qimage if necessary
if( check_qimage( frame_properties ) == true )
{
generate_qimage( frame_properties );
}
*format = mlt_image_rgb24a;
*width = qImg->width();
*height = qImg->height();
// Allocate and fill the image buffer
img_size = mlt_image_format_size( *format, *width, *height, NULL );
*buffer = static_cast<uint8_t*>( mlt_pool_alloc( img_size ) );
copy_qimage_to_mlt_image( qImg, *buffer );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
// Allocate and fill the alpha buffer
alpha_size = *width * *height;
alpha = static_cast<uint8_t*>( mlt_pool_alloc( alpha_size ) );
copy_image_to_alpha( *buffer, alpha, *width, *height );
// Update the frame
mlt_frame_set_image( frame, *buffer, img_size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha, alpha_size, mlt_pool_release );
mlt_properties_set_int( frame_properties, "width", *width );
mlt_properties_set_int( frame_properties, "height", *height );
return 0;
}
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 get_image(mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable)
{
mlt_transition transition = mlt_frame_pop_service(frame);
*format = mlt_frame_pop_service_int(frame);
int error = mlt_frame_get_image(frame, image, format, width, height, writable);
if (!error) {
mlt_properties properties = MLT_FRAME_PROPERTIES(frame);
mlt_frame clone = mlt_properties_get_data(properties, "mask frame", NULL);
if (clone) {
mlt_frame_push_get_image(frame, dummy_get_image);
mlt_service_lock(MLT_TRANSITION_SERVICE(transition));
mlt_transition_process(transition, clone, frame);
mlt_service_unlock(MLT_TRANSITION_SERVICE(transition));
error = mlt_frame_get_image(clone, image, format, width, height, writable);
if (!error) {
int size = mlt_image_format_size(*format, *width, *height, NULL);
mlt_frame_set_image(frame, *image, size, NULL);
}
}
}
return error;
}
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;
}
static int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the filter from the frame
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the properties from the filter
mlt_properties filter_props = MLT_FILTER_PROPERTIES( filter );
// Get the frame's filter instance properties
mlt_properties instance_props = mlt_frame_unique_properties( frame, MLT_FILTER_SERVICE( filter ) );
// Get the parameters
double gain = mlt_properties_get_double( instance_props, "gain" );
double max_gain = mlt_properties_get_double( instance_props, "max_gain" );
double limiter_level = 0.5; /* -6 dBFS */
int normalise = mlt_properties_get_int( instance_props, "normalise" );
double amplitude = mlt_properties_get_double( instance_props, "amplitude" );
int i, j;
double sample;
int16_t peak;
// Use animated value for gain if "level" property is set
char* level_property = mlt_properties_get( filter_props, "level" );
if ( level_property != NULL )
{
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
gain = mlt_properties_anim_get_double( filter_props, "level", position, length );
gain = DBFSTOAMP( gain );
}
if ( mlt_properties_get( instance_props, "limiter" ) != NULL )
limiter_level = mlt_properties_get_double( instance_props, "limiter" );
// Get the producer's audio
*format = normalise? mlt_audio_s16 : mlt_audio_f32le;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
if ( normalise )
{
int window = mlt_properties_get_int( filter_props, "window" );
double *smooth_buffer = mlt_properties_get_data( filter_props, "smooth_buffer", NULL );
if ( window > 0 && smooth_buffer != NULL )
{
int smooth_index = mlt_properties_get_int( filter_props, "_smooth_index" );
// Compute the signal power and put into smoothing buffer
smooth_buffer[ smooth_index ] = signal_max_power( *buffer, *channels, *samples, &peak );
if ( smooth_buffer[ smooth_index ] > EPSILON )
{
mlt_properties_set_int( filter_props, "_smooth_index", ( smooth_index + 1 ) % window );
// Smooth the data and compute the gain
gain *= amplitude / get_smoothed_data( smooth_buffer, window );
}
}
else
{
gain *= amplitude / signal_max_power( *buffer, *channels, *samples, &peak );
}
}
if ( max_gain > 0 && gain > max_gain )
gain = max_gain;
// Initialise filter's previous gain value to prevent an inadvertant jump from 0
mlt_position last_position = mlt_properties_get_position( filter_props, "_last_position" );
mlt_position current_position = mlt_frame_get_position( frame );
if ( mlt_properties_get( filter_props, "_previous_gain" ) == NULL
|| current_position != last_position + 1 )
mlt_properties_set_double( filter_props, "_previous_gain", gain );
// Start the gain out at the previous
double previous_gain = mlt_properties_get_double( filter_props, "_previous_gain" );
// Determine ramp increment
double gain_step = ( gain - previous_gain ) / *samples;
// Save the current gain for the next iteration
mlt_properties_set_double( filter_props, "_previous_gain", gain );
mlt_properties_set_position( filter_props, "_last_position", current_position );
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
// Ramp from the previous gain to the current
gain = previous_gain;
// Apply the gain
if ( normalise )
{
int16_t *p = *buffer;
// Determine numeric limits
int bytes_per_samp = (samp_width - 1) / 8 + 1;
int samplemax = (1 << (bytes_per_samp * 8 - 1)) - 1;
for ( i = 0; i < *samples; i++, gain += gain_step ) {
for ( j = 0; j < *channels; j++ ) {
sample = *p * gain;
*p = ROUND( sample );
if ( gain > 1.0 && normalise ) {
/* use limiter function instead of clipping */
*p = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) );
}
p++;
}
}
}
else
{
float *p = *buffer;
for ( i = 0; i < *samples; i++, gain += gain_step ) {
for ( j = 0; j < *channels; j++, p++ ) {
p[0] *= gain;
}
}
}
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_frame_pop_service( frame );
*format = mlt_image_rgb24;
mlt_properties_set_int( MLT_FRAME_PROPERTIES(frame), "consumer_deinterlace", 1 );
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
if ( !error && *image )
{
videostab self = filter->child;
mlt_position length = mlt_filter_get_length2( filter, frame );
int h = *height;
int w = *width;
// Service locks are for concurrency control
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
if ( !self->initialized )
{
// Initialize our context
self->initialized = 1;
self->es = es_init( w, h );
self->pos_i = (vc*) malloc( length * sizeof(vc) );
self->pos_h = (vc*) malloc( length * sizeof(vc) );
self->pos_y = (vc*) malloc( h * sizeof(vc) );
self->rs = rs_init( w, h );
}
char *vectors = mlt_properties_get( MLT_FILTER_PROPERTIES(filter), "vectors" );
if ( !vectors )
{
// Analyse
int pos = (int) mlt_filter_get_position( filter, frame );
self->pos_i[pos] = vc_add( pos == 0 ? vc_zero() : self->pos_i[pos - 1], es_estimate( self->es, *image ) );
// On last frame
if ( pos == length - 1 )
{
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE(filter) );
double fps = mlt_profile_fps( profile );
// Filter and store the results
hipass( self->pos_i, self->pos_h, length, fps );
serialize_vectors( self, length );
}
} else {
// Apply
if ( self->initialized != 2 )
{
// Load analysis results from property
self->initialized = 2;
deserialize_vectors( self, vectors, length );
}
if ( self->initialized == 2 )
{
// Stabilize
float shutter_angle = mlt_properties_get_double( MLT_FRAME_PROPERTIES(frame) , "shutterangle" );
float pos = mlt_filter_get_position( filter, frame );
int i;
for (i = 0; i < h; i ++)
self->pos_y[i] = interp( self->lanc_kernels,self->pos_h, length, pos + (i - h / 2.0) * shutter_angle / (h * 360.0) );
rs_resample( self->lanc_kernels,self->rs, *image, self->pos_y );
}
}
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
}
return error;
}
static void *consumer_thread( void *arg )
{
// Identify the arg
consumer_sdl self = arg;
// Get the consumer
mlt_consumer consumer = &self->parent;
// Get the properties
mlt_properties properties = MLT_CONSUMER_PROPERTIES( consumer );
// internal intialization
mlt_frame frame = NULL;
int last_position = -1;
int eos = 0;
int eos_threshold = 20;
if ( self->play )
eos_threshold = eos_threshold + mlt_properties_get_int( MLT_CONSUMER_PROPERTIES( self->play ), "buffer" );
// Determine if the application is dealing with the preview
int preview_off = mlt_properties_get_int( properties, "preview_off" );
pthread_mutex_lock( &self->refresh_mutex );
self->refresh_count = 0;
pthread_mutex_unlock( &self->refresh_mutex );
// Loop until told not to
while( self->running )
{
// Get a frame from the attached producer
frame = mlt_consumer_get_frame( consumer );
// Ensure that we have a frame
if ( self->running && frame != NULL )
{
// Get the speed of the frame
double speed = mlt_properties_get_double( MLT_FRAME_PROPERTIES( frame ), "_speed" );
// Lock during the operation
mlt_service_lock( MLT_CONSUMER_SERVICE( consumer ) );
// Get refresh request for the current frame
int refresh = mlt_properties_get_int( properties, "refresh" );
// Decrement refresh and clear changed
mlt_events_block( properties, properties );
mlt_properties_set_int( properties, "refresh", 0 );
mlt_events_unblock( properties, properties );
// Unlock after the operation
mlt_service_unlock( MLT_CONSUMER_SERVICE( consumer ) );
// Set the changed property on this frame for the benefit of still
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "refresh", refresh );
// Make sure the recipient knows that this frame isn't really rendered
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "rendered", 0 );
// Optimisation to reduce latency
if ( speed == 1.0 )
{
if ( last_position != -1 && last_position + 1 != mlt_frame_get_position( frame ) )
mlt_consumer_purge( self->play );
last_position = mlt_frame_get_position( frame );
}
else
{
//mlt_consumer_purge( self->play );
last_position = -1;
}
// If we aren't playing normally, then use the still
if ( speed != 1 )
{
mlt_producer producer = MLT_PRODUCER( mlt_service_get_producer( MLT_CONSUMER_SERVICE( consumer ) ) );
mlt_position duration = producer? mlt_producer_get_playtime( producer ) : -1;
int pause = 0;
#ifndef SKIP_WAIT_EOS
if ( self->active == self->play )
{
// Do not interrupt the play consumer near the end
if ( duration - self->last_position > eos_threshold )
{
// Get a new frame at the sought position
mlt_frame_close( frame );
if ( producer )
mlt_producer_seek( producer, self->last_position );
frame = mlt_consumer_get_frame( consumer );
pause = 1;
}
else
{
// Send frame with speed 0 to stop it
if ( frame && !mlt_consumer_is_stopped( self->play ) )
{
mlt_consumer_put_frame( self->play, frame );
frame = NULL;
eos = 1;
}
// Check for end of stream
if ( mlt_consumer_is_stopped( self->play ) )
{
// Stream has ended
mlt_log_verbose( MLT_CONSUMER_SERVICE( consumer ), "END OF STREAM\n" );
pause = 1;
eos = 0; // reset eos indicator
}
else
{
// Prevent a tight busy loop
struct timespec tm = { 0, 100000L }; // 100 usec
nanosleep( &tm, NULL );
}
}
}
#else
pause = self->active == self->play;
#endif
if ( pause )
{
// Start the still consumer
if ( !mlt_consumer_is_stopped( self->play ) )
mlt_consumer_stop( self->play );
self->last_speed = speed;
self->active = self->still;
self->ignore_change = 0;
mlt_consumer_start( self->still );
}
// Send the frame to the active child
if ( frame && !eos )
{
mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "refresh", 1 );
if ( self->active )
mlt_consumer_put_frame( self->active, frame );
}
if ( pause && speed == 0.0 )
{
mlt_events_fire( properties, "consumer-sdl-paused", NULL );
}
}
// Allow a little grace time before switching consumers on speed changes
else if ( self->ignore_change -- > 0 && self->active != NULL && !mlt_consumer_is_stopped( self->active ) )
{
mlt_consumer_put_frame( self->active, frame );
}
// Otherwise use the normal player
else
{
if ( !mlt_consumer_is_stopped( self->still ) )
mlt_consumer_stop( self->still );
if ( mlt_consumer_is_stopped( self->play ) )
{
self->last_speed = speed;
self->active = self->play;
self->ignore_change = 0;
mlt_consumer_start( self->play );
}
if ( self->play )
mlt_consumer_put_frame( self->play, frame );
}
// Copy the rectangle info from the active consumer
if ( self->running && preview_off == 0 && self->active )
{
mlt_properties active = MLT_CONSUMER_PROPERTIES( self->active );
mlt_service_lock( MLT_CONSUMER_SERVICE( consumer ) );
mlt_properties_set_int( properties, "rect_x", mlt_properties_get_int( active, "rect_x" ) );
mlt_properties_set_int( properties, "rect_y", mlt_properties_get_int( active, "rect_y" ) );
mlt_properties_set_int( properties, "rect_w", mlt_properties_get_int( active, "rect_w" ) );
mlt_properties_set_int( properties, "rect_h", mlt_properties_get_int( active, "rect_h" ) );
mlt_service_unlock( MLT_CONSUMER_SERVICE( consumer ) );
}
if ( self->active == self->still )
{
pthread_mutex_lock( &self->refresh_mutex );
if ( self->running && speed == 0 && self->refresh_count <= 0 )
{
mlt_events_fire( properties, "consumer-sdl-paused", NULL );
pthread_cond_wait( &self->refresh_cond, &self->refresh_mutex );
}
self->refresh_count --;
pthread_mutex_unlock( &self->refresh_mutex );
}
}
else
{
if ( frame ) mlt_frame_close( frame );
mlt_consumer_put_frame( self->active, NULL );
self->running = 0;
}
}
if ( self->play ) mlt_consumer_stop( self->play );
if ( self->still ) mlt_consumer_stop( self->still );
return NULL;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
// Obtain properties of frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Obtain the producer for this frame
mlt_producer producer = mlt_properties_get_data( properties, "producer_colour", NULL );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
// Obtain properties of producer
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Get the current and previous colour strings
char *now = mlt_properties_get( producer_props, "resource" );
char *then = mlt_properties_get( producer_props, "_resource" );
// Get the current image and dimensions cached in the producer
int size = 0;
uint8_t *image = mlt_properties_get_data( producer_props, "image", &size );
int current_width = mlt_properties_get_int( producer_props, "_width" );
int current_height = mlt_properties_get_int( producer_props, "_height" );
mlt_image_format current_format = mlt_properties_get_int( producer_props, "_format" );
// Parse the colour
if ( now && strchr( now, '/' ) )
{
now = strdup( strrchr( now, '/' ) + 1 );
mlt_properties_set( producer_props, "resource", now );
free( now );
now = mlt_properties_get( producer_props, "resource" );
}
mlt_color color = mlt_properties_get_color( producer_props, "resource" );
if ( mlt_properties_get( producer_props, "mlt_image_format") )
*format = mlt_image_format_id( mlt_properties_get( producer_props, "mlt_image_format") );
// Choose suitable out values if nothing specific requested
if ( *format == mlt_image_none || *format == mlt_image_glsl )
*format = mlt_image_rgb24a;
if ( *width <= 0 )
*width = mlt_service_profile( MLT_PRODUCER_SERVICE(producer) )->width;
if ( *height <= 0 )
*height = mlt_service_profile( MLT_PRODUCER_SERVICE(producer) )->height;
// Choose default image format if specific request is unsupported
if (*format!=mlt_image_yuv420p && *format!=mlt_image_yuv422 && *format!=mlt_image_rgb24 && *format!= mlt_image_glsl && *format!= mlt_image_glsl_texture)
*format = mlt_image_rgb24a;
// See if we need to regenerate
if ( !now || ( then && strcmp( now, then ) ) || *width != current_width || *height != current_height || *format != current_format )
{
// Color the image
int i = *width * *height + 1;
int bpp;
// Allocate the image
size = mlt_image_format_size( *format, *width, *height, &bpp );
uint8_t *p = image = mlt_pool_alloc( size );
// Update the producer
mlt_properties_set_data( producer_props, "image", image, size, mlt_pool_release, NULL );
mlt_properties_set_int( producer_props, "_width", *width );
mlt_properties_set_int( producer_props, "_height", *height );
mlt_properties_set_int( producer_props, "_format", *format );
mlt_properties_set( producer_props, "_resource", now );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
switch ( *format )
{
case mlt_image_yuv420p:
{
int plane_size = *width * *height;
uint8_t y, u, v;
RGB2YUV_601_SCALED( color.r, color.g, color.b, y, u, v );
memset(p + 0, y, plane_size);
memset(p + plane_size, u, plane_size/4);
memset(p + plane_size + plane_size/4, v, plane_size/4);
mlt_properties_set_int( properties, "colorspace", 601 );
break;
}
case mlt_image_yuv422:
{
int uneven = *width % 2;
int count = ( *width - uneven ) / 2 + 1;
uint8_t y, u, v;
RGB2YUV_601_SCALED( color.r, color.g, color.b, y, u, v );
i = *height + 1;
while ( --i )
{
int j = count;
while ( --j )
{
*p ++ = y;
*p ++ = u;
*p ++ = y;
*p ++ = v;
}
if ( uneven )
{
*p ++ = y;
*p ++ = u;
}
}
mlt_properties_set_int( properties, "colorspace", 601 );
break;
}
case mlt_image_rgb24:
while ( --i )
{
*p ++ = color.r;
*p ++ = color.g;
*p ++ = color.b;
}
break;
case mlt_image_glsl:
case mlt_image_glsl_texture:
memset(p, 0, size);
break;
case mlt_image_rgb24a:
while ( --i )
{
*p ++ = color.r;
*p ++ = color.g;
*p ++ = color.b;
*p ++ = color.a;
}
break;
default:
mlt_log_error( MLT_PRODUCER_SERVICE( producer ),
"invalid image format %s\n", mlt_image_format_name( *format ) );
}
}
else
{
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
}
// Create the alpha channel
int alpha_size = 0;
uint8_t *alpha = NULL;
// Initialise the alpha
if (color.a < 255 || *format == mlt_image_rgb24a) {
alpha_size = *width * *height;
alpha = mlt_pool_alloc( alpha_size );
if ( alpha )
memset( alpha, color.a, alpha_size );
else
alpha_size = 0;
}
// Clone our image
if (buffer && image && size > 0) {
*buffer = mlt_pool_alloc( size );
memcpy( *buffer, image, size );
}
// Now update properties so we free the copy after
mlt_frame_set_image( frame, *buffer, size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha, alpha_size, mlt_pool_release );
mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( producer_props, "aspect_ratio" ) );
mlt_properties_set_int( properties, "meta.media.width", *width );
mlt_properties_set_int( properties, "meta.media.height", *height );
return 0;
}
static int framebuffer_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the filter object and properties
mlt_producer producer = mlt_frame_pop_service( frame );
int index = ( int )mlt_frame_pop_service( frame );
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
// Frame properties objects
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_frame first_frame = mlt_properties_get_data( properties, "first_frame", NULL );
// Get producer parameters
int strobe = mlt_properties_get_int( properties, "strobe" );
int freeze = mlt_properties_get_int( properties, "freeze" );
int freeze_after = mlt_properties_get_int( properties, "freeze_after" );
int freeze_before = mlt_properties_get_int( properties, "freeze_before" );
int in = mlt_properties_get_position( properties, "in" );
// Determine the position
mlt_position first_position = (first_frame != NULL) ? mlt_frame_get_position( first_frame ) : -1;
mlt_position need_first = freeze;
if ( !freeze || freeze_after || freeze_before )
{
double prod_speed = mlt_properties_get_double( properties, "_speed" );
double actual_position = in + prod_speed * (double) mlt_producer_position( producer );
if ( mlt_properties_get_int( properties, "reverse" ) )
actual_position = mlt_producer_get_playtime( producer ) - actual_position;
if ( strobe < 2 )
{
need_first = floor( actual_position );
}
else
{
// Strobe effect wanted, calculate frame position
need_first = floor( actual_position );
need_first -= need_first % strobe;
}
if ( freeze )
{
if ( freeze_after && need_first > freeze ) need_first = freeze;
else if ( freeze_before && need_first < freeze ) need_first = freeze;
}
}
// Determine output buffer size
*width = mlt_properties_get_int( frame_properties, "width" );
*height = mlt_properties_get_int( frame_properties, "height" );
int size = mlt_image_format_size( *format, *width, *height, NULL );
// Get output buffer
int buffersize = 0;
int alphasize = *width * *height;
uint8_t *output = mlt_properties_get_data( properties, "output_buffer", &buffersize );
uint8_t *output_alpha = mlt_properties_get_data( properties, "output_alpha", NULL );
if( buffersize == 0 || buffersize != size )
{
// invalidate cached frame
first_position = -1;
}
if ( need_first != first_position )
{
// invalidate cached frame
first_position = -1;
// Bust the cached frame
mlt_properties_set_data( properties, "first_frame", NULL, 0, NULL, NULL );
first_frame = NULL;
}
if ( output && first_position != -1 ) {
// Using the cached frame
uint8_t *image_copy = mlt_pool_alloc( size );
memcpy( image_copy, output, size );
uint8_t *alpha_copy = mlt_pool_alloc( alphasize );
memcpy( alpha_copy, output_alpha, alphasize );
// Set the output image
*image = image_copy;
mlt_frame_set_image( frame, image_copy, size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha_copy, alphasize, mlt_pool_release );
*width = mlt_properties_get_int( properties, "_output_width" );
*height = mlt_properties_get_int( properties, "_output_height" );
*format = mlt_properties_get_int( properties, "_output_format" );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return 0;
}
// Get the cached frame
if ( first_frame == NULL )
{
// Get the frame to cache from the real producer
mlt_producer real_producer = mlt_properties_get_data( properties, "producer", NULL );
// Seek the producer to the correct place
mlt_producer_seek( real_producer, need_first );
// Get the frame
mlt_service_get_frame( MLT_PRODUCER_SERVICE( real_producer ), &first_frame, index );
// Cache the frame
mlt_properties_set_data( properties, "first_frame", first_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
mlt_properties first_frame_properties = MLT_FRAME_PROPERTIES( first_frame );
// Which frames are buffered?
uint8_t *first_image = mlt_properties_get_data( first_frame_properties, "image", NULL );
uint8_t *first_alpha = mlt_properties_get_data( first_frame_properties, "alpha", NULL );
if ( !first_image )
{
mlt_properties_set( first_frame_properties, "rescale.interp", mlt_properties_get( frame_properties, "rescale.interp" ) );
int error = mlt_frame_get_image( first_frame, &first_image, format, width, height, writable );
if ( error != 0 ) {
mlt_log_error( MLT_PRODUCER_SERVICE( producer ), "first_image == NULL get image died\n" );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return error;
}
output = mlt_pool_alloc( size );
memcpy( output, first_image, size );
// Let someone else clean up
mlt_properties_set_data( properties, "output_buffer", output, size, mlt_pool_release, NULL );
mlt_properties_set_int( properties, "_output_width", *width );
mlt_properties_set_int( properties, "_output_height", *height );
mlt_properties_set_int( properties, "_output_format", *format );
}
if ( !first_alpha )
{
alphasize = *width * *height;
first_alpha = mlt_frame_get_alpha_mask( first_frame );
output_alpha = mlt_pool_alloc( alphasize );
memcpy( output_alpha, first_alpha, alphasize );
mlt_properties_set_data( properties, "output_alpha", output_alpha, alphasize, mlt_pool_release, NULL );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
// Create a copy
uint8_t *image_copy = mlt_pool_alloc( size );
memcpy( image_copy, first_image, size );
uint8_t *alpha_copy = mlt_pool_alloc( alphasize );
memcpy( alpha_copy, first_alpha, alphasize );
// Set the output image
*image = image_copy;
mlt_frame_set_image( frame, *image, size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha_copy, alphasize, mlt_pool_release );
return 0;
}
static int filter_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
// Get the filter from the frame
mlt_filter this = mlt_frame_pop_audio( frame );
// Get the properties from the filter
mlt_properties filter_props = MLT_FILTER_PROPERTIES( this );
// Get the frame's filter instance properties
mlt_properties instance_props = mlt_frame_unique_properties( frame, MLT_FILTER_SERVICE( this ) );
// Get the parameters
double gain = mlt_properties_get_double( instance_props, "gain" );
double max_gain = mlt_properties_get_double( instance_props, "max_gain" );
double limiter_level = 0.5; /* -6 dBFS */
int normalise = mlt_properties_get_int( instance_props, "normalise" );
double amplitude = mlt_properties_get_double( instance_props, "amplitude" );
int i, j;
double sample;
int16_t peak;
if ( mlt_properties_get( instance_props, "limiter" ) != NULL )
limiter_level = mlt_properties_get_double( instance_props, "limiter" );
// Get the producer's audio
*format = mlt_audio_s16;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
// fprintf( stderr, "filter_volume: frequency %d\n", *frequency );
// Determine numeric limits
int bytes_per_samp = (samp_width - 1) / 8 + 1;
int samplemax = (1 << (bytes_per_samp * 8 - 1)) - 1;
int samplemin = -samplemax - 1;
mlt_service_lock( MLT_FILTER_SERVICE( this ) );
if ( normalise )
{
int window = mlt_properties_get_int( filter_props, "window" );
double *smooth_buffer = mlt_properties_get_data( filter_props, "smooth_buffer", NULL );
if ( window > 0 && smooth_buffer != NULL )
{
int smooth_index = mlt_properties_get_int( filter_props, "_smooth_index" );
// Compute the signal power and put into smoothing buffer
smooth_buffer[ smooth_index ] = signal_max_power( *buffer, *channels, *samples, &peak );
// fprintf( stderr, "filter_volume: raw power %f ", smooth_buffer[ smooth_index ] );
if ( smooth_buffer[ smooth_index ] > EPSILON )
{
mlt_properties_set_int( filter_props, "_smooth_index", ( smooth_index + 1 ) % window );
// Smooth the data and compute the gain
// fprintf( stderr, "smoothed %f over %d frames\n", get_smoothed_data( smooth_buffer, window ), window );
gain *= amplitude / get_smoothed_data( smooth_buffer, window );
}
}
else
{
gain *= amplitude / signal_max_power( (int16_t*) *buffer, *channels, *samples, &peak );
}
}
// if ( gain > 1.0 && normalise )
// fprintf(stderr, "filter_volume: limiter level %f gain %f\n", limiter_level, gain );
if ( max_gain > 0 && gain > max_gain )
gain = max_gain;
// Initialise filter's previous gain value to prevent an inadvertant jump from 0
mlt_position last_position = mlt_properties_get_position( filter_props, "_last_position" );
mlt_position current_position = mlt_frame_get_position( frame );
if ( mlt_properties_get( filter_props, "_previous_gain" ) == NULL
|| current_position != last_position + 1 )
mlt_properties_set_double( filter_props, "_previous_gain", gain );
// Start the gain out at the previous
double previous_gain = mlt_properties_get_double( filter_props, "_previous_gain" );
// Determine ramp increment
double gain_step = ( gain - previous_gain ) / *samples;
// fprintf( stderr, "filter_volume: previous gain %f current gain %f step %f\n", previous_gain, gain, gain_step );
// Save the current gain for the next iteration
mlt_properties_set_double( filter_props, "_previous_gain", gain );
mlt_properties_set_position( filter_props, "_last_position", current_position );
mlt_service_unlock( MLT_FILTER_SERVICE( this ) );
// Ramp from the previous gain to the current
gain = previous_gain;
int16_t *p = (int16_t*) *buffer;
// Apply the gain
for ( i = 0; i < *samples; i++ )
{
for ( j = 0; j < *channels; j++ )
{
sample = *p * gain;
*p = ROUND( sample );
if ( gain > 1.0 )
{
/* use limiter function instead of clipping */
if ( normalise )
*p = ROUND( samplemax * limiter( sample / (double) samplemax, limiter_level ) );
/* perform clipping */
else if ( sample > samplemax )
*p = samplemax;
else if ( sample < samplemin )
*p = samplemin;
}
p++;
}
gain += gain_step;
}
return 0;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
/* Obtain properties of frame */
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
/* Obtain the producer for this frame */
producer_ktitle self = mlt_properties_get_data( properties, "producer_kdenlivetitle", NULL );
/* Obtain properties of producer */
mlt_producer producer = &self->parent;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
if ( mlt_properties_get_int( properties, "rescale_width" ) > 0 )
*width = mlt_properties_get_int( properties, "rescale_width" );
if ( mlt_properties_get_int( properties, "rescale_height" ) > 0 )
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
/* Allocate the image */
if ( mlt_properties_get_int( producer_props, "force_reload" ) ) {
if ( mlt_properties_get_int( producer_props, "force_reload" ) > 1 ) read_xml( producer_props );
mlt_properties_set_int( producer_props, "force_reload", 0 );
drawKdenliveTitle( self, frame, *format, *width, *height, mlt_frame_original_position( frame ), 1 );
}
else
{
drawKdenliveTitle( self, frame, *format, *width, *height, mlt_frame_original_position( frame ), 0 );
}
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
*format = self->format;
if ( self->current_image )
{
// Clone the image and the alpha
int image_size = mlt_image_format_size( self->format, self->current_width, self->current_height, NULL );
uint8_t *image_copy = mlt_pool_alloc( image_size );
// We use height-1 because mlt_image_format_size() uses height + 1.
// XXX Remove -1 when mlt_image_format_size() is changed.
memcpy( image_copy, self->current_image,
mlt_image_format_size( self->format, self->current_width, self->current_height - 1, NULL ) );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
// Clone the alpha channel
if ( self->current_alpha )
{
image_copy = mlt_pool_alloc( self->current_width * self->current_height );
memcpy( image_copy, self->current_alpha, self->current_width * self->current_height );
mlt_frame_set_alpha( frame, image_copy, self->current_width * self->current_height, mlt_pool_release );
}
}
else
{
error = 1;
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return error;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
producer_qimage self = mlt_properties_get_data( properties, "producer_qimage", NULL );
mlt_producer producer = &self->parent;
*width = mlt_properties_get_int( properties, "rescale_width" );
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( &self->parent ) );
// Refresh the image
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage = mlt_cache_item_data( self->qimage_cache, NULL );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.image" );
self->current_image = mlt_cache_item_data( self->image_cache, NULL );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha" );
self->current_alpha = mlt_cache_item_data( self->alpha_cache, NULL );
refresh_image( self, frame, *format, *width, *height );
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
*format = self->format;
// NB: Cloning is necessary with this producer (due to processing of images ahead of use)
// The fault is not in the design of mlt, but in the implementation of the qimage producer...
if ( self->current_image )
{
// Clone the image and the alpha
int image_size = mlt_image_format_size( self->format, self->current_width, self->current_height, NULL );
uint8_t *image_copy = mlt_pool_alloc( image_size );
memcpy( image_copy, self->current_image, image_size );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
mlt_log_debug( MLT_PRODUCER_SERVICE( &self->parent ), "%dx%d (%s)\n",
self->current_width, self->current_height, mlt_image_format_name( *format ) );
// Clone the alpha channel
if ( self->current_alpha )
{
image_copy = mlt_pool_alloc( self->current_width * self->current_height );
memcpy( image_copy, self->current_alpha, self->current_width * self->current_height );
mlt_frame_set_alpha( frame, image_copy, self->current_width * self->current_height, mlt_pool_release );
}
}
else
{
error = 1;
}
// Release references and locks
mlt_cache_item_close( self->qimage_cache );
mlt_cache_item_close( self->image_cache );
mlt_cache_item_close( self->alpha_cache );
mlt_service_unlock( MLT_PRODUCER_SERVICE( &self->parent ) );
return error;
}
static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the b frame from the stack
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
// Get the transition object
mlt_transition transition = mlt_frame_pop_service( a_frame );
// Get the properties of the transition
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
// Get the properties of the b frame
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// Image, format, width, height and image for the b frame
uint8_t *b_image = NULL;
mlt_image_format b_format = mlt_image_rgb24a;
int b_width;
int b_height;
// Assign the current position
mlt_position position = mlt_transition_get_position( transition, a_frame );
int mirror = mlt_properties_get_position( properties, "mirror" );
int length = mlt_transition_get_length( transition );
if ( mlt_properties_get_int( properties, "always_active" ) )
{
mlt_properties props = mlt_properties_get_data( b_props, "_producer", NULL );
mlt_position in = mlt_properties_get_int( props, "in" );
mlt_position out = mlt_properties_get_int( props, "out" );
length = out - in + 1;
}
// Obtain the normalised width and height from the a_frame
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
int normalised_width = profile->width;
int normalised_height = profile->height;
double consumer_ar = mlt_profile_sar( mlt_service_profile( MLT_TRANSITION_SERVICE(transition) ) );
// Structures for geometry
struct mlt_geometry_item_s result;
if ( mirror && position > length / 2 )
position = abs( position - length );
// Fetch the a frame image
*format = mlt_image_rgb24a;
mlt_frame_get_image( a_frame, image, format, width, height, 1 );
// Calculate the region now
mlt_service_lock( MLT_TRANSITION_SERVICE( transition ) );
composite_calculate( transition, &result, normalised_width, normalised_height, ( float )position );
mlt_service_unlock( MLT_TRANSITION_SERVICE( transition ) );
// Fetch the b frame image
result.w = ( result.w * *width / normalised_width );
result.h = ( result.h * *height / normalised_height );
result.x = ( result.x * *width / normalised_width );
result.y = ( result.y * *height / normalised_height );
// Request full resolution of b frame image.
b_width = mlt_properties_get_int( b_props, "meta.media.width" );
b_height = mlt_properties_get_int( b_props, "meta.media.height" );
mlt_properties_set_int( b_props, "rescale_width", b_width );
mlt_properties_set_int( b_props, "rescale_height", b_height );
// Suppress padding and aspect normalization.
char *interps = mlt_properties_get( a_props, "rescale.interp" );
if ( interps )
interps = strdup( interps );
mlt_properties_set( b_props, "rescale.interp", "none" );
// This is not a field-aware transform.
mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
mlt_frame_get_image( b_frame, &b_image, &b_format, &b_width, &b_height, 0 );
// Check that both images are of the correct format and process
if ( *format == mlt_image_rgb24a && b_format == mlt_image_rgb24a )
{
float x, y;
float dx, dy;
float dz;
float sw, sh;
uint8_t *p = *image;
// Get values from the transition
float scale_x = mlt_properties_get_double( properties, "scale_x" );
float scale_y = mlt_properties_get_double( properties, "scale_y" );
int scale = mlt_properties_get_int( properties, "scale" );
int b_alpha = mlt_properties_get_int( properties, "b_alpha" );
float geom_scale_x = (float) b_width / result.w;
float geom_scale_y = (float) b_height / result.h;
float cx = result.x + result.w / 2.0;
float cy = result.y + result.h / 2.0;
float lower_x = - cx;
float lower_y = - cy;
float x_offset = (float) b_width / 2.0;
float y_offset = (float) b_height / 2.0;
affine_t affine;
interpp interp = interpBL_b32;
int i, j; // loop counters
affine_init( affine.matrix );
// Compute the affine transform
get_affine( &affine, transition, ( float )position );
dz = MapZ( affine.matrix, 0, 0 );
if ( ( int )abs( dz * 1000 ) < 25 )
{
if ( interps )
free( interps );
return 0;
}
// Factor scaling into the transformation based on output resolution.
if ( mlt_properties_get_int( properties, "distort" ) )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
}
else
{
// Determine scale with respect to aspect ratio.
double consumer_dar = consumer_ar * normalised_width / normalised_height;
double b_ar = mlt_properties_get_double( b_props, "aspect_ratio" );
double b_dar = b_ar * b_width / b_height;
if ( b_dar > consumer_dar )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_x * ( scale_y == 0 ? 1 : scale_y );
}
else
{
scale_x = geom_scale_y * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
}
scale_x *= consumer_ar / b_ar;
}
if ( scale )
{
affine_max_output( affine.matrix, &sw, &sh, dz, *width, *height );
affine_scale( affine.matrix, sw * MIN( geom_scale_x, geom_scale_y ), sh * MIN( geom_scale_x, geom_scale_y ) );
}
else if ( scale_x != 0 && scale_y != 0 )
{
affine_scale( affine.matrix, scale_x, scale_y );
}
// Set the interpolation function
if ( interps == NULL || strcmp( interps, "nearest" ) == 0 || strcmp( interps, "neighbor" ) == 0 )
interp = interpNN_b32;
else if ( strcmp( interps, "tiles" ) == 0 || strcmp( interps, "fast_bilinear" ) == 0 )
interp = interpNN_b32;
else if ( strcmp( interps, "bilinear" ) == 0 )
interp = interpBL_b32;
else if ( strcmp( interps, "bicubic" ) == 0 )
interp = interpBC_b32;
// TODO: lanczos 8x8
else if ( strcmp( interps, "hyper" ) == 0 || strcmp( interps, "sinc" ) == 0 || strcmp( interps, "lanczos" ) == 0 )
interp = interpBC_b32;
else if ( strcmp( interps, "spline" ) == 0 ) // TODO: spline 4x4 or 6x6
interp = interpBC_b32;
// Do the transform with interpolation
for ( i = 0, y = lower_y; i < *height; i++, y++ )
{
for ( j = 0, x = lower_x; j < *width; j++, x++ )
{
dx = MapX( affine.matrix, x, y ) / dz + x_offset;
dy = MapY( affine.matrix, x, y ) / dz + y_offset;
if ( dx >= 0 && dx < (b_width - 1) && dy >=0 && dy < (b_height - 1) )
interp( b_image, b_width, b_height, dx, dy, result.mix/100.0, p, b_alpha );
p += 4;
}
}
}
if ( interps )
free( interps );
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 );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_position pos = mlt_filter_get_position( filter, frame );
mlt_position len = mlt_filter_get_length2( filter, frame );
int maxdia = mlt_properties_anim_get_int( properties, "maxdiameter", pos, len );
int maxcount = mlt_properties_anim_get_int( properties, "maxcount", pos, len );
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Load svg
char *factory = mlt_properties_get( properties, "factory" );
char temp[1204] = "";
sprintf( temp, "%s/oldfilm/", mlt_environment( "MLT_DATA" ) );
mlt_properties direntries = mlt_properties_new();
mlt_properties_dir_list( direntries, temp,"dust*.svg",1 );
if (!maxcount)
return 0;
double position = mlt_filter_get_progress( filter, frame );
srand( position * 10000 );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
int im = rand() % maxcount;
int piccount = mlt_properties_count( direntries );
while ( im-- && piccount )
{
int picnum = rand() % piccount;
int y1 = rand() % *height;
int x1 = rand() % *width;
char resource[1024] = "";
char savename[1024] = "", savename1[1024] = "", cachedy[100];
int dx = ( *width * maxdia / 100);
int luma_width, luma_height;
uint8_t *luma_image = NULL;
uint8_t *alpha = NULL;
int updown = rand() % 2;
int mirror = rand() % 2;
sprintf( resource, "%s", mlt_properties_get_value(direntries,picnum) );
sprintf( savename, "cache-%d-%d", picnum,dx );
sprintf( savename1, "cache-alpha-%d-%d", picnum, dx );
sprintf( cachedy, "cache-dy-%d-%d", picnum,dx );
luma_image = mlt_properties_get_data( properties , savename , NULL );
alpha = mlt_properties_get_data( properties , savename1 , NULL );
if ( luma_image == NULL || alpha == NULL )
{
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
mlt_producer producer = mlt_factory_producer( profile, factory, resource );
if ( producer != NULL )
{
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_properties_set( producer_properties, "eof", "loop" );
mlt_frame luma_frame = NULL;
if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &luma_frame, 0 ) == 0 )
{
mlt_image_format luma_format = mlt_image_yuv422;
luma_width = dx;
luma_height = luma_width * mlt_properties_get_int( MLT_FRAME_PROPERTIES ( luma_frame ) , "height" ) / mlt_properties_get_int( MLT_FRAME_PROPERTIES ( luma_frame ) , "width" );
mlt_properties_set( MLT_FRAME_PROPERTIES( luma_frame ), "rescale.interp", "best" );// none/nearest/tiles/hyper
mlt_frame_get_image( luma_frame, &luma_image, &luma_format, &luma_width, &luma_height, 0 );
alpha = mlt_frame_get_alpha_mask (luma_frame );
uint8_t* savealpha = mlt_pool_alloc( luma_width * luma_height );
uint8_t* savepic = mlt_pool_alloc( luma_width * luma_height * 2);
if ( savealpha && savepic )
{
memcpy( savealpha, alpha , luma_width * luma_height );
memcpy( savepic, luma_image , luma_width * luma_height * 2 );
mlt_properties_set_data( properties, savename, savepic, luma_width * luma_height * 2, mlt_pool_release, NULL );
mlt_properties_set_data( properties, savename1, savealpha, luma_width * luma_height, mlt_pool_release, NULL );
mlt_properties_set_int( properties, cachedy, luma_height );
overlay_image( *image, *width, *height, luma_image, luma_width, luma_height, alpha, x1, y1, updown, mirror );
}
else
{
if ( savealpha )
mlt_pool_release( savealpha );
if ( savepic )
mlt_pool_release( savepic );
}
mlt_frame_close( luma_frame );
}
mlt_producer_close( producer );
}
}
else
{
overlay_image ( *image, *width, *height, luma_image, dx, mlt_properties_get_int ( properties, cachedy ), alpha, x1, y1, updown, mirror );
}
}
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
if (piccount>0 )
return 0;
if ( error == 0 && *image )
{
int h = *height;
int w = *width;
int im = rand() % maxcount;
while ( im-- )
{
int type = im % 2;
int y1 = rand() % h;
int x1 = rand() % w;
int dx = rand() % maxdia;
int dy = rand() % maxdia;
int x=0, y=0;
double v = 0.0;
for ( x = -dx ; x < dx ; x++ )
{
for ( y = -dy ; y < dy ; y++ )
{
if ( x1 + x < w && x1 + x > 0 && y1 + y < h && y1 + y > 0 ){
uint8_t *pix = *image + (y+y1) * w * 2 + (x + x1) * 2;
v=pow((double) x /(double)dx * 5.0, 2.0) + pow((double)y / (double)dy * 5.0, 2.0);
if (v>10)
v=10;
v = 1.0 - ( v / 10.0 );
switch(type)
{
case 0:
*pix -= (*pix) * v;
break;
case 1:
*pix += ( 255-*pix ) * v;
break;
}
}
}
}
}
}
return error;
}
static int transition_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Error we will return
int error = 0;
// We will get the 'b frame' from the frame stack
mlt_frame b_frame = mlt_frame_pop_frame( frame );
// Get the watermark transition object
mlt_transition transition = mlt_frame_pop_service( frame );
// Get the properties of the transitionfin
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( frame );
mlt_service_lock( MLT_TRANSITION_SERVICE( transition ) );
// Get the composite from the transition
mlt_transition composite = mlt_properties_get_data( properties, "composite", NULL );
// Look for the first filter
mlt_filter filter = mlt_properties_get_data( properties, "_filter_0", NULL );
// Get the position
mlt_position position = mlt_transition_get_position( transition, frame );
// Create a composite if we don't have one
if ( composite == NULL )
{
// Create composite via the factory
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
composite = mlt_factory_transition( profile, "composite", NULL );
// If we have one
if ( composite != NULL )
{
// Get the properties
mlt_properties composite_properties = MLT_TRANSITION_PROPERTIES( composite );
// We want to ensure that we don't get a wobble...
//mlt_properties_set_int( composite_properties, "distort", 1 );
mlt_properties_set_int( composite_properties, "progressive", 1 );
// Pass all the composite. properties on the transition down
mlt_properties_pass( composite_properties, properties, "composite." );
// Register the composite for reuse/destruction
mlt_properties_set_data( properties, "composite", composite, 0, ( mlt_destructor )mlt_transition_close, NULL );
}
}
else
{
// Pass all current properties down
mlt_properties composite_properties = MLT_TRANSITION_PROPERTIES( composite );
mlt_properties_pass( composite_properties, properties, "composite." );
}
// Create filters
if ( filter == NULL )
{
// Loop Variable
int i = 0;
// Number of filters created
int count = 0;
// Loop for all properties
for ( i = 0; i < mlt_properties_count( properties ); i ++ )
{
// Get the name of this property
char *name = mlt_properties_get_name( properties, i );
// If the name does not contain a . and matches filter
if ( strchr( name, '.' ) == NULL && !strncmp( name, "filter", 6 ) )
{
// Get the filter constructor
char *value = mlt_properties_get_value( properties, i );
// Create an instance
if ( create_instance( transition, name, value, count ) == 0 )
count ++;
}
}
// Look for the first filter again
filter = mlt_properties_get_data( properties, "_filter_0", NULL );
}
else
{
// Pass all properties down
mlt_filter temp = NULL;
// Loop Variable
int i = 0;
// Number of filters found
int count = 0;
// Loop for all properties
for ( i = 0; i < mlt_properties_count( properties ); i ++ )
{
// Get the name of this property
char *name = mlt_properties_get_name( properties, i );
// If the name does not contain a . and matches filter
if ( strchr( name, '.' ) == NULL && !strncmp( name, "filter", 6 ) )
{
// Strings to hold the id and pass down key
char id[ 256 ];
char key[ 256 ];
// Construct id and key
sprintf( id, "_filter_%d", count );
sprintf( key, "%s.", name );
// Get the filter
temp = mlt_properties_get_data( properties, id, NULL );
if ( temp != NULL )
{
mlt_properties_pass( MLT_FILTER_PROPERTIES( temp ), properties, key );
count ++;
}
}
}
}
mlt_properties_set_int( a_props, "width", *width );
mlt_properties_set_int( a_props, "height", *height );
// Only continue if we have both filter and composite
if ( composite != NULL )
{
// Get the resource of this filter (could be a shape [rectangle/circle] or an alpha provider of choice
const char *resource = mlt_properties_get( properties, "resource" );
// Get the old resource in case it's changed
char *old_resource = mlt_properties_get( properties, "_old_resource" );
// String to hold the filter to query on
char id[ 256 ];
// Index to hold the count
int i = 0;
// We will get the 'b frame' from the composite only if it's NULL (region filter)
if ( b_frame == NULL )
{
// Copy the region
b_frame = composite_copy_region( composite, frame, position );
// Ensure a destructor
char *name = mlt_properties_get( properties, "_unique_id" );
mlt_properties_set_data( a_props, name, b_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
// Properties of the B framr
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// filter_only prevents copying the alpha channel of the shape to the output frame
// by compositing filtered frame over itself
if ( mlt_properties_get_int( properties, "filter_only" ) )
{
char *name = mlt_properties_get( properties, "_unique_id" );
frame = composite_copy_region( composite, b_frame, position );
mlt_properties_set_data( b_props, name, frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
// Make sure the filter is in the correct position
while ( filter != NULL )
{
// Stack this filter
if ( mlt_properties_get_int( MLT_FILTER_PROPERTIES( filter ), "off" ) == 0 )
mlt_filter_process( filter, b_frame );
// Generate the key for the next
sprintf( id, "_filter_%d", ++ i );
// Get the next filter
filter = mlt_properties_get_data( properties, id, NULL );
}
// Allow filters to be attached to a region filter
filter = mlt_properties_get_data( properties, "_region_filter", NULL );
if ( filter != NULL )
mlt_service_apply_filters( MLT_FILTER_SERVICE( filter ), b_frame, 0 );
// Hmm - this is probably going to go wrong....
mlt_frame_set_position( frame, position );
// Get the b frame and process with composite if successful
mlt_transition_process( composite, frame, b_frame );
// If we have a shape producer copy the alpha mask from the shape frame to the b_frame
if ( strcmp( resource, "rectangle" ) != 0 )
{
// Get the producer from the transition
mlt_producer producer = mlt_properties_get_data( properties, "producer", NULL );
// If We have no producer then create one
if ( producer == NULL || ( old_resource != NULL && strcmp( resource, old_resource ) ) )
{
// Get the factory producer service
char *factory = mlt_properties_get( properties, "factory" );
// Store the old resource
mlt_properties_set( properties, "_old_resource", resource );
// Special case circle resource
if ( strcmp( resource, "circle" ) == 0 )
resource = "pixbuf:<svg width='100' height='100'><circle cx='50' cy='50' r='50' fill='black'/></svg>";
// Create the producer
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
producer = mlt_factory_producer( profile, factory, resource );
// If we have one
if ( producer != NULL )
{
// Get the producer properties
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
// Ensure that we loop
mlt_properties_set( producer_properties, "eof", "loop" );
// Now pass all producer. properties on the transition down
mlt_properties_pass( producer_properties, properties, "producer." );
// Register the producer for reuse/destruction
mlt_properties_set_data( properties, "producer", producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
}
}
// Now use the shape producer
if ( producer != NULL )
{
// We will get the alpha frame from the producer
mlt_frame shape_frame = NULL;
// Make sure the producer is in the correct position
mlt_producer_seek( producer, position );
// Get the shape frame
if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &shape_frame, 0 ) == 0 )
{
// Ensure that the shape frame will be closed
mlt_properties_set_data( b_props, "shape_frame", shape_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
if ( mlt_properties_get_int(properties, "holecolor") ) {
mlt_properties_set_int(b_props, "holecolor", mlt_properties_get_int(properties,"holecolor"));
}
// Specify the callback for evaluation
b_frame->get_alpha_mask = filter_get_alpha_mask;
}
}
}
// Get the image
error = mlt_frame_get_image( frame, image, format, width, height, 0 );
}
mlt_service_unlock( MLT_TRANSITION_SERVICE( transition ) );
return error;
}
static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the b frame from the stack
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
// Get the transition object
mlt_transition transition = mlt_frame_pop_service( a_frame );
// Get the properties of the transition
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
// Get the properties of the b frame
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// Image, format, width, height and image for the b frame
uint8_t *b_image = NULL;
mlt_image_format b_format = mlt_image_rgb24a;
int b_width = mlt_properties_get_int( b_props, "meta.media.width" );
int b_height = mlt_properties_get_int( b_props, "meta.media.height" );
double b_ar = mlt_frame_get_aspect_ratio( b_frame );
double b_dar = b_ar * b_width / b_height;
// Assign the current position
mlt_position position = mlt_transition_get_position( transition, a_frame );
int mirror = mlt_properties_get_position( properties, "mirror" );
int length = mlt_transition_get_length( transition );
if ( mlt_properties_get_int( properties, "always_active" ) )
{
mlt_properties props = mlt_properties_get_data( b_props, "_producer", NULL );
mlt_position in = mlt_properties_get_int( props, "in" );
mlt_position out = mlt_properties_get_int( props, "out" );
length = out - in + 1;
}
// Obtain the normalised width and height from the a_frame
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
int normalised_width = profile->width;
int normalised_height = profile->height;
double consumer_ar = mlt_profile_sar( profile );
if ( mirror && position > length / 2 )
position = abs( position - length );
// Fetch the a frame image
*format = mlt_image_rgb24a;
int error = mlt_frame_get_image( a_frame, image, format, width, height, 1 );
if (error || !image)
return error;
// Calculate the region now
mlt_rect result = {0, 0, normalised_width, normalised_height, 1.0};
mlt_service_lock( MLT_TRANSITION_SERVICE( transition ) );
if (mlt_properties_get(properties, "geometry"))
{
// Structures for geometry
struct mlt_geometry_item_s geometry;
composite_calculate( transition, &geometry, normalised_width, normalised_height, ( double )position );
result.x = geometry.x;
result.y = geometry.y;
result.w = geometry.w;
result.h = geometry.h;
result.o = geometry.mix / 100.0f;
}
else if (mlt_properties_get(properties, "rect"))
{
// Determine length and obtain cycle
double cycle = mlt_properties_get_double( properties, "cycle" );
// Allow a repeat cycle
if ( cycle >= 1 )
length = cycle;
else if ( cycle > 0 )
length *= cycle;
mlt_position anim_pos = repeat_position(properties, "rect", position, length);
result = mlt_properties_anim_get_rect(properties, "rect", anim_pos, length);
if (mlt_properties_get(properties, "rect") && strchr(mlt_properties_get(properties, "rect"), '%')) {
result.x *= normalised_width;
result.y *= normalised_height;
result.w *= normalised_width;
result.h *= normalised_height;
}
result.o = (result.o == DBL_MIN)? 1.0 : MIN(result.o, 1.0);
}
mlt_service_unlock( MLT_TRANSITION_SERVICE( transition ) );
double geometry_w = result.w;
double geometry_h = result.h;
if ( !mlt_properties_get_int( properties, "fill" ) )
{
double geometry_dar = result.w * consumer_ar / result.h;
if ( b_dar > geometry_dar )
{
result.w = MIN( result.w, b_width * b_ar / consumer_ar );
result.h = result.w * consumer_ar / b_dar;
}
else
{
result.h = MIN( result.h, b_height );
result.w = result.h * b_dar / consumer_ar;
}
}
// Fetch the b frame image
result.w = ( result.w * *width / normalised_width );
result.h = ( result.h * *height / normalised_height );
result.x = ( result.x * *width / normalised_width );
result.y = ( result.y * *height / normalised_height );
if (mlt_properties_get_int(properties, "b_scaled")) {
// Request b frame image size just what is needed.
b_width = result.w;
b_height = result.h;
// Set the rescale interpolation to match the frame
mlt_properties_set( b_props, "rescale.interp", mlt_properties_get( a_props, "rescale.interp" ) );
} else {
// Request full resolution of b frame image.
mlt_properties_set_int( b_props, "rescale_width", b_width );
mlt_properties_set_int( b_props, "rescale_height", b_height );
// Suppress padding and aspect normalization.
mlt_properties_set( b_props, "rescale.interp", "none" );
}
// This is not a field-aware transform.
mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
error = mlt_frame_get_image( b_frame, &b_image, &b_format, &b_width, &b_height, 0 );
if (error || !b_image) {
// Remove potentially large image on the B frame.
mlt_frame_set_image( b_frame, NULL, 0, NULL );
return error;
}
// Check that both images are of the correct format and process
if ( *format == mlt_image_rgb24a && b_format == mlt_image_rgb24a )
{
double sw, sh;
// Get values from the transition
double scale_x = mlt_properties_anim_get_double( properties, "scale_x", position, length );
double scale_y = mlt_properties_anim_get_double( properties, "scale_y", position, length );
int scale = mlt_properties_get_int( properties, "scale" );
double geom_scale_x = (double) b_width / result.w;
double geom_scale_y = (double) b_height / result.h;
struct sliced_desc desc = {
.a_image = *image,
.b_image = b_image,
.interp = interpBL_b32,
.a_width = *width,
.a_height = *height,
.b_width = b_width,
.b_height = b_height,
.lower_x = -(result.x + result.w / 2.0), // center
.lower_y = -(result.y + result.h / 2.0), // middle
.mix = result.o,
.x_offset = (double) b_width / 2.0,
.y_offset = (double) b_height / 2.0,
.b_alpha = mlt_properties_get_int( properties, "b_alpha" ),
// Affine boundaries
.minima = 0,
.xmax = b_width - 1,
.ymax = b_height - 1
};
// Recalculate vars if alignment supplied.
if ( mlt_properties_get( properties, "halign" ) || mlt_properties_get( properties, "valign" ) )
{
double halign = alignment_parse( mlt_properties_get( properties, "halign" ) );
double valign = alignment_parse( mlt_properties_get( properties, "valign" ) );
desc.x_offset = halign * b_width / 2.0;
desc.y_offset = valign * b_height / 2.0;
desc.lower_x = -(result.x + geometry_w * halign / 2.0f);
desc.lower_y = -(result.y + geometry_h * valign / 2.0f);
}
affine_init( desc.affine.matrix );
// Compute the affine transform
get_affine( &desc.affine, transition, ( double )position, length );
desc.dz = MapZ( desc.affine.matrix, 0, 0 );
if ( (int) fabs( desc.dz * 1000 ) < 25 )
return 0;
// Factor scaling into the transformation based on output resolution.
if ( mlt_properties_get_int( properties, "distort" ) )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
}
else
{
// Determine scale with respect to aspect ratio.
double consumer_dar = consumer_ar * normalised_width / normalised_height;
if ( b_dar > consumer_dar )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_x * ( scale_y == 0 ? 1 : scale_y );
scale_y *= b_ar / consumer_ar;
}
else
{
scale_x = geom_scale_y * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
scale_x *= consumer_ar / b_ar;
}
}
if ( scale )
{
affine_max_output( desc.affine.matrix, &sw, &sh, desc.dz, *width, *height );
affine_scale( desc.affine.matrix, sw * MIN( geom_scale_x, geom_scale_y ), sh * MIN( geom_scale_x, geom_scale_y ) );
}
else if ( scale_x != 0 && scale_y != 0 )
{
affine_scale( desc.affine.matrix, scale_x, scale_y );
}
char *interps = mlt_properties_get( a_props, "rescale.interp" );
// Copy in case string is changed.
if ( interps )
interps = strdup( interps );
// Set the interpolation function
if ( interps == NULL || strcmp( interps, "nearest" ) == 0 || strcmp( interps, "neighbor" ) == 0 || strcmp( interps, "tiles" ) == 0 || strcmp( interps, "fast_bilinear" ) == 0 )
{
desc.interp = interpNN_b32;
// uses lrintf. Values should be >= -0.5 and < max + 0.5
desc.minima -= 0.5;
desc.xmax += 0.49;
desc.ymax += 0.49;
}
else if ( strcmp( interps, "bilinear" ) == 0 )
{
desc.interp = interpBL_b32;
// uses floorf.
}
else if ( strcmp( interps, "bicubic" ) == 0 || strcmp( interps, "hyper" ) == 0 || strcmp( interps, "sinc" ) == 0 || strcmp( interps, "lanczos" ) == 0 || strcmp( interps, "spline" ) == 0 )
{
// TODO: lanczos 8x8
// TODO: spline 4x4 or 6x6
desc.interp = interpBC_b32;
// uses ceilf. Values should be > -1 and <= max.
desc.minima -= 1;
}
free( interps );
// Do the transform with interpolation
int threads = mlt_properties_get_int(properties, "threads");
threads = CLAMP(threads, 0, mlt_slices_count_normal());
if (threads == 1)
sliced_proc(0, 0, 1, &desc);
else
mlt_slices_run_normal(threads, sliced_proc, &desc);
// Remove potentially large image on the B frame.
mlt_frame_set_image( b_frame, NULL, 0, NULL );
}
return 0;
}
static int resample_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 );
// Get the resample information
int output_rate = mlt_properties_get_int( filter_properties, "frequency" );
// If no resample frequency is specified, default to requested value
if ( output_rate == 0 )
output_rate = *frequency;
// Get the producer's audio
int error = mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
if ( error ) return error;
// Return now if no work to do
if ( output_rate != *frequency && *frequency > 0 && *channels > 0 )
{
mlt_log_debug( MLT_FILTER_SERVICE(filter), "channels %d samples %d frequency %d -> %d\n",
*channels, *samples, *frequency, output_rate );
// Do not convert to float unless we need to change the rate
if ( *format != mlt_audio_f32le )
frame->convert_audio( frame, buffer, format, mlt_audio_f32le );
mlt_service_lock( MLT_FILTER_SERVICE(filter) );
SRC_DATA data;
data.data_in = *buffer;
data.data_out = mlt_properties_get_data( filter_properties, "output_buffer", NULL );
data.src_ratio = ( float ) output_rate / ( float ) *frequency;
data.input_frames = *samples;
data.output_frames = BUFFER_LEN / *channels;
data.end_of_input = 0;
SRC_STATE *state = mlt_properties_get_data( filter_properties, "state", NULL );
if ( !state || mlt_properties_get_int( filter_properties, "channels" ) != *channels )
{
// Recreate the resampler if the number of channels changed
state = src_new( RESAMPLE_TYPE, *channels, &error );
mlt_properties_set_data( filter_properties, "state", state, 0, (mlt_destructor) src_delete, NULL );
mlt_properties_set_int( filter_properties, "channels", *channels );
}
// Resample the audio
error = src_process( state, &data );
if ( !error )
{
// Update output variables
*samples = data.output_frames_gen;
*frequency = output_rate;
*buffer = data.data_out;
}
else
{
mlt_log_error( MLT_FILTER_SERVICE( filter ), "%s %d,%d,%d\n", src_strerror( error ), *frequency, *samples, output_rate );
}
mlt_service_unlock( MLT_FILTER_SERVICE(filter) );
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Error we will return
int error = 0;
// Get the watermark filter object
mlt_filter this = mlt_frame_pop_service( frame );
// Get the properties of the filter
mlt_properties properties = MLT_FILTER_PROPERTIES( this );
mlt_service_lock( MLT_FILTER_SERVICE( this ) );
// Get the producer from the filter
mlt_producer producer = mlt_properties_get_data( properties, "producer", NULL );
// Get the composite from the filter
mlt_transition composite = mlt_properties_get_data( properties, "composite", NULL );
// Get the resource to use
char *resource = mlt_properties_get( properties, "resource" );
// Get the old resource
char *old_resource = mlt_properties_get( properties, "_old_resource" );
// Create a composite if we don't have one
if ( composite == NULL )
{
// Create composite via the factory
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( this ) );
composite = mlt_factory_transition( profile, "composite", NULL );
// Register the composite for reuse/destruction
if ( composite != NULL )
mlt_properties_set_data( properties, "composite", composite, 0, ( mlt_destructor )mlt_transition_close, NULL );
}
// If we have one
if ( composite != NULL )
{
// Get the properties
mlt_properties composite_properties = MLT_TRANSITION_PROPERTIES( composite );
// Pass all the composite. properties on the filter down
mlt_properties_pass( composite_properties, properties, "composite." );
if ( mlt_properties_get( properties, "composite.out" ) == NULL )
mlt_properties_set_int( composite_properties, "out", mlt_properties_get_int( properties, "_out" ) );
// Force a refresh
mlt_properties_set_int( composite_properties, "refresh", 1 );
}
// Create a producer if don't have one
if ( producer == NULL || ( old_resource != NULL && strcmp( resource, old_resource ) ) )
{
// Get the factory producer service
char *factory = mlt_properties_get( properties, "factory" );
// Create the producer
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( this ) );
producer = mlt_factory_producer( profile, factory, resource );
// If we have one
if ( producer != NULL )
{
// Register the producer for reuse/destruction
mlt_properties_set_data( properties, "producer", producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
// Ensure that we loop
mlt_properties_set( MLT_PRODUCER_PROPERTIES( producer ), "eof", "loop" );
// Set the old resource
mlt_properties_set( properties, "_old_resource", resource );
}
}
if ( producer != NULL )
{
// Get the producer properties
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
// Now pass all producer. properties on the filter down
mlt_properties_pass( producer_properties, properties, "producer." );
}
mlt_service_unlock( MLT_FILTER_SERVICE( this ) );
// Only continue if we have both producer and composite
if ( composite != NULL && producer != NULL )
{
// Get the service of the producer
mlt_service service = MLT_PRODUCER_SERVICE( producer );
// We will get the 'b frame' from the producer
mlt_frame b_frame = NULL;
// Get the original producer position
mlt_position position = mlt_filter_get_position( this, frame );
// Make sure the producer is in the correct position
mlt_producer_seek( producer, position );
// Resetting position to appease the composite transition
mlt_frame_set_position( frame, position );
// Get the b frame and process with composite if successful
if ( mlt_service_get_frame( service, &b_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( b_frame );
mlt_profile profile = mlt_service_profile( service );
// Set the b frame to be in the same position and have same consumer requirements
mlt_frame_set_position( b_frame, position );
mlt_properties_set_int( b_props, "consumer_deinterlace", mlt_properties_get_int( a_props, "consumer_deinterlace" ) || mlt_properties_get_int( properties, "deinterlace" ) );
// Check for the special case - no aspect ratio means no problem :-)
if ( mlt_frame_get_aspect_ratio( b_frame ) == 0 )
mlt_frame_set_aspect_ratio( b_frame, mlt_profile_sar( profile ) );
if ( mlt_frame_get_aspect_ratio( frame ) == 0 )
mlt_frame_set_aspect_ratio( frame, mlt_profile_sar( profile ) );
if ( mlt_properties_get_int( properties, "distort" ) )
{
mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( composite ), "distort", 1 );
mlt_properties_set_int( a_props, "distort", 1 );
mlt_properties_set_int( b_props, "distort", 1 );
}
*format = mlt_image_yuv422;
if ( mlt_properties_get_int( properties, "reverse" ) == 0 )
{
// Apply all filters that are attached to this filter to the b frame
mlt_service_apply_filters( MLT_FILTER_SERVICE( this ), b_frame, 0 );
// Process the frame
mlt_transition_process( composite, frame, b_frame );
// Get the image
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
}
else
{
char temp[ 132 ];
int count = 0;
uint8_t *alpha = NULL;
const char *rescale = mlt_properties_get( a_props, "rescale.interp" );
if ( rescale == NULL || !strcmp( rescale, "none" ) )
rescale = "hyper";
mlt_transition_process( composite, b_frame, frame );
mlt_properties_set_int( a_props, "consumer_deinterlace", 1 );
mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
mlt_properties_set( a_props, "rescale.interp", rescale );
mlt_properties_set( b_props, "rescale.interp", rescale );
mlt_service_apply_filters( MLT_FILTER_SERVICE( this ), b_frame, 0 );
error = mlt_frame_get_image( b_frame, image, format, width, height, 1 );
alpha = mlt_frame_get_alpha_mask( b_frame );
mlt_frame_set_image( frame, *image, *width * *height * 2, NULL );
mlt_frame_set_alpha( frame, alpha, *width * *height, NULL );
mlt_properties_set_int( a_props, "width", *width );
mlt_properties_set_int( a_props, "height", *height );
mlt_properties_set_int( a_props, "progressive", 1 );
mlt_properties_inc_ref( b_props );
strcpy( temp, "_b_frame" );
while( mlt_properties_get_data( a_props, temp, NULL ) != NULL )
sprintf( temp, "_b_frame%d", count ++ );
mlt_properties_set_data( a_props, temp, b_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
}
// Close the b frame
mlt_frame_close( b_frame );
}
else
{
// Get the image from the frame without running fx
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
}
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;
}