src/framework/mlt_frame.c

+ Corrections for resizing images and alpha (uneven widths)

src/framework/mlt_tractor.c
+ Added an output aspect ratio (being the aspect ratio of the background)

src/modules/core/filter_rescale.c
+ Force a rescale of the alpha in parallel with image

src/modules/core/filter_resize.c
+ Rounding errors corrections

src/modules/core/filter_watermark.c
+ Propogation of output aspect ratio in reverse case

src/modules/core/producer_colour.c
+ Reassign aspect ratio after get_image

src/modules/core/transition_composite.c
+ More uneven width corrections
+ Use of output aspect ratio when available

src/modules/feeds/PAL/etv.properties
+ Temporary work around to keep composites correct

git-svn-id: https://mlt.svn.sourceforge.net/svnroot/mlt/trunk/mlt@833 d19143bc-622f-0410-bfdd-b5b2a6649095

diff --git a/src/framework/mlt_frame.c b/src/framework/mlt_frame.c
index 1e080fa80948876d87860459fbc249ab595cc79e..2ee3569da342070254fa3037b5e2bd423f5529c2 100644 (file)
--- a/src/framework/mlt_frame.c
+++ b/src/framework/mlt_frame.c
@@ -429,10 +429,10 @@ int mlt_frame_get_audio( mlt_frame this, int16_t **buffer, mlt_audio_format *for
        if ( mlt_properties_get( properties, "meta.volume" ) )
        {
                double value = mlt_properties_get_double( properties, "meta.volume" );
+
                if ( value == 0.0 )
                {
                        memset( *buffer, 0, *samples * *channels * 2 );
-                       mlt_properties_set_double( properties, "meta.volume", 1.0 );
                }
                else if ( value != 1.0 )
                {
@@ -443,8 +443,9 @@ int mlt_frame_get_audio( mlt_frame this, int16_t **buffer, mlt_audio_format *for
                                *p = *p * value;
                                p ++;
                        }
-                       mlt_properties_set_double( properties, "meta.volume", 1.0 );
                }
+
+               mlt_properties_set( properties, "meta.volume", NULL );
        }
 
        return 0;
@@ -643,23 +644,27 @@ uint8_t *mlt_resize_alpha( uint8_t *input, int owidth, int oheight, int iwidth,
 
        if ( input != NULL && ( iwidth != owidth || iheight != oheight ) && ( owidth > 6 && oheight > 6 ) )
        {
-               uint8_t *in_line = input;
                uint8_t *out_line;
+               int offset_x = ( owidth - iwidth ) / 2;
+               int offset_y = ( oheight - iheight ) / 2;
+               int iused = iwidth;
 
                output = mlt_pool_alloc( owidth * oheight );
                memset( output, 0, owidth * oheight );
 
-               out_line = output + ( ( oheight - iheight ) / 2 ) * owidth;
-               out_line += 2 * ( int )( ( owidth - iwidth ) / 2 );
+               offset_x -= offset_x % 2;
+
+               out_line = output + offset_y * owidth;
+               out_line += offset_x;
 
                // Loop for the entirety of our output height.
                while ( iheight -- )
                {
                        // We're in the input range for this row.
-                       memcpy( out_line, input, iwidth );
+                       memcpy( out_line, input, iused );
 
                        // Move to next input line
-                       in_line += iwidth;
+                       input += iwidth;
 
                        // Move to next output line
                        out_line += owidth;
@@ -674,6 +679,12 @@ void mlt_resize_yuv422( uint8_t *output, int owidth, int oheight, uint8_t *input
        // Calculate strides
        int istride = iwidth * 2;
        int ostride = owidth * 2;
+       int offset_x = ( owidth - iwidth );
+       int offset_y = ( oheight - iheight ) / 2;
+       uint8_t *in_line = input;
+       uint8_t *out_line;
+       int size = owidth * oheight;
+       uint8_t *p = output;
 
        // Optimisation point
        if ( output == NULL || input == NULL || ( owidth <= 6 || oheight <= 6 || iwidth <= 6 || oheight <= 6 ) )
@@ -686,26 +697,22 @@ void mlt_resize_yuv422( uint8_t *output, int owidth, int oheight, uint8_t *input
                return;
        }
 
-       uint8_t *in_line = input;
-       uint8_t *out_line;
-
-       int size = owidth * oheight;
-       uint8_t *p = output;
-
        while( size -- )
        {
                *p ++ = 16;
                *p ++ = 128;
        }
 
-       out_line = output + ( ( oheight - iheight ) / 2 ) * ostride;
-       out_line += 4 * ( int )( ( owidth - iwidth ) / 4 );
-               
+       offset_x -= offset_x % 4;
+
+       out_line = output + offset_y * ostride;
+       out_line += offset_x;
+
        // Loop for the entirety of our output height.
        while ( iheight -- )
        {
                // We're in the input range for this row.
-               memcpy( out_line, in_line, istride );
+               memcpy( out_line, in_line, iwidth * 2 );
 
                // Move to next input line
                in_line += istride;
@@ -749,7 +756,7 @@ uint8_t *mlt_frame_resize_yuv422( mlt_frame this, int owidth, int oheight )
                alpha = mlt_resize_alpha( alpha, owidth, oheight, iwidth, iheight );
                if ( alpha != NULL )
                {
-                       mlt_properties_set_data( properties, "alpha", alpha, owidth * ( oheight + 1 ), ( mlt_destructor )mlt_pool_release, NULL );
+                       mlt_properties_set_data( properties, "alpha", alpha, owidth * oheight, ( mlt_destructor )mlt_pool_release, NULL );
                        this->get_alpha_mask = NULL;
                }
 

diff --git a/src/framework/mlt_tractor.c b/src/framework/mlt_tractor.c
index b044873bfb840d30f65e77949b8c86941f2fbdbd..094352e32678ccb70ef7959dbabaec3f91dcc304 100644 (file)
--- a/src/framework/mlt_tractor.c
+++ b/src/framework/mlt_tractor.c
@@ -389,6 +389,11 @@ static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int tra
                                        video = temp;
                                        if ( first_video == NULL )
                                                first_video = temp;
+
+                                       // Ensure that all frames know the aspect ratio of the background
+                                       mlt_properties_set_double( temp_properties, "output_ratio", 
+                                                                                          mlt_properties_get_double( MLT_FRAME_PROPERTIES( first_video ), "aspect_ratio" ) );
+
                                        mlt_properties_set_int( MLT_FRAME_PROPERTIES( temp ), "image_count", ++ image_count );
                                        image_count = 1;
                                }

diff --git a/src/modules/core/filter_rescale.c b/src/modules/core/filter_rescale.c
index 0305db4174026f9d14811fccd1cd26dab1170b37..19b087f1ad86e018dbf97b5445b021fe6a19b004 100644 (file)
--- a/src/modules/core/filter_rescale.c
+++ b/src/modules/core/filter_rescale.c
@@ -25,6 +25,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <math.h>
 
 typedef int ( *image_scaler )( mlt_frame this, uint8_t **image, mlt_image_format iformat, mlt_image_format oformat, int iwidth, int iheight, int owidth, int oheight );
 
@@ -110,60 +111,26 @@ static int filter_scale( mlt_frame this, uint8_t **image, mlt_image_format iform
 
 static void scale_alpha( mlt_frame this, int iwidth, int iheight, int owidth, int oheight )
 {
-       int size = 0;
-       uint8_t *input = mlt_properties_get_data( MLT_FRAME_PROPERTIES( this ), "alpha", &size );
-       
-       if ( input != NULL && ( ( size == iwidth * iheight ) || size == ( iwidth * ( iheight + 1 ) ) ) )
+       uint8_t *output = NULL;
+       uint8_t *input = mlt_frame_get_alpha_mask( this );
+
+       if ( input != NULL )
        {
-               uint8_t *output = mlt_pool_alloc( owidth * oheight );
-
-               // Derived coordinates
-               int dy, dx;
-
-       // Calculate ranges
-       int out_x_range = owidth / 2;
-       int out_y_range = oheight / 2;
-       int in_x_range = iwidth / 2;
-       int in_y_range = iheight / 2;
-
-       // Output pointers
-       register uint8_t *out_line = output;
-       register uint8_t *out_ptr;
-
-       // Calculate a middle pointer
-       uint8_t *in_middle = input + iwidth * in_y_range + in_x_range;
-       uint8_t *in_line;
-
-               // Generate the affine transform scaling values
-               register int scale_width = ( iwidth << 16 ) / owidth;
-               register int scale_height = ( iheight << 16 ) / oheight;
-               register int base = 0;
-
-               int outer = out_x_range * scale_width;
-               int bottom = out_y_range * scale_height;
-
-       // Loop for the entirety of our output height.
-       for ( dy = - bottom; dy < bottom; dy += scale_height )
-       {
-               // Start at the beginning of the line
-               out_ptr = out_line;
-       
-               // Pointer to the middle of the input line
-               in_line = in_middle + ( dy >> 16 ) * iwidth;
-
-               // Loop for the entirety of our output row.
-               for ( dx = - outer; dx < outer; dx += scale_width )
-               {
-                               base = dx >> 15;
-                               *out_ptr ++ = *( in_line + base );
-               }
-
-               // Move to next output line
-               out_line += owidth;
-       }
-
-               this->get_alpha_mask = NULL;
-               mlt_properties_set_data( MLT_FRAME_PROPERTIES( this ), "alpha", output, 0, mlt_pool_release, NULL );
+               uint8_t *out_line;
+               int x, y;
+               int ox = ( iwidth << 10 ) / owidth;
+               int oy = ( iheight << 10 ) / oheight;
+
+               output = mlt_pool_alloc( owidth * oheight );
+               out_line = output;
+
+               // Loop for the entirety of our output height.
+               for ( y = 0; y < oheight; y ++ )
+                       for ( x = 0; x < owidth; x ++ )
+                               *out_line ++ = *( input + ( ( 512 + ( y * oy * iwidth ) + x * ox ) >> 10 ) );
+
+               // Set it back on the frame
+               mlt_properties_set_data( MLT_FRAME_PROPERTIES( this ), "alpha", output, owidth * oheight, mlt_pool_release, NULL );
        }
 }
 
@@ -224,7 +191,7 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
                else
                {
                        // When no scaling is requested, revert the requested dimensions if possible
-                       mlt_properties_set_int( properties, "rescale_width", ( iwidth / 2 ) * 2 );
+                       mlt_properties_set_int( properties, "rescale_width", iwidth );
                        mlt_properties_set_int( properties, "rescale_height", iheight );
                }
        
@@ -285,6 +252,8 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
                }
                else
                {
+                               // Scale the alpha
+                               scale_alpha( this, iwidth, iheight, owidth, oheight );
                        *width = iwidth;
                        *height = iheight;
                }

diff --git a/src/modules/core/filter_resize.c b/src/modules/core/filter_resize.c
index 8ad0210f827d2775f666e8ccb40ebd8e370ddb54..c82423aa11cdd3cfc22d3f7502bc56d766c59344 100644 (file)
--- a/src/modules/core/filter_resize.c
+++ b/src/modules/core/filter_resize.c
@@ -25,6 +25,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <math.h>
 
 /** Do it :-).
 */
@@ -75,19 +76,19 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
                //fprintf( stderr, "normalised %dx%d output %dx%d %f %f\n", normalised_width, normalised_height, owidth, oheight, ( float )output_ar, ( float )mlt_properties_get_double( properties, "consumer_aspect_ratio" ) * owidth / oheight );
 
                // Optimised for the input_ar > output_ar case (e.g. widescreen on standard)
-               int scaled_width = ( input_ar * normalised_width ) / output_ar + 0.5;
+               int scaled_width = rint( 0.5 + ( 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 = ( output_ar * normalised_height ) / input_ar + 0.5;
+                       scaled_height = rint( 0.5 + ( output_ar * normalised_height ) / input_ar );
                }
 
                // Now calculate the actual image size that we want
-               owidth = scaled_width * owidth / normalised_width;
-               oheight = scaled_height * oheight / normalised_height;
+               owidth = rint( 0.5 + scaled_width * owidth / normalised_width );
+               oheight = rint( 0.5 + scaled_height * oheight / normalised_height );
 
                // Tell frame we have conformed the aspect to the consumer
                mlt_frame_set_aspect_ratio( this, mlt_properties_get_double( properties, "consumer_aspect_ratio" ) );

diff --git a/src/modules/core/filter_watermark.c b/src/modules/core/filter_watermark.c
index 1ca0b8be1e040bde51fbd8c64c1e3daa7dc84d74..d9506e4ce62fe3392f5ac521bbbd6ba3d68e64b6 100644 (file)
--- a/src/modules/core/filter_watermark.c
+++ b/src/modules/core/filter_watermark.c
@@ -146,6 +146,7 @@ static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format
                        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_double( a_props, "consumer_deinterlace" ) );
+                       mlt_properties_set_int( 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 )

diff --git a/src/modules/core/producer_colour.c b/src/modules/core/producer_colour.c
index 9f504f767c81aad8fd96811e705f2857929ee333..725570b971db25e7dbf831f131e44a5c2fee211c 100644 (file)
--- a/src/modules/core/producer_colour.c
+++ b/src/modules/core/producer_colour.c
@@ -198,6 +198,7 @@ static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_form
                // Now update properties so we free the copy after
                mlt_properties_set_data( properties, "image", copy, size, mlt_pool_release, NULL );
                mlt_properties_set_data( properties, "alpha", alpha, size >> 1, mlt_pool_release, NULL );
+               mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( producer_props, "aspect_ratio" ) );
        }
 
        // Pass on the image

diff --git a/src/modules/core/transition_composite.c b/src/modules/core/transition_composite.c
index 11fd958569f87d3bac74773acded53a3f14ddace..64694814739cbe10aab87ba8b0e124078fb13841 100644 (file)
--- a/src/modules/core/transition_composite.c
+++ b/src/modules/core/transition_composite.c
@@ -375,31 +375,19 @@ static void composite_line_yuv( uint8_t *dest, uint8_t *src, int width, uint8_t
        register int j;
        register int a;
        register int mix;
-       int uneven_w = width % 2;
 
        for ( j = 0; j < width; j ++ )
        {
                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 = ( ( *src++ + uneven_x ) * mix + *dest * ( ( 1 << 16 ) - mix ) ) >> 16;
                dest++;
                *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, int uneven_x )
@@ -407,7 +395,6 @@ static void composite_line_yuv_or( uint8_t *dest, uint8_t *src, int width, uint8
        register int j;
        register int a;
        register int mix;
-       int uneven_w = width % 2;
 
        for ( j = 0; j < width; j ++ )
        {
@@ -421,17 +408,6 @@ static void composite_line_yuv_or( uint8_t *dest, uint8_t *src, int width, uint8
                *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, int uneven_x )
@@ -439,7 +415,6 @@ static void composite_line_yuv_and( uint8_t *dest, uint8_t *src, int width, uint
        register int j;
        register int a;
        register int mix;
-       int uneven_w = width % 2;
 
        for ( j = 0; j < width; j ++ )
        {
@@ -453,17 +428,6 @@ static void composite_line_yuv_and( uint8_t *dest, uint8_t *src, int width, uint
                *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, int uneven_x )
@@ -471,7 +435,6 @@ static void composite_line_yuv_xor( uint8_t *dest, uint8_t *src, int width, uint
        register int j;
        register int a;
        register int mix;
-       int uneven_w = width % 2;
 
        for ( j = 0; j < width; j ++ )
        {
@@ -485,17 +448,6 @@ static void composite_line_yuv_xor( uint8_t *dest, uint8_t *src, int width, uint
                *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.
@@ -588,9 +540,6 @@ static int composite_yuv( uint8_t *p_dest, int width_dest, int height_dest, uint
        int alpha_b_stride = stride_src / bpp;
        int alpha_a_stride = stride_dest / bpp;
 
-       // Incorrect, but keeps noise away?
-       height_src --;
-
        // now do the compositing only to cropped extents
        for ( i = 0; i < height_src; i += step )
        {
@@ -776,19 +725,21 @@ static int get_b_frame_image( mlt_transition this, mlt_frame b_frame, uint8_t **
                int real_width = get_value( b_props, "real_width", "width" );
                int real_height = get_value( b_props, "real_height", "height" );
                double input_ar = mlt_properties_get_double( b_props, "aspect_ratio" );
-               double output_ar = mlt_properties_get_double( b_props, "consumer_aspect_ratio" );
-               int scaled_width = ( input_ar == 0.0 ? output_ar : input_ar ) / output_ar * real_width;
+               double consumer_ar = mlt_properties_get_double( b_props, "consumer_aspect_ratio" );
+               double background_ar = mlt_properties_get_double( b_props, "output_ratio" );
+               double output_ar = background_ar != 0.0 ? background_ar : consumer_ar;
+               int scaled_width = rint( 0.5 + ( 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 )
                {
-                       scaled_height = scaled_height * normalised_width / scaled_width;
+                       scaled_height = rint( 0.5 + scaled_height * normalised_width / scaled_width );
                        scaled_width = normalised_width;
                }
                if ( scaled_height > normalised_height )
                {
-                       scaled_width = scaled_width * normalised_height / scaled_height;
+                       scaled_width = rint( 0.5 + scaled_width * normalised_height / scaled_height );
                        scaled_height = normalised_height;
                }
 
@@ -798,12 +749,12 @@ static int get_b_frame_image( mlt_transition this, mlt_frame b_frame, uint8_t **
                {
                        if ( scaled_height < normalised_height && scaled_width * normalised_height / scaled_height < normalised_width )
                        {
-                               scaled_width = scaled_width * normalised_height / scaled_height;
+                               scaled_width = rint( 0.5 + scaled_width * normalised_height / scaled_height );
                                scaled_height = normalised_height;
                        }
                        else if ( scaled_width < normalised_width && scaled_height * normalised_width / scaled_width < normalised_height )
                        {
-                               scaled_height = scaled_height * normalised_width / scaled_width;
+                               scaled_height = rint( 0.5 + scaled_height * normalised_width / scaled_width );
                                scaled_width = normalised_width;
                        }
                }
@@ -819,15 +770,15 @@ static int get_b_frame_image( mlt_transition this, mlt_frame b_frame, uint8_t **
        }
 
        // We want to ensure that we bypass resize now...
-       mlt_properties_set_int( b_props, "distort", 1 );
+       mlt_properties_set_int( b_props, "distort", mlt_properties_get_int( properties, "distort" ) );
 
-       // Take into consideration alignment for optimisation
+       // Take into consideration alignment for optimisation (titles are a special case)
        if ( !mlt_properties_get_int( properties, "titles" ) )
                alignment_calculate( geometry );
 
        // Adjust to consumer scale
-       *width = geometry->sw * *width / geometry->nw;
-       *height = geometry->sh * *height / geometry->nh;
+       *width = rint( 0.5 + geometry->sw * *width / geometry->nw );
+       *height = rint( 0.5 + geometry->sh * *height / geometry->nh );
 
        ret = mlt_frame_get_image( b_frame, image, &format, width, height, 1 );
 
@@ -895,16 +846,6 @@ static mlt_geometry composite_calculate( mlt_transition this, struct geometry_s
        return start;
 }
 
-static inline void inline_memcpy( uint8_t *dest, uint8_t *src, int length )
-{
-       uint8_t *end = src + length;
-       while ( src < end )
-       {
-               *dest ++ = *src ++;
-               *dest ++ = *src ++;
-       }
-}
-
 mlt_frame composite_copy_region( mlt_transition this, mlt_frame a_frame, mlt_position frame_position )
 {
        // Create a frame to return
@@ -1004,7 +945,7 @@ mlt_frame composite_copy_region( mlt_transition this, mlt_frame a_frame, mlt_pos
 
                while ( h -- )
                {
-                       inline_memcpy( dest, p, w * 2 );
+                       memcpy( dest, p, w * 2 );
                        dest += ds;
                        p += ss;
                }
@@ -1188,9 +1129,9 @@ static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_f
 
                                if ( mlt_properties_get_int( properties, "titles" ) )
                                {
-                                       result.item.w = *width * ( result.item.w / result.nw );
+                                       result.item.w = rint( 0.5 + *width * ( result.item.w / result.nw ) );
                                        result.nw = result.item.w;
-                                       result.item.h = *height * ( result.item.h / result.nh );
+                                       result.item.h = rint( 0.5 + *height * ( result.item.h / result.nh ) );
                                        result.nh = *height;
                                        result.sw = width_b;
                                        result.sh = height_b;
@@ -1258,10 +1199,6 @@ mlt_transition transition_composite_init( char *arg )
 
                // Inform apps and framework that this is a video only transition
                mlt_properties_set_int( properties, "_transition_type", 1 );
-
-#ifdef USE_MMX
-               //mlt_properties_set_int( properties, "_MMX", composite_have_mmx() );
-#endif
        }
        return this;
 }

diff --git a/src/modules/feeds/PAL/etv.properties b/src/modules/feeds/PAL/etv.properties
index e6993989747176e2e3cb2a6e4ab9901276ca740f..07be453bbcb8d438a8041db61eef1be789f3823a 100644 (file)
--- a/src/modules/feeds/PAL/etv.properties
+++ b/src/modules/feeds/PAL/etv.properties
@@ -25,6 +25,7 @@ location=region
 .composite.softness=.3
 .filter[0]=watermark
 .filter[0].resource=colour:0x6c0101ff
+.filter[0].composite.distort=1
 .filter[1]=watermark
 .filter[1].resource=pango:
 .filter[1].producer.text=
@@ -47,6 +48,7 @@ courtesy=region
 .composite.softness=.3
 .filter[0]=watermark
 .filter[0].resource=colour:0x6c0101ff
+.filter[0].composite.distort=1
 .filter[1]=watermark
 .filter[1].resource=pango:
 .filter[1].producer.text=
@@ -67,6 +69,7 @@ exclusive=region
 .composite.geometry=-230,115:230x30;12=0
 .filter[0]=watermark
 .filter[0].resource=colour:0x6c0101ff
+.filter[0].composite.distort=1
 .filter[1]=watermark
 .filter[1].resource=pango:
 .filter[1].producer.text=ETV Exclusive
@@ -87,6 +90,7 @@ file_shot=region
 .composite.geometry=590,160:80x25:0;12=,:x:100
 .filter[0]=watermark
 .filter[0].resource=colour:0x6c0101ff
+.filter[0].composite.distort=1
 .filter[1]=watermark
 .filter[1].resource=pango:
 .filter[1].producer.text=File Shot
@@ -108,6 +112,7 @@ special=region
 .filter[0]=watermark
 .filter[0].resource=colour:0x6c0101ff
 .filter[0].composite.geometry=100%,0%:100%x100%:0;12=0%,0%:x:100
+.filter[0].composite.distort=1
 .filter[1]=watermark
 .filter[1].resource=pango:
 .filter[1].producer.text=Special
@@ -158,6 +163,7 @@ super=region
 .filter[0]=watermark
 .filter[0].resource=colour:0xbbbbbbff
 .filter[0].composite.geometry=0,0:100%:100%:70
+.filter[0].composite.distort=1
 .filter[1]=watermark
 .filter[1].resource=pango:
 .filter[1].producer.text=