X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fmodules%2Fqimage%2Fqimage_wrapper.cpp;h=2856324b240ca047d0962dd82811d77d5888ea29;hb=18d9ae818addddc1a836fa7644bbf18df544792b;hp=c07883629e93abd3126b1df4cf13d5fef38b3573;hpb=6ea63dd55257ba97df916aedc00711fcbb2f7906;p=melted diff --git a/src/modules/qimage/qimage_wrapper.cpp b/src/modules/qimage/qimage_wrapper.cpp index c078836..2856324 100644 --- a/src/modules/qimage/qimage_wrapper.cpp +++ b/src/modules/qimage/qimage_wrapper.cpp @@ -1,6 +1,6 @@ /* * qimage_wrapper.cpp -- a QT/QImage based producer for MLT - * Copyright (C) 2003-2004 Ushodaya Enterprises Limited + * Copyright (C) 2006 Visual Media * Author: Charles Yates * * NB: This module is designed to be functionally equivalent to the @@ -22,43 +22,63 @@ */ #include "qimage_wrapper.h" + +#ifdef USE_QT3 #include +#include + +#ifdef USE_KDE +#include +#include +#endif + +#endif + + +#ifdef USE_QT4 +#include +#include +#include +#endif + + #include extern "C" { #include +#ifdef USE_KDE +static KInstance *instance = 0L; +#endif + static void qimage_delete( void *data ) { QImage *image = ( QImage * )data; delete image; + image = NULL; +#ifdef USE_KDE + if (instance) delete instance; + instance = 0L; +#endif } -static void clear_buffered_image( mlt_properties producer_props, uint8_t **current_image, uint8_t **current_alpha ) -{ - mlt_events_block( producer_props, NULL ); - mlt_properties_set_data( producer_props, "_qimage_image", NULL, 0, NULL, NULL ); - mlt_properties_set_data( producer_props, "_qimage_alpha", NULL, 0, NULL, NULL ); - *current_image = NULL; - *current_alpha = NULL; - mlt_events_unblock( producer_props, NULL ); -} +QMutex mutex; -static void assign_buffered_image( mlt_properties producer_props, uint8_t *current_image, uint8_t *current_alpha, int width, int height ) +#ifdef USE_KDE +void init_qimage() { - mlt_events_block( producer_props, NULL ); - mlt_properties_set_data( producer_props, "_qimage_image", current_image, 0, mlt_pool_release, NULL ); - mlt_properties_set_data( producer_props, "_qimage_alpha", current_alpha, 0, mlt_pool_release, NULL ); - mlt_properties_set_int( producer_props, "_qimage_width", width ); - mlt_properties_set_int( producer_props, "_qimage_height", height ); - mlt_events_unblock( producer_props, NULL ); + if (!instance) { + instance = new KInstance("qimage_prod"); + KImageIO::registerFormats(); + } } +#endif void refresh_qimage( mlt_frame frame, int width, int height ) { // Obtain a previous assigned qimage (if it exists) - QImage *qimage = ( QImage * )mlt_properties_get_data( MLT_FRAME_PROPERTIES( frame ), "qimage", NULL ); + QImage *qimage = static_cast (mlt_properties_get_data( MLT_FRAME_PROPERTIES( frame ), "qimage", NULL )); // Obtain properties of frame mlt_properties properties = MLT_FRAME_PROPERTIES( frame ); @@ -72,33 +92,86 @@ void refresh_qimage( mlt_frame frame, int width, int height ) // Obtain properties of producer mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer ); - // Retrieve current info if available - uint8_t *current_image = ( uint8_t * )mlt_properties_get_data( producer_props, "_qimage_image", NULL ); - uint8_t *current_alpha = ( uint8_t * )mlt_properties_get_data( producer_props, "_qimage_alpha", NULL ); - int current_width = mlt_properties_get_int( producer_props, "_qimage_width" ); - int current_height = mlt_properties_get_int( producer_props, "_qimage_height" ); + // Check if user wants us to reload the image + if ( mlt_properties_get_int( producer_props, "force_reload" ) ) + { + qimage = NULL; + self->current_image = NULL; + mlt_properties_set_int( producer_props, "force_reload", 0 ); + } + + // Obtain the cache flag and structure + int use_cache = mlt_properties_get_int( producer_props, "cache" ); + mlt_properties cache = ( mlt_properties )mlt_properties_get_data( producer_props, "_cache", NULL ); + int update_cache = 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, "qimage_position" ); + position += mlt_producer_get_in( producer ); // Image index int image_idx = ( int )floor( ( double )position / ttl ) % self->count; + // Key for the cache + char image_key[ 10 ]; + sprintf( image_key, "%d", image_idx ); + + mutex.lock(); + + // Check if the frame is already loaded + if ( use_cache ) + { + if ( cache == NULL ) + { + cache = mlt_properties_new( ); + mlt_properties_set_data( producer_props, "_cache", cache, 0, ( mlt_destructor )mlt_properties_close, NULL ); + } + + mlt_frame cached = ( mlt_frame )mlt_properties_get_data( cache, image_key, NULL ); + + if ( cached ) + { + self->image_idx = image_idx; + mlt_properties cached_props = MLT_FRAME_PROPERTIES( cached ); + self->current_width = mlt_properties_get_int( cached_props, "width" ); + self->current_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" ) ); + self->current_image = ( uint8_t * )mlt_properties_get_data( cached_props, "image", NULL ); + self->current_alpha = ( uint8_t * )mlt_properties_get_data( cached_props, "alpha", NULL ); + + if ( width != 0 && ( width != self->current_width || height != self->current_height ) ) + self->current_image = NULL; + } + } + // optimization for subsequent iterations on single picture - if ( width != 0 && current_image != NULL && image_idx == self->image_idx ) + if ( width != 0 && self->current_image != NULL && image_idx == self->image_idx ) { - if ( width != current_width || height != current_height ) + if ( width != self->current_width || height != self->current_height ) { - qimage = ( QImage * )mlt_properties_get_data( producer_props, "_qimage", NULL ); - clear_buffered_image( producer_props, ¤t_image, ¤t_alpha ); + qimage = static_cast(mlt_properties_get_data( producer_props, "_qimage", NULL )); + if ( !use_cache ) + { + mlt_pool_release( self->current_image ); + mlt_pool_release( self->current_alpha ); + } + self->current_image = NULL; + self->current_alpha = NULL; } } - else if ( qimage == NULL && ( current_image == NULL || image_idx != self->image_idx ) ) + else if ( qimage == NULL && ( self->current_image == NULL || image_idx != self->image_idx ) ) { - clear_buffered_image( producer_props, ¤t_image, ¤t_alpha ); + if ( !use_cache ) + { + mlt_pool_release( self->current_image ); + mlt_pool_release( self->current_alpha ); + } + self->current_image = NULL; + self->current_alpha = NULL; self->image_idx = image_idx; qimage = new QImage( mlt_properties_get_value( self->filenames, image_idx ) ); @@ -108,15 +181,15 @@ void refresh_qimage( mlt_frame frame, int width, int height ) QImage *frame_copy = new QImage( *qimage ); // Store the width/height of the pixbuf - current_width = qimage->width( ); - current_height = qimage->height( ); + self->current_width = qimage->width( ); + self->current_height = qimage->height( ); // Register qimage for destruction and reuse mlt_events_block( producer_props, NULL ); mlt_properties_set_data( producer_props, "_qimage", qimage, 0, ( mlt_destructor )qimage_delete, NULL ); mlt_properties_set_data( MLT_FRAME_PROPERTIES( frame ), "qimage", frame_copy, 0, ( mlt_destructor )qimage_delete, NULL ); - mlt_properties_set_int( producer_props, "_real_width", current_width ); - mlt_properties_set_int( producer_props, "_real_height", current_height ); + mlt_properties_set_int( producer_props, "_real_width", self->current_width ); + mlt_properties_set_int( producer_props, "_real_height", self->current_height ); mlt_events_unblock( producer_props, NULL ); } else @@ -127,7 +200,7 @@ void refresh_qimage( mlt_frame frame, int width, int height ) } // If we have a pixbuf and this request specifies a valid dimension and we haven't already got a cached version... - if ( qimage && width > 0 && current_image == NULL ) + if ( qimage && width > 0 && self->current_image == NULL ) { char *interps = mlt_properties_get( properties, "rescale.interp" ); int interp = 0; @@ -138,36 +211,81 @@ void refresh_qimage( mlt_frame frame, int width, int height ) else if ( strcmp( interps, "hyper" ) == 0 ) interp = 1; +#ifdef USE_QT4 + // Note - the original qimage is already safe and ready for destruction + QImage scaled = interp == 0 ? qimage->scaled( QSize( width, height)) : qimage->scaled( QSize(width, height), Qt::IgnoreAspectRatio, Qt::SmoothTransformation); + QImage temp; + bool hasAlpha = scaled.hasAlphaChannel(); + if (hasAlpha) + temp = scaled.convertToFormat(QImage::Format_ARGB32); + else + temp = scaled.convertToFormat(QImage::Format_RGB888); +#endif + +#ifdef USE_QT3 // Note - the original qimage is already safe and ready for destruction QImage scaled = interp == 0 ? qimage->scale( width, height, QImage::ScaleFree ) : qimage->smoothScale( width, height, QImage::ScaleFree ); QImage temp = scaled.convertDepth( 32 ); + bool hasAlpha = true; +#endif // Store width and height - current_width = width; - current_height = height; + self->current_width = width; + self->current_height = height; // Allocate/define image - current_image = ( uint8_t * )mlt_pool_alloc( width * ( height + 1 ) * 2 ); + self->current_image = ( uint8_t * )mlt_pool_alloc( width * ( height + 1 ) * 2 ); - // Allocate the alpha mask - current_alpha = ( uint8_t * )mlt_pool_alloc( current_width * current_height ); - // Convert the image - mlt_convert_bgr24a_to_yuv422( temp.bits( ), current_width, current_height, temp.bytesPerLine( ), current_image, current_alpha ); + if (!hasAlpha) { + mlt_convert_rgb24_to_yuv422( temp.bits(), self->current_width, self->current_height, temp.bytesPerLine(), self->current_image ); + } + else { + // Allocate the alpha mask + self->current_alpha = ( uint8_t * )mlt_pool_alloc( self->current_width * self->current_height ); +#ifdef USE_QT4 + if ( QSysInfo::ByteOrder == QSysInfo::BigEndian ) + mlt_convert_argb_to_yuv422( temp.bits( ), self->current_width, self->current_height, temp.bytesPerLine(), self->current_image, self->current_alpha ); + else + mlt_convert_bgr24a_to_yuv422( temp.bits( ), self->current_width, self->current_height, temp.bytesPerLine( ), self->current_image, self->current_alpha ); +#endif - assign_buffered_image( producer_props, current_image, current_alpha, current_width, current_height ); +#ifdef USE_QT3 + // Convert the image + if ( QImage::systemByteOrder( ) == QImage::BigEndian ) + mlt_convert_argb_to_yuv422( temp.bits( ), self->current_width, self->current_height, temp.bytesPerLine( ), self->current_image, self->current_alpha ); + else + mlt_convert_bgr24a_to_yuv422( temp.bits( ), self->current_width, self->current_height, temp.bytesPerLine( ), self->current_image, self->current_alpha ); +#endif + } + + // Ensure we update the cache when we need to + update_cache = use_cache; } // Set width/height of frame - mlt_properties_set_int( properties, "width", current_width ); - mlt_properties_set_int( properties, "height", current_height ); + mlt_properties_set_int( properties, "width", self->current_width ); + mlt_properties_set_int( properties, "height", self->current_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", current_image, current_width * ( current_height + 1 ) * 2, NULL, NULL ); - mlt_properties_set_data( properties, "alpha", current_alpha, current_width * current_height, NULL, NULL ); -} + mlt_properties_set_data( properties, "image", self->current_image, self->current_width * ( self->current_height + 1 ) * 2, NULL, NULL ); + mlt_properties_set_data( properties, "alpha", self->current_alpha, self->current_width * self->current_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", self->current_width ); + mlt_properties_set_int( cached_props, "height", self->current_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", self->current_image, self->current_width * ( self->current_height + 1 ) * 2, mlt_pool_release, NULL ); + mlt_properties_set_data( cached_props, "alpha", self->current_alpha, self->current_width * self->current_height, mlt_pool_release, NULL ); + mlt_properties_set_data( cache, image_key, cached, 0, ( mlt_destructor )mlt_frame_close, NULL ); + } + mutex.unlock(); + } }