typedef struct
{
+ int hash[ 199 ];
char **name;
mlt_property *value;
int count;
int size;
+ mlt_properties mirror;
}
property_list;
return this;
}
+/** Load properties from a file.
+*/
+
+mlt_properties mlt_properties_load( char *filename )
+{
+ // Construct a standalone properties object
+ mlt_properties this = mlt_properties_new( );
+
+ if ( this != NULL )
+ {
+ // Open the file
+ FILE *file = fopen( filename, "r" );
+
+ // Load contents of file
+ if ( file != NULL )
+ {
+ // Temp string
+ char temp[ 1024 ];
+
+ // Read each string from the file
+ while( fgets( temp, 1024, file ) )
+ {
+ // Chomp the string
+ temp[ strlen( temp ) - 1 ] = '\0';
+
+ // Parse and set the property
+ if ( strcmp( temp, "" ) && temp[ 0 ] != '#' )
+ mlt_properties_parse( this, temp );
+ }
+
+ // Close the file
+ fclose( file );
+ }
+ }
+
+ // Return the pointer
+ return this;
+}
+
+static inline int generate_hash( char *name )
+{
+ int hash = 0;
+ int i = 1;
+ while ( *name )
+ hash = ( hash + ( i ++ * ( *name ++ & 31 ) ) ) % 199;
+ return hash;
+}
+
/** Special case - when a container (such as fezzik) is protecting another
producer, we need to ensure that properties are passed through to the
real producer.
*/
-static void mlt_properties_do_mirror( mlt_properties this, char *name )
+static inline void mlt_properties_do_mirror( mlt_properties this, char *name )
{
- if ( strcmp( name, "in" ) && strcmp( name, "out" ) )
+ property_list *list = this->private;
+ if ( list->mirror != NULL )
{
- mlt_properties mirror = mlt_properties_get_data( this, "mlt_mirror", NULL );
- if ( mirror != NULL )
- {
- char *value = mlt_properties_get( this, name );
- if ( value != NULL )
- mlt_properties_set( mirror, name, value );
- }
+ char *value = mlt_properties_get( this, name );
+ if ( value != NULL )
+ mlt_properties_set( list->mirror, name, value );
}
}
void mlt_properties_mirror( mlt_properties this, mlt_properties that )
{
- mlt_properties_set_data( this, "mlt_mirror", that, 0, NULL, NULL );
+ property_list *list = this->private;
+ list->mirror = that;
}
/** Inherit all serialisable properties from that into this.
int mlt_properties_inherit( mlt_properties this, mlt_properties that )
{
int count = mlt_properties_count( that );
- while ( count -- )
+ int i = 0;
+ for ( i = 0; i < count; i ++ )
{
- char *value = mlt_properties_get_value( that, count );
+ char *value = mlt_properties_get_value( that, i );
if ( value != NULL )
{
- char *name = mlt_properties_get_name( that, count );
+ char *name = mlt_properties_get_name( that, i );
mlt_properties_set( this, name, value );
}
}
return 0;
}
+/** Pass all properties from 'that' that match the prefix to 'this' (excluding the prefix).
+*/
+
+int mlt_properties_pass( mlt_properties this, mlt_properties that, char *prefix )
+{
+ int count = mlt_properties_count( that );
+ int length = strlen( prefix );
+ int i = 0;
+ for ( i = 0; i < count; i ++ )
+ {
+ char *name = mlt_properties_get_name( that, i );
+ if ( !strncmp( name, prefix, length ) )
+ {
+ char *value = mlt_properties_get_value( that, i );
+ if ( value != NULL )
+ mlt_properties_set( this, name + length, value );
+ }
+ }
+ return 0;
+}
+
/** Locate a property by name
*/
-static mlt_property mlt_properties_find( mlt_properties this, char *name )
+static inline mlt_property mlt_properties_find( mlt_properties this, char *name )
{
- mlt_property value = NULL;
property_list *list = this->private;
- int i = 0;
+ mlt_property value = NULL;
+ int key = generate_hash( name );
+ int i = list->hash[ key ] - 1;
- // Locate the item
- for ( i = 0; value == NULL && i < list->count; i ++ )
- if ( !strcmp( list->name[ i ], name ) )
+ if ( i >= 0 )
+ {
+ // Check if we're hashed
+ if ( list->count > 0 &&
+ name[ 0 ] == list->name[ i ][ 0 ] &&
+ !strcmp( list->name[ i ], name ) )
value = list->value[ i ];
+ // Locate the item
+ for ( i = list->count - 1; value == NULL && i >= 0; i -- )
+ if ( name[ 0 ] == list->name[ i ][ 0 ] && !strcmp( list->name[ i ], name ) )
+ value = list->value[ i ];
+ }
+
return value;
}
static mlt_property mlt_properties_add( mlt_properties this, char *name )
{
property_list *list = this->private;
+ int key = generate_hash( name );
// Check that we have space and resize if necessary
if ( list->count == list->size )
list->name[ list->count ] = strdup( name );
list->value[ list->count ] = mlt_property_init( );
+ // Assign to hash table
+ if ( list->hash[ key ] == 0 )
+ list->hash[ key ] = list->count + 1;
+
// Return and increment count accordingly
return list->value[ list->count ++ ];
}
return error;
}
+/** Set or default the property.
+*/
+
+int mlt_properties_set_or_default( mlt_properties this, char *name, char *value, char *def )
+{
+ return mlt_properties_set( this, name, value == NULL ? def : value );
+}
+
/** Get a string value by name.
*/
{
free( list->name[ i ] );
list->name[ i ] = strdup( dest );
+ list->hash[ generate_hash( dest ) ] = i + 1;
break;
}
}