[Mlt-devel] mlt/src/modules/qimage Makefile,NONE,1.1 configure,NONE,1.1 factory.c,NONE,1.1 gpl,NONE,
Brought to you by:
ddennedy,
lilo_booter
From: Charles Y. <lil...@us...> - 2006-03-29 08:59:10
|
Update of /cvsroot/mlt/mlt/src/modules/qimage In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv28590/qimage Added Files: Makefile configure factory.c gpl producer_qimage.c producer_qimage.h qimage_wrapper.cpp qimage_wrapper.h Log Message: + QImage module added - default is still GTK2 when available --- NEW FILE: gpl --- --- NEW FILE: configure --- #!/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 --- NEW FILE: qimage_wrapper.cpp --- /* * qimage_wrapper.cpp -- a QT/QImage based producer for MLT * Copyright (C) 2003-2004 Ushodaya Enterprises Limited * Author: Charles Yates <cha...@gm...> * * 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 <qimage.h> #include <cmath> extern "C" { #include <framework/mlt_pool.h> 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 ); } } --- NEW FILE: Makefile --- 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 --- NEW FILE: producer_qimage.c --- /* * producer_image.c -- a QT/QImage based producer for MLT * Copyright (C) 2003-2004 Ushodaya Enterprises Limited * Author: Dan Dennedy <da...@de...> * Charles Yates <cha...@gm...> * * 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 <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> 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, "<svg" ) ) { // Generate a temporary file for the svg char fullname[ 1024 ] = "/tmp/mlt.XXXXXX"; int fd = mkstemp( fullname ); if ( fd > -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 ); } --- NEW FILE: qimage_wrapper.h --- /* * qimage_wrapper.h -- a QT/QImage based producer for MLT * Copyright (C) 2003-2004 Ushodaya Enterprises Limited * Author: Charles Yates <cha...@gm...> * * 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 <framework/mlt.h> #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 --- NEW FILE: producer_qimage.h --- /* * producer_qimage.h -- a QT/QImage based producer for MLT * Copyright (C) 2006 Visual Media * Author: Charles Yates <cha...@gm...> * * 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 <framework/mlt_producer.h> extern mlt_producer producer_qimage_init( char *filename ); #endif --- NEW FILE: factory.c --- /* * factory.c -- the factory method interfaces * Copyright (C) 2006 Visual Media * Author: Charles Yates <cha...@gm...> * * 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 <string.h> #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; } |