From 6ea63dd55257ba97df916aedc00711fcbb2f7906 Mon Sep 17 00:00:00 2001 From: lilo_booter Date: Wed, 29 Mar 2006 08:59:07 +0000 Subject: [PATCH] + QImage module added - default is still GTK2 when available git-svn-id: https://mlt.svn.sourceforge.net/svnroot/mlt/trunk/mlt@902 d19143bc-622f-0410-bfdd-b5b2a6649095 --- src/modules/fezzik.dict | 14 +- src/modules/qimage/Makefile | 33 ++++ src/modules/qimage/configure | 51 +++++++ src/modules/qimage/factory.c | 46 ++++++ src/modules/qimage/producer_qimage.c | 267 +++++++++++++++++++++++++++++++++ src/modules/qimage/producer_qimage.h | 28 ++++ src/modules/qimage/qimage_wrapper.cpp | 173 +++++++++++++++++++++ src/modules/qimage/qimage_wrapper.h | 49 ++++++ 8 files changed, 654 insertions(+), 7 deletions(-) create mode 100644 src/modules/qimage/Makefile create mode 100755 src/modules/qimage/configure create mode 100644 src/modules/qimage/factory.c create mode 100644 src/modules/qimage/gpl create mode 100644 src/modules/qimage/producer_qimage.c create mode 100644 src/modules/qimage/producer_qimage.h create mode 100644 src/modules/qimage/qimage_wrapper.cpp create mode 100644 src/modules/qimage/qimage_wrapper.h diff --git a/src/modules/fezzik.dict b/src/modules/fezzik.dict index 7e4b0a0..e7ee588 100644 --- a/src/modules/fezzik.dict +++ b/src/modules/fezzik.dict @@ -4,15 +4,15 @@ http://*=avformat *.inigo=inigo_file *.asf=avformat *.avi=mcdv,libdv,avformat -*.bmp=pixbuf,sdl_image +*.bmp=pixbuf,qimage,sdl_image *.dv=mcdv,libdv,avformat *.dif=mcdv,libdv -*.gif=pixbuf,sdl_image +*.gif=pixbuf,qimage,sdl_image *.graphics=westley *.jfx=westley *.jef=westley -*.jpg=pixbuf,sdl_image -*.jpeg=pixbuf,sdl_image +*.jpg=pixbuf,qimage,sdl_image +*.jpeg=pixbuf,qimage,sdl_image *.kino=westley *.mp3=avformat *.mov=mcdv,libdv,avformat @@ -20,11 +20,11 @@ http://*=avformat *.mpeg=mcmpeg,avformat *.mpl=pango *.ogg=vorbis -*.pgm=pgm,pixbuf,sdl_image -*.png=pixbuf,sdl_image +*.pgm=pgm,pixbuf,qimage,sdl_image +*.png=pixbuf,qimage,sdl_image *.story=westley *.svg=pixbuf -*.tga=pixbuf,sdl_image +*.tga=pixbuf,qimage,sdl_image *.txt=pango *.vob=mcmpeg,avformat *.wav=avformat diff --git a/src/modules/qimage/Makefile b/src/modules/qimage/Makefile new file mode 100644 index 0000000..742d951 --- /dev/null +++ b/src/modules/qimage/Makefile @@ -0,0 +1,33 @@ +include ../../../config.mak +include config.mak + +TARGET=../libmltqimage.so + +OBJS=factory.o producer_qimage.o +CPPOBJS=qimage_wrapper.o +CFLAGS+=-I../../ +LDFLAGS+=-L../../framework $(QTLIBS) -lmlt -lstdc++ +CXXFLAGS+=$(CFLAGS) $(QTCXXFLAGS) -Wno-deprecated + +SRCS := $(OBJS:.o=.c) $(CPPOBJS:.o=.cpp) + +all: $(TARGET) + +$(TARGET): $(OBJS) $(CPPOBJS) + $(CC) -shared -o $@ $(OBJS) $(CPPOBJS) $(LDFLAGS) + +depend: $(SRCS) + $(CC) -MM $(CFLAGS) $(QTCXXFLAGS) $^ 1>.depend + +distclean: clean + rm -f .depend config.h config.mak + +clean: + rm -f $(OBJS) $(TARGET) $(CPPOBJS) + +install: all + install -m 755 $(TARGET) "$(DESTDIR)$(prefix)/share/mlt/modules" + +ifneq ($(wildcard .depend),) +include .depend +endif diff --git a/src/modules/qimage/configure b/src/modules/qimage/configure new file mode 100755 index 0000000..9f80fb3 --- /dev/null +++ b/src/modules/qimage/configure @@ -0,0 +1,51 @@ +#!/bin/sh + +if [ "$help" = "1" ] +then + cat << EOF +QImage options: + + --qimage-libdir - Location of QT lib directory [/usr/lib/qt3] + --qimage-includedir - Location of QT include directory [/usr/include/qt3] + +EOF +else + targetos=$(uname -s) + case $targetos in + MINGW32*) + export LIBSUF=.dll + ;; + Darwin) + export LIBSUF=.dylib + ;; + Linux) + export LIBSUF=.so + ;; + *) + ;; + esac + + qimage_includedir=/usr/include/qt3 + qimage_libdir=/usr/lib/qt3 + + [ "$QTDIR" != "" ] && qimage_libdir=$QTDIR + + for i in "$@" + do + case $i in + --qimage-libdir=* ) qimage_libdir="${i#--qimage-libdir=}" ;; + --qimage-includedir=* ) qimage_includedir="${i#--qimage-includedir=}" ;; + esac + done + + if [ -d "$qimage_libdir" -a -d "$qimage_includedir" ] + then + echo QTCXXFLAGS=-I$qimage_includedir > config.mak + echo QTLIBS=-lqt-mt >> config.mak + echo qimage libmltqimage$LIBSUF >> ../producers.dat + else + echo "qimage: QT environment not found - disabling" + touch ../disable-qimage + fi + +fi diff --git a/src/modules/qimage/factory.c b/src/modules/qimage/factory.c new file mode 100644 index 0000000..5f0a507 --- /dev/null +++ b/src/modules/qimage/factory.c @@ -0,0 +1,46 @@ +/* + * factory.c -- the factory method interfaces + * Copyright (C) 2006 Visual Media + * Author: Charles Yates + * + * 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 program 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. + * + * 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. + */ + +#include + +#include "producer_qimage.h" + +void *mlt_create_producer( char *id, void *arg ) +{ + if ( !strcmp( id, "qimage" ) ) + return producer_qimage_init( arg ); + return NULL; +} + +void *mlt_create_filter( char *id, void *arg ) +{ + return NULL; +} + +void *mlt_create_transition( char *id, void *arg ) +{ + return NULL; +} + +void *mlt_create_consumer( char *id, void *arg ) +{ + return NULL; +} + diff --git a/src/modules/qimage/gpl b/src/modules/qimage/gpl new file mode 100644 index 0000000..e69de29 diff --git a/src/modules/qimage/producer_qimage.c b/src/modules/qimage/producer_qimage.c new file mode 100644 index 0000000..34fae62 --- /dev/null +++ b/src/modules/qimage/producer_qimage.c @@ -0,0 +1,267 @@ +/* + * producer_image.c -- a QT/QImage based producer for MLT + * Copyright (C) 2003-2004 Ushodaya Enterprises Limited + * Author: Dan Dennedy + * Charles Yates + * + * NB: This module is designed to be functionally equivalent to the + * gtk2 image loading module so it can be used as replacement. + * + * 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 program 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. + * + * 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. + */ + +#include "producer_qimage.h" +#include "qimage_wrapper.h" + +#include +#include +#include +#include +#include +#include +#include + +static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int index ); +static void producer_close( mlt_producer parent ); + +mlt_producer producer_qimage_init( char *filename ) +{ + producer_qimage this = calloc( sizeof( struct producer_qimage_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 = ( 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 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_qimage( 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 qimage 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 ); + + // 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_qimage 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 ); + } + } + // 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 ); + } + + // 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_qimage", 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, "qimage_position", mlt_producer_position( producer ) ); + + // Refresh the image + refresh_qimage( *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; + + // 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; +} + +static void producer_close( mlt_producer parent ) +{ + producer_qimage this = parent->child; + parent->close = NULL; + mlt_producer_close( parent ); + mlt_properties_close( this->filenames ); + free( this ); +} diff --git a/src/modules/qimage/producer_qimage.h b/src/modules/qimage/producer_qimage.h new file mode 100644 index 0000000..6a2248d --- /dev/null +++ b/src/modules/qimage/producer_qimage.h @@ -0,0 +1,28 @@ +/* + * producer_qimage.h -- a QT/QImage based producer for MLT + * Copyright (C) 2006 Visual Media + * Author: Charles Yates + * + * 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 program 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. + * + * 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. + */ + +#ifndef _PRODUCER_QIMAGE_H_ +#define _PRODUCER_QIMAGE_H_ + +#include + +extern mlt_producer producer_qimage_init( char *filename ); + +#endif diff --git a/src/modules/qimage/qimage_wrapper.cpp b/src/modules/qimage/qimage_wrapper.cpp new file mode 100644 index 0000000..c078836 --- /dev/null +++ b/src/modules/qimage/qimage_wrapper.cpp @@ -0,0 +1,173 @@ +/* + * qimage_wrapper.cpp -- a QT/QImage based producer for MLT + * Copyright (C) 2003-2004 Ushodaya Enterprises Limited + * Author: Charles Yates + * + * NB: This module is designed to be functionally equivalent to the + * gtk2 image loading module so it can be used as replacement. + * + * 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 program 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. + * + * 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. + */ + +#include "qimage_wrapper.h" +#include +#include + +extern "C" { + +#include + +static void qimage_delete( void *data ) +{ + QImage *image = ( QImage * )data; + delete image; +} + +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 ); +} + +static void assign_buffered_image( mlt_properties producer_props, uint8_t *current_image, uint8_t *current_alpha, int width, int height ) +{ + 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 ); +} + +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 ); + + // Obtain properties of frame + mlt_properties properties = MLT_FRAME_PROPERTIES( frame ); + + // Obtain the producer for this frame + producer_qimage self = ( producer_qimage )mlt_properties_get_data( properties, "producer_qimage", NULL ); + + // Obtain the producer + mlt_producer producer = &self->parent; + + // 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" ); + + // 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" ); + + // Image index + int image_idx = ( int )floor( ( double )position / ttl ) % self->count; + + // optimization for subsequent iterations on single picture + if ( width != 0 && current_image != NULL && image_idx == self->image_idx ) + { + if ( width != current_width || height != current_height ) + { + qimage = ( QImage * )mlt_properties_get_data( producer_props, "_qimage", NULL ); + clear_buffered_image( producer_props, ¤t_image, ¤t_alpha ); + } + } + else if ( qimage == NULL && ( current_image == NULL || image_idx != self->image_idx ) ) + { + clear_buffered_image( producer_props, ¤t_image, ¤t_alpha ); + + self->image_idx = image_idx; + qimage = new QImage( mlt_properties_get_value( self->filenames, image_idx ) ); + + if ( !qimage->isNull( ) ) + { + QImage *frame_copy = new QImage( *qimage ); + + // Store the width/height of the pixbuf + current_width = qimage->width( ); + 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_events_unblock( producer_props, NULL ); + } + else + { + delete qimage; + qimage = NULL; + } + } + + // 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 ) + { + char *interps = mlt_properties_get( properties, "rescale.interp" ); + int interp = 0; + + // QImage has two scaling modes - we'll toggle between them here + if ( strcmp( interps, "tiles" ) == 0 ) + interp = 1; + else if ( strcmp( interps, "hyper" ) == 0 ) + interp = 1; + + // 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 ); + + // Store width and height + current_width = width; + current_height = height; + + // Allocate/define image + 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 ); + + assign_buffered_image( producer_props, current_image, current_alpha, current_width, current_height ); + } + + // 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, "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 ); +} + +} + diff --git a/src/modules/qimage/qimage_wrapper.h b/src/modules/qimage/qimage_wrapper.h new file mode 100644 index 0000000..0f2214d --- /dev/null +++ b/src/modules/qimage/qimage_wrapper.h @@ -0,0 +1,49 @@ +/* + * qimage_wrapper.h -- a QT/QImage based producer for MLT + * Copyright (C) 2003-2004 Ushodaya Enterprises Limited + * Author: Charles Yates + * + * NB: This module is designed to be functionally equivalent to the + * gtk2 image loading module so it can be used as replacement. + * + * 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 program 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. + * + * 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. + */ + +#ifndef MLT_QIMAGE_WRAPPER +#define MLT_QIMAGE_WRAPPER + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct producer_qimage_s +{ + struct mlt_producer_s parent; + mlt_properties filenames; + int count; + int image_idx; +}; + +typedef struct producer_qimage_s *producer_qimage; + +extern void refresh_qimage( mlt_frame, int width, int height ); + +#ifdef __cplusplus +} +#endif + +#endif -- 1.7.4.4