audio mix and repeated frames

[melted] / src / modules / plus / transition_affine.c

diff --git a/src/modules/plus/transition_affine.c b/src/modules/plus/transition_affine.c
index e04f9ff..a8c92d0 100644 (file)
--- a/src/modules/plus/transition_affine.c
+++ b/src/modules/plus/transition_affine.c
@@ -407,18 +407,18 @@ static void affine_offset( float this[3][3], int x, int y )
 }
 
 // Obtain the mapped x coordinate of the input
-static inline int MapX( float this[3][3], int x, int y )
+static inline double MapX( float this[3][3], int x, int y )
 {
        return this[0][0] * x + this[0][1] * y + this[0][2];
 }
 
 // Obtain the mapped y coordinate of the input
-static inline int MapY( float this[3][3], int x, int y )
+static inline double MapY( float this[3][3], int x, int y )
 {
        return this[1][0] * x + this[1][1] * y + this[1][2];
 }
 
-static inline float MapZ( float this[3][3], int x, int y )
+static inline double MapZ( float this[3][3], int x, int y )
 {
        return this[2][0] * x + this[2][1] * y + this[2][2];
 }
@@ -517,7 +517,7 @@ static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_f
        mlt_frame_get_image( a_frame, image, format, width, height, 1 );
 
        // Calculate the region now
-       composite_calculate( &result, this, a_frame, ( float )position / ( out - in + 1 ) );
+       composite_calculate( &result, this, a_frame, ( float )( position ) / ( out - in + 1 ) );
 
        // Fetch the b frame image
        result.w = ( int )( result.w * *width / result.nw );
@@ -550,10 +550,14 @@ static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_f
        {
                register int x, y;
                register int dx, dy;
+               double dz;
                float sw, sh;
 
                // Get values from the transition
-               float rotate_x = mlt_properties_get_double( properties, "rotate" );
+               float fix_rotate_x = mlt_properties_get_double( properties, "fix_rotate_x" );
+               float fix_rotate_y = mlt_properties_get_double( properties, "fix_rotate_y" );
+               float fix_rotate_z = mlt_properties_get_double( properties, "fix_rotate_z" );
+               float rotate_x = mlt_properties_get_double( properties, "rotate_x" );
                float rotate_y = mlt_properties_get_double( properties, "rotate_y" );
                float rotate_z = mlt_properties_get_double( properties, "rotate_z" );
                float fix_shear_x = mlt_properties_get_double( properties, "fix_shear_x" );
@@ -583,13 +587,15 @@ static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_f
                int y_offset = ( int )result.h >> 1;
 
                uint8_t *alpha = mlt_frame_get_alpha_mask( b_frame );
+               uint8_t *mask = mlt_pool_alloc( b_width * b_height );
+               uint8_t *pmask = mask;
                float mix;
 
                affine_t affine;
                affine_init( affine.matrix );
-               affine_rotate( affine.matrix, rotate_x * ( position - in ) );
-               affine_rotate_y( affine.matrix, rotate_y * ( position - in ) );
-               affine_rotate_z( affine.matrix, rotate_z * ( position - in ) );
+               affine_rotate( affine.matrix, fix_rotate_x + rotate_x * ( position - in ) );
+               affine_rotate_y( affine.matrix, fix_rotate_y + rotate_y * ( position - in ) );
+               affine_rotate_z( affine.matrix, fix_rotate_z + rotate_z * ( position - in ) );
                affine_shear( affine.matrix, 
                                          fix_shear_x + shear_x * ( position - in ), 
                                          fix_shear_y + shear_y * ( position - in ),
@@ -607,39 +613,52 @@ static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_f
 
                q = *image;
 
+               dz = MapZ( affine.matrix, 0, 0 );
+
+               if ( mask != NULL )
+                       memset( mask, 0, b_width * b_height );
+
                for ( y = lower_y; y < upper_y; y ++ )
                {
                        p = q;
 
                        for ( x = lower_x; x < upper_x; x ++ )
                        {
-                               dx = MapX( affine.matrix, x, y ) + x_offset;
-                               dy = MapY( affine.matrix, x, y ) + y_offset;
+                               dx = MapX( affine.matrix, x, y ) / dz + x_offset;
+                               dy = MapY( affine.matrix, x, y ) / dz + y_offset;
 
                                if ( dx >= 0 && dx < b_width && dy >=0 && dy < b_height )
                                {
                                        if ( alpha == NULL )
                                        {
-                                               dx -= dx & 1;
+                                               *pmask ++ = 255;
+                                               dx += dx & 1;
                                                *p ++ = *( b_image + dy * b_stride + ( dx << 1 ) );
                                                *p ++ = *( b_image + dy * b_stride + ( dx << 1 ) + ( ( x & 1 ) << 1 ) + 1 );
                                        }
                                        else
                                        {
-                                               dx -= dx & 1;
+                                               *pmask ++ = *( alpha + dy * b_width + dx );
                                                mix = ( float )*( alpha + dy * b_width + dx ) / 255.0;
-                                               *p ++ = *p * ( 1 - mix ) + mix * *( b_image + dy * b_stride + ( dx << 1 ) );
-                                               *p ++ = *p * ( 1 - mix ) + mix * *( b_image + dy * b_stride + ( dx << 1 ) + ( ( x & 1 ) << 1 ) + 1 );
+                                               dx += dx & 1;
+                                               *p = *p * ( 1 - mix ) + mix * *( b_image + dy * b_stride + ( dx << 1 ) );
+                                               p ++;
+                                               *p = *p * ( 1 - mix ) + mix * *( b_image + dy * b_stride + ( dx << 1 ) + ( ( x & 1 ) << 1 ) + 1 );
+                                               p ++;
                                        }
                                }
                                else
                                {
                                        p += 2;
+                                       pmask ++;
                                }
                        }
 
                        q += a_stride;
                }
+
+               b_frame->get_alpha_mask = NULL;
+               mlt_properties_set_data( b_props, "alpha", mask, 0, mlt_pool_release, NULL );
        }
 
        return 0;
@@ -666,7 +685,6 @@ static mlt_frame transition_process( mlt_transition transition, mlt_frame a_fram
        // Push the transition method
        mlt_frame_push_get_image( a_frame, transition_get_image );
 
-
        return a_frame;
 }