research.m1stereo.tv/gitweb/ - melted/blob - src/framework/mlt_properties.c

   1 /*
   2  * mlt_properties.c -- base properties class
   3  * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
   4  * Author: Charles Yates <charles.yates@pandora.be>
   5  *
   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.
  10  *
  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.
  15  *
  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.
  19  */
  20
  21 #include "config.h"
  22 #include "mlt_properties.h"
  23 #include "mlt_property.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <ctype.h>
  29
  30 /* ---------------- // Private Implementation // ---------------- */
  31
  32 /** Private implementation of the property list.
  33 */
  34
  35 typedef struct
  36 {
  37         int hash[ 199 ];
  38         char **name;
  39         mlt_property *value;
  40         int count;
  41         int size;
  42         mlt_properties mirror;
  43         int ref_count;
  44 }
  45 property_list;
  46
  47 /** Memory leak checks.
  48 */
  49
  50 //#define _MLT_PROPERTY_CHECKS_
  51
  52 #ifdef _MLT_PROPERTY_CHECKS_
  53 static int properties_created = 0;
  54 static int properties_destroyed = 0;
  55 #endif
  56
  57 /** Basic implementation.
  58 */
  59
  60 int mlt_properties_init( mlt_properties this, void *child )
  61 {
  62         if ( this != NULL )
  63         {
  64 #ifdef _MLT_PROPERTY_CHECKS_
  65                 // Increment number of properties created
  66                 properties_created ++;
  67 #endif
  68
  69                 // NULL all methods
  70                 memset( this, 0, sizeof( struct mlt_properties_s ) );
  71
  72                 // Assign the child of the object
  73                 this->child = child;
  74
  75                 // Allocate the local structure
  76                 this->local = calloc( sizeof( property_list ), 1 );
  77
  78                 // Increment the ref count
  79                 ( ( property_list * )this->local )->ref_count = 1;
  80         }
  81
  82         // Check that initialisation was successful
  83         return this != NULL && this->local == NULL;
  84 }
  85
  86 /** Constructor for stand alone object.
  87 */
  88
  89 mlt_properties mlt_properties_new( )
  90 {
  91         // Construct a standalone properties object
  92         mlt_properties this = calloc( sizeof( struct mlt_properties_s ), 1 );
  93
  94         // Initialise this
  95         mlt_properties_init( this, NULL );
  96
  97         // Return the pointer
  98         return this;
  99 }
 100
 101 /** Load properties from a file.
 102 */
 103
 104 mlt_properties mlt_properties_load( char *filename )
 105 {
 106         // Construct a standalone properties object
 107         mlt_properties this = mlt_properties_new( );
 108
 109         if ( this != NULL )
 110         {
 111                 // Open the file
 112                 FILE *file = fopen( filename, "r" );
 113
 114                 // Load contents of file
 115                 if ( file != NULL )
 116                 {
 117                         // Temp string
 118                         char temp[ 1024 ];
 119
 120                         // Read each string from the file
 121                         while( fgets( temp, 1024, file ) )
 122                         {
 123                                 // Chomp the string
 124                                 temp[ strlen( temp ) - 1 ] = '\0';
 125
 126                                 // Parse and set the property
 127                                 if ( strcmp( temp, "" ) && temp[ 0 ] != '#' )
 128                                         mlt_properties_parse( this, temp );
 129                         }
 130
 131                         // Close the file
 132                         fclose( file );
 133                 }
 134         }
 135
 136         // Return the pointer
 137         return this;
 138 }
 139
 140 static inline int generate_hash( char *name )
 141 {
 142         int hash = 0;
 143         int i = 1;
 144         while ( *name )
 145                 hash = ( hash + ( i ++ * ( *name ++ & 31 ) ) ) % 199;
 146         return hash;
 147 }
 148
 149 /** Special case - when a container (such as fezzik) is protecting another
 150         producer, we need to ensure that properties are passed through to the
 151         real producer.
 152 */
 153
 154 static inline void mlt_properties_do_mirror( mlt_properties this, char *name )
 155 {
 156         property_list *list = this->local;
 157         if ( list->mirror != NULL )
 158         {
 159                 char *value = mlt_properties_get( this, name );
 160                 if ( value != NULL )
 161                         mlt_properties_set( list->mirror, name, value );
 162         }
 163 }
 164
 165 /** Maintain ref count to allow multiple uses of an mlt object.
 166 */
 167
 168 int mlt_properties_inc_ref( mlt_properties this )
 169 {
 170         if ( this != NULL )
 171         {
 172                 property_list *list = this->local;
 173                 return ++ list->ref_count;
 174         }
 175         return 0;
 176 }
 177
 178 /** Maintain ref count to allow multiple uses of an mlt object.
 179 */
 180
 181 int mlt_properties_dec_ref( mlt_properties this )
 182 {
 183         if ( this != NULL )
 184         {
 185                 property_list *list = this->local;
 186                 return -- list->ref_count;
 187         }
 188         return 0;
 189 }
 190
 191 /** Allow the specification of a mirror.
 192 */
 193
 194 void mlt_properties_mirror( mlt_properties this, mlt_properties that )
 195 {
 196         property_list *list = this->local;
 197         list->mirror = that;
 198 }
 199
 200 /** Inherit all serialisable properties from that into this.
 201 */
 202
 203 int mlt_properties_inherit( mlt_properties this, mlt_properties that )
 204 {
 205         int count = mlt_properties_count( that );
 206         int i = 0;
 207         for ( i = 0; i < count; i ++ )
 208         {
 209                 char *value = mlt_properties_get_value( that, i );
 210                 if ( value != NULL )
 211                 {
 212                         char *name = mlt_properties_get_name( that, i );
 213                         mlt_properties_set( this, name, value );
 214                 }
 215         }
 216         return 0;
 217 }
 218
 219 /** Pass all properties from 'that' that match the prefix to 'this' (excluding the prefix).
 220 */
 221
 222 int mlt_properties_pass( mlt_properties this, mlt_properties that, char *prefix )
 223 {
 224         int count = mlt_properties_count( that );
 225         int length = strlen( prefix );
 226         int i = 0;
 227         for ( i = 0; i < count; i ++ )
 228         {
 229                 char *name = mlt_properties_get_name( that, i );
 230                 if ( !strncmp( name, prefix, length ) )
 231                 {
 232                         char *value = mlt_properties_get_value( that, i );
 233                         if ( value != NULL )
 234                                 mlt_properties_set( this, name + length, value );
 235                 }
 236         }
 237         return 0;
 238 }
 239
 240 /** Locate a property by name
 241 */
 242
 243 static inline mlt_property mlt_properties_find( mlt_properties this, char *name )
 244 {
 245         property_list *list = this->local;
 246         mlt_property value = NULL;
 247         int key = generate_hash( name );
 248         int i = list->hash[ key ] - 1;
 249
 250         if ( i >= 0 )
 251         {
 252                 // Check if we're hashed
 253                 if ( list->count > 0 &&
 254                         name[ 0 ] == list->name[ i ][ 0 ] &&
 255                         !strcmp( list->name[ i ], name ) )
 256                         value = list->value[ i ];
 257
 258                 // Locate the item
 259                 for ( i = list->count - 1; value == NULL && i >= 0; i -- )
 260                         if ( name[ 0 ] == list->name[ i ][ 0 ] && !strcmp( list->name[ i ], name ) )
 261                                 value = list->value[ i ];
 262         }
 263
 264         return value;
 265 }
 266
 267 /** Add a new property.
 268 */
 269
 270 static mlt_property mlt_properties_add( mlt_properties this, char *name )
 271 {
 272         property_list *list = this->local;
 273         int key = generate_hash( name );
 274
 275         // Check that we have space and resize if necessary
 276         if ( list->count == list->size )
 277         {
 278                 list->size += 50;
 279                 list->name = realloc( list->name, list->size * sizeof( char * ) );
 280                 list->value = realloc( list->value, list->size * sizeof( mlt_property ) );
 281         }
 282
 283         // Assign name/value pair
 284         list->name[ list->count ] = strdup( name );
 285         list->value[ list->count ] = mlt_property_init( );
 286
 287         // Assign to hash table
 288         if ( list->hash[ key ] == 0 )
 289                 list->hash[ key ] = list->count + 1;
 290
 291         // Return and increment count accordingly
 292         return list->value[ list->count ++ ];
 293 }
 294
 295 /** Fetch a property by name - this includes add if not found.
 296 */
 297
 298 static mlt_property mlt_properties_fetch( mlt_properties this, char *name )
 299 {
 300         // Try to find an existing property first
 301         mlt_property property = mlt_properties_find( this, name );
 302
 303         // If it wasn't found, create one
 304         if ( property == NULL )
 305                 property = mlt_properties_add( this, name );
 306
 307         // Return the property
 308         return property;
 309 }
 310
 311 /** Set the property.
 312 */
 313
 314 int mlt_properties_set( mlt_properties this, char *name, char *value )
 315 {
 316         int error = 1;
 317
 318         // Fetch the property to work with
 319         mlt_property property = mlt_properties_fetch( this, name );
 320
 321         // Set it if not NULL
 322         if ( property != NULL && ( value == NULL || value[ 0 ] != '@' ) )
 323         {
 324                 error = mlt_property_set_string( property, value );
 325                 mlt_properties_do_mirror( this, name );
 326         }
 327         else if ( property != NULL && value[ 0 ] == '@' )
 328         {
 329                 int total = 0;
 330                 int current = 0;
 331                 char id[ 255 ];
 332                 char op = '+';
 333
 334                 value ++;
 335
 336                 while ( *value != '\0' )
 337                 {
 338                         int length = strcspn( value, "+-*/" );
 339
 340                         // Get the identifier
 341                         strncpy( id, value, length );
 342                         id[ length ] = '\0';
 343                         value += length;
 344
 345                         // Determine the value
 346                         if ( isdigit( id[ 0 ] ) )
 347                                 current = atof( id );
 348                         else
 349                                 current = mlt_properties_get_int( this, id );
 350
 351                         // Apply the operation
 352                         switch( op )
 353                         {
 354                                 case '+':
 355                                         total += current;
 356                                         break;
 357                                 case '-':
 358                                         total -= current;
 359                                         break;
 360                                 case '*':
 361                                         total *= current;
 362                                         break;
 363                                 case '/':
 364                                         total /= current;
 365                                         break;
 366                         }
 367
 368                         // Get the next op
 369                         op = *value != '\0' ? *value ++ : ' ';
 370                 }
 371
 372                 error = mlt_property_set_int( property, total );
 373                 mlt_properties_do_mirror( this, name );
 374         }
 375
 376         return error;
 377 }
 378
 379 /** Set or default the property.
 380 */
 381
 382 int mlt_properties_set_or_default( mlt_properties this, char *name, char *value, char *def )
 383 {
 384         return mlt_properties_set( this, name, value == NULL ? def : value );
 385 }
 386
 387 /** Get a string value by name.
 388 */
 389
 390 char *mlt_properties_get( mlt_properties this, char *name )
 391 {
 392         mlt_property value = mlt_properties_find( this, name );
 393         return value == NULL ? NULL : mlt_property_get_string( value );
 394 }
 395
 396 /** Get a name by index.
 397 */
 398
 399 char *mlt_properties_get_name( mlt_properties this, int index )
 400 {
 401         property_list *list = this->local;
 402         if ( index >= 0 && index < list->count )
 403                 return list->name[ index ];
 404         return NULL;
 405 }
 406
 407 /** Get a string value by index.
 408 */
 409
 410 char *mlt_properties_get_value( mlt_properties this, int index )
 411 {
 412         property_list *list = this->local;
 413         if ( index >= 0 && index < list->count )
 414                 return mlt_property_get_string( list->value[ index ] );
 415         return NULL;
 416 }
 417
 418 /** Get a data value by index.
 419 */
 420
 421 void *mlt_properties_get_data_at( mlt_properties this, int index, int *size )
 422 {
 423         property_list *list = this->local;
 424         if ( index >= 0 && index < list->count )
 425                 return mlt_property_get_data( list->value[ index ], size );
 426         return NULL;
 427 }
 428
 429 /** Return the number of items in the list.
 430 */
 431
 432 int mlt_properties_count( mlt_properties this )
 433 {
 434         property_list *list = this->local;
 435         return list->count;
 436 }
 437
 438 /** Set a value by parsing a name=value string
 439 */
 440
 441 int mlt_properties_parse( mlt_properties this, char *namevalue )
 442 {
 443         char *name = strdup( namevalue );
 444         char *value = NULL;
 445         int error = 0;
 446         char *ptr = strchr( name, '=' );
 447
 448         if ( ptr )
 449         {
 450                 *( ptr ++ ) = '\0';
 451
 452                 if ( *ptr != '\"' )
 453                 {
 454                         value = strdup( ptr );
 455                 }
 456                 else
 457                 {
 458                         ptr ++;
 459                         value = strdup( ptr );
 460                         if ( value != NULL && value[ strlen( value ) - 1 ] == '\"' )
 461                                 value[ strlen( value ) - 1 ] = '\0';
 462                 }
 463         }
 464         else
 465         {
 466                 value = strdup( "" );
 467         }
 468
 469         error = mlt_properties_set( this, name, value );
 470
 471         free( name );
 472         free( value );
 473
 474         return error;
 475 }
 476
 477 /** Get a value associated to the name.
 478 */
 479
 480 int mlt_properties_get_int( mlt_properties this, char *name )
 481 {
 482         mlt_property value = mlt_properties_find( this, name );
 483         return value == NULL ? 0 : mlt_property_get_int( value );
 484 }
 485
 486 /** Set a value associated to the name.
 487 */
 488
 489 int mlt_properties_set_int( mlt_properties this, char *name, int value )
 490 {
 491         int error = 1;
 492
 493         // Fetch the property to work with
 494         mlt_property property = mlt_properties_fetch( this, name );
 495
 496         // Set it if not NULL
 497         if ( property != NULL )
 498         {
 499                 error = mlt_property_set_int( property, value );
 500                 mlt_properties_do_mirror( this, name );
 501         }
 502
 503         return error;
 504 }
 505
 506 /** Get a value associated to the name.
 507 */
 508
 509 double mlt_properties_get_double( mlt_properties this, char *name )
 510 {
 511         mlt_property value = mlt_properties_find( this, name );
 512         return value == NULL ? 0 : mlt_property_get_double( value );
 513 }
 514
 515 /** Set a value associated to the name.
 516 */
 517
 518 int mlt_properties_set_double( mlt_properties this, char *name, double value )
 519 {
 520         int error = 1;
 521
 522         // Fetch the property to work with
 523         mlt_property property = mlt_properties_fetch( this, name );
 524
 525         // Set it if not NULL
 526         if ( property != NULL )
 527         {
 528                 error = mlt_property_set_double( property, value );
 529                 mlt_properties_do_mirror( this, name );
 530         }
 531
 532         return error;
 533 }
 534
 535 /** Get a value associated to the name.
 536 */
 537
 538 mlt_position mlt_properties_get_position( mlt_properties this, char *name )
 539 {
 540         mlt_property value = mlt_properties_find( this, name );
 541         return value == NULL ? 0 : mlt_property_get_position( value );
 542 }
 543
 544 /** Set a value associated to the name.
 545 */
 546
 547 int mlt_properties_set_position( mlt_properties this, char *name, mlt_position value )
 548 {
 549         int error = 1;
 550
 551         // Fetch the property to work with
 552         mlt_property property = mlt_properties_fetch( this, name );
 553
 554         // Set it if not NULL
 555         if ( property != NULL )
 556         {
 557                 error = mlt_property_set_position( property, value );
 558                 mlt_properties_do_mirror( this, name );
 559         }
 560
 561         return error;
 562 }
 563
 564 /** Get a value associated to the name.
 565 */
 566
 567 void *mlt_properties_get_data( mlt_properties this, char *name, int *length )
 568 {
 569         mlt_property value = mlt_properties_find( this, name );
 570         return value == NULL ? NULL : mlt_property_get_data( value, length );
 571 }
 572
 573 /** Set a value associated to the name.
 574 */
 575
 576 int mlt_properties_set_data( mlt_properties this, char *name, void *value, int length, mlt_destructor destroy, mlt_serialiser serialise )
 577 {
 578         int error = 1;
 579
 580         // Fetch the property to work with
 581         mlt_property property = mlt_properties_fetch( this, name );
 582
 583         // Set it if not NULL
 584         if ( property != NULL )
 585                 error = mlt_property_set_data( property, value, length, destroy, serialise );
 586
 587         return error;
 588 }
 589
 590 /** Rename a property.
 591 */
 592
 593 int mlt_properties_rename( mlt_properties this, char *source, char *dest )
 594 {
 595         mlt_property value = mlt_properties_find( this, dest );
 596
 597         if ( value == NULL )
 598         {
 599                 property_list *list = this->local;
 600                 int i = 0;
 601
 602                 // Locate the item
 603                 for ( i = 0; i < list->count; i ++ )
 604                 {
 605                         if ( !strcmp( list->name[ i ], source ) )
 606                         {
 607                                 free( list->name[ i ] );
 608                                 list->name[ i ] = strdup( dest );
 609                                 list->hash[ generate_hash( dest ) ] = i + 1;
 610                                 break;
 611                         }
 612                 }
 613         }
 614
 615         return value != NULL;
 616 }
 617
 618 /** Dump the properties.
 619 */
 620
 621 void mlt_properties_dump( mlt_properties this, FILE *output )
 622 {
 623         property_list *list = this->local;
 624         int i = 0;
 625         for ( i = 0; i < list->count; i ++ )
 626                 if ( mlt_properties_get( this, list->name[ i ] ) != NULL )
 627                         fprintf( output, "%s=%s\n", list->name[ i ], mlt_properties_get( this, list->name[ i ] ) );
 628 }
 629
 630 void mlt_properties_debug( mlt_properties this, char *title, FILE *output )
 631 {
 632         fprintf( stderr, "%s: ", title );
 633         if ( this != NULL )
 634         {
 635                 property_list *list = this->local;
 636                 int i = 0;
 637                 fprintf( output, "[ ref=%d", list->ref_count );
 638                 for ( i = 0; i < list->count; i ++ )
 639                         if ( mlt_properties_get( this, list->name[ i ] ) != NULL )
 640                                 fprintf( output, ", %s=%s", list->name[ i ], mlt_properties_get( this, list->name[ i ] ) );
 641                 fprintf( output, " ]" );
 642         }
 643         fprintf( stderr, "\n" );
 644 }
 645
 646 /** Close the list.
 647 */
 648
 649 void mlt_properties_close( mlt_properties this )
 650 {
 651         if ( this != NULL && mlt_properties_dec_ref( this ) <= 0 )
 652         {
 653                 if ( this->close != NULL )
 654                 {
 655                         this->close( this->close_object );
 656                 }
 657                 else
 658                 {
 659                         property_list *list = this->local;
 660                         int index = 0;
 661
 662 #ifdef _MLT_PROPERTY_CHECKS_
 663                         // Show debug info
 664                         mlt_properties_debug( this, "Closing", stderr );
 665
 666                         // Increment destroyed count
 667                         properties_destroyed ++;
 668
 669                         // Show current stats - these should match when the app is closed
 670                         fprintf( stderr, "Created %d, destroyed %d\n", properties_created, properties_destroyed );
 671 #endif
 672
 673                         // Clean up names and values
 674                         for ( index = list->count - 1; index >= 0; index -- )
 675                         {
 676                                 free( list->name[ index ] );
 677                                 mlt_property_close( list->value[ index ] );
 678                         }
 679
 680                         // Clear up the list
 681                         free( list->name );
 682                         free( list->value );
 683                         free( list );
 684
 685                         // Free this now if this has no child
 686                         if ( this->child == NULL )
 687                                 free( this );
 688                 }
 689         }
 690 }
 691