]> git.sesse.net Git - mlt/blobdiff - src/modules/gtk2/filter_rescale.c
Big modification - switch to macros for parent class access
[mlt] / src / modules / gtk2 / filter_rescale.c
index 5151a059b46043bfde9448721386842f0809421f..14f3f28d4924abbb33575757d2bb48fd0d7132a3 100644 (file)
 #include "pixops.h"
 
 #include <framework/mlt_frame.h>
+#include <framework/mlt_factory.h>
 
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
-
-/** Do it :-).
-*/
-
-static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
+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 )
 {
-       if ( *width == 0 )
-               *width = 720;
-       if ( *height == 0 )
-               *height = 576;
-
-       mlt_properties properties = mlt_frame_properties( this );
-       int iwidth = *width;
-       int iheight = *height;
-       int owidth = *width;
-       int oheight = *height;
-       uint8_t *input = NULL;
+       // Get the properties
+       mlt_properties properties = MLT_FRAME_PROPERTIES( this );
+
+       // Get the requested interpolation method
        char *interps = mlt_properties_get( properties, "rescale.interp" );
+
+       // Convert to the GTK flag
        int interp = PIXOPS_INTERP_BILINEAR;
-       
+
        if ( strcmp( interps, "nearest" ) == 0 )
                interp = PIXOPS_INTERP_NEAREST;
        else if ( strcmp( interps, "tiles" ) == 0 )
@@ -55,156 +47,89 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
        else if ( strcmp( interps, "hyper" ) == 0 )
                interp = PIXOPS_INTERP_HYPER;
 
-       // If real_width/height exist, we want that as minimum information
-       if ( mlt_properties_get_int( properties, "real_width" ) )
+       // Carry out the rescaling
+       if ( iformat == mlt_image_yuv422 && oformat == mlt_image_yuv422 )
        {
-               iwidth = mlt_properties_get_int( properties, "real_width" );
-               iheight = mlt_properties_get_int( properties, "real_height" );
-       }
+               // Create the output image
+               uint8_t *output = mlt_pool_alloc( owidth * ( oheight + 1 ) * 2 );
 
-       // Let the producer know what we are actually requested to obtain
-       mlt_properties_set_int( properties, "rescale_width", *width );
-       mlt_properties_set_int( properties, "rescale_height", *height );
+               // Calculate strides
+               int istride = iwidth * 2;
+               int ostride = owidth * 2;
 
-       // Get the image as requested
-       mlt_frame_get_image( this, &input, format, &iwidth, &iheight, writable );
+               yuv422_scale_simple( output, owidth, oheight, ostride, *image, iwidth, iheight, istride, interp );
+               
+               // Now update the frame
+               mlt_properties_set_data( properties, "image", output, owidth * ( oheight + 1 ) * 2, ( mlt_destructor )mlt_pool_release, NULL );
+               mlt_properties_set_int( properties, "width", owidth );
+               mlt_properties_set_int( properties, "height", oheight );
 
-       if ( input != NULL )
+               // Return the output
+               *image = output;
+       }
+       else if ( iformat == mlt_image_rgb24 || iformat == mlt_image_rgb24a )
        {
-               // If width and height are correct, don't do anything
-               if ( *format == mlt_image_yuv422 && strcmp( interps, "none" ) && ( iwidth != owidth || iheight != oheight ) )
+               int bpp = (iformat == mlt_image_rgb24a ? 4 : 3 );
+                       
+               // Create the yuv image
+               uint8_t *output = mlt_pool_alloc( owidth * ( oheight + 1 ) * 2 );
+
+               if ( strcmp( interps, "none" ) && ( iwidth != owidth || iheight != oheight ) )
                {
-                       // Create the output image
-                       uint8_t *output = mlt_pool_alloc( owidth * ( oheight + 1 ) * 2 );
+                       GdkPixbuf *pixbuf = gdk_pixbuf_new_from_data( *image, GDK_COLORSPACE_RGB,
+                               ( iformat == mlt_image_rgb24a ), 8, iwidth, iheight,
+                               iwidth * bpp, NULL, NULL );
 
-                       // Calculate strides
-                       int istride = iwidth * 2;
-                       int ostride = owidth * 2;
+                       GdkPixbuf *scaled = gdk_pixbuf_scale_simple( pixbuf, owidth, oheight, interp );
+                       g_object_unref( pixbuf );
+                       
+                       // Extract YUV422 and alpha
+                       if ( bpp == 4 )
+                       {
+                               // Allocate the alpha mask
+                               uint8_t *alpha = mlt_pool_alloc( owidth * ( oheight + 1 ) );
 
-                       yuv422_scale_simple( output, owidth, oheight, ostride, input, iwidth, iheight, istride, interp );
-               
-                       // Now update the frame
-                       mlt_properties_set_data( properties, "image", output, owidth * ( oheight + 1 ) * 2, ( mlt_destructor )mlt_pool_release, NULL );
-                       mlt_properties_set_int( properties, "width", owidth );
-                       mlt_properties_set_int( properties, "height", oheight );
+                               // Convert the image and extract alpha
+                               mlt_convert_rgb24a_to_yuv422( gdk_pixbuf_get_pixels( scaled ), owidth, oheight, gdk_pixbuf_get_rowstride( scaled ), output, alpha );
 
-                       // Return the output
-                       *image = output;
-               }
-               else if ( *format == mlt_image_yuv422 && !strcmp( interps, "none" ) )
-               {
-                       // Do nothing
-                       *width = iwidth;
-                       *height = iheight;
-                       *image = input;
+                               mlt_properties_set_data( properties, "alpha", alpha, owidth * ( oheight + 1 ), ( mlt_destructor )mlt_pool_release, NULL );
+                       }
+                       else
+                       {
+                               // No alpha to extract
+                               mlt_convert_rgb24_to_yuv422( gdk_pixbuf_get_pixels( scaled ), owidth, oheight, gdk_pixbuf_get_rowstride( scaled ), output );
+                       }
+                       g_object_unref( scaled );
                }
-               else if ( *format == mlt_image_rgb24 || *format == mlt_image_rgb24a )
+               else
                {
-                       int bpp = (*format == mlt_image_rgb24a ? 4 : 3 );
-                       
-                       // Create the yuv image
-                       uint8_t *output = mlt_pool_alloc( owidth * ( oheight + 1 ) * 2 );
-
-                       if ( strcmp( interps, "none" ) && ( iwidth != owidth || iheight != oheight ) )
+                       // Extract YUV422 and alpha
+                       if ( bpp == 4 )
                        {
-                               GdkPixbuf *pixbuf = gdk_pixbuf_new_from_data( input, GDK_COLORSPACE_RGB,
-                                       ( *format == mlt_image_rgb24a ), 8, iwidth, iheight,
-                                       iwidth * bpp, NULL, NULL );
-
-                               GdkPixbuf *scaled = gdk_pixbuf_scale_simple( pixbuf, owidth, oheight, interp );
-                               g_object_unref( pixbuf );
-                               
-                               // Extract YUV422 and alpha
-                               if ( bpp == 4 )
-                               {
-                                       // Allocate the alpha mask
-                                       uint8_t *alpha = mlt_pool_alloc( owidth * ( oheight + 1 ) );
-
-                                       // Convert the image and extract alpha
-                                       mlt_convert_rgb24a_to_yuv422( gdk_pixbuf_get_pixels( scaled ),
-                                                                                 owidth, oheight,
-                                                                                 gdk_pixbuf_get_rowstride( scaled ),
-                                                                                 output, alpha );
-
-                                       mlt_properties_set_data( properties, "alpha", alpha, owidth * ( oheight + 1 ), ( mlt_destructor )mlt_pool_release, NULL );
-                               }
-                               else
-                               {
-                                       // No alpha to extract
-                                       mlt_convert_rgb24_to_yuv422( gdk_pixbuf_get_pixels( scaled ),
-                                                                                owidth, oheight,
-                                                                                gdk_pixbuf_get_rowstride( scaled ),
-                                                                                output );
-                               }
-                               g_object_unref( scaled );
+                               // Allocate the alpha mask
+                               uint8_t *alpha = mlt_pool_alloc( owidth * ( oheight + 1 ) );
+
+                               // Convert the image and extract alpha
+                               mlt_convert_rgb24a_to_yuv422( *image, owidth, oheight, owidth * 4, output, alpha );
+
+                               mlt_properties_set_data( properties, "alpha", alpha, owidth * ( oheight + 1 ), ( mlt_destructor )mlt_pool_release, NULL );
                        }
                        else
                        {
-                               // Extract YUV422 and alpha
-                               if ( bpp == 4 )
-                               {
-                                       // Allocate the alpha mask
-                                       uint8_t *alpha = mlt_pool_alloc( owidth * ( oheight + 1 ) );
-
-                                       // Convert the image and extract alpha
-                                       mlt_convert_rgb24a_to_yuv422( input,
-                                                                                 owidth, oheight,
-                                                                                 owidth * 4,
-                                                                                 output, alpha );
-
-                                       mlt_properties_set_data( properties, "alpha", alpha, owidth * ( oheight + 1 ), ( mlt_destructor )mlt_pool_release, NULL );
-                               }
-                               else
-                               {
-                                       // No alpha to extract
-                                       mlt_convert_rgb24_to_yuv422( input,
-                                                                                owidth, oheight,
-                                                                                owidth * 3,
-                                                                                output );
-                               }
+                               // No alpha to extract
+                               mlt_convert_rgb24_to_yuv422( *image, owidth, oheight, owidth * 3, output );
                        }
-
-                       // Now update the frame
-                       mlt_properties_set_data( properties, "image", output, owidth * ( oheight + 1 ) * 2, ( mlt_destructor )mlt_pool_release, NULL );
-                       mlt_properties_set_int( properties, "width", owidth );
-                       mlt_properties_set_int( properties, "height", oheight );
-
-                       // Return the output
-                       *format = mlt_image_yuv422;
-                       *width = owidth;
-                       *height = oheight;
-                       *image = output;
                }
-               else
-                       *image = input;
-       }
-       else
-               *image = input;
-               
-       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 );
-}
+               // Now update the frame
+               mlt_properties_set_data( properties, "image", output, owidth * ( oheight + 1 ) * 2, ( mlt_destructor )mlt_pool_release, NULL );
+               mlt_properties_set_int( properties, "width", owidth );
+               mlt_properties_set_int( properties, "height", oheight );
 
