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         mlt_events_fire( this, "property-changed", name, NULL );
 377
 378         return error;
 379 }
 380
 381 /** Set or default the property.
 382 */
 383
 384 int mlt_properties_set_or_default( mlt_properties this, char *name, char *value, char *def )
 385 {
 386         return mlt_properties_set( this, name, value == NULL ? def : value );
 387 }
 388
 389 /** Get a string value by name.
 390 */
 391
 392 char *mlt_properties_get( mlt_properties this, char *name )
 393 {
 394         mlt_property value = mlt_properties_find( this, name );
 395         return value == NULL ? NULL : mlt_property_get_string( value );
 396 }
 397
 398 /** Get a name by index.
 399 */
 400
 401 char *mlt_properties_get_name( mlt_properties this, int index )
 402 {
 403         property_list *list = this->local;
 404         if ( index >= 0 && index < list->count )
 405                 return list->name[ index ];
 406         return NULL;
 407 }
 408
 409 /** Get a string value by index.
 410 */
 411
 412 char *mlt_properties_get_value( mlt_properties this, int index )
 413 {
 414         property_list *list = this->local;
 415         if ( index >= 0 && index < list->count )
 416                 return mlt_property_get_string( list->value[ index ] );
 417         return NULL;
 418 }
 419
 420 /** Get a data value by index.
 421 */
 422
 423 void *mlt_properties_get_data_at( mlt_properties this, int index, int *size )
 424 {
 425         property_list *list = this->local;
 426         if ( index >= 0 && index < list->count )
 427                 return mlt_property_get_data( list->value[ index ], size );
 428         return NULL;
 429 }
 430
 431 /** Return the number of items in the list.
 432 */
 433
 434 int mlt_properties_count( mlt_properties this )
 435 {
 436         property_list *list = this->local;
 437         return list->count;
 438 }
 439
 440 /** Set a value by parsing a name=value string
 441 */
 442
 443 int mlt_properties_parse( mlt_properties this, char *namevalue )
 444 {
 445         char *name = strdup( namevalue );
 446         char *value = NULL;
 447         int error = 0;
 448         char *ptr = strchr( name, '=' );
 449
 450         if ( ptr )
 451         {
 452                 *( ptr ++ ) = '\0';
 453
 454                 if ( *ptr != '\"' )
 455                 {
 456                         value = strdup( ptr );
 457                 }
 458                 else
 459                 {
 460                         ptr ++;
 461                         value = strdup( ptr );
 462                         if ( value != NULL && value[ strlen( value ) - 1 ] == '\"' )
 463                                 value[ strlen( value ) - 1 ] = '\0';
 464                 }
 465         }
 466         else
 467         {
 468                 value = strdup( "" );
 469         }
 470
 471         error = mlt_properties_set( this, name, value );
 472
 473         free( name );
 474         free( value );
 475
 476         return error;
 477 }
 478
 479 /** Get a value associated to the name.
 480 */
 481
 482 int mlt_properties_get_int( mlt_properties this, char *name )
 483 {
 484         mlt_property value = mlt_properties_find( this, name );
 485         return value == NULL ? 0 : mlt_property_get_int( value );
 486 }
 487
 488 /** Set a value associated to the name.
 489 */
 490
 491 int mlt_properties_set_int( mlt_properties this, char *name, int value )
 492 {
 493         int error = 1;
 494
 495         // Fetch the property to work with
 496         mlt_property property = mlt_properties_fetch( this, name );
 497
 498         // Set it if not NULL
 499         if ( property != NULL )
 500         {
 501                 error = mlt_property_set_int( property, value );
 502                 mlt_properties_do_mirror( this, name );
 503         }
 504
 505         mlt_events_fire( this, "property-changed", name, NULL );
 506
 507         return error;
 508 }
 509
 510 /** Get a value associated to the name.
 511 */
 512
 513 double mlt_properties_get_double( mlt_properties this, char *name )
 514 {
 515         mlt_property value = mlt_properties_find( this, name );
 516         return value == NULL ? 0 : mlt_property_get_double( value );
 517 }
 518
 519 /** Set a value associated to the name.
 520 */
 521
 522 int mlt_properties_set_double( mlt_properties this, char *name, double value )
 523 {
 524         int error = 1;
 525
 526         // Fetch the property to work with
 527         mlt_property property = mlt_properties_fetch( this, name );
 528
 529         // Set it if not NULL
 530         if ( property != NULL )
 531         {
 532                 error = mlt_property_set_double( property, value );
 533                 mlt_properties_do_mirror( this, name );
 534         }
 535
 536         mlt_events_fire( this, "property-changed", name, NULL );
 537
 538         return error;
 539 }
 540
 541 /** Get a value associated to the name.
 542 */
 543
 544 mlt_position mlt_properties_get_position( mlt_properties this, char *name )
 545 {
 546         mlt_property value = mlt_properties_find( this, name );
 547         return value == NULL ? 0 : mlt_property_get_position( value );
 548 }
 549
 550 /** Set a value associated to the name.
 551 */
 552
 553 int mlt_properties_set_position( mlt_properties this, char *name, mlt_position value )
 554 {
 555         int error = 1;
 556
 557         // Fetch the property to work with
 558         mlt_property property = mlt_properties_fetch( this, name );
 559
 560         // Set it if not NULL
 561         if ( property != NULL )
 562         {
 563                 error = mlt_property_set_position( property, value );
 564                 mlt_properties_do_mirror( this, name );
 565         }
 566
 567         mlt_events_fire( this, "property-changed", name, NULL );
 568
 569         return error;
 570 }
 571
 572 /** Get a value associated to the name.
 573 */
 574
 575 void *mlt_properties_get_data( mlt_properties this, char *name, int *length )
 576 {
 577         mlt_property value = mlt_properties_find( this, name );
 578         return value == NULL ? NULL : mlt_property_get_data( value, length );
 579 }
 580
 581 /** Set a value associated to the name.
 582 */
 583
 584 int mlt_properties_set_data( mlt_properties this, char *name, void *value, int length, mlt_destructor destroy, mlt_serialiser serialise )
 585 {
 586         int error = 1;
 587
 588         // Fetch the property to work with
 589         mlt_property property = mlt_properties_fetch( this, name );
 590
 591         // Set it if not NULL
 592         if ( property != NULL )
 593                 error = mlt_property_set_data( property, value, length, destroy, serialise );
 594
 595         mlt_events_fire( this, "property-changed", name, NULL );
 596
 597         return error;
 598 }
 599
 600 /** Rename a property.
 601 */
 602
 603 int mlt_properties_rename( mlt_properties this, char *source, char *dest )
 604 {
 605         mlt_property value = mlt_properties_find( this, dest );
 606
 607         if ( value == NULL )
 608         {
 609                 property_list *list = this->local;
 610                 int i = 0;
 611
 612                 // Locate the item
 613                 for ( i = 0; i < list->count; i ++ )
 614                 {
 615                         if ( !strcmp( list->name[ i ], source ) )
 616                         {
 617                                 free( list->name[ i ] );
 618                                 list->name[ i ] = strdup( dest );
 619                                 list->hash[ generate_hash( dest ) ] = i + 1;
 620                                 break;
 621                         }
 622                 }
 623         }
 624
 625         return value != NULL;
 626 }
 627
 628 /** Dump the properties.
 629 */
 630
 631 void mlt_properties_dump( mlt_properties this, FILE *output )
 632 {
 633         property_list *list = this->local;
 634         int i = 0;
 635         for ( i = 0; i < list->count; i ++ )
 636                 if ( mlt_properties_get( this, list->name[ i ] ) != NULL )
 637                         fprintf( output, "%s=%s\n", list->name[ i ], mlt_properties_get( this, list->name[ i ] ) );
 638 }
 639
 640 void mlt_properties_debug( mlt_properties this, char *title, FILE *output )
 641 {
 642         fprintf( stderr, "%s: ", title );
 643         if ( this != NULL )
 644         {
 645                 property_list *list = this->local;
 646                 int i = 0;
 647                 fprintf( output, "[ ref=%d", list->ref_count );
 648                 for ( i = 0; i < list->count; i ++ )
 649                         if ( mlt_properties_get( this, list->name[ i ] ) != NULL )
 650                                 fprintf( output, ", %s=%s", list->name[ i ], mlt_properties_get( this, list->name[ i ] ) );
 651                 fprintf( output, " ]" );
 652         }
 653         fprintf( stderr, "\n" );
 654 }
 655
 656 /** Close the list.
 657 */
 658
 659 void mlt_properties_close( mlt_properties this )
 660 {
 661         if ( this != NULL && mlt_properties_dec_ref( this ) <= 0 )
 662         {
 663                 if ( this->close != NULL )
 664                 {
 665                         this->close( this->close_object );
 666                 }
 667                 else
 668                 {
 669                         property_list *list = this->local;
 670                         int index = 0;
 671
 672 #ifdef _MLT_PROPERTY_CHECKS_
 673                         // Show debug info
 674                         mlt_properties_debug( this, "Closing", stderr );
 675
 676                         // Increment destroyed count
 677                         properties_destroyed ++;
 678
 679                         // Show current stats - these should match when the app is closed
 680                         fprintf( stderr, "Created %d, destroyed %d\n", properties_created, properties_destroyed );
 681 #endif
 682
 683                         // Clean up names and values
 684                         for ( index = list->count - 1; index >= 0; index -- )
 685                         {
 686                                 free( list->name[ index ] );
 687                                 mlt_property_close( list->value[ index ] );
 688                         }
 689
 690                         // Clear up the list
 691                         free( list->name );
 692                         free( list->value );
 693                         free( list );
 694
 695                         // Free this now if this has no child
 696                         if ( this->child == NULL )
 697                                 free( this );
 698                 }
 699         }
 700 }
 701