Constness changes
[melted] / src / framework / mlt_repository.c
1 /**
2 * \file mlt_repository.c
3 * \brief provides a map between service and shared objects
4 * \see mlt_repository_s
5 *
6 * Copyright (C) 2003-2009 Ushodaya Enterprises Limited
7 * \author Charles Yates <charles.yates@pandora.be>
8 * \author Dan Dennedy <dan@dennedy.org>
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 #include "mlt_repository.h"
26 #include "mlt_properties.h"
27 #include "mlt_tokeniser.h"
28 #include "mlt_log.h"
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <dlfcn.h>
33 #include <string.h>
34
35 /** \brief Repository class
36 *
37 * The Repository is a collection of plugin modules and their services and service metadata.
38 *
39 * \extends mlt_properties_s
40 * \properties \p language a cached list of user locales
41 */
42
43 struct mlt_repository_s
44 {
45 struct mlt_properties_s parent; /// a list of object files
46 mlt_properties consumers; /// a list of entry points for consumers
47 mlt_properties filters; /// a list of entry points for filters
48 mlt_properties producers; /// a list of entry points for producers
49 mlt_properties transitions; /// a list of entry points for transitions
50 };
51
52 /** Construct a new repository.
53 *
54 * \public \memberof mlt_repository_s
55 * \param directory the full path of a directory from which to read modules
56 * \return a new repository or NULL if failed
57 */
58
59 mlt_repository mlt_repository_init( const char *directory )
60 {
61 // Safety check
62 if ( directory == NULL || strcmp( directory, "" ) == 0 )
63 return NULL;
64
65 // Construct the repository
66 mlt_repository this = calloc( sizeof( struct mlt_repository_s ), 1 );
67 mlt_properties_init( &this->parent, this );
68 this->consumers = mlt_properties_new();
69 this->filters = mlt_properties_new();
70 this->producers = mlt_properties_new();
71 this->transitions = mlt_properties_new();
72
73 // Get the directory list
74 mlt_properties dir = mlt_properties_new();
75 int count = mlt_properties_dir_list( dir, directory, NULL, 0 );
76 int i;
77
78 // Iterate over files
79 for ( i = 0; i < count; i++ )
80 {
81 int flags = RTLD_NOW;
82 const char *object_name = mlt_properties_get_value( dir, i);
83
84 // Very temporary hack to allow the quicktime plugins to work
85 // TODO: extend repository to allow this to be used on a case by case basis
86 if ( strstr( object_name, "libmltkino" ) )
87 flags |= RTLD_GLOBAL;
88
89 // Open the shared object
90 void *object = dlopen( object_name, flags );
91 if ( object != NULL )
92 {
93 // Get the registration function
94 mlt_repository_callback symbol_ptr = dlsym( object, "mlt_register" );
95
96 // Call the registration function
97 if ( symbol_ptr != NULL )
98 {
99 symbol_ptr( this );
100
101 // Register the object file for closure
102 mlt_properties_set_data( &this->parent, object_name, object, 0, ( mlt_destructor )dlclose, NULL );
103 }
104 else
105 {
106 dlclose( object );
107 }
108 }
109 else if ( strstr( object_name, "libmlt" ) )
110 {
111 mlt_log( NULL, MLT_LOG_WARNING, "%s: failed to dlopen %s\n (%s)\n", __FUNCTION__, object_name, dlerror() );
112 }
113 }
114
115 mlt_properties_close( dir );
116
117 return this;
118 }
119
120 /** Create a properties list for a service holding a function pointer to its constructor function.
121 *
122 * \private \memberof mlt_repository_s
123 * \param symbol a pointer to a function that can create the service.
124 * \return a properties list
125 */
126
127 static mlt_properties new_service( void *symbol )
128 {
129 mlt_properties properties = mlt_properties_new();
130 mlt_properties_set_data( properties, "symbol", symbol, 0, NULL, NULL );
131 return properties;
132 }
133
134 /** Register a service with the repository.
135 *
136 * Typically, this is invoked by a module within its mlt_register().
137 *
138 * \public \memberof mlt_repository_s
139 * \param this a repository
140 * \param service_type a service class
141 * \param service the name of a service
142 * \param symbol a pointer to a function to create the service
143 */
144
145 void mlt_repository_register( mlt_repository this, mlt_service_type service_type, const char *service, mlt_register_callback symbol )
146 {
147 // Add the entry point to the corresponding service list
148 switch ( service_type )
149 {
150 case consumer_type:
151 mlt_properties_set_data( this->consumers, service, new_service( symbol ), 0, ( mlt_destructor )mlt_properties_close, NULL );
152 break;
153 case filter_type:
154 mlt_properties_set_data( this->filters, service, new_service( symbol ), 0, ( mlt_destructor )mlt_properties_close, NULL );
155 break;
156 case producer_type:
157 mlt_properties_set_data( this->producers, service, new_service( symbol ), 0, ( mlt_destructor )mlt_properties_close, NULL );
158 break;
159 case transition_type:
160 mlt_properties_set_data( this->transitions, service, new_service( symbol ), 0, ( mlt_destructor )mlt_properties_close, NULL );
161 break;
162 default:
163 break;
164 }
165 }
166
167 /** Get the repository properties for particular service class.
168 *
169 * \private \memberof mlt_repository_s
170 * \param this a repository
171 * \param type a service class
172 * \param service the name of a service
173 * \return a properties list or NULL if error
174 */
175
176 static mlt_properties get_service_properties( mlt_repository this, mlt_service_type type, const char *service )
177 {
178 mlt_properties service_properties = NULL;
179
180 // Get the entry point from the corresponding service list
181 switch ( type )
182 {
183 case consumer_type:
184 service_properties = mlt_properties_get_data( this->consumers, service, NULL );
185 break;
186 case filter_type:
187 service_properties = mlt_properties_get_data( this->filters, service, NULL );
188 break;
189 case producer_type:
190 service_properties = mlt_properties_get_data( this->producers, service, NULL );
191 break;
192 case transition_type:
193 service_properties = mlt_properties_get_data( this->transitions, service, NULL );
194 break;
195 default:
196 break;
197 }
198 return service_properties;
199 }
200
201 /** Construct a new instance of a service.
202 *
203 * \public \memberof mlt_repository_s
204 * \param this a repository
205 * \param profile a \p mlt_profile to give the service
206 * \param type a service class
207 * \param service the name of the service
208 * \param input an optional argument to the service constructor
209 */
210
211 void *mlt_repository_create( mlt_repository this, mlt_profile profile, mlt_service_type type, const char *service, const void *input )
212 {
213 mlt_properties properties = get_service_properties( this, type, service );
214 if ( properties != NULL )
215 {
216 mlt_register_callback symbol_ptr = mlt_properties_get_data( properties, "symbol", NULL );
217
218 // Construct the service
219 return ( symbol_ptr != NULL ) ? symbol_ptr( profile, type, service, input ) : NULL;
220 }
221 return NULL;
222 }
223
224 /** Destroy a repository and free its resources.
225 *
226 * \public \memberof mlt_repository_s
227 * \param this a repository
228 */
229
230 void mlt_repository_close( mlt_repository this )
231 {
232 mlt_properties_close( this->consumers );
233 mlt_properties_close( this->filters );
234 mlt_properties_close( this->producers );
235 mlt_properties_close( this->transitions );
236 mlt_properties_close( &this->parent );
237 free( this );
238 }
239
240 /** Get the list of registered consumers.
241 *
242 * \public \memberof mlt_repository_s
243 * \param self a repository
244 * \return a properties list containing all of the consumers
245 */
246
247 mlt_properties mlt_repository_consumers( mlt_repository self )
248 {
249 return self->consumers;
250 }
251
252 /** Get the list of registered filters.
253 *
254 * \public \memberof mlt_repository_s
255 * \param self a repository
256 * \return a properties list of all of the filters
257 */
258
259 mlt_properties mlt_repository_filters( mlt_repository self )
260 {
261 return self->filters;
262 }
263
264 /** Get the list of registered producers.
265 *
266 * \public \memberof mlt_repository_s
267 * \param self a repository
268 * \return a properties list of all of the producers
269 */
270
271 mlt_properties mlt_repository_producers( mlt_repository self )
272 {
273 return self->producers;
274 }
275
276 /** Get the list of registered transitions.
277 *
278 * \public \memberof mlt_repository_s
279 * \param self a repository
280 * \return a properties list of all of the transitions
281 */
282
283 mlt_properties mlt_repository_transitions( mlt_repository self )
284 {
285 return self->transitions;
286 }
287
288 /** Register the metadata for a service.
289 *
290 * IMPORTANT: mlt_repository will take responsibility for deallocating the metadata properties
291 * that you supply!
292 *
293 * \public \memberof mlt_repository_s
294 * \param self a repository
295 * \param type a service class
296 * \param service the name of a service
297 * \param callback the pointer to a function that can supply metadata
298 * \param callback_data an opaque user data pointer to be supplied on the callback
299 */
300
301 void mlt_repository_register_metadata( mlt_repository self, mlt_service_type type, const char *service, mlt_metadata_callback callback, void *callback_data )
302 {
303 mlt_properties service_properties = get_service_properties( self, type, service );
304 mlt_properties_set_data( service_properties, "metadata_cb", callback, 0, NULL, NULL );
305 mlt_properties_set_data( service_properties, "metadata_cb_data", callback_data, 0, NULL, NULL );
306 }
307
308 /** Get the metadata about a service.
309 *
310 * Returns NULL if service or its metadata are unavailable.
311 *
312 * \public \memberof mlt_repository_s
313 * \param self a repository
314 * \param type a service class
315 * \param service the name of a service
316 * \return the service metadata as a structured properties list
317 */
318
319 mlt_properties mlt_repository_metadata( mlt_repository self, mlt_service_type type, const char *service )
320 {
321 mlt_properties metadata = NULL;
322 mlt_properties properties = get_service_properties( self, type, service );
323
324 // If this is a valid service
325 if ( properties )
326 {
327 // Lookup cached metadata
328 metadata = mlt_properties_get_data( properties, "metadata", NULL );
329 if ( ! metadata )
330 {
331 // Not cached, so get the registered metadata callback function
332 mlt_metadata_callback callback = mlt_properties_get_data( properties, "metadata_cb", NULL );
333
334 // If a metadata callback function is registered
335 if ( callback )
336 {
337 // Fetch the callback data arg
338 void *data = mlt_properties_get_data( properties, "metadata_cb_data", NULL );
339
340 // Fetch the metadata through the callback
341 metadata = callback( type, service, data );
342
343 // Cache the metadata
344 if ( metadata )
345 // Include dellocation and serialisation
346 mlt_properties_set_data( properties, "metadata", metadata, 0, ( mlt_destructor )mlt_properties_close, ( mlt_serialiser )mlt_properties_serialise_yaml );
347 }
348 }
349 }
350 return metadata;
351 }
352
353 /** Try to determine the locale from some commonly used environment variables.
354 *
355 * \private \memberof mlt_repository_s
356 * \return a string containing the locale id or NULL if unknown
357 */
358
359 static char *getenv_locale()
360 {
361 char *s = getenv( "LANGUAGE" );
362 if ( s && s[0] )
363 return s;
364 s = getenv( "LC_ALL" );
365 if ( s && s[0] )
366 return s;
367 s = getenv( "LC_MESSAGES" );
368 if ( s && s[0] )
369 return s;
370 s = getenv( "LANG" );
371 if ( s && s[0] )
372 return s;
373 return NULL;
374 }
375
376 /** Return a list of user-preferred language codes taken from environment variables.
377 *
378 * A module should use this to locate a localized YAML Tiny file from which to build
379 * its metadata strucutured properties.
380 *
381 * \public \memberof mlt_repository_s
382 * \param self a repository
383 * \return a properties list that is a list (not a map) of locales, defaults to "en" if not
384 * overridden by environment variables, in order: LANGUAGE, LC_ALL, LC_MESSAGES, LANG
385 */
386
387 mlt_properties mlt_repository_languages( mlt_repository self )
388 {
389 mlt_properties languages = mlt_properties_get_data( &self->parent, "languages", NULL );
390 if ( languages )
391 return languages;
392
393 languages = mlt_properties_new();
394 char *locale = getenv_locale();
395 if ( locale )
396 {
397 locale = strdup( locale );
398 mlt_tokeniser tokeniser = mlt_tokeniser_init();
399 int count = mlt_tokeniser_parse_new( tokeniser, locale, ":" );
400 if ( count )
401 {
402 int i;
403 for ( i = 0; i < count; i++ )
404 {
405 char *locale = mlt_tokeniser_get_string( tokeniser, i );
406 if ( strcmp( locale, "C" ) == 0 || strcmp( locale, "POSIX" ) == 0 )
407 locale = "en";
408 else if ( strlen( locale ) > 2 )
409 locale[2] = 0;
410 char string[21];
411 snprintf( string, sizeof(string), "%d", i );
412 mlt_properties_set( languages, string, locale );
413 }
414 }
415 else
416 {
417 mlt_properties_set( languages, "0", "en" );
418 }
419 free( locale );
420 mlt_tokeniser_close( tokeniser );
421 }
422 else
423 {
424 mlt_properties_set( languages, "0", "en" );
425 }
426 mlt_properties_set_data( &self->parent, "languages", languages, 0, ( mlt_destructor )mlt_properties_close, NULL );
427 return languages;
428 }