/** Calculate the field delta for this frame - position between two frames.
*/
-static inline double delta_calculate( mlt_transition this, mlt_frame frame )
+static inline double delta_calculate( mlt_transition this, mlt_frame frame, mlt_position position )
{
// Get the in and out position
mlt_position in = mlt_transition_get_in( this );
mlt_position out = mlt_transition_get_out( this );
double length = out - in + 1;
- // Get the position of the frame
- char *name = mlt_properties_get( MLT_TRANSITION_PROPERTIES( this ), "_unique_id" );
- mlt_position position = mlt_properties_get_position( MLT_FRAME_PROPERTIES( frame ), name );
-
// Now do the calcs
double x = ( double )( position - in ) / length;
double y = ( double )( position + 1 - in ) / length;
}
}
+static void composite_line_yuv_and( uint8_t *dest, uint8_t *src, int width, uint8_t *alpha_b, uint8_t *alpha_a, int weight, uint16_t *luma, int softness )
+{
+ register int j;
+ register int a;
+ register int mix;
+
+ for ( j = 0; j < width; j ++ )
+ {
+ a = *alpha_b ++ & *alpha_a;
+ mix = ( luma == NULL ) ? weight : smoothstep( luma[ j ], luma[ j ] + softness, weight + softness );
+ mix = ( mix * a ) >> 8;
+ *dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ dest++;
+ *dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ dest++;
+ *alpha_a = mix | *alpha_a;
+ alpha_a ++;
+ }
+}
+
+static void composite_line_yuv_xor( uint8_t *dest, uint8_t *src, int width, uint8_t *alpha_b, uint8_t *alpha_a, int weight, uint16_t *luma, int softness )
+{
+ register int j;
+ register int a;
+ register int mix;
+
+ for ( j = 0; j < width; j ++ )
+ {
+ a = *alpha_b ++ ^ *alpha_a;
+ mix = ( luma == NULL ) ? weight : smoothstep( luma[ j ], luma[ j ] + softness, weight + softness );
+ mix = ( mix * a ) >> 8;
+ *dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ dest++;
+ *dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ dest++;
+ *alpha_a = mix | *alpha_a;
+ alpha_a ++;
+ }
+}
+
/** Composite function.
*/
int normalised_height = geometry->item.h;
int real_width = get_value( b_props, "real_width", "width" );
int real_height = get_value( b_props, "real_height", "height" );
- double input_ar = mlt_frame_get_aspect_ratio( b_frame );
+ double input_ar = mlt_properties_get_double( b_props, "aspect_ratio" );
double output_ar = mlt_properties_get_double( b_props, "consumer_aspect_ratio" );
- if ( input_ar == 0.0 ) input_ar = output_ar;
- int scaled_width = input_ar / output_ar * real_width;
+ int scaled_width = ( input_ar == 0.0 ? output_ar : input_ar ) / output_ar * real_width;
int scaled_height = real_height;
-
+
// Now ensure that our images fit in the normalised frame
if ( scaled_width > normalised_width )
{
// Honour the fill request - this will scale the image to fill width or height while maintaining a/r
// ????: Shouln't this be the default behaviour?
- if ( mlt_properties_get_int( properties, "fill" ) )
+ if ( mlt_properties_get_int( properties, "fill" ) && scaled_width > 0 && scaled_height > 0 )
{
if ( scaled_height < normalised_height && scaled_width * normalised_height / scaled_height < normalised_width )
{
uint8_t *image = mlt_properties_get_data( a_props, "image", NULL );
int width = mlt_properties_get_int( a_props, "width" );
int height = mlt_properties_get_int( a_props, "height" );
+ int format = mlt_properties_get_int( a_props, "format" );
// Pointers for copy operation
uint8_t *p;
// Will need to know region to copy
struct geometry_s result;
- double delta = delta_calculate( this, a_frame );
+ double delta = delta_calculate( this, a_frame, frame_position );
// Calculate the region now
composite_calculate( this, &result, a_frame, position + delta / 2 );
mlt_properties_set_data( b_props, "image", dest, w * h * 2, mlt_pool_release, NULL );
mlt_properties_set_int( b_props, "width", w );
mlt_properties_set_int( b_props, "height", h );
+ mlt_properties_set_int( b_props, "format", format );
if ( y < 0 )
{
mlt_transition this = mlt_frame_pop_service( a_frame );
// Get in and out
+ double position = mlt_deque_pop_back_double( MLT_FRAME_IMAGE_STACK( a_frame ) );
int out = mlt_frame_pop_service_int( a_frame );
int in = mlt_frame_pop_service_int( a_frame );
struct geometry_s result;
// Calculate the position
- double position = mlt_properties_get_double( b_props, "relative_position" );
- double delta = delta_calculate( this, a_frame );
+ double delta = delta_calculate( this, a_frame, position );
// Get the image from the b frame
uint8_t *image_b = NULL;
int width_b = *width;
int height_b = *height;
+ // Vars for alphas
+ uint8_t *alpha_a = NULL;
+ uint8_t *alpha_b = NULL;
+
+ // Composites always need scaling... defaulting to lowest
+ char *rescale = mlt_properties_get( a_props, "rescale.interp" );
+ if ( rescale == NULL || !strcmp( rescale, "none" ) )
+ rescale = "nearest";
+ mlt_properties_set( a_props, "rescale.interp", rescale );
+ mlt_properties_set( b_props, "rescale.interp", rescale );
+
// Do the calculation
+ // NB: Locks needed here since the properties are being modified
+ mlt_service_lock( MLT_TRANSITION_SERVICE( this ) );
composite_calculate( this, &result, a_frame, position );
+ mlt_service_unlock( MLT_TRANSITION_SERVICE( this ) );
// Since we are the consumer of the b_frame, we must pass along these
// consumer properties from the a_frame
mlt_properties_set_double( b_props, "consumer_deinterlace", mlt_properties_get_double( a_props, "consumer_deinterlace" ) );
+ mlt_properties_set( b_props, "consumer_deinterlace_method", mlt_properties_get( a_props, "consumer_deinterlace_method" ) );
mlt_properties_set_double( b_props, "consumer_aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
- mlt_properties_set_int( b_props, "normalised_width", mlt_properties_get_double( a_props, "normalised_width" ) );
- mlt_properties_set_int( b_props, "normalised_height", mlt_properties_get_double( a_props, "normalised_height" ) );
// TODO: Dangerous/temporary optimisation - if nothing to do, then do nothing
if ( mlt_properties_get_int( properties, "no_alpha" ) &&
return 0;
}
+ if ( a_frame == b_frame )
+ {
+ double aspect_ratio = mlt_frame_get_aspect_ratio( b_frame );
+ get_b_frame_image( this, b_frame, &image_b, &width_b, &height_b, &result );
+ alpha_b = mlt_frame_get_alpha_mask( b_frame );
+ mlt_properties_set_double( a_props, "aspect_ratio", aspect_ratio );
+ }
+
// Get the image from the a frame
mlt_frame_get_image( a_frame, image, format, width, height, 1 );
+ alpha_a = mlt_frame_get_alpha_mask( a_frame );
// Optimisation - no compositing required
if ( result.item.mix == 0 || ( result.item.w == 0 && result.item.h == 0 ) )
height_b = mlt_properties_get_int( a_props, "dest_height" );
}
- if ( get_b_frame_image( this, b_frame, &image_b, &width_b, &height_b, &result ) == 0 )
+ if ( *image != image_b && ( image_b != NULL || get_b_frame_image( this, b_frame, &image_b, &width_b, &height_b, &result ) == 0 ) )
{
uint8_t *dest = *image;
uint8_t *src = image_b;
- uint8_t *alpha_b = mlt_frame_get_alpha_mask( b_frame );
- uint8_t *alpha_a = mlt_frame_get_alpha_mask( a_frame );
int progressive =
mlt_properties_get_int( a_props, "consumer_deinterlace" ) ||
mlt_properties_get_int( properties, "progressive" );
int32_t luma_softness = mlt_properties_get_double( properties, "softness" ) * ( 1 << 16 );
uint16_t *luma_bitmap = get_luma( properties, width_b, height_b );
+ char *operator = mlt_properties_get( properties, "operator" );
+
+ alpha_b = alpha_b == NULL ? mlt_frame_get_alpha_mask( b_frame ) : alpha_b;
+
composite_line_fn line_fn = composite_line_yuv;
+ // Silly - this isn't a good solution - deprecating
if ( mlt_properties_get_int( properties, "or" ) )
line_fn = composite_line_yuv_or;
+ if ( mlt_properties_get_int( properties, "and" ) )
+ line_fn = composite_line_yuv_and;
+ if ( mlt_properties_get_int( properties, "xor" ) )
+ line_fn = composite_line_yuv_xor;
+ // Replacement and override
+ if ( operator != NULL )
+ {
+ if ( !strcmp( operator, "or" ) )
+ line_fn = composite_line_yuv_or;
+ if ( !strcmp( operator, "and" ) )
+ line_fn = composite_line_yuv_and;
+ if ( !strcmp( operator, "xor" ) )
+ line_fn = composite_line_yuv_xor;
+ }
+
+ // Allow the user to completely obliterate the alpha channels from both frames
if ( mlt_properties_get( properties, "alpha_a" ) )
memset( alpha_a, mlt_properties_get_int( properties, "alpha_a" ), *width * *height );
double field_position = position + field * delta;
// Do the calculation if we need to
+ // NB: Locks needed here since the properties are being modified
+ mlt_service_lock( MLT_TRANSITION_SERVICE( this ) );
composite_calculate( this, &result, a_frame, field_position );
+ mlt_service_unlock( MLT_TRANSITION_SERVICE( this ) );
if ( mlt_properties_get_int( properties, "titles" ) )
{
static mlt_frame composite_process( mlt_transition this, mlt_frame a_frame, mlt_frame b_frame )
{
- // Get a unique name to store the frame position
- char *name = mlt_properties_get( MLT_TRANSITION_PROPERTIES( this ), "_unique_id" );
-
// UGH - this is a TODO - find a more reliable means of obtaining in/out for the always_active case
if ( mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( this ), "always_active" ) == 0 )
{
mlt_frame_push_service_int( a_frame, mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( this ), "in" ) );
mlt_frame_push_service_int( a_frame, mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( this ), "out" ) );
-
- // Assign the current position to the name
- mlt_properties_set_position( MLT_FRAME_PROPERTIES( a_frame ), name, mlt_frame_get_position( a_frame ) );
-
- // Propogate the transition properties to the b frame
- mlt_properties_set_double( MLT_FRAME_PROPERTIES( b_frame ), "relative_position", position_calculate( this, mlt_frame_get_position( a_frame ) ) );
+ mlt_deque_push_back_double( MLT_FRAME_IMAGE_STACK( a_frame ), position_calculate( this, mlt_frame_get_position( a_frame ) ) );
}
else
{
mlt_properties props = mlt_properties_get_data( MLT_FRAME_PROPERTIES( b_frame ), "_producer", NULL );
mlt_frame_push_service_int( a_frame, mlt_properties_get_int( props, "in" ) );
mlt_frame_push_service_int( a_frame, mlt_properties_get_int( props, "out" ) );
- mlt_properties_set_int( MLT_FRAME_PROPERTIES( b_frame ), "relative_position", mlt_properties_get_int( props, "_frame" ) - mlt_properties_get_int( props, "in" ) );
-
- // Assign the current position to the name
- mlt_properties_set_position( MLT_FRAME_PROPERTIES( a_frame ), name, mlt_properties_get_position( MLT_FRAME_PROPERTIES( b_frame ), "relative_position" ) );
+ mlt_deque_push_back_double( MLT_FRAME_IMAGE_STACK( a_frame ), mlt_properties_get_int( props, "_frame" ) - mlt_properties_get_int( props, "in" ) );
}
mlt_frame_push_service( a_frame, this );