X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fframework%2Fmlt_factory.c;h=552b8ce30304ce78715f211b1ec6008b8cc6a35e;hb=f4963a6aa07644399b273b5d2b1f9299c9047414;hp=61093a13dfa657d8624880470768c0d81a306aaf;hpb=2c0cf75e5da5906e48c5a6398bd48d04501283b9;p=melted diff --git a/src/framework/mlt_factory.c b/src/framework/mlt_factory.c index 61093a1..552b8ce 100644 --- a/src/framework/mlt_factory.c +++ b/src/framework/mlt_factory.c @@ -1,24 +1,25 @@ -/* - * mlt_factory.c -- the factory method interfaces - * Copyright (C) 2003-2004 Ushodaya Enterprises Limited - * Author: Charles Yates +/** + * \file mlt_factory.c + * \brief the factory method interfaces * - * 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. + * Copyright (C) 2003-2009 Ushodaya Enterprises Limited + * \author Charles Yates * - * This program is distributed in the hope that it will be useful, + * 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 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 "config.h" #include "mlt.h" #include "mlt_repository.h" @@ -26,79 +27,206 @@ #include #include -/** Singleton repositories -*/ +/** the default subdirectory of the libdir for holding modules (plugins) */ +#define PREFIX_LIB LIBDIR "/mlt" +/** the default subdirectory of the install prefix for holding module (plugin) data */ +#define PREFIX_DATA PREFIX "/share/mlt" + -static char *mlt_prefix = NULL; +/** holds the full path to the modules directory - initialized and retained for the entire session */ +static char *mlt_directory = NULL; +/** a global properties list for holding environment config data and things needing session-oriented cleanup */ static mlt_properties global_properties = NULL; -static mlt_properties object_list = NULL; -static mlt_repository producers = NULL; -static mlt_repository filters = NULL; -static mlt_repository transitions = NULL; -static mlt_repository consumers = NULL; +/** the global repository singleton */ +static mlt_repository repository = NULL; +/** the events object for the factory events */ +static mlt_properties event_object = NULL; +/** for tracking the unique_id set on each constructed service */ static int unique_id = 0; -/** Construct the factories. -*/ +/* Event transmitters. */ + +/** the -create-request event transmitter + * + * \param listener + * \param owner + * \param this + * \param args + */ + +static void mlt_factory_create_request( mlt_listener listener, mlt_properties owner, mlt_service this, void **args ) +{ + if ( listener != NULL ) + listener( owner, this, ( char * )args[ 0 ], ( char * )args[ 1 ], ( mlt_service * )args[ 2 ] ); +} + +/** the -create-done event transmitter + * + * \param listener + * \param owner + * \param this + * \param args + */ + +static void mlt_factory_create_done( mlt_listener listener, mlt_properties owner, mlt_service this, void **args ) +{ + if ( listener != NULL ) + listener( owner, this, ( char * )args[ 0 ], ( char * )args[ 1 ], ( mlt_service )args[ 2 ] ); +} + +/** Construct the repository and factories. + * + * The environment variable MLT_PRODUCER is the name of a default producer often used by other services, defaults to "fezzil". + * + * The environment variable MLT_CONSUMER is the name of a default consumer, defaults to "sdl". + * + * The environment variable MLT_TEST_CARD is the name of a producer or file to be played when nothing is available (all tracks blank). + * + * The environment variable MLT_DATA overrides the default full path to the MLT and module supplemental data files, defaults to \p PREFIX_DATA. + * + * The environment variable MLT_PROFILE defaults to "dv_pal." + * + * The environment variable MLT_REPOSITORY overrides the default location of the plugin modules, defaults to \p PREFIX_LIB. + * + * \param directory an optional full path to a directory containing the modules that overrides the default and + * the MLT_REPOSITORY environment variable + * \return the repository + */ -int mlt_factory_init( char *prefix ) +mlt_repository mlt_factory_init( const char *directory ) { // Only initialise once - if ( mlt_prefix == NULL ) + if ( mlt_directory == NULL ) { // Allow user over rides - if ( prefix == NULL ) - prefix = getenv( "MLT_REPOSITORY" ); + if ( directory == NULL || !strcmp( directory, "" ) ) + directory = getenv( "MLT_REPOSITORY" ); // If no directory is specified, default to install directory - if ( prefix == NULL ) - prefix = PREFIX_DATA; + if ( directory == NULL ) + directory = PREFIX_LIB; // Store the prefix for later retrieval - mlt_prefix = strdup( prefix ); + mlt_directory = strdup( directory ); // Initialise the pool mlt_pool_init( ); + // Create and set up the events object + event_object = mlt_properties_new( ); + mlt_events_init( event_object ); + mlt_events_register( event_object, "producer-create-request", ( mlt_transmitter )mlt_factory_create_request ); + mlt_events_register( event_object, "producer-create-done", ( mlt_transmitter )mlt_factory_create_done ); + mlt_events_register( event_object, "filter-create-request", ( mlt_transmitter )mlt_factory_create_request ); + mlt_events_register( event_object, "filter-create-done", ( mlt_transmitter )mlt_factory_create_done ); + mlt_events_register( event_object, "transition-create-request", ( mlt_transmitter )mlt_factory_create_request ); + mlt_events_register( event_object, "transition-create-done", ( mlt_transmitter )mlt_factory_create_done ); + mlt_events_register( event_object, "consumer-create-request", ( mlt_transmitter )mlt_factory_create_request ); + mlt_events_register( event_object, "consumer-create-done", ( mlt_transmitter )mlt_factory_create_done ); + // Create the global properties global_properties = mlt_properties_new( ); + + // Create the repository of services + repository = mlt_repository_init( directory ); + + // Force a clean up when app closes + atexit( mlt_factory_close ); + } + + // Allow property refresh on a subsequent initialisation + if ( global_properties != NULL ) + { mlt_properties_set_or_default( global_properties, "MLT_NORMALISATION", getenv( "MLT_NORMALISATION" ), "PAL" ); mlt_properties_set_or_default( global_properties, "MLT_PRODUCER", getenv( "MLT_PRODUCER" ), "fezzik" ); mlt_properties_set_or_default( global_properties, "MLT_CONSUMER", getenv( "MLT_CONSUMER" ), "sdl" ); + mlt_properties_set( global_properties, "MLT_TEST_CARD", getenv( "MLT_TEST_CARD" ) ); + mlt_properties_set_or_default( global_properties, "MLT_PROFILE", getenv( "MLT_PROFILE" ), "dv_pal" ); + mlt_properties_set_or_default( global_properties, "MLT_DATA", getenv( "MLT_DATA" ), PREFIX_DATA ); + } - // Create the object list. - object_list = mlt_properties_new( ); - // Create a repository for each service type - producers = mlt_repository_init( object_list, prefix, "producers.dat", "mlt_create_producer" ); - filters = mlt_repository_init( object_list, prefix, "filters.dat", "mlt_create_filter" ); - transitions = mlt_repository_init( object_list, prefix, "transitions.dat", "mlt_create_transition" ); - consumers = mlt_repository_init( object_list, prefix, "consumers.dat", "mlt_create_consumer" ); - } + return repository; +} + +/** Fetch the events object. + * + * \return the global factory event object + */ - return 0; +mlt_properties mlt_factory_event_object( ) +{ + return event_object; } -/** Fetch the prefix used in this instance. -*/ +/** Fetch the module directory used in this instance. + * + * \return the full path to the module directory that this session is using + */ -const char *mlt_factory_prefix( ) +const char *mlt_factory_directory( ) { - return mlt_prefix; + return mlt_directory; } /** Get a value from the environment. -*/ + * + * \param name the name of a MLT (runtime configuration) environment variable + * \return the value of the variable + */ -char *mlt_environment( char *name ) +char *mlt_environment( const char *name ) { - return mlt_properties_get( global_properties, name ); + if ( global_properties ) + return mlt_properties_get( global_properties, name ); + else + return NULL; +} + +/** Set a value in the environment. + * + * \param name the name of a MLT environment variable + * \param value the value of the variable + * \return true on error + */ + +int mlt_environment_set( const char *name, const char *value ) +{ + if ( global_properties ) + return mlt_properties_set( global_properties, name, value ); + else + return -1; +} + +/** Set some properties common to all services. + * + * This sets _unique_id, \p mlt_type, \p mlt_service (unless _mlt_service_hidden), and _profile. + * + * \param properties a service's properties list + * \param profile the \p mlt_profile supplied to the factory function + * \param type the MLT service class + * \param service the name of the service + */ + +static void set_common_properties( mlt_properties properties, mlt_profile profile, const char *type, const char *service ) +{ + mlt_properties_set_int( properties, "_unique_id", ++ unique_id ); + mlt_properties_set( properties, "mlt_type", type ); + if ( mlt_properties_get_int( properties, "_mlt_service_hidden" ) == 0 ) + mlt_properties_set( properties, "mlt_service", service ); + if ( profile != NULL ) + mlt_properties_set_data( properties, "_profile", profile, 0, NULL, NULL ); } /** Fetch a producer from the repository. -*/ + * + * \param profile the \p mlt_profile to use + * \param service the name of the producer (optional, defaults to MLT_PRODUCER) + * \param input an optional argument to the producer constructor, typically a string + * \return a new producer + */ -mlt_producer mlt_factory_producer( char *service, void *input ) +mlt_producer mlt_factory_producer( mlt_profile profile, const char *service, const void *input ) { mlt_producer obj = NULL; @@ -106,76 +234,118 @@ mlt_producer mlt_factory_producer( char *service, void *input ) if ( service == NULL ) service = mlt_environment( "MLT_PRODUCER" ); - // Try to instantiate via the specified service - obj = mlt_repository_fetch( producers, service, input ); + // Offer the application the chance to 'create' + mlt_events_fire( event_object, "producer-create-request", service, input, &obj, NULL ); - if ( obj != NULL ) + // Try to instantiate via the specified service + if ( obj == NULL ) { - mlt_properties properties = mlt_producer_properties( obj ); - mlt_properties_set_int( properties, "_unique_id", ++ unique_id ); - mlt_properties_set( properties, "mlt_type", "producer" ); - if ( mlt_properties_get_int( properties, "_mlt_service_hidden" ) == 0 ) - mlt_properties_set( properties, "mlt_service", service ); + obj = mlt_repository_create( repository, profile, producer_type, service, input ); + mlt_events_fire( event_object, "producer-create-done", service, input, obj, NULL ); + if ( obj != NULL ) + { + mlt_properties properties = MLT_PRODUCER_PROPERTIES( obj ); + set_common_properties( properties, profile, "producer", service ); + } } return obj; } /** Fetch a filter from the repository. -*/ + * + * \param profile the \p mlt_profile to use + * \param service the name of the filter + * \param input an optional argument to the filter constructor, typically a string + * \return a new filter + */ -mlt_filter mlt_factory_filter( char *service, void *input ) +mlt_filter mlt_factory_filter( mlt_profile profile, const char *service, const void *input ) { - mlt_filter obj = mlt_repository_fetch( filters, service, input ); + mlt_filter obj = NULL; + + // Offer the application the chance to 'create' + mlt_events_fire( event_object, "filter-create-request", service, input, &obj, NULL ); + + if ( obj == NULL ) + { + obj = mlt_repository_create( repository, profile, filter_type, service, input ); + mlt_events_fire( event_object, "filter-create-done", service, input, obj, NULL ); + } + if ( obj != NULL ) { - mlt_properties properties = mlt_filter_properties( obj ); - mlt_properties_set_int( properties, "_unique_id", ++ unique_id ); - mlt_properties_set( properties, "mlt_type", "filter" ); - mlt_properties_set( properties, "mlt_service", service ); + mlt_properties properties = MLT_FILTER_PROPERTIES( obj ); + set_common_properties( properties, profile, "filter", service ); } return obj; } /** Fetch a transition from the repository. -*/ + * + * \param profile the \p mlt_profile to use + * \param service the name of the transition + * \param input an optional argument to the transition constructor, typically a string + * \return a new transition + */ -mlt_transition mlt_factory_transition( char *service, void *input ) +mlt_transition mlt_factory_transition( mlt_profile profile, const char *service, const void *input ) { - mlt_transition obj = mlt_repository_fetch( transitions, service, input ); + mlt_transition obj = NULL; + + // Offer the application the chance to 'create' + mlt_events_fire( event_object, "transition-create-request", service, input, &obj, NULL ); + + if ( obj == NULL ) + { + obj = mlt_repository_create( repository, profile, transition_type, service, input ); + mlt_events_fire( event_object, "transition-create-done", service, input, obj, NULL ); + } + if ( obj != NULL ) { - mlt_properties properties = mlt_transition_properties( obj ); - mlt_properties_set_int( properties, "_unique_id", ++ unique_id ); - mlt_properties_set( properties, "mlt_type", "transition" ); - mlt_properties_set( properties, "mlt_service", service ); + mlt_properties properties = MLT_TRANSITION_PROPERTIES( obj ); + set_common_properties( properties, profile, "transition", service ); } return obj; } -/** Fetch a consumer from the repository -*/ +/** Fetch a consumer from the repository. + * + * \param profile the \p mlt_profile to use + * \param service the name of the consumer (optional, defaults to MLT_CONSUMER) + * \param input an optional argument to the consumer constructor, typically a string + * \return a new consumer + */ -mlt_consumer mlt_factory_consumer( char *service, void *input ) +mlt_consumer mlt_factory_consumer( mlt_profile profile, const char *service, const void *input ) { mlt_consumer obj = NULL; if ( service == NULL ) service = mlt_environment( "MLT_CONSUMER" ); - obj = mlt_repository_fetch( consumers, service, input ); + // Offer the application the chance to 'create' + mlt_events_fire( event_object, "consumer-create-request", service, input, &obj, NULL ); + + if ( obj == NULL ) + { + obj = mlt_repository_create( repository, profile, consumer_type, service, input ); + mlt_events_fire( event_object, "consumer-create-done", service, input, obj, NULL ); + } if ( obj != NULL ) { - mlt_properties properties = mlt_consumer_properties( obj ); - mlt_properties_set_int( properties, "_unique_id", ++ unique_id ); - mlt_properties_set( properties, "mlt_type", "consumer" ); - mlt_properties_set( properties, "mlt_service", service ); + mlt_properties properties = MLT_CONSUMER_PROPERTIES( obj ); + set_common_properties( properties, profile, "consumer", service ); } return obj; } /** Register an object for clean up. -*/ + * + * \param ptr an opaque pointer to anything allocated on the heap + * \param destructor the function pointer of the deallocation subroutine (e.g., free or \p mlt_pool_release) + */ void mlt_factory_register_for_clean_up( void *ptr, mlt_destructor destructor ) { @@ -185,21 +355,24 @@ void mlt_factory_register_for_clean_up( void *ptr, mlt_destructor destructor ) } /** Close the factory. -*/ + * + * Cleanup all resources for the session. + */ void mlt_factory_close( ) { - if ( mlt_prefix != NULL ) + if ( mlt_directory != NULL ) { - mlt_repository_close( producers ); - mlt_repository_close( filters ); - mlt_repository_close( transitions ); - mlt_repository_close( consumers ); - mlt_properties_close( object_list ); + mlt_properties_close( event_object ); mlt_properties_close( global_properties ); - free( mlt_prefix ); - mlt_prefix = NULL; + mlt_repository_close( repository ); + free( mlt_directory ); + mlt_directory = NULL; mlt_pool_close( ); } } +mlt_properties mlt_global_properties( ) +{ + return global_properties; +}