From: ddennedy Date: Thu, 19 Feb 2004 04:23:15 +0000 (+0000) Subject: field rendering and alignment for composite, bugfixes for luma, pixbuf and pango X-Git-Url: http://research.m1stereo.tv/gitweb?a=commitdiff_plain;h=4bc1c05b81568697d4f7cb7b033c85be0ed95034;hp=bd9b3ea690d8dc803419a9b4a427a9c9d4e97889;p=melted field rendering and alignment for composite, bugfixes for luma, pixbuf and pango git-svn-id: https://mlt.svn.sourceforge.net/svnroot/mlt/trunk/mlt@154 d19143bc-622f-0410-bfdd-b5b2a6649095 --- diff --git a/src/modules/core/transition_composite.c b/src/modules/core/transition_composite.c index 49f7c94..b5121ed 100644 --- a/src/modules/core/transition_composite.c +++ b/src/modules/core/transition_composite.c @@ -23,19 +23,24 @@ #include #include +#include /** Geometry struct. */ struct geometry_s { - int nw; - int nh; + int nw; // normalised width + int nh; // normalised height + int sw; // scaled width, not including consumer scale based upon w/nw + int sh; // scaled height, not including consumer scale based upon h/nh float x; float y; float w; float h; float mix; + int halign; // horizontal alignment: 0=left, 1=center, 2=right + int valign; // vertical alignment: 0=top, 1=middle, 2=bottom }; /** Parse a value from a geometry string. @@ -78,8 +83,8 @@ static void geometry_parse( struct geometry_s *geometry, struct geometry_s *defa { geometry->x = defaults->x; geometry->y = defaults->y; - geometry->w = defaults->w; - geometry->h = defaults->h; + geometry->w = geometry->sw = defaults->w; + geometry->h = geometry->sh = defaults->h; geometry->mix = defaults->mix; } else @@ -93,8 +98,8 @@ static void geometry_parse( struct geometry_s *geometry, struct geometry_s *defa char *ptr = property; geometry->x = parse_value( &ptr, nw, ',', geometry->x ); geometry->y = parse_value( &ptr, nh, ':', geometry->y ); - geometry->w = parse_value( &ptr, nw, 'x', geometry->w ); - geometry->h = parse_value( &ptr, nh, ':', geometry->h ); + geometry->w = geometry->sw = parse_value( &ptr, nw, 'x', geometry->w ); + geometry->h = geometry->sh = parse_value( &ptr, nh, ':', geometry->h ); geometry->mix = parse_value( &ptr, 100, ' ', geometry->mix ); } } @@ -107,13 +112,40 @@ static void geometry_calculate( struct geometry_s *output, struct geometry_s *in // Calculate this frames geometry output->nw = in->nw; output->nh = in->nh; - output->x = in->x + ( out->x - in->x ) * position; - output->y = in->y + ( out->y - in->y ) * position; + output->x = in->x + ( out->x - in->x ) * position + 0.5; + output->y = in->y + ( out->y - in->y ) * position + 0.5; output->w = in->w + ( out->w - in->w ) * position; output->h = in->h + ( out->h - in->h ) * position; output->mix = in->mix + ( out->mix - in->mix ) * position; } +/** Parse the alignment properties into the geometry. +*/ + +static int alignment_parse( char* align ) +{ + int ret = 0; + + if ( align == NULL ); + else if ( isdigit( align[ 0 ] ) ) + ret = atoi( align ); + else if ( align[ 0 ] == 'c' || align[ 0 ] == 'm' ) + ret = 1; + else if ( align[ 0 ] == 'r' || align[ 0 ] == 'b' ) + ret = 2; + + return ret; +} + +/** Adjust position according to scaled size and alignment properties. +*/ + +static void alignment_calculate( struct geometry_s *geometry ) +{ + geometry->x += ( geometry->w - geometry->sw ) * geometry->halign / 2 + 0.5; + geometry->y += ( geometry->h - geometry->sh ) * geometry->valign / 2 + 0.5; +} + /** Calculate the position for this frame. */ @@ -130,6 +162,26 @@ static float position_calculate( mlt_transition this, mlt_frame frame ) return ( float )( position - in ) / ( float )( out - in + 1 ); } +/** Calculate the field delta for this frame - position between two frames. +*/ + +static float delta_calculate( mlt_transition this, mlt_frame frame ) +{ + // Get the in and out position + mlt_position in = mlt_transition_get_in( this ); + mlt_position out = mlt_transition_get_out( this ); + + // Get the position of the frame + mlt_position position = mlt_frame_get_position( frame ); + + // Now do the calcs + float x = ( float )( position - in ) / ( float )( out - in + 1 ); + position++; + float y = ( float )( position - in ) / ( float )( out - in + 1 ); + + return ( y - x ) / 2.0; +} + static int get_value( mlt_properties properties, char *preferred, char *fallback ) { int value = mlt_properties_get_int( properties, preferred ); @@ -141,17 +193,19 @@ static int get_value( mlt_properties properties, char *preferred, char *fallback /** Composite function. */ -static int composite_yuv( uint8_t *p_dest, int width_dest, int height_dest, uint8_t *p_src, int width_src, int height_src, uint8_t *p_alpha, struct geometry_s geometry ) +static int composite_yuv( uint8_t *p_dest, int width_dest, int height_dest, uint8_t *p_src, int width_src, int height_src, uint8_t *p_alpha, struct geometry_s geometry, int field ) { int ret = 0; int i, j; int x_src = 0, y_src = 0; float weight = geometry.mix / 100; - int x = ( geometry.x * width_dest ) / geometry.nw; - int y = ( geometry.y * height_dest ) / geometry.nh; int stride_src = width_src * 2; int stride_dest = width_dest * 2; + // Adjust to consumer scale + int x = geometry.x * width_dest / geometry.nw + 0.5; + int y = geometry.y * height_dest / geometry.nh + 0.5; + x -= x % 2; // optimization points - no work to do @@ -193,6 +247,27 @@ static int composite_yuv( uint8_t *p_dest, int width_dest, int height_dest, uint if ( p_alpha ) p_alpha += x_src + y_src * stride_src / 2; + // Assuming lower field first + // Special care is taken to make sure the b_frame is aligned to the correct field. + // field 0 = lower field and y should be odd (y is 0-based). + // field 1 = upper field and y should be even. + if ( ( field > -1 ) && ( y % 2 == field ) ) + { + if ( y == 0 ) + p_dest += stride_dest; + else + p_dest -= stride_dest; + } + + // On the second field, use the other lines from b_frame + if ( field == 1 ) + { + p_src += stride_src; + if ( p_alpha ) + p_alpha += stride_src / 2; + height_src--; + } + uint8_t *p = p_src; uint8_t *q = p_dest; uint8_t *o = p_dest; @@ -202,14 +277,16 @@ static int composite_yuv( uint8_t *p_dest, int width_dest, int height_dest, uint uint8_t UV; uint8_t a; float value; + int step = ( field > -1 ) ? 2 : 1; // now do the compositing only to cropped extents - for ( i = 0; i < height_src; i++ ) + for ( i = 0; i < height_src; i += step ) { - p = p_src; - q = p_dest; - o = p_dest; - z = p_alpha; + p = &p_src[ i * stride_src ]; + q = &p_dest[ i * stride_dest ]; + o = &p_dest[ i * stride_dest ]; + if ( p_alpha ) + z = &p_alpha[ i * stride_src / 2 ]; for ( j = 0; j < width_src; j ++ ) { @@ -220,11 +297,6 @@ static int composite_yuv( uint8_t *p_dest, int width_dest, int height_dest, uint *o ++ = (uint8_t)( Y * value + *q++ * ( 1 - value ) ); *o ++ = (uint8_t)( UV * value + *q++ * ( 1 - value ) ); } - - p_src += stride_src; - p_dest += stride_dest; - if ( p_alpha ) - p_alpha += stride_src / 2; } return ret; @@ -239,6 +311,10 @@ static int get_b_frame_image( mlt_frame b_frame, uint8_t **image, int *width, in int ret = 0; mlt_image_format format = mlt_image_yuv422; + // Initialise the scaled dimensions from the computed + geometry->sw = geometry->w; + geometry->sh = geometry->h; + // Compute the dimensioning rectangle mlt_properties b_props = mlt_frame_properties( b_frame ); mlt_transition this = mlt_properties_get_data( b_props, "transition_composite", NULL ); @@ -247,16 +323,17 @@ static int get_b_frame_image( mlt_frame b_frame, uint8_t **image, int *width, in if ( mlt_properties_get( properties, "distort" ) == NULL ) { // Now do additional calcs based on real_width/height etc - //int normalised_width = mlt_properties_get_int( b_props, "normalised_width" ); - //int normalised_height = mlt_properties_get_int( b_props, "normalised_height" ); int normalised_width = geometry->w; int normalised_height = geometry->h; - int real_width = get_value( b_props, "real_width", "width" ); + //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 output_ar = mlt_properties_get_double( b_props, "consumer_aspect_ratio" ); - int scaled_width = ( input_ar > output_ar ? input_ar / output_ar : output_ar / input_ar ) * real_width; - int scaled_height = ( input_ar > output_ar ? input_ar / output_ar : output_ar / input_ar ) * real_height; + //int scaled_width = ( input_ar > output_ar ? input_ar / output_ar : output_ar / input_ar ) * real_width; + //int scaled_height = ( input_ar > output_ar ? input_ar / output_ar : output_ar / input_ar ) * real_height; + int scaled_width = ( float )geometry->nw / geometry->nh / output_ar * real_height * input_ar; + int scaled_height = real_height; + //fprintf( stderr, "composite: real %dx%d scaled %dx%d normalised %dx%d\n", real_width, real_height, scaled_width, scaled_height, normalised_width, normalised_height ); // Now ensure that our images fit in the normalised frame if ( scaled_width > normalised_width ) @@ -277,13 +354,10 @@ static int get_b_frame_image( mlt_frame b_frame, uint8_t **image, int *width, in // Now we need to align to the geometry if ( scaled_width <= geometry->w && scaled_height <= geometry->h ) { - // TODO: Should take into account requested alignment here... - // Assume centred alignment for now - - geometry->x = geometry->x + ( geometry->w - scaled_width ) / 2; - geometry->y = geometry->y + ( geometry->h - scaled_height ) / 2; - geometry->w = scaled_width; - geometry->h = scaled_height; + // Save the new scaled dimensions + geometry->sw = scaled_width; + geometry->sh = scaled_height; + mlt_properties_set( b_props, "distort", "true" ); } else @@ -297,13 +371,19 @@ static int get_b_frame_image( mlt_frame b_frame, uint8_t **image, int *width, in mlt_properties_set( b_props, "distort", "true" ); } - int x = ( geometry->x * *width ) / geometry->nw; - int y = ( geometry->y * *height ) / geometry->nh; - *width = ( geometry->w * *width ) / geometry->nw; - *height = ( geometry->h * *height ) / geometry->nh; + // Take into consideration alignment for optimisation + alignment_calculate( geometry ); + + // Adjust to consumer scale + int x = geometry->x * *width / geometry->nw + 0.5; + int y = geometry->y * *height / geometry->nh + 0.5; + *width = geometry->sw * *width / geometry->nw; + *height = geometry->sh * *height / geometry->nh; x -= x % 2; + //fprintf( stderr, "composite calculated %d,%d:%dx%d\n", x, y, *width, *height ); + // optimization points - no work to do if ( *width <= 0 || *height <= 0 ) return 1; @@ -352,6 +432,7 @@ static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_f // Calculate the position float position = position_calculate( this, a_frame ); + float delta = delta_calculate( this, a_frame ); // Obtain the normalised width and height from the a_frame int normalised_width = mlt_properties_get_int( a_props, "normalised_width" ); @@ -361,24 +442,45 @@ static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_f geometry_parse( &start, NULL, mlt_properties_get( properties, "start" ), normalised_width, normalised_height ); geometry_parse( &end, &start, mlt_properties_get( properties, "end" ), normalised_width, normalised_height ); - // Do the calculation - geometry_calculate( &result, &start, &end, position ); + // Now parse the alignment + result.halign = alignment_parse( mlt_properties_get( properties, "halign" ) ); + result.valign = alignment_parse( mlt_properties_get( properties, "valign" ) ); // 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_aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) ); mlt_properties_set_double( b_props, "consumer_scale", mlt_properties_get_double( a_props, "consumer_scale" ) ); + // Do the calculation + geometry_calculate( &result, &start, &end, position ); + // Get the image from the b frame uint8_t *image_b; int width_b = *width; int height_b = *height; + if ( get_b_frame_image( b_frame, &image_b, &width_b, &height_b, &result ) == 0 ) { uint8_t *alpha = mlt_frame_get_alpha_mask( b_frame ); - - // Composite the b_frame on the a_frame - composite_yuv( *image, *width, *height, image_b, width_b, height_b, alpha, result ); + int progressive = mlt_properties_get_int( a_props, "progressive" ) || + mlt_properties_get_int( a_props, "consumer_progressive" ) || + mlt_properties_get_int( properties, "progressive" ); + int field; + + for ( field = 0; field < ( progressive ? 1 : 2 ); field++ ) + { + // Assume lower field (0) first + float field_position = position + field * delta; + + // Do the calculation + geometry_calculate( &result, &start, &end, field_position ); + + // Align + alignment_calculate( &result ); + + // Composite the b_frame on the a_frame + composite_yuv( *image, *width, *height, image_b, width_b, height_b, alpha, result, progressive ? -1 : field ); + } } } diff --git a/src/modules/core/transition_luma.c b/src/modules/core/transition_luma.c index 6c57339..15ed022 100644 --- a/src/modules/core/transition_luma.c +++ b/src/modules/core/transition_luma.c @@ -34,7 +34,7 @@ typedef struct struct mlt_transition_s parent; char *filename; int width; - int height; + int height; float *bitmap; } transition_luma; @@ -59,6 +59,42 @@ static inline float smoothstep( float edge1, float edge2, float a ) return ( a * a * ( 3 - 2 * a ) ); } +/** Calculate the position for this frame. +*/ + +static float position_calculate( mlt_transition this, mlt_frame frame ) +{ + // Get the in and out position + mlt_position in = mlt_transition_get_in( this ); + mlt_position out = mlt_transition_get_out( this ); + + // Get the position of the frame + mlt_position position = mlt_frame_get_position( frame ); + + // Now do the calcs + return ( float )( position - in ) / ( float )( out - in + 1 ); +} + +/** Calculate the field delta for this frame - position between two frames. +*/ + +static float delta_calculate( mlt_transition this, mlt_frame frame ) +{ + // Get the in and out position + mlt_position in = mlt_transition_get_in( this ); + mlt_position out = mlt_transition_get_out( this ); + + // Get the position of the frame + mlt_position position = mlt_frame_get_position( frame ); + + // Now do the calcs + float x = ( float )( position - in ) / ( float )( out - in + 1 ); + position++; + float y = ( float )( position - in ) / ( float )( out - in + 1 ); + + return ( y - x ) / 2.0; +} + static int frame_composite_yuv( mlt_frame this, mlt_frame that, int x, int y, float weight, int *width, int *height ) { int ret = 0; @@ -243,13 +279,16 @@ static int transition_get_image( mlt_frame this, uint8_t **image, mlt_image_form mlt_properties b_props = mlt_frame_properties( b_frame ); // Arbitrary composite defaults - float frame_delta = 1 / mlt_properties_get_double( b_props, "fps" ); float mix = mlt_properties_get_double( b_props, "image.mix" ); + float frame_delta = mlt_properties_get_double( b_props, "luma.delta" ); int luma_width = mlt_properties_get_int( b_props, "luma.width" ); int luma_height = mlt_properties_get_int( b_props, "luma.height" ); float *luma_bitmap = mlt_properties_get_data( b_props, "luma.bitmap", NULL ); float luma_softness = mlt_properties_get_double( b_props, "luma.softness" ); - int progressive = mlt_properties_get_int( b_props, "progressive" ) || mlt_properties_get_int( a_props, "consumer_progressive" ); + int progressive = mlt_properties_get_int( b_props, "progressive" ) || + mlt_properties_get_int( a_props, "consumer_progressive" ) || + mlt_properties_get_int( b_props, "luma.progressive" ); + int top_field_first = mlt_properties_get_int( b_props, "top_field_first" ); int reverse = mlt_properties_get_int( b_props, "luma.reverse" ); @@ -260,6 +299,7 @@ static int transition_get_image( mlt_frame this, uint8_t **image, mlt_image_form // Honour the reverse here mix = reverse ? 1 - mix : mix; + frame_delta *= reverse ? -1.0 : 1.0; // Ensure we get scaling on the b_frame mlt_properties_set( b_props, "rescale.interp", "nearest" ); @@ -401,14 +441,9 @@ static mlt_frame transition_process( mlt_transition transition, mlt_frame a_fram } } - // Determine the time position of this frame in the transition duration - mlt_position in = mlt_transition_get_in( transition ); - mlt_position out = mlt_transition_get_out( transition ); - mlt_position time = mlt_frame_get_position( b_frame ); - float pos = ( float )( time - in ) / ( float )( out - in + 1 ); - // Set the b frame properties - mlt_properties_set_double( b_props, "image.mix", pos ); + mlt_properties_set_double( b_props, "image.mix", position_calculate( transition, b_frame ) ); + mlt_properties_set_double( b_props, "luma.delta", delta_calculate( transition, b_frame ) ); mlt_properties_set_int( b_props, "luma.width", this->width ); mlt_properties_set_int( b_props, "luma.height", this->height ); mlt_properties_set_data( b_props, "luma.bitmap", this->bitmap, 0, NULL, NULL ); diff --git a/src/modules/gtk2/producer_pango.c b/src/modules/gtk2/producer_pango.c index 11f9285..c04d942 100644 --- a/src/modules/gtk2/producer_pango.c +++ b/src/modules/gtk2/producer_pango.c @@ -55,6 +55,24 @@ static void pango_draw_background( GdkPixbuf *pixbuf, rgba_color bg ); static GdkPixbuf *pango_get_pixbuf( const char *markup, const char *text, const char *font, rgba_color fg, rgba_color bg, int pad, int align ); +/** Parse the alignment property. +*/ + +static int alignment_parse( char* align ) +{ + int ret = pango_align_left; + + if ( align == NULL ); + else if ( isdigit( align[ 0 ] ) ) + ret = atoi( align ); + else if ( align[ 0 ] == 'c' || align[ 0 ] == 'm' ) + ret = pango_align_center; + else if ( align[ 0 ] == 'r' ) + ret = pango_align_right; + + return ret; +} + mlt_producer producer_pango_init( const char *filename ) { producer_pango this = calloc( sizeof( struct producer_pango_s ), 1 ); @@ -224,16 +242,16 @@ static void refresh_image( mlt_frame frame, int width, int height ) // Get producer properties char *fg = mlt_properties_get( producer_props, "fgcolour" ); char *bg = mlt_properties_get( producer_props, "bgcolour" ); - int align = mlt_properties_get_int( producer_props, "align" ); + int align = alignment_parse( mlt_properties_get( producer_props, "align" ) ); int pad = mlt_properties_get_int( producer_props, "pad" ); char *markup = mlt_properties_get( producer_props, "markup" ); char *text = mlt_properties_get( producer_props, "text" ); char *font = mlt_properties_get( producer_props, "font" ); // See if any properties changed - int property_changed = ( this->fgcolor == NULL || strcmp( fg, this->fgcolor ) ); - property_changed = property_changed || ( this->bgcolor == NULL || strcmp( bg, this->bgcolor ) ); - property_changed = property_changed || ( align != this->align ); + int property_changed = ( align != this->align ); + property_changed = property_changed || ( this->fgcolor == NULL || ( fg && strcmp( fg, this->fgcolor ) ) ); + property_changed = property_changed || ( this->bgcolor == NULL || ( bg && strcmp( bg, this->bgcolor ) ) ); property_changed = property_changed || ( pad != this->pad ); property_changed = property_changed || ( markup && this->markup && strcmp( markup, this->markup ) ); property_changed = property_changed || ( text && this->text && strcmp( text, this->text ) ); @@ -272,11 +290,9 @@ static void refresh_image( mlt_frame frame, int width, int height ) // Store the width/height of the pixbuf temporarily this->width = gdk_pixbuf_get_width( pixbuf ); this->height = gdk_pixbuf_get_height( pixbuf ); - - mlt_properties_set_int( producer_props, "bpp", gdk_pixbuf_get_has_alpha( pixbuf ) ? 4 : 3 ); } } - else if ( this->image == NULL || width != this->width || height != this->height ) + else if ( width > 0 && ( this->image == NULL || width != this->width || height != this->height ) ) { free( this->image ); free( this->alpha ); @@ -284,16 +300,25 @@ static void refresh_image( mlt_frame frame, int width, int height ) this->alpha = NULL; pixbuf = mlt_properties_get_data( producer_props, "pixbuf", NULL ); - mlt_properties_set_int( producer_props, "bpp", gdk_pixbuf_get_has_alpha( pixbuf ) ? 4 : 3 ); } - int bpp = mlt_properties_get_int( producer_props, "bpp" ); - // If we have a pixbuf and a valid width if ( pixbuf && width > 0 ) { + char *interps = mlt_properties_get( properties, "rescale.interp" ); + int interp = GDK_INTERP_BILINEAR; + + if ( strcmp( interps, "nearest" ) == 0 ) + interp = GDK_INTERP_NEAREST; + else if ( strcmp( interps, "tiles" ) == 0 ) + interp = GDK_INTERP_TILES; + else if ( strcmp( interps, "hyper" ) == 0 ) + interp = GDK_INTERP_HYPER; + +// fprintf( stderr, "SCALING PANGO from %dx%d to %dx%d was %dx%d\n", gdk_pixbuf_get_width( pixbuf ), gdk_pixbuf_get_height( pixbuf ), width, height, this->width, this->height ); + // Note - the original pixbuf is already safe and ready for destruction - pixbuf = gdk_pixbuf_scale_simple( pixbuf, width, height, GDK_INTERP_NEAREST ); + pixbuf = gdk_pixbuf_scale_simple( pixbuf, width, height, interp ); // Store width and height this->width = width; @@ -301,7 +326,7 @@ static void refresh_image( mlt_frame frame, int width, int height ) // Allocate/define image // IRRIGATE ME - uint8_t *image = malloc( width * ( height + 1 ) * bpp ); + uint8_t *image = malloc( width * ( height + 1 ) * 2 ); uint8_t *alpha = NULL; // Allocate the alpha mask @@ -328,7 +353,7 @@ static void refresh_image( mlt_frame frame, int width, int height ) mlt_properties_set_int( properties, "real_height", mlt_properties_get_int( producer_props, "real_height" ) ); // pass the image data without destructor - mlt_properties_set_data( properties, "image", this->image, this->width * ( this->height + 1 ) * bpp, NULL, NULL ); + mlt_properties_set_data( properties, "image", this->image, this->width * ( this->height + 1 ) * 2, NULL, NULL ); mlt_properties_set_data( properties, "alpha", this->alpha, this->width * this->height, NULL, NULL ); } diff --git a/src/modules/gtk2/producer_pixbuf.c b/src/modules/gtk2/producer_pixbuf.c index 3cdd5ed..9150e36 100644 --- a/src/modules/gtk2/producer_pixbuf.c +++ b/src/modules/gtk2/producer_pixbuf.c @@ -162,7 +162,6 @@ static void refresh_image( mlt_frame frame, int width, int height ) if ( width != this->width || height != this->height ) { pixbuf = mlt_properties_get_data( producer_props, "pixbuf", NULL ); - mlt_properties_set_int( producer_props, "bpp", gdk_pixbuf_get_has_alpha( pixbuf ) ? 4 : 3 ); free( this->image ); free( this->alpha ); this->image = NULL; @@ -190,28 +189,34 @@ static void refresh_image( mlt_frame frame, int width, int height ) // Store the width/height of the pixbuf temporarily this->width = gdk_pixbuf_get_width( pixbuf ); this->height = gdk_pixbuf_get_height( pixbuf ); - - mlt_properties_set_int( producer_props, "bpp", gdk_pixbuf_get_has_alpha( pixbuf ) ? 4 : 3 ); } } - int bpp = mlt_properties_get_int( producer_props, "bpp" ); - // If we have a pixbuf if ( pixbuf && width > 0 ) { + char *interps = mlt_properties_get( properties, "rescale.interp" ); + int interp = GDK_INTERP_BILINEAR; + + if ( strcmp( interps, "nearest" ) == 0 ) + interp = GDK_INTERP_NEAREST; + else if ( strcmp( interps, "tiles" ) == 0 ) + interp = GDK_INTERP_TILES; + else if ( strcmp( interps, "hyper" ) == 0 ) + interp = GDK_INTERP_HYPER; + +// fprintf( stderr, "SCALING PIXBUF from %dx%d to %dx%d was %dx%d\n", gdk_pixbuf_get_width( pixbuf ), gdk_pixbuf_get_height( pixbuf ), width, height, this->width, this->height ); // Note - the original pixbuf is already safe and ready for destruction - pixbuf = gdk_pixbuf_scale_simple( pixbuf, width, height, GDK_INTERP_NEAREST ); + pixbuf = gdk_pixbuf_scale_simple( pixbuf, width, height, interp ); // Store width and height this->width = width; this->height = height; - //fprintf( stderr, "SCALING PIXBUF from %dx%d to %dx%d %dx%d\n", gdk_pixbuf_get_width( pixbuf ), gdk_pixbuf_get_height( pixbuf ), width, height, this->width, this->height ); // Allocate/define image // IRRIGATE ME - uint8_t *image = malloc( width * ( height + 1 ) * bpp ); + uint8_t *image = malloc( width * ( height + 1 ) * 2 ); uint8_t *alpha = NULL; // Extract YUV422 and alpha