static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
{
// Get the real structure for this producer
producer_qimage self = producer->child;
// Fetch the producers properties
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
if ( self->filenames == NULL && mlt_properties_get( producer_properties, "resource" ) != NULL )
load_filenames( self, producer_properties );
// Generate a frame
*frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
if ( *frame != NULL && self->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_qimage", self, 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, "qimage_position", mlt_producer_position( producer ) );
// Refresh the image
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage = mlt_cache_item_data( self->qimage_cache, NULL );
refresh_qimage( self, *frame );
mlt_cache_item_close( self->qimage_cache );
// Set producer-specific frame properties
mlt_properties_set_int( properties, "progressive", mlt_properties_get_int( producer_properties, "progressive" ) );
double force_ratio = mlt_properties_get_double( producer_properties, "force_aspect_ratio" );
if ( force_ratio > 0.0 )
mlt_properties_set_double( properties, "aspect_ratio", force_ratio );
else
mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( producer_properties, "aspect_ratio" ) );
// Push the get_image method
mlt_frame_push_get_image( *frame, producer_get_image );
}
// Calculate the next timecode
mlt_producer_prepare_next( producer );
return 0;
}
void refresh_image( producer_qimage self, mlt_frame frame, mlt_image_format format, int width, int height )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
// Get index and qimage
int image_idx = refresh_qimage( self, frame );
// optimization for subsequent iterations on single pictur
if ( image_idx != self->image_idx || width != self->current_width || height != self->current_height )
self->current_image = NULL;
// If we have a qimage and need a new scaled image
if ( self->qimage && ( !self->current_image || ( format != mlt_image_none && format != self->format ) ) )
{
char *interps = mlt_properties_get( properties, "rescale.interp" );
int interp = 0;
QImage *qimage = static_cast<QImage*>( self->qimage );
// QImage has two scaling modes - we'll toggle between them here
if ( strcmp( interps, "tiles" ) == 0
|| strcmp( interps, "hyper" ) == 0
|| strcmp( interps, "bicubic" ) == 0 )
interp = 1;
// Note - the original qimage is already safe and ready for destruction
if ( qimage->depth() == 1 )
{
QImage temp = qimage->convertToFormat( QImage::Format_RGB32 );
delete qimage;
qimage = new QImage( temp );
self->qimage = qimage;
}
QImage scaled = interp == 0 ? qimage->scaled( QSize( width, height ) ) :
qimage->scaled( QSize(width, height), Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
int has_alpha = scaled.hasAlphaChannel();
// Store width and height
self->current_width = width;
self->current_height = height;
// Allocate/define image
int dst_stride = width * ( has_alpha ? 4 : 3 );
int image_size = dst_stride * ( height + 1 );
self->current_image = ( uint8_t * )mlt_pool_alloc( image_size );
self->current_alpha = NULL;
self->format = has_alpha ? mlt_image_rgb24a : mlt_image_rgb24;
// Copy the image
int y = self->current_height + 1;
uint8_t *dst = self->current_image;
while ( --y )
{
QRgb *src = (QRgb*) scaled.scanLine( self->current_height - y );
int x = self->current_width + 1;
while ( --x )
{
*dst++ = qRed(*src);
*dst++ = qGreen(*src);
*dst++ = qBlue(*src);
if ( has_alpha ) *dst++ = qAlpha(*src);
++src;
}
}
// Convert image to requested format
if ( format != mlt_image_none && format != self->format )
{
uint8_t *buffer = NULL;
// First, set the image so it can be converted when we get it
mlt_frame_replace_image( frame, self->current_image, self->format, width, height );
mlt_frame_set_image( frame, self->current_image, image_size, mlt_pool_release );
self->format = format;
// get_image will do the format conversion
mlt_frame_get_image( frame, &buffer, &format, &width, &height, 0 );
// cache copies of the image and alpha buffers
if ( buffer )
{
image_size = mlt_image_format_size( format, width, height, NULL );
self->current_image = (uint8_t*) mlt_pool_alloc( image_size );
memcpy( self->current_image, buffer, image_size );
}
if ( ( buffer = mlt_frame_get_alpha_mask( frame ) ) )
{
self->current_alpha = (uint8_t*) mlt_pool_alloc( width * height );
memcpy( self->current_alpha, buffer, width * height );
}
}
// Update the cache
mlt_cache_item_close( self->image_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.image", self->current_image, image_size, mlt_pool_release );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.image" );
self->image_idx = image_idx;
mlt_cache_item_close( self->alpha_cache );
self->alpha_cache = NULL;
if ( self->current_alpha )
{
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha", self->current_alpha, width * height, mlt_pool_release );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha" );
}
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->current_width );
mlt_properties_set_int( properties, "height", self->current_height );
}
int refresh_qimage( producer_qimage self, mlt_frame frame )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Check if user wants us to reload the image
if ( mlt_properties_get_int( producer_props, "force_reload" ) )
{
self->qimage = NULL;
self->current_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_frame_original_position( frame );
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 );
int disable_exif = mlt_properties_get_int( producer_props, "disable_exif" );
if ( app == NULL )
{
if ( qApp )
{
app = qApp;
}
else
{
#ifdef linux
if ( getenv("DISPLAY") == 0 )
{
mlt_log_panic( MLT_PRODUCER_SERVICE( producer ), "Error, cannot render titles without an X11 environment.\nPlease either run melt from an X session or use a fake X server like xvfb:\nxvfb-run -a melt (...)\n" );
return -1;
}
#endif
int argc = 1;
char* argv[1];
argv[0] = (char*) "xxx";
app = new QApplication( argc, argv );
const char *localename = mlt_properties_get_lcnumeric( MLT_SERVICE_PROPERTIES( MLT_PRODUCER_SERVICE( producer ) ) );
QLocale::setDefault( QLocale( localename ) );
}
}
if ( image_idx != self->qimage_idx )
self->qimage = NULL;
if ( !self->qimage || mlt_properties_get_int( producer_props, "_disable_exif" ) != disable_exif )
{
self->current_image = NULL;
QImage *qimage = new QImage( QString::fromUtf8( mlt_properties_get_value( self->filenames, image_idx ) ) );
self->qimage = qimage;
if ( !qimage->isNull( ) )
{
// Read the exif value for this file
if ( !disable_exif )
qimage = reorient_with_exif( self, image_idx, qimage );
// Register qimage for destruction and reuse
mlt_cache_item_close( self->qimage_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage", qimage, 0, ( mlt_destructor )qimage_delete );
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage_idx = image_idx;
// Store the width/height of the qimage
self->current_width = qimage->width( );
self->current_height = qimage->height( );
mlt_events_block( producer_props, NULL );
mlt_properties_set_int( producer_props, "meta.media.width", self->current_width );
mlt_properties_set_int( producer_props, "meta.media.height", self->current_height );
mlt_properties_set_int( producer_props, "_disable_exif", disable_exif );
mlt_events_unblock( producer_props, NULL );
}
else
{
delete qimage;
self->qimage = NULL;
}
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->current_width );
mlt_properties_set_int( properties, "height", self->current_height );
return image_idx;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
producer_qimage self = mlt_properties_get_data( properties, "producer_qimage", NULL );
mlt_producer producer = &self->parent;
*width = mlt_properties_get_int( properties, "rescale_width" );
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( &self->parent ) );
// Refresh the image
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage = mlt_cache_item_data( self->qimage_cache, NULL );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.image" );
self->current_image = mlt_cache_item_data( self->image_cache, NULL );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha" );
self->current_alpha = mlt_cache_item_data( self->alpha_cache, NULL );
refresh_image( self, frame, *format, *width, *height );
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
*format = self->format;
// 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 qimage producer...
if ( self->current_image )
{
// Clone the image and the alpha
int image_size = mlt_image_format_size( self->format, self->current_width, self->current_height, NULL );
uint8_t *image_copy = mlt_pool_alloc( image_size );
memcpy( image_copy, self->current_image, image_size );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
mlt_log_debug( MLT_PRODUCER_SERVICE( &self->parent ), "%dx%d (%s)\n",
self->current_width, self->current_height, mlt_image_format_name( *format ) );
// Clone the alpha channel
if ( self->current_alpha )
{
image_copy = mlt_pool_alloc( self->current_width * self->current_height );
memcpy( image_copy, self->current_alpha, self->current_width * self->current_height );
mlt_frame_set_alpha( frame, image_copy, self->current_width * self->current_height, mlt_pool_release );
}
}
else
{
error = 1;
}
// Release references and locks
mlt_cache_item_close( self->qimage_cache );
mlt_cache_item_close( self->image_cache );
mlt_cache_item_close( self->alpha_cache );
mlt_service_unlock( MLT_PRODUCER_SERVICE( &self->parent ) );
return error;
}
int refresh_qimage( producer_qimage self, mlt_frame frame )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Check if user wants us to reload the image
if ( mlt_properties_get_int( producer_props, "force_reload" ) )
{
self->qimage = NULL;
self->current_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_frame_original_position( frame );
position += mlt_producer_get_in( producer );
// Image index
int image_idx = ( int )floor( ( double )position / ttl ) % self->count;
int disable_exif = mlt_properties_get_int( producer_props, "disable_exif" );
if ( !createQApplicationIfNeeded( MLT_PRODUCER_SERVICE(producer) ) )
return -1;
if ( image_idx != self->qimage_idx )
self->qimage = NULL;
if ( !self->qimage || mlt_properties_get_int( producer_props, "_disable_exif" ) != disable_exif )
{
self->current_image = NULL;
QImage *qimage = new QImage( QString::fromUtf8( mlt_properties_get_value( self->filenames, image_idx ) ) );
self->qimage = qimage;
if ( !qimage->isNull( ) )
{
// Read the exif value for this file
if ( !disable_exif )
qimage = reorient_with_exif( self, image_idx, qimage );
// Register qimage for destruction and reuse
mlt_cache_item_close( self->qimage_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage", qimage, 0, ( mlt_destructor )qimage_delete );
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage_idx = image_idx;
// Store the width/height of the qimage
self->current_width = qimage->width( );
self->current_height = qimage->height( );
mlt_events_block( producer_props, NULL );
mlt_properties_set_int( producer_props, "meta.media.width", self->current_width );
mlt_properties_set_int( producer_props, "meta.media.height", self->current_height );
mlt_properties_set_int( producer_props, "_disable_exif", disable_exif );
mlt_events_unblock( producer_props, NULL );
}
else
{
delete qimage;
self->qimage = NULL;
}
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->current_width );
mlt_properties_set_int( properties, "height", self->current_height );
return image_idx;
}
static void refresh_image( producer_pixbuf self, mlt_frame frame, mlt_image_format format, int width, int height )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
// Get index and pixbuf
int current_idx = refresh_pixbuf( self, frame );
// optimization for subsequent iterations on single picture
if ( current_idx != self->image_idx || width != self->width || height != self->height )
self->image = NULL;
mlt_log_debug( MLT_PRODUCER_SERVICE( producer ), "image %p pixbuf %p idx %d current_idx %d pixbuf_idx %d width %d\n",
self->image, self->pixbuf, current_idx, self->image_idx, self->pixbuf_idx, width );
// If we have a pixbuf and we need an image
if ( self->pixbuf && ( !self->image || ( format != mlt_image_none && format != mlt_image_glsl && format != self->format ) ) )
{
char *interps = mlt_properties_get( properties, "rescale.interp" );
if ( interps ) interps = strdup( interps );
int interp = GDK_INTERP_BILINEAR;
if ( !interps ) {
// Keep bilinear by default
}
else 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 || strcmp( interps, "bicubic" ) == 0 )
interp = GDK_INTERP_HYPER;
free( interps );
// Note - the original pixbuf is already safe and ready for destruction
pthread_mutex_lock( &g_mutex );
GdkPixbuf* pixbuf = gdk_pixbuf_scale_simple( self->pixbuf, width, height, interp );
// Store width and height
self->width = width;
self->height = height;
// Allocate/define image
int has_alpha = gdk_pixbuf_get_has_alpha( pixbuf );
int src_stride = gdk_pixbuf_get_rowstride( pixbuf );
int dst_stride = self->width * ( has_alpha ? 4 : 3 );
int image_size = dst_stride * ( height + 1 );
self->image = mlt_pool_alloc( image_size );
self->alpha = NULL;
self->format = has_alpha ? mlt_image_rgb24a : mlt_image_rgb24;
if ( src_stride != dst_stride )
{
int y = self->height;
uint8_t *src = gdk_pixbuf_get_pixels( pixbuf );
uint8_t *dst = self->image;
while ( y-- )
{
memcpy( dst, src, dst_stride );
dst += dst_stride;
src += src_stride;
}
}
else
{
memcpy( self->image, gdk_pixbuf_get_pixels( pixbuf ), src_stride * height );
}
pthread_mutex_unlock( &g_mutex );
// Convert image to requested format
if ( format != mlt_image_none && format != mlt_image_glsl && format != self->format )
{
uint8_t *buffer = NULL;
// First, set the image so it can be converted when we get it
mlt_frame_replace_image( frame, self->image, self->format, width, height );
mlt_frame_set_image( frame, self->image, image_size, mlt_pool_release );
self->format = format;
// get_image will do the format conversion
mlt_frame_get_image( frame, &buffer, &format, &width, &height, 0 );
// cache copies of the image and alpha buffers
if ( buffer )
{
image_size = mlt_image_format_size( format, width, height, NULL );
self->image = mlt_pool_alloc( image_size );
memcpy( self->image, buffer, image_size );
}
if ( ( buffer = mlt_frame_get_alpha_mask( frame ) ) )
{
self->alpha = mlt_pool_alloc( width * height );
memcpy( self->alpha, buffer, width * height );
}
}
// Update the cache
mlt_cache_item_close( self->image_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.image", self->image, image_size, mlt_pool_release );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.image" );
self->image_idx = current_idx;
mlt_cache_item_close( self->alpha_cache );
self->alpha_cache = NULL;
if ( self->alpha )
{
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.alpha", self->alpha, width * height, mlt_pool_release );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.alpha" );
}
// Finished with pixbuf now
g_object_unref( pixbuf );
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->width );
mlt_properties_set_int( properties, "height", self->height );
}
static int refresh_pixbuf( producer_pixbuf self, mlt_frame frame )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Check if user wants us to reload the image
if ( mlt_properties_get_int( producer_props, "force_reload" ) )
{
self->pixbuf = NULL;
self->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_frame_original_position( frame );
position += mlt_producer_get_in( producer );
// Image index
int loop = mlt_properties_get_int( producer_props, "loop" );
int current_idx;
if (loop) {
current_idx = ( int )floor( ( double )position / ttl ) % self->count;
} else {
current_idx = MIN(( double )position / ttl, self->count - 1);
}
// Key for the cache
char image_key[ 10 ];
sprintf( image_key, "%d", current_idx );
int disable_exif = mlt_properties_get_int( producer_props, "disable_exif" );
if ( current_idx != self->pixbuf_idx )
self->pixbuf = NULL;
if ( !self->pixbuf || mlt_properties_get_int( producer_props, "_disable_exif" ) != disable_exif )
{
GError *error = NULL;
self->image = NULL;
pthread_mutex_lock( &g_mutex );
self->pixbuf = gdk_pixbuf_new_from_file( mlt_properties_get_value( self->filenames, current_idx ), &error );
if ( self->pixbuf )
{
// Read the exif value for this file
if ( !disable_exif )
self->pixbuf = reorient_with_exif( self, current_idx, self->pixbuf );
// Register this pixbuf for destruction and reuse
mlt_cache_item_close( self->pixbuf_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.pixbuf", self->pixbuf, 0, ( mlt_destructor )g_object_unref );
self->pixbuf_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.pixbuf" );
self->pixbuf_idx = current_idx;
// Store the width/height of the pixbuf temporarily
self->width = gdk_pixbuf_get_width( self->pixbuf );
self->height = gdk_pixbuf_get_height( self->pixbuf );
mlt_events_block( producer_props, NULL );
mlt_properties_set_int( producer_props, "meta.media.width", self->width );
mlt_properties_set_int( producer_props, "meta.media.height", self->height );
mlt_properties_set_int( producer_props, "_disable_exif", disable_exif );
mlt_events_unblock( producer_props, NULL );
}
pthread_mutex_unlock( &g_mutex );
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->width );
mlt_properties_set_int( properties, "height", self->height );
return current_idx;
}
