src/framework/mlt_frame.c

[melted] / src / modules / core / filter_rescale.c

diff --git a/src/modules/core/filter_rescale.c b/src/modules/core/filter_rescale.c
index dfbec8f..19b087f 100644 (file)
--- a/src/modules/core/filter_rescale.c
+++ b/src/modules/core/filter_rescale.c
@@ -25,13 +25,14 @@
 #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 );
 
 static int filter_scale( mlt_frame this, uint8_t **image, mlt_image_format iformat, mlt_image_format oformat, int iwidth, int iheight, int owidth, int oheight )
 {
        // Get the properties
-       mlt_properties properties = mlt_frame_properties( this );
+       mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 
        // Get the rescaling interpolsation
        char *interps = mlt_properties_get( properties, "rescale.interp" );
@@ -108,19 +109,44 @@ static int filter_scale( mlt_frame this, uint8_t **image, mlt_image_format iform
        return 0;
 }
 
+static void scale_alpha( mlt_frame this, int iwidth, int iheight, int owidth, int oheight )
+{
+       uint8_t *output = NULL;
+       uint8_t *input = mlt_frame_get_alpha_mask( this );
+
+       if ( input != 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 );
+       }
+}
+
 /** Do it :-).
 */
 
 static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
 {
        // Get the frame properties
-       mlt_properties properties = mlt_frame_properties( this );
+       mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 
        // Get the filter from the stack
        mlt_filter filter = mlt_frame_pop_service( this );
 
        // Get the filter properties
-       mlt_properties filter_properties = mlt_filter_properties( filter );
+       mlt_properties filter_properties = MLT_FILTER_PROPERTIES( filter );
 
        // Get the image scaler method
        image_scaler scaler_method = mlt_properties_get_data( filter_properties, "method", NULL );
@@ -133,7 +159,7 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
        }
 
        // There can be problems with small images - avoid them (by hacking - gah)
-       if ( *width >= 2 && *height >= 6 )
+       if ( *width >= 6 && *height >= 6 )
        {
                int iwidth = *width;
                int iheight = *height;
@@ -145,7 +171,7 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
                // Default from the scaler if not specifed on the frame
                if ( interps == NULL )
                {
-                       interps = mlt_properties_get( mlt_filter_properties( filter ), "interpolation" );
+                       interps = mlt_properties_get( MLT_FILTER_PROPERTIES( filter ), "interpolation" );
                        mlt_properties_set( properties, "rescale.interp", interps );
                }
        
@@ -165,13 +191,13 @@ 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_height", ( iheight / 2 ) * 2 );
+                       mlt_properties_set_int( properties, "rescale_width", iwidth );
+                       mlt_properties_set_int( properties, "rescale_height", iheight );
                }
        
                // Get the image as requested
                mlt_frame_get_image( this, image, format, &iwidth, &iheight, writable );
-       
+
                // Get rescale interpretation again, in case the producer wishes to override scaling
                interps = mlt_properties_get( properties, "rescale.interp" );
        
@@ -189,6 +215,9 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
                                scaler_method( this, image, *format, mlt_image_yuv422, iwidth, iheight, owidth, oheight );
                                *width = owidth;
                                *height = oheight;
+
+                               // Scale the alpha
+                               scale_alpha( this, iwidth, iheight, owidth, oheight );
                        }
                        else if ( *format == mlt_image_rgb24 && wanted_format == mlt_image_rgb24 )
                        {
@@ -198,6 +227,9 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
                                // Return the output
                                *width = owidth;
                                *height = oheight;
+
+                               // Scale the alpha
+                               scale_alpha( this, iwidth, iheight, owidth, oheight );
                        }
                        else if ( *format == mlt_image_rgb24 || *format == mlt_image_rgb24a )
                        {
@@ -208,6 +240,9 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
                                *format = mlt_image_yuv422;
                                *width = owidth;
                                *height = oheight;
+
+                               // Scale the alpha
+                               scale_alpha( this, iwidth, iheight, owidth, oheight );
                        }
                        else
                        {
@@ -217,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;
                }
@@ -239,15 +276,6 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
        return 0;
 }
 
-static uint8_t *producer_get_alpha_mask( mlt_frame this )
-{
-       // Obtain properties of frame
-       mlt_properties properties = mlt_frame_properties( this );
-
-       // Return the alpha mask
-       return mlt_properties_get_data( properties, "alpha", NULL );
-}
-
 /** Filter processing.
 */
 
@@ -259,9 +287,6 @@ static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
        // Push the get image method
        mlt_frame_push_service( frame, filter_get_image );
 
-       // Set alpha call back
-       frame->get_alpha_mask = producer_get_alpha_mask;
-
        return frame;
 }
 
@@ -277,7 +302,7 @@ mlt_filter filter_rescale_init( char *arg )
        if ( this != NULL )
        {
                // Get the properties
-               mlt_properties properties = mlt_filter_properties( this );
+               mlt_properties properties = MLT_FILTER_PROPERTIES( this );
 
                // Set the process method
                this->process = filter_process;