X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fmodules%2Fgtk2%2Fproducer_pixbuf.c;h=70df32c6c181962e0c76fb55280c8d514ed37415;hb=7da94c89e514fc4fd5f207a182e0de128e1de7bd;hp=c98fd41c65fdb857f15082017da494e229a71a00;hpb=0eb958f7574601ea463d7c2103bc15f06d2672d1;p=melted diff --git a/src/modules/gtk2/producer_pixbuf.c b/src/modules/gtk2/producer_pixbuf.c index c98fd41..70df32c 100644 --- a/src/modules/gtk2/producer_pixbuf.c +++ b/src/modules/gtk2/producer_pixbuf.c @@ -1,26 +1,26 @@ - /* * producer_pixbuf.c -- raster image loader based upon gdk-pixbuf * Copyright (C) 2003-2004 Ushodaya Enterprises Limited * Author: Dan Dennedy * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. * - * This program is distributed in the hope that it will be useful, + * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include "producer_pixbuf.h" +#include #include +#include #include #include @@ -33,7 +33,7 @@ #include #include -static pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER; typedef struct producer_pixbuf_s *producer_pixbuf; @@ -50,8 +50,13 @@ struct producer_pixbuf_s int height; uint8_t *image; uint8_t *alpha; + mlt_cache_item image_cache; + mlt_cache_item alpha_cache; + pthread_mutex_t mutex; }; +static void load_filenames( producer_pixbuf this, mlt_properties producer_properties ); +static void refresh_image( producer_pixbuf this, mlt_frame frame, int width, int height ); static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int index ); static void producer_close( mlt_producer parent ); @@ -74,72 +79,215 @@ mlt_producer producer_pixbuf_init( char *filename ) mlt_properties_set_int( properties, "ttl", 25 ); mlt_properties_set_int( properties, "aspect_ratio", 1 ); mlt_properties_set_int( properties, "progressive", 1 ); - + + // Validate the resource + if ( filename ) + load_filenames( this, properties ); + if ( this->count ) + { + mlt_frame frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) ); + if ( frame ) + { + mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame ); + pthread_mutex_init( &this->mutex, NULL ); + mlt_properties_set_data( frame_properties, "producer_pixbuf", this, 0, NULL, NULL ); + mlt_frame_set_position( frame, mlt_producer_position( producer ) ); + mlt_properties_set_position( frame_properties, "pixbuf_position", mlt_producer_position( producer ) ); + refresh_image( this, frame, 0, 0 ); + mlt_frame_close( frame ); + } + } + if ( this->width == 0 ) + { + producer_close( producer ); + producer = NULL; + } return producer; } free( this ); return NULL; } -static void refresh_image( mlt_frame frame, int width, int height ) +static void load_filenames( producer_pixbuf this, mlt_properties producer_properties ) { - // Pixbuf - GdkPixbuf *pixbuf = mlt_properties_get_data( MLT_FRAME_PROPERTIES( frame ), "pixbuf", NULL ); - GError *error = 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 ); + } + } + // 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, key, full ); + gap = 0; + } + else + { + gap ++; + } + } + } + else if ( strstr( filename, "/.all." ) != NULL ) + { + char wildcard[ 1024 ]; + char *dir_name = strdup( filename ); + char *extension = strrchr( dir_name, '.' ); + *( 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 ); +} + +static void refresh_image( producer_pixbuf this, mlt_frame frame, int width, int height ) +{ // Obtain properties of frame mlt_properties properties = MLT_FRAME_PROPERTIES( frame ); - // Obtain the producer for this frame - producer_pixbuf this = mlt_properties_get_data( properties, "producer_pixbuf", NULL ); - - // Obtain the producer + // Obtain the producer mlt_producer producer = &this->parent; // Obtain properties of producer mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer ); + // Obtain the cache flag and structure + int use_cache = mlt_properties_get_int( producer_props, "cache" ); + mlt_properties cache = mlt_properties_get_data( producer_props, "_cache", NULL ); + int update_cache = 0; + + // restore GdkPixbuf + pthread_mutex_lock( &this->mutex ); + mlt_cache_item pixbuf_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.pixbuf" ); + GdkPixbuf *pixbuf = mlt_cache_item_data( pixbuf_cache, NULL ); + GError *error = NULL; + + // restore scaled image + this->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.image" ); + this->image = mlt_cache_item_data( this->image_cache, NULL ); + + // restore alpha channel + this->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.alpha" ); + this->alpha = mlt_cache_item_data( this->alpha_cache, NULL ); + + // Check if user wants us to reload the image + if ( mlt_properties_get_int( producer_props, "force_reload" ) ) + { + pixbuf = NULL; + this->image = NULL; + mlt_properties_set_int( producer_props, "force_reload", 0 ); + } + // Get the time to live for each frame double ttl = mlt_properties_get_int( producer_props, "ttl" ); // Get the original position of this frame mlt_position position = mlt_properties_get_position( properties, "pixbuf_position" ); + position += mlt_producer_get_in( producer ); // Image index int image_idx = ( int )floor( ( double )position / ttl ) % this->count; - pthread_mutex_lock( &fastmutex ); + // Key for the cache + char image_key[ 10 ]; + sprintf( image_key, "%d", image_idx ); - // optimization for subsequent iterations on single picture - if ( width != 0 && this->image != NULL && image_idx == this->image_idx ) + pthread_mutex_lock( &g_mutex ); + + // Check if the frame is already loaded + if ( use_cache ) { - if ( width != this->width || height != this->height ) + if ( cache == NULL ) { - 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; + cache = mlt_properties_new( ); + mlt_properties_set_data( producer_props, "_cache", cache, 0, ( mlt_destructor )mlt_properties_close, NULL ); + } + + mlt_frame cached = mlt_properties_get_data( cache, image_key, NULL ); + + if ( cached ) + { + this->image_idx = image_idx; + mlt_properties cached_props = MLT_FRAME_PROPERTIES( cached ); + this->width = mlt_properties_get_int( cached_props, "width" ); + this->height = mlt_properties_get_int( cached_props, "height" ); + mlt_properties_set_int( producer_props, "_real_width", mlt_properties_get_int( cached_props, "real_width" ) ); + mlt_properties_set_int( producer_props, "_real_height", mlt_properties_get_int( cached_props, "real_height" ) ); + this->image = mlt_properties_get_data( cached_props, "image", NULL ); + this->alpha = mlt_properties_get_data( cached_props, "alpha", NULL ); + + if ( width != 0 && ( width != this->width || height != this->height ) ) + this->image = NULL; } } - else if ( pixbuf == NULL && ( this->image == NULL || image_idx != this->image_idx ) ) + + // optimization for subsequent iterations on single picture + if ( width != 0 && ( image_idx != this->image_idx || width != this->width || height != this->height ) ) + this->image = NULL; + if ( image_idx != this->image_idx ) + pixbuf = NULL; + if ( pixbuf == NULL && ( width == 0 || this->image == NULL ) ) { - 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 ) + if ( pixbuf ) { // 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_cache_item_close( pixbuf_cache ); + mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.pixbuf", pixbuf, 0, ( mlt_destructor )g_object_unref ); + pixbuf_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.pixbuf" ); + mlt_events_block( producer_props, 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 ); @@ -150,8 +298,8 @@ static void refresh_image( mlt_frame frame, int width, int height ) } } - // If we have a pixbuf - if ( pixbuf && width > 0 ) + // If we have a pixbuf and we need an image + if ( pixbuf && width > 0 && this->image == NULL ) { char *interps = mlt_properties_get( properties, "rescale.interp" ); int interp = GDK_INTERP_BILINEAR; @@ -172,12 +320,20 @@ static void refresh_image( mlt_frame frame, int width, int height ) // Allocate/define image this->image = mlt_pool_alloc( width * ( height + 1 ) * 2 ); + if ( !use_cache ) + mlt_cache_item_close( this->image_cache ); + mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.image", this->image, width * ( height + 1 ) * 2, mlt_pool_release ); + this->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.image" ); // Extract YUV422 and alpha if ( gdk_pixbuf_get_has_alpha( pixbuf ) ) { // Allocate the alpha mask this->alpha = mlt_pool_alloc( this->width * this->height ); + if ( !use_cache ) + mlt_cache_item_close( this->alpha_cache ); + mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.alpha", this->alpha, width * height, mlt_pool_release ); + this->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.alpha" ); // Convert the image mlt_convert_rgb24a_to_yuv422( gdk_pixbuf_get_pixels( pixbuf ), @@ -196,6 +352,18 @@ static void refresh_image( mlt_frame frame, int width, int height ) // Finished with pixbuf now g_object_unref( pixbuf ); + + // Ensure we update the cache when we need to + update_cache = use_cache; + } + + // release references no longer needed + mlt_cache_item_close( pixbuf_cache ); + if ( width == 0 ) + { + pthread_mutex_unlock( &this->mutex ); + mlt_cache_item_close( this->image_cache ); + mlt_cache_item_close( this->alpha_cache ); } // Set width/height of frame @@ -204,11 +372,20 @@ static void refresh_image( mlt_frame frame, int width, int 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 ); + if ( update_cache ) + { + mlt_frame cached = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) ); + mlt_properties cached_props = MLT_FRAME_PROPERTIES( cached ); + mlt_properties_set_int( cached_props, "width", this->width ); + mlt_properties_set_int( cached_props, "height", this->height ); + mlt_properties_set_int( cached_props, "real_width", mlt_properties_get_int( producer_props, "_real_width" ) ); + mlt_properties_set_int( cached_props, "real_height", mlt_properties_get_int( producer_props, "_real_height" ) ); + mlt_properties_set_data( cached_props, "image", this->image, this->width * ( this->height + 1 ) * 2, mlt_pool_release, NULL ); + mlt_properties_set_data( cached_props, "alpha", this->alpha, this->width * this->height, mlt_pool_release, NULL ); + mlt_properties_set_data( cache, image_key, cached, 0, ( mlt_destructor )mlt_frame_close, NULL ); + } - pthread_mutex_unlock( &fastmutex ); + pthread_mutex_unlock( &g_mutex ); } static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable ) @@ -216,22 +393,18 @@ static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_form // 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; + // Obtain the producer for this frame + producer_pixbuf this = mlt_properties_get_data( properties, "producer_pixbuf", 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 ); + refresh_image( this, 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 the image size + int image_size = this->width * ( this->height + 1 ) * 2; + int alpha_size = this->width * this->height; // Get width and height (may have changed during the refresh) *width = mlt_properties_get_int( properties, "width" ); @@ -239,26 +412,47 @@ static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_form // 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 ) + if ( this->image ) { - // Clone the image and the alpha - uint8_t *image_copy = mlt_pool_alloc( image_size ); - uint8_t *alpha_copy = mlt_pool_alloc( alpha_size ); + if ( *format == mlt_image_yuv422 || *format == mlt_image_yuv420p ) + { + // 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 ); + memcpy( image_copy, this->image, image_size ); - // Copy or default the alpha - if ( alpha != NULL ) - memcpy( alpha_copy, alpha, alpha_size ); - else - memset( alpha_copy, 255, alpha_size ); + // Copy or default the alpha + if ( this->alpha != NULL ) + memcpy( alpha_copy, this->alpha, alpha_size ); + else + memset( alpha_copy, 255, alpha_size ); + + // 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 if ( *format == mlt_image_rgb24a ) + { + // Clone the image and the alpha + image_size = *width * ( *height + 1 ) * 4; + alpha_size = *width * ( *height + 1 ); + uint8_t *image_copy = mlt_pool_alloc( image_size ); + uint8_t *alpha_copy = mlt_pool_alloc( alpha_size ); + + mlt_convert_yuv422_to_rgb24a( this->image, image_copy, (*width)*(*height) ); - // 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 ); + // 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; + } - // We're going to pass the copy on - *buffer = image_copy; } else { @@ -269,6 +463,11 @@ static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_form *height = 50; } + // Release references and locks + pthread_mutex_unlock( &this->mutex ); + mlt_cache_item_close( this->image_cache ); + mlt_cache_item_close( this->alpha_cache ); + return 0; } @@ -290,87 +489,10 @@ static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int i 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 ); - } - } - // 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 ) - { - char wildcard[ 1024 ]; - char *dir_name = strdup( filename ); - char *extension = strrchr( dir_name, '.' ); - - *( 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 ); - } + load_filenames( this, producer_properties ); // Generate a frame - *frame = mlt_frame_init( ); + *frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) ); if ( *frame != NULL && this->count > 0 ) { @@ -387,7 +509,7 @@ static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int i mlt_properties_set_position( properties, "pixbuf_position", mlt_producer_position( producer ) ); // Refresh the image - refresh_image( *frame, 0, 0 ); + refresh_image( this, *frame, 0, 0 ); // Set producer-specific frame properties mlt_properties_set_int( properties, "progressive", mlt_properties_get_int( producer_properties, "progressive" ) ); @@ -409,7 +531,7 @@ 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; - mlt_pool_release( this->image ); + pthread_mutex_destroy( &this->mutex ); parent->close = NULL; mlt_producer_close( parent ); mlt_properties_close( this->filenames );