#include <string.h>
#include <math.h>
-typedef void ( *composite_line_fn )( uint8_t *dest, uint8_t *src, int width_src, uint8_t *alpha_b, uint8_t *alpha_a, int weight, uint16_t *luma, int softness );
+typedef void ( *composite_line_fn )( uint8_t *dest, uint8_t *src, int width_src, uint8_t *alpha_b, uint8_t *alpha_a, int weight, uint16_t *luma, int softness, int uneven );
/** Geometry struct.
*/
/** Composite a source line over a destination line
*/
-static void composite_line_yuv( uint8_t *dest, uint8_t *src, int width, uint8_t *alpha_b, uint8_t *alpha_a, int weight, uint16_t *luma, int softness )
+static void composite_line_yuv( uint8_t *dest, uint8_t *src, int width, uint8_t *alpha_b, uint8_t *alpha_a, int weight, uint16_t *luma, int softness, int uneven_x )
{
register int j;
register int a;
register int mix;
-
+ int uneven_w = width % 2;
+
for ( j = 0; j < width; j ++ )
{
a = *alpha_b ++;
mix = ( mix * a ) >> 8;
*dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
dest++;
- *dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ *dest = ( *( src ++ + uneven_x ) * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ dest++;
+ *alpha_a = mix | *alpha_a;
+ alpha_a ++;
+ }
+
+ if ( uneven_w )
+ {
+ a = *alpha_b ++;
+ 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++;
*alpha_a = mix | *alpha_a;
alpha_a ++;
}
}
-static void composite_line_yuv_or( uint8_t *dest, uint8_t *src, int width, uint8_t *alpha_b, uint8_t *alpha_a, int weight, uint16_t *luma, int softness )
+static void composite_line_yuv_or( uint8_t *dest, uint8_t *src, int width, uint8_t *alpha_b, uint8_t *alpha_a, int weight, uint16_t *luma, int softness, int uneven_x )
{
register int j;
register int a;
register int mix;
-
+ int uneven_w = width % 2;
+
for ( j = 0; j < width; j ++ )
{
a = *alpha_b ++ | *alpha_a;
mix = ( mix * a ) >> 8;
*dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
dest++;
- *dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ *dest = ( *( src ++ + uneven_x ) * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
dest++;
*alpha_a = mix | *alpha_a;
alpha_a ++;
}
+
+ if ( uneven_w )
+ {
+ a = *alpha_b ++ | *alpha_a;
+ mix = ( luma == NULL ) ? weight : smoothstep( luma[ j ], luma[ j ] + softness, weight + softness );
+ mix = ( mix * a ) >> 8;
+ *dest = ( *( src ++ + uneven_x ) * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ dest++;
+ *alpha_a = mix | *alpha_a;
+ alpha_a ++;
+ }
}
-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 )
+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, int uneven_x )
{
register int j;
register int a;
register int mix;
-
+ int uneven_w = width % 2;
+
for ( j = 0; j < width; j ++ )
{
a = *alpha_b ++ & *alpha_a;
mix = ( mix * a ) >> 8;
*dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
dest++;
- *dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ *dest = ( *( src ++ ) * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
dest++;
*alpha_a = mix | *alpha_a;
alpha_a ++;
}
+
+ if ( uneven_w )
+ {
+ 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++;
+ *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 )
+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, int uneven_x )
{
register int j;
register int a;
register int mix;
-
+ int uneven_w = width % 2;
+
for ( j = 0; j < width; j ++ )
{
a = *alpha_b ++ ^ *alpha_a;
mix = ( mix * a ) >> 8;
*dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
dest++;
- *dest = ( *src++ * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ *dest = ( *( src ++ + uneven_x ) * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
dest++;
*alpha_a = mix | *alpha_a;
alpha_a ++;
}
+
+ if ( uneven_w )
+ {
+ a = *alpha_b ++ ^ *alpha_a;
+ mix = ( luma == NULL ) ? weight : smoothstep( luma[ j ], luma[ j ] + softness, weight + softness );
+ mix = ( mix * a ) >> 8;
+ *dest = ( *( src ++ + uneven_x ) * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
+ dest++;
+ *alpha_a = mix | *alpha_a;
+ alpha_a ++;
+ }
}
/** Composite function.
// Adjust to consumer scale
int x = rint( 0.5 + geometry.item.x * width_dest / geometry.nw );
int y = rint( 0.5 + geometry.item.y * height_dest / geometry.nh );
- int x_uneven = x & 1;
+ int uneven_x = 2 * ( x % 2 );
// optimization points - no work to do
if ( width_src <= 0 || height_src <= 0 )
int alpha_b_stride = stride_src / bpp;
int alpha_a_stride = stride_dest / bpp;
- // Make sure than x and w are even
- if ( x_uneven )
- {
- p_src += 2;
- width_src --;
- alpha_a ++;
- }
+ // Incorrect, but keeps noise away?
+ height_src --;
// now do the compositing only to cropped extents
for ( i = 0; i < height_src; i += step )
{
- line_fn( p_dest, p_src, width_src, alpha_b, alpha_a, weight, p_luma, softness );
+ line_fn( p_dest, p_src, width_src, alpha_b, alpha_a, weight, p_luma, softness, uneven_x );
p_src += stride_src;
p_dest += stride_dest;
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 )
{
int normalised_width = mlt_properties_get_int( a_props, "normalised_width" );
int normalised_height = mlt_properties_get_int( a_props, "normalised_height" );
- // Now parse the geometries
- if ( start == NULL )
- {
- // Parse the transitions properties
- start = transition_parse_keys( this, normalised_width, normalised_height );
+ char *name = mlt_properties_get( properties, "_unique_id" );
+ char key[ 256 ];
- // Assign to properties to ensure we get destroyed
- mlt_properties_set_data( properties, "geometries", start, 0, ( mlt_destructor )mlt_geometry_close, NULL );
+ sprintf( key, "%s.in", name );
+ if ( mlt_properties_get( a_props, key ) )
+ {
+ sscanf( mlt_properties_get( a_props, key ), "%f,%f,%f,%f,%f,%d,%d", &result->item.x, &result->item.y, &result->item.w, &result->item.h, &result->item.mix, &result->nw, &result->nh );
}
else
{
- int length = mlt_transition_get_out( this ) - mlt_transition_get_in( this ) + 1;
- double cycle = mlt_properties_get_double( properties, "cycle" );
- if ( cycle > 1 )
- length = cycle;
- else if ( cycle > 0 )
- length *= cycle;
- mlt_geometry_refresh( start, mlt_properties_get( properties, "geometry" ), length, normalised_width, normalised_height );
- }
+ // Now parse the geometries
+ if ( start == NULL )
+ {
+ // Parse the transitions properties
+ start = transition_parse_keys( this, normalised_width, normalised_height );
- // Do the calculation
- geometry_calculate( this, result, position );
+ // Assign to properties to ensure we get destroyed
+ mlt_properties_set_data( properties, "geometries", start, 0, ( mlt_destructor )mlt_geometry_close, NULL );
+ }
+ else
+ {
+ int length = mlt_transition_get_out( this ) - mlt_transition_get_in( this ) + 1;
+ double cycle = mlt_properties_get_double( properties, "cycle" );
+ if ( cycle > 1 )
+ length = cycle;
+ else if ( cycle > 0 )
+ length *= cycle;
+ mlt_geometry_refresh( start, mlt_properties_get( properties, "geometry" ), length, normalised_width, normalised_height );
+ }
- // Assign normalised info
- result->nw = normalised_width;
- result->nh = normalised_height;
+ // Do the calculation
+ geometry_calculate( this, result, position );
+
+ // Assign normalised info
+ result->nw = normalised_width;
+ result->nh = normalised_height;
+ }
// Now parse the alignment
result->halign = alignment_parse( mlt_properties_get( properties, "halign" ) );
// Get the position
int position = position_calculate( this, frame_position );
+ // Get the unique id of the transition
+ char *name = mlt_properties_get( MLT_TRANSITION_PROPERTIES( this ), "_unique_id" );
+ char key[ 256 ];
+
// Destination image
uint8_t *dest = NULL;
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, frame_position );
-
// Calculate the region now
- composite_calculate( this, &result, a_frame, position + delta / 2 );
+ composite_calculate( this, &result, a_frame, position );
// Need to scale down to actual dimensions
x = rint( 0.5 + result.item.x * width / result.nw );
w = rint( 0.5 + result.item.w * width / result.nw );
h = rint( 0.5 + result.item.h * height / result.nh );
- // Make sure that x and w are even
- if ( x & 1 )
+ if ( x % 2 )
{
x --;
- w += 2;
- if ( w & 1 )
- w --;
- }
- else if ( w & 1 )
- {
w ++;
}
+ // Store the key
+ sprintf( key, "%s.in=%d,%d,%d,%d,%f,%d,%d", name, x, y, w, h, result.item.mix, width, height );
+ mlt_properties_parse( a_props, key );
+ sprintf( key, "%s.out=%d,%d,%d,%d,%f,%d,%d", name, x, y, w, h, result.item.mix, width, height );
+ mlt_properties_parse( a_props, key );
+
ds = w * 2;
ss = width * 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_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" ) &&
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
height_b = mlt_properties_get_int( a_props, "dest_height" );
}
- if ( image_b != NULL || 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;
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;
- 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" ) )
{
projects / mlt / blobdiff