static void draw_spectrum( mlt_filter filter, mlt_frame frame, QImage* qimg )
{
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
mlt_rect rect = mlt_properties_anim_get_rect( filter_properties, "rect", position, length );
if ( strchr( mlt_properties_get( filter_properties, "rect" ), '%' ) ) {
rect.x *= qimg->width();
rect.w *= qimg->width();
rect.y *= qimg->height();
rect.h *= qimg->height();
}
char* graph_type = mlt_properties_get( filter_properties, "type" );
int mirror = mlt_properties_get_int( filter_properties, "mirror" );
int fill = mlt_properties_get_int( filter_properties, "fill" );
double tension = mlt_properties_get_double( filter_properties, "tension" );
QRectF r( rect.x, rect.y, rect.w, rect.h );
QPainter p( qimg );
if( mirror ) {
// Draw two half rectangle instead of one full rectangle.
r.setHeight( r.height() / 2.0 );
}
setup_graph_painter( p, r, filter_properties );
setup_graph_pen( p, r, filter_properties );
int bands = mlt_properties_get_int( filter_properties, "bands" );
if ( bands == 0 ) {
// "0" means match rectangle width
bands = r.width();
}
float* spectrum = (float*)mlt_pool_alloc( bands * sizeof(float) );
convert_fft_to_spectrum( filter, frame, bands, spectrum );
if( graph_type && graph_type[0] == 'b' ) {
paint_bar_graph( p, r, bands, spectrum );
} else {
paint_line_graph( p, r, bands, spectrum, tension, fill );
}
if( mirror ) {
// Second rectangle is mirrored.
p.translate( 0, r.y() * 2 + r.height() * 2 );
p.scale( 1, -1 );
if( graph_type && graph_type[0] == 'b' ) {
paint_bar_graph( p, r, bands, spectrum );
} else {
paint_line_graph( p, r, bands, spectrum, tension, fill );
}
}
mlt_pool_release( spectrum );
p.end();
}
static void draw_waveforms( mlt_filter filter, mlt_frame frame, QImage* qimg, int16_t* audio, int channels, int samples )
{
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
int show_channel = mlt_properties_get_int( filter_properties, "show_channel" );
int fill = mlt_properties_get_int( filter_properties, "fill" );
mlt_rect rect = mlt_properties_anim_get_rect( filter_properties, "rect", position, length );
if ( strchr( mlt_properties_get( filter_properties, "rect" ), '%' ) ) {
rect.x *= qimg->width();
rect.w *= qimg->width();
rect.y *= qimg->height();
rect.h *= qimg->height();
}
QRectF r( rect.x, rect.y, rect.w, rect.h );
QPainter p( qimg );
setup_graph_painter( p, r, filter_properties );
if ( show_channel == 0 ) // Show all channels
{
QRectF c_rect = r;
qreal c_height = r.height() / channels;
for ( int c = 0; c < channels; c++ )
{
// Divide the rectangle into smaller rectangles for each channel.
c_rect.setY( r.y() + c_height * c );
c_rect.setHeight( c_height );
setup_graph_pen( p, c_rect, filter_properties );
paint_waveform( p, c_rect, audio + c, samples, channels, fill );
}
} else if ( show_channel > 0 ) { // Show one specific channel
if ( show_channel > channels ) {
// Sanity
show_channel = 1;
}
setup_graph_pen( p, r, filter_properties );
paint_waveform( p, r, audio + show_channel - 1, samples, channels, fill );
}
p.end();
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
mlt_filter filter = (mlt_filter)mlt_frame_pop_service( frame );
mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
char* rect_str = mlt_properties_get( filter_properties, "rect" );
if ( !rect_str )
{
mlt_log_warning( MLT_FILTER_SERVICE(filter), "rect property not set\n" );
return mlt_frame_get_image( frame, image, format, width, height, writable );
}
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
mlt_rect rect = mlt_properties_anim_get_rect( filter_properties, "rect", position, length );
if ( strchr( rect_str, '%' ) )
{
rect.x *= profile->width;
rect.w *= profile->width;
rect.y *= profile->height;
rect.h *= profile->height;
}
rect = constrain_rect( rect, profile->width, profile->height );
if ( rect.w < 1 || rect.h < 1 )
{
mlt_log_info( MLT_FILTER_SERVICE(filter), "rect invalid\n" );
return mlt_frame_get_image( frame, image, format, width, height, writable );
}
switch( *format )
{
case mlt_image_rgb24a:
case mlt_image_rgb24:
case mlt_image_yuv422:
case mlt_image_yuv420p:
// These formats are all supported
break;
default:
*format = mlt_image_rgb24a;
break;
}
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
if (error) return error;
int i;
switch( *format )
{
case mlt_image_rgb24a:
for ( i = 0; i < 4; i++ )
{
remove_spot_channel( *image + i, *width, 4, rect );
}
break;
case mlt_image_rgb24:
for ( i = 0; i < 3; i++ )
{
remove_spot_channel( *image + i, *width, 3, rect );
}
break;
case mlt_image_yuv422:
// Y
remove_spot_channel( *image, *width, 2, rect );
// U
remove_spot_channel( *image + 1, *width / 2, 4,
constrain_rect( scale_rect( rect, 2, 1 ), *width / 2, *height ) );
// V
remove_spot_channel( *image + 3, *width / 2, 4,
constrain_rect( scale_rect( rect, 2, 1 ), *width / 2, *height ) );
break;
case mlt_image_yuv420p:
// Y
remove_spot_channel( *image, *width, 1, rect );
// U
remove_spot_channel( *image + (*width * *height), *width / 2, 1,
constrain_rect( scale_rect( rect, 2, 2 ), *width / 2, *height / 2 ) );
// V
remove_spot_channel( *image + (*width * *height * 5 / 4), *width / 2, 1,
constrain_rect( scale_rect( rect, 2, 2 ), *width / 2, *height / 2 ) );
break;
default:
return 1;
}
uint8_t *alpha = mlt_frame_get_alpha( frame );
if ( alpha && *format != mlt_image_rgb24a )
{
remove_spot_channel( alpha, *width, 1, rect );
}
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;
}
