2 * mlt_properties.c -- base properties class
3 * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4 * Author: Charles Yates <charles.yates@pandora.be>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 #include "mlt_properties.h"
23 #include "mlt_property.h"
30 /* ---------------- // Private Implementation // ---------------- */
32 /** Private implementation of the property list.
42 mlt_properties mirror;
47 /** Memory leak checks.
50 //#define _MLT_PROPERTY_CHECKS_
52 #ifdef _MLT_PROPERTY_CHECKS_
53 static int properties_created = 0;
54 static int properties_destroyed = 0;
57 /** Basic implementation.
60 int mlt_properties_init( mlt_properties this, void *child )
64 #ifdef _MLT_PROPERTY_CHECKS_
65 // Increment number of properties created
66 properties_created ++;
70 memset( this, 0, sizeof( struct mlt_properties_s ) );
72 // Assign the child of the object
75 // Allocate the local structure
76 this->local = calloc( sizeof( property_list ), 1 );
78 // Increment the ref count
79 ( ( property_list * )this->local )->ref_count = 1;
82 // Check that initialisation was successful
83 return this != NULL && this->local == NULL;
86 /** Constructor for stand alone object.
89 mlt_properties mlt_properties_new( )
91 // Construct a standalone properties object
92 mlt_properties this = calloc( sizeof( struct mlt_properties_s ), 1 );
95 mlt_properties_init( this, NULL );
101 /** Load properties from a file.
104 mlt_properties mlt_properties_load( char *filename )
106 // Construct a standalone properties object
107 mlt_properties this = mlt_properties_new( );
112 FILE *file = fopen( filename, "r" );
114 // Load contents of file
119 char last[ 1024 ] = "";
121 // Read each string from the file
122 while( fgets( temp, 1024, file ) )
125 temp[ strlen( temp ) - 1 ] = '\0';
127 // Check if the line starts with a .
128 if ( temp[ 0 ] == '.' )
131 sprintf( temp2, "%s%s", last, temp );
132 strcpy( temp, temp2 );
134 else if ( strchr( temp, '=' ) )
136 strcpy( last, temp );
137 *( strchr( last, '=' ) ) = '\0';
140 // Parse and set the property
141 if ( strcmp( temp, "" ) && temp[ 0 ] != '#' )
142 mlt_properties_parse( this, temp );
150 // Return the pointer
154 static inline int generate_hash( char *name )
159 hash = ( hash + ( i ++ * ( *name ++ & 31 ) ) ) % 199;
163 /** Special case - when a container (such as fezzik) is protecting another
164 producer, we need to ensure that properties are passed through to the
168 static inline void mlt_properties_do_mirror( mlt_properties this, char *name )
170 property_list *list = this->local;
171 if ( list->mirror != NULL )
173 char *value = mlt_properties_get( this, name );
175 mlt_properties_set( list->mirror, name, value );
179 /** Maintain ref count to allow multiple uses of an mlt object.
182 int mlt_properties_inc_ref( mlt_properties this )
186 property_list *list = this->local;
187 return ++ list->ref_count;
192 /** Maintain ref count to allow multiple uses of an mlt object.
195 int mlt_properties_dec_ref( mlt_properties this )
199 property_list *list = this->local;
200 return -- list->ref_count;
205 /** Return the ref count of this object.
208 int mlt_properties_ref_count( mlt_properties this )
212 property_list *list = this->local;
213 return list->ref_count;
218 /** Allow the specification of a mirror.
221 void mlt_properties_mirror( mlt_properties this, mlt_properties that )
223 property_list *list = this->local;
227 /** Inherit all serialisable properties from that into this.
230 int mlt_properties_inherit( mlt_properties this, mlt_properties that )
232 int count = mlt_properties_count( that );
234 for ( i = 0; i < count; i ++ )
236 char *value = mlt_properties_get_value( that, i );
239 char *name = mlt_properties_get_name( that, i );
240 mlt_properties_set( this, name, value );
246 /** Pass all properties from 'that' that match the prefix to 'this' (excluding the prefix).
249 int mlt_properties_pass( mlt_properties this, mlt_properties that, char *prefix )
251 int count = mlt_properties_count( that );
252 int length = strlen( prefix );
254 for ( i = 0; i < count; i ++ )
256 char *name = mlt_properties_get_name( that, i );
257 if ( !strncmp( name, prefix, length ) )
259 char *value = mlt_properties_get_value( that, i );
261 mlt_properties_set( this, name + length, value );
267 /** Locate a property by name
270 static inline mlt_property mlt_properties_find( mlt_properties this, char *name )
272 property_list *list = this->local;
273 mlt_property value = NULL;
274 int key = generate_hash( name );
275 int i = list->hash[ key ] - 1;
279 // Check if we're hashed
280 if ( list->count > 0 &&
281 name[ 0 ] == list->name[ i ][ 0 ] &&
282 !strcmp( list->name[ i ], name ) )
283 value = list->value[ i ];
286 for ( i = list->count - 1; value == NULL && i >= 0; i -- )
287 if ( name[ 0 ] == list->name[ i ][ 0 ] && !strcmp( list->name[ i ], name ) )
288 value = list->value[ i ];
294 /** Add a new property.
297 static mlt_property mlt_properties_add( mlt_properties this, char *name )
299 property_list *list = this->local;
300 int key = generate_hash( name );
302 // Check that we have space and resize if necessary
303 if ( list->count == list->size )
306 list->name = realloc( list->name, list->size * sizeof( char * ) );
307 list->value = realloc( list->value, list->size * sizeof( mlt_property ) );
310 // Assign name/value pair
311 list->name[ list->count ] = strdup( name );
312 list->value[ list->count ] = mlt_property_init( );
314 // Assign to hash table
315 if ( list->hash[ key ] == 0 )
316 list->hash[ key ] = list->count + 1;
318 // Return and increment count accordingly
319 return list->value[ list->count ++ ];
322 /** Fetch a property by name - this includes add if not found.
325 static mlt_property mlt_properties_fetch( mlt_properties this, char *name )
327 // Try to find an existing property first
328 mlt_property property = mlt_properties_find( this, name );
330 // If it wasn't found, create one
331 if ( property == NULL )
332 property = mlt_properties_add( this, name );
334 // Return the property
338 /** Set the property.
341 int mlt_properties_set( mlt_properties this, char *name, char *value )
345 // Fetch the property to work with
346 mlt_property property = mlt_properties_fetch( this, name );
348 // Set it if not NULL
349 if ( property != NULL && ( value == NULL || value[ 0 ] != '@' ) )
351 error = mlt_property_set_string( property, value );
352 mlt_properties_do_mirror( this, name );
354 else if ( property != NULL && value[ 0 ] == '@' )
363 while ( *value != '\0' )
365 int length = strcspn( value, "+-*/" );
367 // Get the identifier
368 strncpy( id, value, length );
372 // Determine the value
373 if ( isdigit( id[ 0 ] ) )
374 current = atof( id );
376 current = mlt_properties_get_int( this, id );
378 // Apply the operation
396 op = *value != '\0' ? *value ++ : ' ';
399 error = mlt_property_set_int( property, total );
400 mlt_properties_do_mirror( this, name );
403 mlt_events_fire( this, "property-changed", name, NULL );
408 /** Set or default the property.
411 int mlt_properties_set_or_default( mlt_properties this, char *name, char *value, char *def )
413 return mlt_properties_set( this, name, value == NULL ? def : value );
416 /** Get a string value by name.
419 char *mlt_properties_get( mlt_properties this, char *name )
421 mlt_property value = mlt_properties_find( this, name );
422 return value == NULL ? NULL : mlt_property_get_string( value );
425 /** Get a name by index.
428 char *mlt_properties_get_name( mlt_properties this, int index )
430 property_list *list = this->local;
431 if ( index >= 0 && index < list->count )
432 return list->name[ index ];
436 /** Get a string value by index.
439 char *mlt_properties_get_value( mlt_properties this, int index )
441 property_list *list = this->local;
442 if ( index >= 0 && index < list->count )
443 return mlt_property_get_string( list->value[ index ] );
447 /** Get a data value by index.
450 void *mlt_properties_get_data_at( mlt_properties this, int index, int *size )
452 property_list *list = this->local;
453 if ( index >= 0 && index < list->count )
454 return mlt_property_get_data( list->value[ index ], size );
458 /** Return the number of items in the list.
461 int mlt_properties_count( mlt_properties this )
463 property_list *list = this->local;
467 /** Set a value by parsing a name=value string
470 int mlt_properties_parse( mlt_properties this, char *namevalue )
472 char *name = strdup( namevalue );
475 char *ptr = strchr( name, '=' );
483 value = strdup( ptr );
488 value = strdup( ptr );
489 if ( value != NULL && value[ strlen( value ) - 1 ] == '\"' )
490 value[ strlen( value ) - 1 ] = '\0';
495 value = strdup( "" );
498 error = mlt_properties_set( this, name, value );
506 /** Get a value associated to the name.
509 int mlt_properties_get_int( mlt_properties this, char *name )
511 mlt_property value = mlt_properties_find( this, name );
512 return value == NULL ? 0 : mlt_property_get_int( value );
515 /** Set a value associated to the name.
518 int mlt_properties_set_int( mlt_properties this, char *name, int value )
522 // Fetch the property to work with
523 mlt_property property = mlt_properties_fetch( this, name );
525 // Set it if not NULL
526 if ( property != NULL )
528 error = mlt_property_set_int( property, value );
529 mlt_properties_do_mirror( this, name );
532 mlt_events_fire( this, "property-changed", name, NULL );
537 /** Get a value associated to the name.
540 double mlt_properties_get_double( mlt_properties this, char *name )
542 mlt_property value = mlt_properties_find( this, name );
543 return value == NULL ? 0 : mlt_property_get_double( value );
546 /** Set a value associated to the name.
549 int mlt_properties_set_double( mlt_properties this, char *name, double value )
553 // Fetch the property to work with
554 mlt_property property = mlt_properties_fetch( this, name );
556 // Set it if not NULL
557 if ( property != NULL )
559 error = mlt_property_set_double( property, value );
560 mlt_properties_do_mirror( this, name );
563 mlt_events_fire( this, "property-changed", name, NULL );
568 /** Get a value associated to the name.
571 mlt_position mlt_properties_get_position( mlt_properties this, char *name )
573 mlt_property value = mlt_properties_find( this, name );
574 return value == NULL ? 0 : mlt_property_get_position( value );
577 /** Set a value associated to the name.
580 int mlt_properties_set_position( mlt_properties this, char *name, mlt_position value )
584 // Fetch the property to work with
585 mlt_property property = mlt_properties_fetch( this, name );
587 // Set it if not NULL
588 if ( property != NULL )
590 error = mlt_property_set_position( property, value );
591 mlt_properties_do_mirror( this, name );
594 mlt_events_fire( this, "property-changed", name, NULL );
599 /** Get a value associated to the name.
602 void *mlt_properties_get_data( mlt_properties this, char *name, int *length )
604 mlt_property value = mlt_properties_find( this, name );
605 return value == NULL ? NULL : mlt_property_get_data( value, length );
608 /** Set a value associated to the name.
611 int mlt_properties_set_data( mlt_properties this, char *name, void *value, int length, mlt_destructor destroy, mlt_serialiser serialise )
615 // Fetch the property to work with
616 mlt_property property = mlt_properties_fetch( this, name );
618 // Set it if not NULL
619 if ( property != NULL )
620 error = mlt_property_set_data( property, value, length, destroy, serialise );
622 mlt_events_fire( this, "property-changed", name, NULL );
627 /** Rename a property.
630 int mlt_properties_rename( mlt_properties this, char *source, char *dest )
632 mlt_property value = mlt_properties_find( this, dest );
636 property_list *list = this->local;
640 for ( i = 0; i < list->count; i ++ )
642 if ( !strcmp( list->name[ i ], source ) )
644 free( list->name[ i ] );
645 list->name[ i ] = strdup( dest );
646 list->hash[ generate_hash( dest ) ] = i + 1;
652 return value != NULL;
655 /** Dump the properties.
658 void mlt_properties_dump( mlt_properties this, FILE *output )
660 property_list *list = this->local;
662 for ( i = 0; i < list->count; i ++ )
663 if ( mlt_properties_get( this, list->name[ i ] ) != NULL )
664 fprintf( output, "%s=%s\n", list->name[ i ], mlt_properties_get( this, list->name[ i ] ) );
667 void mlt_properties_debug( mlt_properties this, char *title, FILE *output )
669 fprintf( stderr, "%s: ", title );
672 property_list *list = this->local;
674 fprintf( output, "[ ref=%d", list->ref_count );
675 for ( i = 0; i < list->count; i ++ )
676 if ( mlt_properties_get( this, list->name[ i ] ) != NULL )
677 fprintf( output, ", %s=%s", list->name[ i ], mlt_properties_get( this, list->name[ i ] ) );
679 fprintf( output, ", %s=%p", list->name[ i ], mlt_properties_get_data( this, list->name[ i ], NULL ) );
680 fprintf( output, " ]" );
682 fprintf( stderr, "\n" );
688 void mlt_properties_close( mlt_properties this )
690 if ( this != NULL && mlt_properties_dec_ref( this ) <= 0 )
692 if ( this->close != NULL )
694 this->close( this->close_object );
698 property_list *list = this->local;
701 #ifdef _MLT_PROPERTY_CHECKS_
703 mlt_properties_debug( this, "Closing", stderr );
705 // Increment destroyed count
706 properties_destroyed ++;
708 // Show current stats - these should match when the app is closed
709 fprintf( stderr, "Created %d, destroyed %d\n", properties_created, properties_destroyed );
712 // Clean up names and values
713 for ( index = list->count - 1; index >= 0; index -- )
715 free( list->name[ index ] );
716 mlt_property_close( list->value[ index ] );
724 // Free this now if this has no child
725 if ( this->child == NULL )