mlt_transition transition_mix_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_transition transition = calloc( 1, sizeof( struct mlt_transition_s ) );
if ( transition != NULL && mlt_transition_init( transition, NULL ) == 0 )
{
transition->process = transition_process;
if ( arg != NULL )
mlt_properties_set_double( MLT_TRANSITION_PROPERTIES( transition ), "start", atof( arg ) );
// Inform apps and framework that this is an audio only transition
mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition ), "_transition_type", 2 );
}
return transition;
}
mlt_producer mlt_producer_new( mlt_profile profile )
{
mlt_producer self = malloc( sizeof( struct mlt_producer_s ) );
if ( self )
{
if ( mlt_producer_init( self, NULL ) == 0 )
{
mlt_properties_set_data( MLT_PRODUCER_PROPERTIES( self ), "_profile", profile, 0, NULL, NULL );
mlt_properties_set_double( MLT_PRODUCER_PROPERTIES( self ), "aspect_ratio", mlt_profile_sar( profile ) );
}
}
return self;
}
mlt_filter filter_panner_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = calloc( 1, sizeof( struct mlt_filter_s ) );
if ( filter != NULL && mlt_filter_init( filter, NULL ) == 0 )
{
filter->process = filter_process;
if ( arg != NULL )
mlt_properties_set_double( MLT_FILTER_PROPERTIES( filter ), "start", atof( arg ) );
mlt_properties_set_int( MLT_FILTER_PROPERTIES( filter ), "channel", -1 );
mlt_properties_set( MLT_FILTER_PROPERTIES( filter ), "split", NULL );
}
return filter;
}
static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
if ( frame )
{
// Construct a new frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
// Stack the producer and producer's get image
mlt_frame_push_service_int( *frame, index );
mlt_frame_push_service( *frame, producer );
mlt_frame_push_service( *frame, framebuffer_get_image );
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_properties frame_properties = MLT_FRAME_PROPERTIES(*frame);
// Get frame from the real producer
mlt_frame first_frame = mlt_properties_get_data( properties, "first_frame", NULL );
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, mlt_producer_position( producer ) );
// 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_inherit( frame_properties, MLT_FRAME_PROPERTIES(first_frame) );
double force_aspect_ratio = mlt_properties_get_double( properties, "force_aspect_ratio" );
if ( force_aspect_ratio <= 0.0 ) force_aspect_ratio = mlt_properties_get_double( properties, "aspect_ratio" );
mlt_properties_set_double( frame_properties, "aspect_ratio", force_aspect_ratio );
// Give the returned frame temporal identity
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
mlt_properties_set_int( frame_properties, "meta.media.width", mlt_properties_get_int( properties, "width" ) );
mlt_properties_set_int( frame_properties, "meta.media.height", mlt_properties_get_int( properties, "height" ) );
mlt_properties_pass_list( frame_properties, properties, "width, height" );
}
return 0;
}
static int producer_get_image( mlt_frame self, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
uint8_t *data = NULL;
int size = 0;
mlt_properties properties = MLT_FRAME_PROPERTIES( self );
mlt_frame frame = mlt_frame_pop_service( self );
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_properties_set( frame_properties, "rescale.interp", mlt_properties_get( properties, "rescale.interp" ) );
mlt_properties_set_int( frame_properties, "resize_alpha", mlt_properties_get_int( properties, "resize_alpha" ) );
mlt_properties_set_int( frame_properties, "distort", mlt_properties_get_int( properties, "distort" ) );
mlt_properties_set_int( frame_properties, "consumer_deinterlace", mlt_properties_get_int( properties, "consumer_deinterlace" ) );
mlt_properties_set( frame_properties, "deinterlace_method", mlt_properties_get( properties, "deinterlace_method" ) );
mlt_properties_set_int( frame_properties, "consumer_tff", mlt_properties_get_int( properties, "consumer_tff" ) );
mlt_properties_set( frame_properties, "consumer_color_trc", mlt_properties_get( properties, "consumer_color_trc" ) );
// WebVfx uses this to setup a consumer-stopping event handler.
mlt_properties_set_data( frame_properties, "consumer", mlt_properties_get_data( properties, "consumer", NULL ), 0, NULL, NULL );
mlt_frame_get_image( frame, buffer, format, width, height, writable );
mlt_frame_set_image( self, *buffer, 0, NULL );
mlt_properties_set_int( properties, "width", *width );
mlt_properties_set_int( properties, "height", *height );
mlt_properties_set_int( properties, "format", *format );
mlt_properties_set_double( properties, "aspect_ratio", mlt_frame_get_aspect_ratio( frame ) );
mlt_properties_set_int( properties, "progressive", mlt_properties_get_int( frame_properties, "progressive" ) );
mlt_properties_set_int( properties, "distort", mlt_properties_get_int( frame_properties, "distort" ) );
mlt_properties_set_int( properties, "colorspace", mlt_properties_get_int( frame_properties, "colorspace" ) );
mlt_properties_set_int( properties, "force_full_luma", mlt_properties_get_int( frame_properties, "force_full_luma" ) );
mlt_properties_set_int( properties, "top_field_first", mlt_properties_get_int( frame_properties, "top_field_first" ) );
mlt_properties_set( properties, "color_trc", mlt_properties_get( frame_properties, "color_trc" ) );
mlt_properties_set_data( properties, "movit.convert.fence",
mlt_properties_get_data( frame_properties, "movit.convert.fence", NULL ),
0, NULL, NULL );
data = mlt_frame_get_alpha( frame );
if ( data )
{
mlt_properties_get_data( frame_properties, "alpha", &size );
mlt_frame_set_alpha( self, data, size, NULL );
};
self->convert_image = frame->convert_image;
self->convert_audio = frame->convert_audio;
return 0;
}
mlt_transition transition_mix_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
transition_mix mix = calloc( 1 , sizeof( struct transition_mix_s ) );
mlt_transition transition = calloc( 1, sizeof( struct mlt_transition_s ) );
if ( mix && transition && !mlt_transition_init( transition, mix ) )
{
mix->parent = transition;
transition->close = transition_close;
transition->process = transition_process;
if ( arg )
mlt_properties_set_double( MLT_TRANSITION_PROPERTIES( transition ), "start", atof( arg ) );
// Inform apps and framework that this is an audio only transition
mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition ), "_transition_type", 2 );
} else {
if ( transition )
mlt_transition_close( transition );
if ( mix )
free( mix );
}
return transition;
}
mlt_producer producer_kino_init( mlt_profile profile, mlt_service_type type, const char *id, char *filename )
{
kino_wrapper wrapper = kino_wrapper_init( );
if ( kino_wrapper_open( wrapper, filename ) )
{
producer_kino this = calloc( 1, sizeof( struct producer_kino_s ) );
if ( this != NULL && mlt_producer_init( &this->parent, this ) == 0 )
{
mlt_producer producer = &this->parent;
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
double fps = kino_wrapper_is_pal( wrapper ) ? 25 : 30000.0 / 1001.0;
// Assign the wrapper
this->wrapper = wrapper;
// Pass wrapper properties (frame rate, count etc)
mlt_properties_set_position( properties, "length", kino_wrapper_get_frame_count( wrapper ) );
mlt_properties_set_position( properties, "in", 0 );
mlt_properties_set_position( properties, "out", kino_wrapper_get_frame_count( wrapper ) - 1 );
mlt_properties_set_double( properties, "real_fps", fps );
mlt_properties_set( properties, "resource", filename );
// Register transport implementation with the producer
producer->close = ( mlt_destructor )producer_close;
// Register our get_frame implementation with the producer
producer->get_frame = producer_get_frame;
// Return the producer
return producer;
}
free( this );
}
kino_wrapper_close( wrapper );
return NULL;
}
mlt_filter filter_vignette_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = mlt_filter_new( );
if ( filter != NULL )
{
filter->process = filter_process;
mlt_properties_set_double( MLT_FILTER_PROPERTIES( filter ), "smooth", 0.8 );
mlt_properties_set_double( MLT_FILTER_PROPERTIES( filter ), "radius", 0.5 );
mlt_properties_set_double( MLT_FILTER_PROPERTIES( filter ), "x", 0.5 );
mlt_properties_set_double( MLT_FILTER_PROPERTIES( filter ), "y", 0.5 );
mlt_properties_set_double( MLT_FILTER_PROPERTIES( filter ), "opacity", 0.0 );
mlt_properties_set_double( MLT_FILTER_PROPERTIES( filter ), "mode", 0 );
}
return filter;
}
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
if( mlt_frame_is_test_card( frame ) ) {
// The producer does not generate video. This filter will create an
// image on the producer's behalf.
mlt_profile profile = mlt_service_profile(
MLT_PRODUCER_SERVICE( mlt_frame_get_original_producer( frame ) ) );
mlt_properties_set_int( frame_properties, "progressive", 1 );
mlt_properties_set_double( frame_properties, "aspect_ratio", mlt_profile_sar( profile ) );
mlt_properties_set_int( frame_properties, "meta.media.width", profile->width );
mlt_properties_set_int( frame_properties, "meta.media.height", profile->height );
// Tell the framework that there really is an image.
mlt_properties_set_int( frame_properties, "test_image", 0 );
// Push a callback to create the image.
mlt_frame_push_get_image( frame, create_image );
}
mlt_frame_push_service( frame, filter );
mlt_frame_push_get_image( frame, filter_get_image );
return frame;
}
mlt_producer producer_colour_init( mlt_profile profile, mlt_service_type type, const char *id, char *colour )
{
mlt_producer producer = calloc( 1, sizeof( struct mlt_producer_s ) );
if ( producer != NULL && mlt_producer_init( producer, NULL ) == 0 )
{
// Get the properties interface
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
// Callback registration
producer->get_frame = producer_get_frame;
producer->close = ( mlt_destructor )producer_close;
// Set the default properties
mlt_properties_set( properties, "resource", ( !colour || !strcmp( colour, "" ) ) ? "0x000000ff" : colour );
mlt_properties_set( properties, "_resource", "" );
mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) );
return producer;
}
free( producer );
return NULL;
}
mlt_producer mlt_producer_cut( mlt_producer self, int in, int out )
{
mlt_producer result = mlt_producer_new( mlt_service_profile( MLT_PRODUCER_SERVICE( self ) ) );
mlt_producer parent = mlt_producer_cut_parent( self );
mlt_properties properties = MLT_PRODUCER_PROPERTIES( result );
mlt_properties parent_props = MLT_PRODUCER_PROPERTIES( parent );
mlt_events_block( MLT_PRODUCER_PROPERTIES( result ), MLT_PRODUCER_PROPERTIES( result ) );
// Special case - allow for a cut of the entire producer (this will squeeze all other cuts to 0)
if ( in <= 0 )
in = 0;
if ( ( out < 0 || out >= mlt_producer_get_length( parent ) ) && !mlt_producer_is_blank( self ) )
out = mlt_producer_get_length( parent ) - 1;
mlt_properties_inc_ref( parent_props );
mlt_properties_set_int( properties, "_cut", 1 );
mlt_properties_set_data( properties, "_cut_parent", parent, 0, ( mlt_destructor )mlt_producer_close, NULL );
mlt_properties_set_position( properties, "length", mlt_properties_get_position( parent_props, "length" ) );
mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( parent_props, "aspect_ratio" ) );
mlt_producer_set_in_and_out( result, in, out );
return result;
}
static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Get the real structure for this producer
producer_ktitle this = producer->child;
/* Generate a frame */
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
if ( *frame != NULL )
{
/* Obtain properties of frame and producer */
mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
/* Obtain properties of producer */
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
/* Set the producer on the frame properties */
mlt_properties_set_data( properties, "producer_kdenlivetitle", this, 0, NULL, NULL );
/* Update timecode on the frame we're creating */
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
/* Set producer-specific frame properties */
mlt_profile profile = mlt_service_profile ( MLT_PRODUCER_SERVICE( producer ) ) ;
mlt_properties_set_int( properties, "progressive", ( profile ) ? profile->progressive : 1 );
mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( producer_props, "aspect_ratio" ) );
/* Push the get_image method */
mlt_frame_push_get_image( *frame, producer_get_image );
}
/* Calculate the next timecode */
mlt_producer_prepare_next( producer );
return 0;
}
static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Generate a frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
if ( *frame != NULL )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
// Obtain properties of producer
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Set the producer on the frame properties
mlt_properties_set_data( properties, "producer_colour", producer, 0, NULL, NULL );
// Update timecode on the frame we're creating
mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
// Set producer-specific frame properties
mlt_properties_set_int( properties, "progressive", 1 );
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) );
// colour is an alias for resource
if ( mlt_properties_get( producer_props, "colour" ) != NULL )
mlt_properties_set( producer_props, "resource", mlt_properties_get( producer_props, "colour" ) );
// Push the get_image method
mlt_frame_push_get_image( *frame, producer_get_image );
}
// Calculate the next timecode
mlt_producer_prepare_next( producer );
return 0;
}
static void add_parameters( mlt_properties params, void *object, int req_flags, const char *unit, const char *subclass )
{
const AVOption *opt = NULL;
// For each AVOption on the AVClass object
#if LIBAVUTIL_VERSION_INT >= ((51<<16)+(12<<8)+0)
while ( ( opt = av_opt_next( object, opt ) ) )
#else
while ( ( opt = av_next_option( object, opt ) ) )
#endif
{
// If matches flags and not a binary option (not supported by Mlt)
if ( !( opt->flags & req_flags ) || ( opt->type == AV_OPT_TYPE_BINARY ) )
continue;
// Ignore constants (keyword values)
if ( !unit && opt->type == AV_OPT_TYPE_CONST )
continue;
// When processing a groups of options (unit)...
// ...ignore non-constants
else if ( unit && opt->type != AV_OPT_TYPE_CONST )
continue;
// ...ignore constants not in this group
else if ( unit && opt->type == AV_OPT_TYPE_CONST && strcmp( unit, opt->unit ) )
continue;
// ..add constants to the 'values' sequence
else if ( unit && opt->type == AV_OPT_TYPE_CONST )
{
char key[20];
snprintf( key, 20, "%d", mlt_properties_count( params ) );
mlt_properties_set( params, key, opt->name );
continue;
}
// Create a map for this option.
mlt_properties p = mlt_properties_new();
char key[20];
snprintf( key, 20, "%d", mlt_properties_count( params ) );
// Add the map to the 'parameters' sequence.
mlt_properties_set_data( params, key, p, 0, (mlt_destructor) mlt_properties_close, NULL );
// Add the parameter metadata for this AVOption.
mlt_properties_set( p, "identifier", opt->name );
if ( opt->help )
{
if ( subclass )
{
char *s = malloc( strlen( opt->help ) + strlen( subclass ) + 4 );
strcpy( s, opt->help );
strcat( s, " (" );
strcat( s, subclass );
strcat( s, ")" );
mlt_properties_set( p, "description", s );
free( s );
}
else
mlt_properties_set( p, "description", opt->help );
}
switch ( opt->type )
{
case AV_OPT_TYPE_FLAGS:
mlt_properties_set( p, "type", "string" );
mlt_properties_set( p, "format", "flags" );
break;
case AV_OPT_TYPE_INT:
if ( !opt->unit )
{
mlt_properties_set( p, "type", "integer" );
if ( opt->min != INT_MIN )
mlt_properties_set_int( p, "minimum", (int) opt->min );
if ( opt->max != INT_MAX )
mlt_properties_set_int( p, "maximum", (int) opt->max );
#if LIBAVUTIL_VERSION_MAJOR > 50
mlt_properties_set_int( p, "default", (int) opt->default_val.dbl );
#endif
}
else
{
mlt_properties_set( p, "type", "string" );
mlt_properties_set( p, "format", "integer or keyword" );
}
break;
case AV_OPT_TYPE_INT64:
mlt_properties_set( p, "type", "integer" );
mlt_properties_set( p, "format", "64-bit" );
if ( opt->min != INT64_MIN )
mlt_properties_set_int64( p, "minimum", (int64_t) opt->min );
if ( opt->max != INT64_MAX )
mlt_properties_set_int64( p, "maximum", (int64_t) opt->max );
#if LIBAVUTIL_VERSION_MAJOR > 50
mlt_properties_set_int64( p, "default", (int64_t) opt->default_val.dbl );
#endif
break;
case AV_OPT_TYPE_FLOAT:
mlt_properties_set( p, "type", "float" );
if ( opt->min != FLT_MIN && opt->min != -340282346638528859811704183484516925440.0 )
mlt_properties_set_double( p, "minimum", opt->min );
if ( opt->max != FLT_MAX )
mlt_properties_set_double( p, "maximum", opt->max );
#if LIBAVUTIL_VERSION_MAJOR > 50
mlt_properties_set_double( p, "default", opt->default_val.dbl );
#endif
break;
case AV_OPT_TYPE_DOUBLE:
mlt_properties_set( p, "type", "float" );
mlt_properties_set( p, "format", "double" );
if ( opt->min != DBL_MIN )
mlt_properties_set_double( p, "minimum", opt->min );
if ( opt->max != DBL_MAX )
mlt_properties_set_double( p, "maximum", opt->max );
#if LIBAVUTIL_VERSION_MAJOR > 50
mlt_properties_set_double( p, "default", opt->default_val.dbl );
#endif
break;
case AV_OPT_TYPE_STRING:
mlt_properties_set( p, "type", "string" );
#if LIBAVUTIL_VERSION_MAJOR > 50
mlt_properties_set( p, "default", opt->default_val.str );
#endif
break;
case AV_OPT_TYPE_RATIONAL:
mlt_properties_set( p, "type", "string" );
mlt_properties_set( p, "format", "numerator:denominator" );
break;
case AV_OPT_TYPE_CONST:
default:
mlt_properties_set( p, "type", "integer" );
mlt_properties_set( p, "format", "constant" );
break;
}
// If the option belongs to a group (unit) and is not a constant (keyword value)
if ( opt->unit && opt->type != AV_OPT_TYPE_CONST )
{
// Create a 'values' sequence.
mlt_properties values = mlt_properties_new();
// Recurse to add constants in this group to the 'values' sequence.
add_parameters( values, object, req_flags, opt->unit, NULL );
if ( mlt_properties_count( values ) )
mlt_properties_set_data( p, "values", values, 0, (mlt_destructor) mlt_properties_close, NULL );
else
mlt_properties_close( values );
}
}
}
static int get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
mlt_properties properties = MLT_FRAME_PROPERTIES( a_frame );
mlt_transition transition = MLT_TRANSITION( mlt_frame_pop_service( a_frame ) );
uint8_t *b_image;
int window_size = mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( transition ), "window_size" );
double psnr[3], ssim[3];
*format = mlt_image_yuv422;
mlt_frame_get_image( b_frame, &b_image, format, width, height, writable );
mlt_frame_get_image( a_frame, image, format, width, height, writable );
psnr[0] = calc_psnr( *image, b_image, *width * *height, 2 );
psnr[1] = calc_psnr( *image + 1, b_image + 1, *width * *height / 2, 4 );
psnr[2] = calc_psnr( *image + 3, b_image + 3, *width * *height / 2, 4 );
ssim[0] = calc_ssim( *image, b_image, *width, *height, window_size, 2 );
ssim[1] = calc_ssim( *image + 1, b_image + 1, *width / 2, *height, window_size, 4 );
ssim[2] = calc_ssim( *image + 3, b_image + 3, *width / 2, *height, window_size, 4 );
mlt_properties_set_double( properties, "meta.vqm.psnr.y", psnr[0] );
mlt_properties_set_double( properties, "meta.vqm.psnr.cb", psnr[1] );
mlt_properties_set_double( properties, "meta.vqm.psnr.cr", psnr[2] );
mlt_properties_set_double( properties, "meta.vqm.ssim.y", ssim[0] );
mlt_properties_set_double( properties, "meta.vqm.ssim.cb", ssim[1] );
mlt_properties_set_double( properties, "meta.vqm.ssim.cr", ssim[2] );
printf( "%05d %05.2f %05.2f %05.2f %5.3f %5.3f %5.3f\n",
mlt_frame_get_position( a_frame ), psnr[0], psnr[1], psnr[2],
ssim[0], ssim[1], ssim[2] );
// copy the B frame to the bottom of the A frame for comparison
window_size = mlt_image_format_size( *format, *width, *height, NULL ) / 2;
memcpy( *image + window_size, b_image + window_size, window_size );
if ( !mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( transition ), "render" ) )
return 0;
// get RGBA image for Qt drawing
*format = mlt_image_rgb24a;
mlt_frame_get_image( a_frame, image, format, width, height, 1 );
// convert mlt image to qimage
QImage img( *width, *height, QImage::Format_ARGB32 );
int y = *height + 1;
uint8_t *src = *image;
while ( --y )
{
QRgb *dst = (QRgb*) img.scanLine( *height - y );
int x = *width + 1;
while ( --x )
{
*dst++ = qRgba( src[0], src[1], src[2], 255 );
src += 4;
}
}
// setup Qt drawing
QPainter painter;
painter.begin( &img );
painter.setRenderHints( QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing );
// draw some stuff with Qt
QPalette palette;
QFont font;
QString s;
font.setBold( true );
font.setPointSize( 30 * *height / 1080 );
painter.setPen( QColor("black") );
painter.drawLine( 0, *height/2 + 1, *width, *height/2 );
painter.setPen( QColor("white") );
painter.drawLine( 0, *height/2 - 1, *width, *height/2 );
painter.setFont( font );
s.sprintf( "Frame: %05d\nPSNR: %05.2f (Y) %05.2f (Cb) %05.2f (Cr)\nSSIM: %5.3f (Y) %5.3f (Cb) %5.3f (Cr)",
mlt_frame_get_position( a_frame ), psnr[0], psnr[1], psnr[2],
ssim[0], ssim[1], ssim[2] );
painter.setPen( QColor("black") );
painter.drawText( 52, *height * 8 / 10 + 2, *width, *height, 0, s );
painter.setPen( QColor("white") );
painter.drawText( 50, *height * 8 / 10, *width, *height, 0, s );
// finish Qt drawing
painter.end();
window_size = mlt_image_format_size( *format, *width, *height, NULL );
uint8_t *dst = (uint8_t *) mlt_pool_alloc( window_size );
mlt_properties_set_data( MLT_FRAME_PROPERTIES(a_frame), "image", dst, window_size, mlt_pool_release, NULL );
*image = dst;
// convert qimage to mlt
y = *height + 1;
while ( --y )
{
QRgb *src = (QRgb*) img.scanLine( *height - y );
int x = *width + 1;
while ( --x )
{
*dst++ = qRed( *src );
*dst++ = qGreen( *src );
*dst++ = qBlue( *src );
*dst++ = qAlpha( *src );
src++;
}
}
return 0;
}
static void analyze_audio( mlt_filter filter, void* buffer, int samples )
{
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
private_data* pdata = (private_data*)filter->child;
int result = -1;
double loudness = 0.0;
ebur128_add_frames_float( pdata->r128, buffer, samples );
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_program" ) )
{
result = ebur128_loudness_global( pdata->r128, &loudness );
if( result == EBUR128_SUCCESS && loudness != HUGE_VAL && loudness != -HUGE_VAL )
{
mlt_properties_set_double( properties, "program", loudness );
}
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_shortterm" ) )
{
result = ebur128_loudness_shortterm( pdata->r128, &loudness );
if( result == EBUR128_SUCCESS && loudness != HUGE_VAL && loudness != -HUGE_VAL )
{
mlt_properties_set_double( properties, "shortterm", loudness );
}
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_momentary" ) )
{
result = ebur128_loudness_momentary( pdata->r128, &loudness );
if( result == EBUR128_SUCCESS && loudness != HUGE_VAL && loudness != -HUGE_VAL )
{
mlt_properties_set_double( properties, "momentary", loudness );
}
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_range" ) )
{
double range = 0;
result = ebur128_loudness_range( pdata->r128, &range );
if( result == EBUR128_SUCCESS && range != HUGE_VAL && range != -HUGE_VAL )
{
mlt_properties_set_double( properties, "range", range );
}
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_peak" ) )
{
double prev_peak = 0.0;
double max_peak = 0.0;
int c = 0;
for( c = 0; c < pdata->r128->channels; c++ )
{
double peak;
result = ebur128_sample_peak( pdata->r128, c, &peak );
if( result == EBUR128_SUCCESS && peak != HUGE_VAL && peak > max_peak )
{
max_peak = peak;
}
result = ebur128_prev_sample_peak( pdata->r128, c, &peak );
if( result == EBUR128_SUCCESS && peak != HUGE_VAL && peak > prev_peak )
{
prev_peak = peak;
}
}
mlt_properties_set_double( properties, "max_peak", 20 * log10(max_peak) );
mlt_properties_set_double( properties, "peak", 20 * log10(prev_peak) );
}
if( mlt_properties_get_int( MLT_FILTER_PROPERTIES(filter), "calc_true_peak" ) )
{
double prev_peak = 0.0;
double max_peak = 0.0;
int c = 0;
for( c = 0; c < pdata->r128->channels; c++ )
{
double peak;
result = ebur128_true_peak( pdata->r128, c, &peak );
if( result == EBUR128_SUCCESS && peak != HUGE_VAL && peak > max_peak )
{
max_peak = peak;
}
result = ebur128_prev_true_peak( pdata->r128, c, &peak );
if( result == EBUR128_SUCCESS && peak != HUGE_VAL && peak > prev_peak )
{
prev_peak = peak;
}
}
mlt_properties_set_double( properties, "max_true_peak", 20 * log10(max_peak) );
mlt_properties_set_double( properties, "true_peak", 20 * log10(prev_peak) );
}
mlt_properties_set_position( properties, "frames_processed", mlt_properties_get_position( properties, "frames_processed" ) + 1 );
}
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 ladspa_get_audio( mlt_frame frame, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
{
int error = 0;
// Get the filter service
mlt_filter filter = mlt_frame_pop_audio( frame );
// Get the filter properties
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
// Check if the channel configuration has changed
int prev_channels = mlt_properties_get_int( filter_properties, "_prev_channels" );
if ( prev_channels != *channels )
{
if( prev_channels )
{
mlt_log_info( MLT_FILTER_SERVICE(filter), "Channel configuration changed. Old: %d New: %d.\n", prev_channels, *channels );
mlt_properties_set_data( filter_properties, "jackrack", NULL, 0, (mlt_destructor) NULL, NULL );
}
mlt_properties_set_int( filter_properties, "_prev_channels", *channels );
}
// Initialise LADSPA if needed
jack_rack_t *jackrack = mlt_properties_get_data( filter_properties, "jackrack", NULL );
if ( jackrack == NULL )
{
sample_rate = *frequency; // global inside jack_rack
jackrack = initialise_jack_rack( filter_properties, *channels );
}
if ( jackrack && jackrack->procinfo && jackrack->procinfo->chain &&
mlt_properties_get_int64( filter_properties, "_pluginid" ) )
{
plugin_t *plugin = jackrack->procinfo->chain;
LADSPA_Data value;
int i, c;
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
// Get the producer's audio
*format = mlt_audio_float;
mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
// Resize the buffer if necessary.
if ( *channels < jackrack->channels )
{
// Add extra channels to satisfy the plugin.
// Extra channels in the buffer will be ignored by downstream services.
int old_size = mlt_audio_format_size( *format, *samples, *channels );
int new_size = mlt_audio_format_size( *format, *samples, jackrack->channels );
uint8_t* new_buffer = mlt_pool_alloc( new_size );
memcpy( new_buffer, *buffer, old_size );
// Put silence in extra channels.
memset( new_buffer + old_size, 0, new_size - old_size );
mlt_frame_set_audio( frame, new_buffer, *format, new_size, mlt_pool_release );
*buffer = new_buffer;
}
for ( i = 0; i < plugin->desc->control_port_count; i++ )
{
// Apply the control port values
char key[20];
value = plugin_desc_get_default_control_value( plugin->desc, i, sample_rate );
snprintf( key, sizeof(key), "%d", i );
if ( mlt_properties_get( filter_properties, key ) )
value = mlt_properties_anim_get_double( filter_properties, key, position, length );
for ( c = 0; c < plugin->copies; c++ )
plugin->holders[c].control_memory[i] = value;
}
plugin->wet_dry_enabled = mlt_properties_get( filter_properties, "wetness" ) != NULL;
if ( plugin->wet_dry_enabled )
{
value = mlt_properties_anim_get_double( filter_properties, "wetness", position, length );
for ( c = 0; c < jackrack->channels; c++ )
plugin->wet_dry_values[c] = value;
}
// Configure the buffers
LADSPA_Data **input_buffers = mlt_pool_alloc( sizeof( LADSPA_Data* ) * jackrack->channels );
LADSPA_Data **output_buffers = mlt_pool_alloc( sizeof( LADSPA_Data* ) * jackrack->channels );
// Some plugins crash with too many frames (samples).
// So, feed the plugin with N samples per loop iteration.
int samples_offset = 0;
int sample_count = MIN(*samples, MAX_SAMPLE_COUNT);
for (i = 0; samples_offset < *samples; i++) {
int j = 0;
for (; j < jackrack->channels; j++)
output_buffers[j] = input_buffers[j] = (LADSPA_Data*) *buffer + j * (*samples) + samples_offset;
sample_count = MIN(*samples - samples_offset, MAX_SAMPLE_COUNT);
// Do LADSPA processing
error = process_ladspa( jackrack->procinfo, sample_count, input_buffers, output_buffers );
samples_offset += MAX_SAMPLE_COUNT;
}
mlt_pool_release( input_buffers );
mlt_pool_release( output_buffers );
// read the status port values
for ( i = 0; i < plugin->desc->status_port_count; i++ )
{
char key[20];
int p = plugin->desc->status_port_indicies[i];
for ( c = 0; c < plugin->copies; c++ )
{
snprintf( key, sizeof(key), "%d[%d]", p, c );
value = plugin->holders[c].status_memory[i];
mlt_properties_set_double( filter_properties, key, value );
}
}
}
else
{
// Nothing to do.
error = mlt_frame_get_audio( frame, buffer, format, frequency, channels, samples );
}
return error;
}
static int producer_get_frame( mlt_service service, mlt_frame_ptr frame, int index )
{
int result = 1;
mlt_producer self = service != NULL ? service->child : NULL;
if ( self != NULL && !mlt_producer_is_cut( self ) )
{
// Get the properties of this producer
mlt_properties properties = MLT_PRODUCER_PROPERTIES( self );
// Determine eof handling
char *eof = mlt_properties_get( MLT_PRODUCER_PROPERTIES( self ), "eof" );
// Get the speed of the producer
double speed = mlt_producer_get_speed( self );
// We need to use the clone if it's specified
mlt_producer clone = mlt_properties_get_data( properties, "use_clone", NULL );
// If no clone is specified, use self
clone = clone == NULL ? self : clone;
// A properly instatiated producer will have a get_frame method...
if ( self->get_frame == NULL || ( eof && !strcmp( eof, "continue" ) && mlt_producer_position( self ) > mlt_producer_get_out( self ) ) )
{
// Generate a test frame
*frame = mlt_frame_init( service );
// Set the position
result = mlt_frame_set_position( *frame, mlt_producer_position( self ) );
// Mark as a test card
mlt_properties_set_int( MLT_FRAME_PROPERTIES( *frame ), "test_image", 1 );
mlt_properties_set_int( MLT_FRAME_PROPERTIES( *frame ), "test_audio", 1 );
// Calculate the next position
mlt_producer_prepare_next( self );
}
else
{
// Get the frame from the implementation
result = self->get_frame( clone, frame, index );
}
// Copy the fps and speed of the producer onto the frame
properties = MLT_FRAME_PROPERTIES( *frame );
mlt_properties_set_double( properties, "_speed", speed );
mlt_properties_set_int( properties, "test_audio", mlt_frame_is_test_audio( *frame ) );
mlt_properties_set_int( properties, "test_image", mlt_frame_is_test_card( *frame ) );
if ( mlt_properties_get_data( properties, "_producer", NULL ) == NULL )
mlt_properties_set_data( properties, "_producer", service, 0, NULL, NULL );
}
else if ( self != NULL )
{
// Get the speed of the cut
double speed = mlt_producer_get_speed( self );
// Get the parent of the cut
mlt_producer parent = mlt_producer_cut_parent( self );
// Get the properties of the parent
mlt_properties parent_properties = MLT_PRODUCER_PROPERTIES( parent );
// Get the properties of the cut
mlt_properties properties = MLT_PRODUCER_PROPERTIES( self );
// Determine the clone index
int clone_index = mlt_properties_get_int( properties, "_clone" );
// Determine the clone to use
mlt_producer clone = self;
if ( clone_index > 0 )
{
char key[ 25 ];
sprintf( key, "_clone.%d", clone_index - 1 );
clone = mlt_properties_get_data( MLT_PRODUCER_PROPERTIES( mlt_producer_cut_parent( self ) ), key, NULL );
if ( clone == NULL ) mlt_log( service, MLT_LOG_ERROR, "requested clone doesn't exist %d\n", clone_index );
clone = clone == NULL ? self : clone;
}
else
{
clone = parent;
}
// We need to seek to the correct position in the clone
mlt_producer_seek( clone, mlt_producer_get_in( self ) + mlt_properties_get_int( properties, "_position" ) );
// Assign the clone property to the parent
mlt_properties_set_data( parent_properties, "use_clone", clone, 0, NULL, NULL );
// Now get the frame from the parents service
result = mlt_service_get_frame( MLT_PRODUCER_SERVICE( parent ), frame, index );
// We're done with the clone now
mlt_properties_set_data( parent_properties, "use_clone", NULL, 0, NULL, NULL );
// This is useful and required by always_active transitions to determine in/out points of the cut
if ( mlt_properties_get_data( MLT_FRAME_PROPERTIES( *frame ), "_producer", NULL ) == MLT_PRODUCER_SERVICE( parent ) )
mlt_properties_set_data( MLT_FRAME_PROPERTIES( *frame ), "_producer", self, 0, NULL, NULL );
mlt_properties_set_double( MLT_FRAME_PROPERTIES( *frame ), "_speed", speed );
mlt_producer_prepare_next( self );
}
else
{
*frame = mlt_frame_init( service );
result = 0;
}
// Pass on all meta properties from the producer/cut on to the frame
if ( *frame != NULL && self != NULL )
{
int i = 0;
mlt_properties p_props = MLT_PRODUCER_PROPERTIES( self );
mlt_properties f_props = MLT_FRAME_PROPERTIES( *frame );
mlt_properties_lock( p_props );
int count = mlt_properties_count( p_props );
for ( i = 0; i < count; i ++ )
{
char *name = mlt_properties_get_name( p_props, i );
if ( !strncmp( name, "meta.", 5 ) )
mlt_properties_set( f_props, name, mlt_properties_get_value( p_props, i ) );
else if ( !strncmp( name, "set.", 4 ) )
mlt_properties_set( f_props, name + 4, mlt_properties_get_value( p_props, i ) );
}
mlt_properties_unlock( p_props );
}
return result;
}
void AsisScript::pre_judge() throw (Exception)
{
ScriptProps::Property& service_prop = type_spec_props->get_property("service");
if (!service_prop.Evaluable::finished())
throw_error_v(ErrorScriptFmtError,"asis producer script service should be determinated");
ScriptProps::Property& resource_prop = type_spec_props->get_property("resource");
if (!resource_prop.Evaluable::finished())
throw_error_v(ErrorScriptFmtError,"asis producer script resource should be determinated");
json_t* svc_value = service_prop.compile();
json_t* res_value = resource_prop.compile();
JsonWrap svc_wrap(svc_value,1);
JsonWrap res_wrap(res_value,1);
if ( !svc_value || !json_is_string(svc_value) || !strlen(json_string_value(svc_value)))
throw_error_v(ErrorScriptFmtError,"asis producer script service should be string value");
if ( !res_value || !json_is_string(res_value) || !strlen(json_string_value(res_value)))
throw_error_v(ErrorScriptFmtError,"asis producer script resource should be string value");
mlt_profile prof = mlt_profile_clone(MltLoader::global_profile);
mlt_producer tmp_prod = mlt_factory_producer(prof, json_string_value(svc_value), json_string_value(res_value));
MltSvcWrap prod_wrap(mlt_producer_service(tmp_prod), 1);
if (tmp_prod == NULL) {
throw_error_v(ErrorRuntimeLoadFailed, "producer %s load failed", json_string_value(svc_value));
}
if ( mlt_props ) {
ScriptProps::PropIter it = mlt_props->begin();
for ( ; it!=mlt_props->end(); it++) {
if ( it->second->Evaluable::finished() ) {
json_t* prop_v = it->second->compile();
JsonWrap prop_wrap(prop_v, 1);
switch(prop_v->type) {
case JSON_INTEGER:
mlt_properties_set_int64(mlt_producer_properties(tmp_prod),
it->first.c_str(), json_integer_value(prop_v));
break;
case JSON_REAL:
mlt_properties_set_double(mlt_producer_properties(tmp_prod),
it->first.c_str(), json_real_value(prop_v));
break;
case JSON_STRING:
mlt_properties_set(mlt_producer_properties(tmp_prod),
it->first.c_str(), json_string_value(prop_v));
break;
case JSON_TRUE:
mlt_properties_set_int(mlt_producer_properties(tmp_prod),
it->first.c_str(), 1);
break;
case JSON_FALSE:
mlt_properties_set_int(mlt_producer_properties(tmp_prod),
it->first.c_str(), 0);
break;
default:
throw_error_v(ErrorRuntimeLoadFailed, "producer %s load failed. %s prop invalid",
json_string_value(svc_value), it->first.c_str());
}
}
}
}
int in = mlt_producer_get_in(tmp_prod);
int out = mlt_producer_get_out(tmp_prod);
set_frame_range(in, out);
if ( !mlt_props.get()) {
mlt_props.reset(new ScriptProps(*this, NULL));
}
json_t* jv = json_integer(in);
mlt_props->add_property("in", jv);
json_decref(jv);
jv = json_integer(out);
mlt_props->add_property("out", jv);
json_decref(jv);
string uuid = Vm::uuid();
type_spec_props->add_property("uuid", JsonWrap(json_string(uuid.c_str()),1).h);
prod_wrap.obj = NULL;
MltLoader::push_mlt_registry(mlt_producer_service(tmp_prod), uuid.c_str());
}
int mlt_producer_set_speed( mlt_producer self, double speed )
{
return mlt_properties_set_double( MLT_PRODUCER_PROPERTIES( self ), "_speed", speed );
}
mlt_producer producer_framebuffer_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
if ( !arg ) return NULL;
mlt_producer producer = NULL;
producer = calloc( 1, sizeof( struct mlt_producer_s ) );
if ( !producer )
return NULL;
if ( mlt_producer_init( producer, NULL ) )
{
free( producer );
return NULL;
}
// Wrap loader
mlt_producer real_producer;
// Check if a speed was specified.
/**
* Speed must be appended to the filename with '?'. To play your video at 50%:
melt framebuffer:my_video.mpg?0.5
* Stroboscope effect can be obtained by adding a stobe=x parameter, where
x is the number of frames that will be ignored.
* You can play the movie backwards by adding reverse=1
* You can freeze the clip at a determined position by adding freeze=frame_pos
add freeze_after=1 to freeze only paste position or freeze_before to freeze before it
**/
double speed = 0.0;
char *props = strdup( arg );
char *ptr = strrchr( props, '?' );
if ( ptr )
{
speed = atof( ptr + 1 );
if ( speed != 0.0 )
// If speed was valid, then strip it and the delimiter.
// Otherwise, an invalid speed probably means this '?' was not a delimiter.
*ptr = '\0';
}
real_producer = mlt_factory_producer( profile, "abnormal", props );
free( props );
if (speed == 0.0) speed = 1.0;
if ( producer != NULL && real_producer != NULL)
{
// Get the properties of this producer
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_properties_set( properties, "resource", arg);
// Store the producer and fitler
mlt_properties_set_data( properties, "producer", real_producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
// Grab some stuff from the real_producer
mlt_properties_pass_list( properties, MLT_PRODUCER_PROPERTIES( real_producer ), "length, width, height, aspect_ratio" );
if ( speed < 0 )
{
speed = -speed;
mlt_properties_set_int( properties, "reverse", 1 );
}
if ( speed != 1.0 )
{
double real_length = ( (double) mlt_producer_get_length( real_producer ) ) / speed;
mlt_properties_set_position( properties, "length", real_length );
mlt_properties real_properties = MLT_PRODUCER_PROPERTIES( real_producer );
const char* service = mlt_properties_get( real_properties, "mlt_service" );
if ( service && !strcmp( service, "avformat" ) )
{
int n = mlt_properties_count( real_properties );
int i;
for ( i = 0; i < n; i++ )
{
if ( strstr( mlt_properties_get_name( real_properties, i ), "stream.frame_rate" ) )
{
double source_fps = mlt_properties_get_double( real_properties, mlt_properties_get_name( real_properties, i ) );
if ( source_fps > mlt_profile_fps( profile ) )
{
mlt_properties_set_double( real_properties, "force_fps", source_fps * speed );
mlt_properties_set_position( real_properties, "length", real_length );
mlt_properties_set_position( real_properties, "out", real_length - 1 );
speed = 1.0;
}
break;
}
}
}
}
mlt_properties_set_position( properties, "out", mlt_producer_get_length( producer ) - 1 );
// Since we control the seeking, prevent it from seeking on its own
mlt_producer_set_speed( real_producer, 0 );
mlt_producer_set_speed( producer, speed );
// Override the get_frame method
producer->get_frame = producer_get_frame;
}
else
{
if ( producer )
mlt_producer_close( producer );
if ( real_producer )
mlt_producer_close( real_producer );
producer = NULL;
}
return producer;
}
mlt_service SingleResourceLoader::get_asis_producer(JsonWrap js)
throw (Exception)
{
json_t* defines = js.h;
defines_tmp=js;
json_t* je = json_object_get(defines, "resource");
json_t* uuid_je = json_object_get(defines, "uuid");
json_t* svc_je = json_object_get(defines, "service");
assert( je && json_is_string(je) && strlen(json_string_value(je)));
assert( svc_je && json_is_string(svc_je) && strlen(json_string_value(svc_je)));
assert( uuid_je && json_is_string(uuid_je) && strlen(json_string_value(uuid_je)));
mlt_producer obj = MLT_PRODUCER(MltLoader::pop_mlt_registry(json_string_value(uuid_je)));
if (obj == NULL) {
mlt_profile profile = mlt_profile_clone(global_profile);
obj = mlt_factory_producer(profile, json_string_value(svc_je), json_string_value(je));
#ifdef DEBUG
std::cout << mlt_producer_properties(obj);
#endif
}
if ( !obj ) {
throw_error_v(ErrorRuntimeLoadFailed, "video producer load failed:%s", json_string_value(je));
}
mlt_properties props = mlt_producer_properties(obj);
je = json_object_get(defines, "props");
if (je && json_is_object(je) && json_object_size(je)) {
json_t* inj = json_object_get(je,"in"), *outj = json_object_get(je,"out");
assert(inj && outj && json_is_integer(inj) && json_is_integer(outj));
mlt_producer_set_in_and_out(obj,json_integer_value(inj), json_integer_value(outj));
void* it = json_object_iter(je);
while(it) {
const char* k = json_object_iter_key(it);
json_t* prop_je = json_object_iter_value(it);
it = json_object_iter_next(je, it);
if ( json_is_object(prop_je) || json_is_array(prop_je))
continue;
if ( !strcmp(k,"in") || !strcmp(k,"out"))
continue;
switch(prop_je->type) {
case JSON_INTEGER:
mlt_properties_set_int64(props, k, json_integer_value(prop_je));
break;
case JSON_REAL:
mlt_properties_set_double(props, k, json_real_value(prop_je));
break;
case JSON_STRING:
mlt_properties_set(props, k, json_string_value(prop_je));
break;
case JSON_TRUE:
mlt_properties_set_int(props,k, 1);
break;
case JSON_FALSE:
mlt_properties_set_int(props,k, 0);
break;
default:
break;
}
}
}
MltSvcWrap wrap(mlt_producer_service(obj), 1);
producer_tmp = obj;
parse_filters();
wrap.obj = NULL;
return mlt_producer_service(obj);
}
static mlt_frame transition_process( mlt_transition transition, mlt_frame a_frame, mlt_frame b_frame )
{
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// Only if mix is specified, otherwise a producer may set the mix
if ( mlt_properties_get( properties, "start" ) )
{
// Determine the time position of this frame in the transition duration
mlt_properties props = mlt_properties_get_data( MLT_FRAME_PROPERTIES( b_frame ), "_producer", NULL );
mlt_position in = mlt_properties_get_int( props, "in" );
mlt_position out = mlt_properties_get_int( props, "out" );
int length = mlt_properties_get_int( properties, "length" );
mlt_position time = mlt_properties_get_int( props, "_frame" );
double mix = mlt_transition_get_progress( transition, b_frame );
if ( mlt_properties_get_int( properties, "always_active" ) )
mix = ( double ) ( time - in ) / ( double ) ( out - in + 1 );
// TODO: Check the logic here - shouldn't we be computing current and next mixing levels in all cases?
if ( length == 0 )
{
// If there is an end mix level adjust mix to the range
if ( mlt_properties_get( properties, "end" ) )
{
double start = mlt_properties_get_double( properties, "start" );
double end = mlt_properties_get_double( properties, "end" );
mix = start + ( end - start ) * mix;
}
// A negative means total crossfade (uses position)
else if ( mlt_properties_get_double( properties, "start" ) >= 0 )
{
// Otherwise, start/constructor is a constant mix level
mix = mlt_properties_get_double( properties, "start" );
}
// Finally, set the mix property on the frame
mlt_properties_set_double( b_props, "audio.mix", mix );
// Initialise transition previous mix value to prevent an inadvertant jump from 0
mlt_position last_position = mlt_properties_get_position( properties, "_last_position" );
mlt_position current_position = mlt_frame_get_position( b_frame );
mlt_properties_set_position( properties, "_last_position", current_position );
if ( !mlt_properties_get( properties, "_previous_mix" )
|| current_position != last_position + 1 )
mlt_properties_set_double( properties, "_previous_mix", mix );
// Tell b frame what the previous mix level was
mlt_properties_set_double( b_props, "audio.previous_mix", mlt_properties_get_double( properties, "_previous_mix" ) );
// Save the current mix level for the next iteration
mlt_properties_set_double( properties, "_previous_mix", mlt_properties_get_double( b_props, "audio.mix" ) );
mlt_properties_set_double( b_props, "audio.reverse", mlt_properties_get_double( properties, "reverse" ) );
}
else
{
double level = mlt_properties_get_double( properties, "start" );
double mix_start = level;
double mix_end = mix_start;
double mix_increment = 1.0 / length;
if ( time - in < length )
{
mix_start = mix_start * ( ( double )( time - in ) / length );
mix_end = mix_start + mix_increment;
}
else if ( time > out - length )
{
mix_end = mix_start * ( ( double )( out - time - in ) / length );
mix_start = mix_end - mix_increment;
}
mix_start = mix_start < 0 ? 0 : mix_start > level ? level : mix_start;
mix_end = mix_end < 0 ? 0 : mix_end > level ? level : mix_end;
mlt_properties_set_double( b_props, "audio.previous_mix", mix_start );
mlt_properties_set_double( b_props, "audio.mix", mix_end );
}
}
// Override the get_audio method
mlt_frame_push_audio( a_frame, transition );
mlt_frame_push_audio( a_frame, b_frame );
mlt_frame_push_audio( a_frame, transition_get_audio );
return a_frame;
}
static void mlt_consumer_property_changed( mlt_properties owner, mlt_consumer self, char *name )
{
if ( !strcmp( name, "mlt_profile" ) )
{
// Get the properies
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
// Get the current profile
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
// Load the new profile
mlt_profile new_profile = mlt_profile_init( mlt_properties_get( properties, name ) );
if ( new_profile )
{
// Copy the profile
if ( profile != NULL )
{
free( profile->description );
memcpy( profile, new_profile, sizeof( struct mlt_profile_s ) );
profile->description = strdup( new_profile->description );
}
else
{
profile = new_profile;
}
// Apply to properties
apply_profile_properties( self, profile, properties );
mlt_profile_close( new_profile );
}
}
else if ( !strcmp( name, "frame_rate_num" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
{
profile->frame_rate_num = mlt_properties_get_int( properties, "frame_rate_num" );
mlt_properties_set_double( properties, "fps", mlt_profile_fps( profile ) );
}
}
else if ( !strcmp( name, "frame_rate_den" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
{
profile->frame_rate_den = mlt_properties_get_int( properties, "frame_rate_den" );
mlt_properties_set_double( properties, "fps", mlt_profile_fps( profile ) );
}
}
else if ( !strcmp( name, "width" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
profile->width = mlt_properties_get_int( properties, "width" );
}
else if ( !strcmp( name, "height" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
profile->height = mlt_properties_get_int( properties, "height" );
}
else if ( !strcmp( name, "progressive" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
profile->progressive = mlt_properties_get_int( properties, "progressive" );
}
else if ( !strcmp( name, "sample_aspect_num" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
{
profile->sample_aspect_num = mlt_properties_get_int( properties, "sample_aspect_num" );
mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) );
}
}
else if ( !strcmp( name, "sample_aspect_den" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
{
profile->sample_aspect_den = mlt_properties_get_int( properties, "sample_aspect_den" );
mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) );
}
}
else if ( !strcmp( name, "display_aspect_num" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
{
profile->display_aspect_num = mlt_properties_get_int( properties, "display_aspect_num" );
mlt_properties_set_double( properties, "display_ratio", mlt_profile_dar( profile ) );
}
}
else if ( !strcmp( name, "display_aspect_den" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
{
profile->display_aspect_den = mlt_properties_get_int( properties, "display_aspect_den" );
mlt_properties_set_double( properties, "display_ratio", mlt_profile_dar( profile ) );
}
}
else if ( !strcmp( name, "colorspace" ) )
{
mlt_properties properties = MLT_CONSUMER_PROPERTIES( self );
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( self ) );
if ( profile )
profile->colorspace = mlt_properties_get_int( properties, "colorspace" );
}
}
mlt_consumer consumer_sdl2_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
// Create the consumer object
consumer_sdl self = calloc( 1, sizeof( struct consumer_sdl_s ) );
// If no malloc'd and consumer init ok
if ( self != NULL && mlt_consumer_init( &self->parent, self, profile ) == 0 )
{
// Create the queue
self->queue = mlt_deque_init( );
// Get the parent consumer object
mlt_consumer parent = &self->parent;
// We have stuff to clean up, so override the close method
parent->close = consumer_close;
// get a handle on properties
mlt_service service = MLT_CONSUMER_SERVICE( parent );
self->properties = MLT_SERVICE_PROPERTIES( service );
// Set the default volume
mlt_properties_set_double( self->properties, "volume", 1.0 );
// This is the initialisation of the consumer
pthread_mutex_init( &self->audio_mutex, NULL );
pthread_cond_init( &self->audio_cond, NULL);
pthread_mutex_init( &self->video_mutex, NULL );
pthread_cond_init( &self->video_cond, NULL);
// Default scaler (for now we'll use nearest)
mlt_properties_set( self->properties, "rescale", "nearest" );
mlt_properties_set( self->properties, "deinterlace_method", "onefield" );
mlt_properties_set_int( self->properties, "top_field_first", -1 );
// Default buffer for low latency
mlt_properties_set_int( self->properties, "buffer", 1 );
// Default audio buffer
mlt_properties_set_int( self->properties, "audio_buffer", 2048 );
#if defined(_WIN32) && SDL_MAJOR_VERSION == 2
mlt_properties_set( self->properties, "audio_driver", "DirectSound" );
#endif
// Ensure we don't join on a non-running object
self->joined = 1;
// process actual param
if ( arg && sscanf( arg, "%dx%d", &self->width, &self->height ) )
{
mlt_properties_set_int( self->properties, "resolution", 1 );
}
else
{
self->width = mlt_properties_get_int( self->properties, "width" );
self->height = mlt_properties_get_int( self->properties, "height" );
}
// Allow thread to be started/stopped
parent->start = consumer_start;
parent->stop = consumer_stop;
parent->is_stopped = consumer_is_stopped;
parent->purge = consumer_purge;
// Register specific events
mlt_events_register( self->properties, "consumer-sdl-event", ( mlt_transmitter )consumer_sdl_event );
// Return the consumer produced
return parent;
}
// malloc or consumer init failed
free( self );
// Indicate failure
return NULL;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
// Get the properties from the frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Pop the top of stack now
mlt_filter filter = mlt_frame_pop_service( frame );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
// Retrieve the aspect ratio
double aspect_ratio = mlt_deque_pop_back_double( MLT_FRAME_IMAGE_STACK( frame ) );
double consumer_aspect = mlt_profile_sar( mlt_service_profile( MLT_FILTER_SERVICE( filter ) ) );
// Correct Width/height if necessary
if ( *width == 0 || *height == 0 )
{
*width = profile->width;
*height = profile->height;
}
// Assign requested width/height from our subordinate
int owidth = *width;
int oheight = *height;
// Check for the special case - no aspect ratio means no problem :-)
if ( aspect_ratio == 0.0 )
aspect_ratio = consumer_aspect;
// Reset the aspect ratio
mlt_properties_set_double( properties, "aspect_ratio", aspect_ratio );
// XXX: This is a hack, but it forces the force_full_luma to apply by doing a RGB
// conversion because range scaling only occurs on YUV->RGB. And we do it here,
// after the deinterlace filter, which only operates in YUV to avoid a YUV->RGB->YUV->?.
// Instead, it will go YUV->RGB->?.
if ( mlt_properties_get_int( properties, "force_full_luma" ) )
*format = mlt_image_rgb24a;
// Hmmm...
char *rescale = mlt_properties_get( properties, "rescale.interp" );
if ( rescale != NULL && !strcmp( rescale, "none" ) )
return mlt_frame_get_image( frame, image, format, width, height, writable );
if ( mlt_properties_get_int( properties, "distort" ) == 0 )
{
// Normalise the input and out display aspect
int normalised_width = profile->width;
int normalised_height = profile->height;
int real_width = mlt_properties_get_int( properties, "meta.media.width" );
int real_height = mlt_properties_get_int( properties, "meta.media.height" );
if ( real_width == 0 )
real_width = mlt_properties_get_int( properties, "width" );
if ( real_height == 0 )
real_height = mlt_properties_get_int( properties, "height" );
double input_ar = aspect_ratio * real_width / real_height;
double output_ar = consumer_aspect * owidth / oheight;
// fprintf( stderr, "real %dx%d normalised %dx%d output %dx%d sar %f in-dar %f out-dar %f\n",
// real_width, real_height, normalised_width, normalised_height, owidth, oheight, aspect_ratio, input_ar, output_ar);
// Optimised for the input_ar > output_ar case (e.g. widescreen on standard)
int scaled_width = rint( ( input_ar * normalised_width ) / output_ar );
int scaled_height = normalised_height;
// Now ensure that our images fit in the output frame
if ( scaled_width > normalised_width )
{
scaled_width = normalised_width;
scaled_height = rint( ( output_ar * normalised_height ) / input_ar );
}
// Now calculate the actual image size that we want
owidth = rint( scaled_width * owidth / normalised_width );
oheight = rint( scaled_height * oheight / normalised_height );
// Tell frame we have conformed the aspect to the consumer
mlt_frame_set_aspect_ratio( frame, consumer_aspect );
}
mlt_properties_set_int( properties, "distort", 0 );
// Now pass on the calculations down the line
mlt_properties_set_int( properties, "resize_width", *width );
mlt_properties_set_int( properties, "resize_height", *height );
// If there will be padding, then we need packed image format.
if ( *format == mlt_image_yuv420p )
{
int iwidth = mlt_properties_get_int( properties, "width" );
int iheight = mlt_properties_get_int( properties, "height" );
if ( iwidth < owidth || iheight < oheight )
*format = mlt_image_yuv422;
}
// Now get the image
if ( *format == mlt_image_yuv422 )
owidth -= owidth % 2;
error = mlt_frame_get_image( frame, image, format, &owidth, &oheight, writable );
if ( error == 0 && *image )
{
int bpp;
mlt_image_format_size( *format, owidth, oheight, &bpp );
*image = frame_resize_image( frame, *width, *height, bpp );
}
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 );
// 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." );
}
// 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 unique id of the filter (used to reacquire the producer position)
char *name = mlt_properties_get( properties, "_unique_id" );
// Get the original producer position
mlt_position position = mlt_properties_get_position( MLT_FRAME_PROPERTIES( frame ), name );
// 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 );
// 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_double( b_props, "consumer_aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
mlt_properties_set_int( b_props, "consumer_deinterlace", mlt_properties_get_int( a_props, "consumer_deinterlace" ) || mlt_properties_get_int( properties, "deinterlace" ) );
mlt_properties_set_double( b_props, "output_ratio", mlt_properties_get_double( a_props, "output_ratio" ) );
// Check for the special case - no aspect ratio means no problem :-)
if ( mlt_frame_get_aspect_ratio( b_frame ) == 0 )
mlt_properties_set_double( b_props, "aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
if ( mlt_frame_get_aspect_ratio( frame ) == 0 )
mlt_properties_set_double( a_props, "aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
mlt_properties_set_int( b_props, "normalised_width", mlt_properties_get_int( a_props, "normalised_width" ) );
mlt_properties_set_int( b_props, "normalised_height", mlt_properties_get_int( a_props, "normalised_height" ) );
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_properties_set_data( a_props, "image", *image, *width * *height * 2, NULL, NULL );
mlt_properties_set_data( a_props, "alpha", alpha, *width * *height, NULL, 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;
}
static mlt_properties metadata( mlt_service_type type, const char *id, char *data )
{
char file[ PATH_MAX ];
if( type == filter_type )
{
snprintf( file, PATH_MAX, "%s/jackrack/%s",
mlt_environment( "MLT_DATA" ), strncmp( id, "ladspa.", 7 ) ? data : "filter_ladspa.yml" );
}
else
{
snprintf( file, PATH_MAX, "%s/jackrack/%s",
mlt_environment( "MLT_DATA" ), strncmp( id, "ladspa.", 7 ) ? data : "producer_ladspa.yml" );
}
mlt_properties result = mlt_properties_parse_yaml( file );
#ifdef GPL
if ( !strncmp( id, "ladspa.", 7 ) )
{
// Annotate the yaml properties with ladspa control port info.
plugin_desc_t *desc = plugin_mgr_get_any_desc( g_jackrack_plugin_mgr, strtol( id + 7, NULL, 10 ) );
if ( desc )
{
mlt_properties params = mlt_properties_new();
mlt_properties p;
char key[20];
int i;
mlt_properties_set( result, "identifier", id );
mlt_properties_set( result, "title", desc->name );
mlt_properties_set( result, "creator", desc->maker ? desc->maker : "unknown" );
mlt_properties_set( result, "description", "LADSPA plugin" );
mlt_properties_set_data( result, "parameters", params, 0, (mlt_destructor) mlt_properties_close, NULL );
for ( i = 0; i < desc->control_port_count; i++ )
{
int j = desc->control_port_indicies[i];
LADSPA_Data sample_rate = 48000;
LADSPA_PortRangeHintDescriptor hint_descriptor = desc->port_range_hints[j].HintDescriptor;
p = mlt_properties_new();
snprintf( key, sizeof(key), "%d", i );
mlt_properties_set_data( params, key, p, 0, (mlt_destructor) mlt_properties_close, NULL );
snprintf( key, sizeof(key), "%d", j );
mlt_properties_set( p, "identifier", key );
mlt_properties_set( p, "title", desc->port_names[ j ] );
if ( LADSPA_IS_HINT_INTEGER( hint_descriptor ) )
{
mlt_properties_set( p, "type", "integer" );
mlt_properties_set_int( p, "default", plugin_desc_get_default_control_value( desc, j, sample_rate ) );
}
else if ( LADSPA_IS_HINT_TOGGLED( hint_descriptor ) )
{
mlt_properties_set( p, "type", "boolean" );
mlt_properties_set_int( p, "default", plugin_desc_get_default_control_value( desc, j, sample_rate ) );
}
else
{
mlt_properties_set( p, "type", "float" );
mlt_properties_set_double( p, "default", plugin_desc_get_default_control_value( desc, j, sample_rate ) );
}
/* set upper and lower, possibly adjusted to the sample rate */
if ( LADSPA_IS_HINT_BOUNDED_BELOW( hint_descriptor ) )
{
LADSPA_Data lower = desc->port_range_hints[j].LowerBound;
if ( LADSPA_IS_HINT_SAMPLE_RATE( hint_descriptor ) )
lower *= sample_rate;
if ( LADSPA_IS_HINT_LOGARITHMIC( hint_descriptor ) )
{
if (lower < FLT_EPSILON)
lower = FLT_EPSILON;
}
mlt_properties_set_double( p, "minimum", lower );
}
if ( LADSPA_IS_HINT_BOUNDED_ABOVE( hint_descriptor ) )
{
LADSPA_Data upper = desc->port_range_hints[j].UpperBound;
if ( LADSPA_IS_HINT_SAMPLE_RATE( hint_descriptor ) )
upper *= sample_rate;
mlt_properties_set_double( p, "maximum", upper );
}
if ( LADSPA_IS_HINT_LOGARITHMIC( hint_descriptor ) )
mlt_properties_set( p, "scale", "log" );
mlt_properties_set( p, "mutable", "yes" );
}
if( type == filter_type )
{
p = mlt_properties_new();
snprintf( key, sizeof(key), "%d", i );
mlt_properties_set_data( params, key, p, 0, (mlt_destructor) mlt_properties_close, NULL );
mlt_properties_set( p, "identifier", "wetness" );
mlt_properties_set( p, "title", "Wet/Dry" );
mlt_properties_set( p, "type", "float" );
mlt_properties_set_double( p, "default", 1 );
mlt_properties_set_double( p, "minimum", 0 );
mlt_properties_set_double( p, "maximum", 1 );
mlt_properties_set( p, "mutable", "yes" );
}
}
}
#endif
return result;
}
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;
}
