X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fmodules%2Fgtk2%2Fproducer_pixbuf.c;h=c98fd41c65fdb857f15082017da494e229a71a00;hb=0eb958f7574601ea463d7c2103bc15f06d2672d1;hp=8a74a468fb13849054785bca922ee430764b1450;hpb=661165812e3410fe2f6f49d7af882b36a0efcf82;p=melted diff --git a/src/modules/gtk2/producer_pixbuf.c b/src/modules/gtk2/producer_pixbuf.c index 8a74a46..c98fd41 100644 --- a/src/modules/gtk2/producer_pixbuf.c +++ b/src/modules/gtk2/producer_pixbuf.c @@ -1,3 +1,4 @@ + /* * producer_pixbuf.c -- raster image loader based upon gdk-pixbuf * Copyright (C) 2003-2004 Ushodaya Enterprises Limited @@ -20,150 +21,169 @@ #include "producer_pixbuf.h" #include +#include + #include #include #include -#include +#include +#include +#include +#include +#include +#include + +static pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER; + +typedef struct producer_pixbuf_s *producer_pixbuf; + +struct producer_pixbuf_s +{ + struct mlt_producer_s parent; + + // File name list + mlt_properties filenames; + int count; + int image_idx; + + int width; + int height; + uint8_t *image; + uint8_t *alpha; +}; static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int index ); static void producer_close( mlt_producer parent ); -mlt_producer producer_pixbuf_init( const char *filename ) +mlt_producer producer_pixbuf_init( char *filename ) { producer_pixbuf this = calloc( sizeof( struct producer_pixbuf_s ), 1 ); if ( this != NULL && mlt_producer_init( &this->parent, this ) == 0 ) { mlt_producer producer = &this->parent; + // Get the properties interface + mlt_properties properties = MLT_PRODUCER_PROPERTIES( &this->parent ); + + // Callback registration producer->get_frame = producer_get_frame; - producer->close = producer_close; - - this->filename = strdup( filename ); - this->counter = -1; - g_type_init(); - + producer->close = ( mlt_destructor )producer_close; + + // Set the default properties + mlt_properties_set( properties, "resource", filename ); + mlt_properties_set_int( properties, "ttl", 25 ); + mlt_properties_set_int( properties, "aspect_ratio", 1 ); + mlt_properties_set_int( properties, "progressive", 1 ); + return producer; } free( this ); return NULL; } -static int producer_get_image( mlt_frame this, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable ) +static void refresh_image( mlt_frame frame, int width, int height ) { - // Obtain properties of frame - mlt_properties properties = mlt_frame_properties( this ); - - // May need to know the size of the image to clone it - int size = 0; - - // Get the image - uint8_t *image = mlt_properties_get_data( properties, "image", &size ); - - // Get width and height - *width = mlt_properties_get_int( properties, "width" ); - *height = mlt_properties_get_int( properties, "height" ); - - // Clone if necessary - if ( writable ) - { - // Clone our image - uint8_t *copy = malloc( size ); - memcpy( copy, image, size ); - - // We're going to pass the copy on - image = copy; - - // Now update properties so we free the copy after - mlt_properties_set_data( properties, "image", copy, size, free, NULL ); - } - - // Pass on the image - *buffer = image; - - return 0; -} + // Pixbuf + GdkPixbuf *pixbuf = mlt_properties_get_data( MLT_FRAME_PROPERTIES( frame ), "pixbuf", NULL ); + GError *error = NULL; -uint8_t *producer_get_alpha_mask( mlt_frame this ) -{ // Obtain properties of frame - mlt_properties properties = mlt_frame_properties( this ); + mlt_properties properties = MLT_FRAME_PROPERTIES( frame ); - // Return the alpha mask - return mlt_properties_get_data( properties, "alpha", NULL ); -} - -static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index ) -{ - producer_pixbuf this = producer->child; - GdkPixbuf *pixbuf = NULL; - GError *error = NULL; + // Obtain the producer for this frame + producer_pixbuf this = mlt_properties_get_data( properties, "producer_pixbuf", NULL ); - // Generate a frame - *frame = mlt_frame_init( ); + // Obtain the producer + mlt_producer producer = &this->parent; - // Obtain properties of frame - mlt_properties properties = mlt_frame_properties( *frame ); + // Obtain properties of producer + mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer ); - // optimization for subsequent iterations on single picture - if ( this->image != NULL ) - { - // Set width/height - mlt_properties_set_int( properties, "width", this->width ); - mlt_properties_set_int( properties, "height", this->height ); + // Get the time to live for each frame + double ttl = mlt_properties_get_int( producer_props, "ttl" ); - // if picture sequence pass the image and alpha data without destructor - mlt_properties_set_data( properties, "image", this->image, 0, NULL, NULL ); - mlt_properties_set_data( properties, "alpha", this->alpha, 0, NULL, NULL ); + // Get the original position of this frame + mlt_position position = mlt_properties_get_position( properties, "pixbuf_position" ); - // Set alpha mask call back - ( *frame )->get_alpha_mask = producer_get_alpha_mask; + // Image index + int image_idx = ( int )floor( ( double )position / ttl ) % this->count; - // Stack the get image callback - mlt_frame_push_get_image( *frame, producer_get_image ); + pthread_mutex_lock( &fastmutex ); - } - else if ( strchr( this->filename, '%' ) != NULL ) + // optimization for subsequent iterations on single picture + if ( width != 0 && this->image != NULL && image_idx == this->image_idx ) { - // handle picture sequences - char filename[1024]; - filename[1023] = 0; - int current = this->counter; - do + if ( width != this->width || height != this->height ) { - ++this->counter; - snprintf( filename, 1023, this->filename, this->counter ); - pixbuf = gdk_pixbuf_new_from_file( filename, &error ); - // allow discontinuity in frame numbers up to 99 - error = NULL; - } while ( pixbuf == NULL && ( this->counter - current ) < 100 ); + pixbuf = mlt_properties_get_data( producer_props, "_pixbuf", NULL ); + mlt_pool_release( this->image ); + mlt_pool_release( this->alpha ); + this->image = NULL; + this->alpha = NULL; + } } - else + else if ( pixbuf == NULL && ( this->image == NULL || image_idx != this->image_idx ) ) { - pixbuf = gdk_pixbuf_new_from_file( this->filename, &error ); + mlt_pool_release( this->image ); + mlt_pool_release( this->alpha ); + this->image = NULL; + this->alpha = NULL; + + this->image_idx = image_idx; + pixbuf = gdk_pixbuf_new_from_file( mlt_properties_get_value( this->filenames, image_idx ), &error ); + + if ( pixbuf != NULL ) + { + // Register this pixbuf for destruction and reuse + mlt_events_block( producer_props, NULL ); + mlt_properties_set_data( producer_props, "_pixbuf", pixbuf, 0, ( mlt_destructor )g_object_unref, NULL ); + g_object_ref( pixbuf ); + mlt_properties_set_data( MLT_FRAME_PROPERTIES( frame ), "pixbuf", pixbuf, 0, ( mlt_destructor )g_object_unref, NULL ); + + mlt_properties_set_int( producer_props, "_real_width", gdk_pixbuf_get_width( pixbuf ) ); + mlt_properties_set_int( producer_props, "_real_height", gdk_pixbuf_get_height( pixbuf ) ); + mlt_events_unblock( producer_props, NULL ); + + // Store the width/height of the pixbuf temporarily + this->width = gdk_pixbuf_get_width( pixbuf ); + this->height = gdk_pixbuf_get_height( pixbuf ); + } } // If we have a pixbuf - if ( pixbuf ) + if ( pixbuf && width > 0 ) { - // Store width and height - this->width = gdk_pixbuf_get_width( pixbuf ); - this->height = gdk_pixbuf_get_height( pixbuf ); + 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; - // Allocate/define image and alpha - uint8_t *image = malloc( this->width * this->height * 2 ); - uint8_t *alpha = NULL; + // Note - the original pixbuf is already safe and ready for destruction + pixbuf = gdk_pixbuf_scale_simple( pixbuf, width, height, interp ); + + // Store width and height + this->width = width; + this->height = height; + + // Allocate/define image + this->image = mlt_pool_alloc( width * ( height + 1 ) * 2 ); // Extract YUV422 and alpha if ( gdk_pixbuf_get_has_alpha( pixbuf ) ) { // Allocate the alpha mask - alpha = malloc( this->width * this->height ); + this->alpha = mlt_pool_alloc( this->width * this->height ); // Convert the image mlt_convert_rgb24a_to_yuv422( gdk_pixbuf_get_pixels( pixbuf ), this->width, this->height, gdk_pixbuf_get_rowstride( pixbuf ), - image, alpha ); + this->image, this->alpha ); } else { @@ -171,33 +191,207 @@ static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int i mlt_convert_rgb24_to_yuv422( gdk_pixbuf_get_pixels( pixbuf ), this->width, this->height, gdk_pixbuf_get_rowstride( pixbuf ), - image ); + this->image ); } // Finished with pixbuf now g_object_unref( pixbuf ); + } + + // Set width/height of frame + mlt_properties_set_int( properties, "width", this->width ); + mlt_properties_set_int( properties, "height", this->height ); + mlt_properties_set_int( properties, "real_width", mlt_properties_get_int( producer_props, "_real_width" ) ); + 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 ) * 2, NULL, NULL ); + mlt_properties_set_data( properties, "alpha", this->alpha, this->width * this->height, NULL, NULL ); + + pthread_mutex_unlock( &fastmutex ); +} - // Set width/height of frame - mlt_properties_set_int( properties, "width", this->width ); - mlt_properties_set_int( properties, "height", this->height ); +static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable ) +{ + // Obtain properties of frame + mlt_properties properties = MLT_FRAME_PROPERTIES( frame ); + + // We need to know the size of the image to clone it + int image_size = 0; + int alpha_size = 0; + + // Alpha channel + uint8_t *alpha = NULL; + + *width = mlt_properties_get_int( properties, "rescale_width" ); + *height = mlt_properties_get_int( properties, "rescale_height" ); + + // Refresh the image + refresh_image( frame, *width, *height ); + + // Get the image + *buffer = mlt_properties_get_data( properties, "image", &image_size ); + alpha = mlt_properties_get_data( properties, "alpha", &alpha_size ); + + // Get width and height (may have changed during the refresh) + *width = mlt_properties_get_int( properties, "width" ); + *height = mlt_properties_get_int( properties, "height" ); + + // NB: Cloning is necessary with this producer (due to processing of images ahead of use) + // The fault is not in the design of mlt, but in the implementation of the pixbuf producer... + if ( *buffer != NULL ) + { + // Clone the image and the alpha + uint8_t *image_copy = mlt_pool_alloc( image_size ); + uint8_t *alpha_copy = mlt_pool_alloc( alpha_size ); + + memcpy( image_copy, *buffer, image_size ); + + // Copy or default the alpha + if ( alpha != NULL ) + memcpy( alpha_copy, alpha, alpha_size ); + else + memset( alpha_copy, 255, alpha_size ); - // Pass alpha and image on properties with or without destructor - if ( this->counter >= 0 ) + // Now update properties so we free the copy after + mlt_properties_set_data( properties, "image", image_copy, image_size, mlt_pool_release, NULL ); + mlt_properties_set_data( properties, "alpha", alpha_copy, alpha_size, mlt_pool_release, NULL ); + + // We're going to pass the copy on + *buffer = image_copy; + } + else + { + // TODO: Review all cases of invalid images + *buffer = mlt_pool_alloc( 50 * 50 * 2 ); + mlt_properties_set_data( properties, "image", *buffer, image_size, mlt_pool_release, NULL ); + *width = 50; + *height = 50; + } + + 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 ); +} + +static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index ) +{ + // Get the real structure for this producer + producer_pixbuf this = producer->child; + + // Fetch the producers properties + mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer ); + + if ( this->filenames == NULL && mlt_properties_get( producer_properties, "resource" ) != NULL ) + { + char *filename = mlt_properties_get( producer_properties, "resource" ); + this->filenames = mlt_properties_new( ); + + // Read xml string + if ( strstr( filename, " -1 ) + { + // Write the svg into the temp file + ssize_t remaining_bytes; + char *xml = filename; + + // Strip leading crap + while ( xml[0] != '<' ) + xml++; + + remaining_bytes = strlen( xml ); + while ( remaining_bytes > 0 ) + remaining_bytes -= write( fd, xml + strlen( xml ) - remaining_bytes, remaining_bytes ); + close( fd ); + + mlt_properties_set( this->filenames, "0", fullname ); + + // Teehe - when the producer closes, delete the temp file and the space allo + mlt_properties_set_data( producer_properties, "__temporary_file__", fullname, 0, ( mlt_destructor )unlink, NULL ); + } } - else + // Obtain filenames + else if ( strchr( filename, '%' ) != NULL ) + { + // handle picture sequences + int i = mlt_properties_get_int( producer_properties, "begin" ); + int gap = 0; + char full[1024]; + int keyvalue = 0; + char key[ 50 ]; + + while ( gap < 100 ) + { + struct stat buf; + snprintf( full, 1023, filename, i ++ ); + if ( stat( full, &buf ) == 0 ) + { + sprintf( key, "%d", keyvalue ++ ); + mlt_properties_set( this->filenames, "0", full ); + gap = 0; + } + else + { + gap ++; + } + } + } + else if ( strstr( filename, "/.all." ) != NULL ) { - // if single picture, reference the image and alpha in the producer - this->image = image; - this->alpha = alpha; + char wildcard[ 1024 ]; + char *dir_name = strdup( filename ); + char *extension = strrchr( dir_name, '.' ); - // pass the image and alpha data without destructor - mlt_properties_set_data( properties, "image", image, 0, NULL, NULL ); - mlt_properties_set_data( properties, "alpha", alpha, 0, NULL, NULL ); + *( strstr( dir_name, "/.all." ) + 1 ) = '\0'; + sprintf( wildcard, "*%s", extension ); + + mlt_properties_dir_list( this->filenames, dir_name, wildcard, 1 ); + + free( dir_name ); } + else + { + mlt_properties_set( this->filenames, "0", filename ); + } + + this->count = mlt_properties_count( this->filenames ); + } + + // Generate a frame + *frame = mlt_frame_init( ); + + if ( *frame != NULL && this->count > 0 ) + { + // Obtain properties of frame and producer + mlt_properties properties = MLT_FRAME_PROPERTIES( *frame ); + + // Set the producer on the frame properties + mlt_properties_set_data( properties, "producer_pixbuf", this, 0, NULL, NULL ); + + // Update timecode on the frame we're creating + mlt_frame_set_position( *frame, mlt_producer_position( producer ) ); + + // Ensure that we have a way to obtain the position in the get_image + mlt_properties_set_position( properties, "pixbuf_position", mlt_producer_position( producer ) ); + + // Refresh the image + refresh_image( *frame, 0, 0 ); + + // Set producer-specific frame properties + mlt_properties_set_int( properties, "progressive", mlt_properties_get_int( producer_properties, "progressive" ) ); + mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( producer_properties, "aspect_ratio" ) ); // Set alpha call back ( *frame )->get_alpha_mask = producer_get_alpha_mask; @@ -206,9 +400,6 @@ static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int i mlt_frame_push_get_image( *frame, producer_get_image ); } - // Update timecode on the frame we're creating - mlt_frame_set_timecode( *frame, mlt_producer_position( producer ) ); - // Calculate the next timecode mlt_producer_prepare_next( producer ); @@ -218,14 +409,9 @@ static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int i static void producer_close( mlt_producer parent ) { producer_pixbuf this = parent->child; - if ( this->filename ) - free( this->filename ); - if ( this->image ) - free( this->image ); - if ( this->alpha ) - free( this->alpha ); + mlt_pool_release( this->image ); parent->close = NULL; mlt_producer_close( parent ); + mlt_properties_close( this->filenames ); free( this ); } -