-/** Filter processing.
-*/
+               *image = output;
+       }
 
-static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
-{
-       mlt_frame_push_get_image( frame, filter_get_image );
-       mlt_properties_set( mlt_frame_properties( frame ), "rescale.interp",
-               mlt_properties_get( mlt_filter_properties( this ), "interpolation" ) );
-               
-       // Set alpha call back
-       frame->get_alpha_mask = producer_get_alpha_mask;
-       return frame;
+       return 0;
 }
 
 /** Constructor for the filter.
@@ -212,11 +137,22 @@ static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
 
 mlt_filter filter_rescale_init( char *arg )
 {
-       mlt_filter this = mlt_filter_new( );
+       // Create a new scaler
+       mlt_filter this = mlt_factory_filter( "rescale", arg );
+
+       // If successful, then initialise it
        if ( this != NULL )
        {
-               this->process = filter_process;
-               mlt_properties_set( mlt_filter_properties( this ), "interpolation", arg == NULL ? "bilinear" : arg );
+               // Get the properties
+               mlt_properties properties = MLT_FILTER_PROPERTIES( this );
+
+               // Set the inerpolation
+               mlt_properties_set( properties, "interpolation", arg == NULL ? "bilinear" : arg );
+
+               // Set the method
+               mlt_properties_set_data( properties, "method", filter_scale, 0, NULL, NULL );
        }
+
        return this;
 }
+