git.sesse.net Git - mlt/blob - src/framework/mlt_service.c

   1 /**
   2  * \file mlt_service.c
   3  * \brief interface definition for all service classes
   4  * \see mlt_service_s
   5  *
   6  * Copyright (C) 2003-2009 Ushodaya Enterprises Limited
   7  * \author Charles Yates <charles.yates@pandora.be>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "mlt_service.h"
  25 #include "mlt_filter.h"
  26 #include "mlt_frame.h"
  27 #include "mlt_cache.h"
  28 #include "mlt_factory.h"
  29 #include "mlt_log.h"
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <pthread.h>
  35
  36
  37 /*  IMPORTANT NOTES
  38
  39         The base service implements a null frame producing service - as such,
  40         it is functional without extension and will produce test cards frames
  41         and PAL sized audio frames.
  42
  43         PLEASE DO NOT CHANGE THIS BEHAVIOUR!!! OVERRIDE THE METHODS THAT
  44         CONTROL THIS IN EXTENDING CLASSES.
  45 */
  46
  47 /** \brief private service definition */
  48
  49 typedef struct
  50 {
  51         int size;
  52         int count;
  53         mlt_service *in;
  54         mlt_service out;
  55         int filter_count;
  56         int filter_size;
  57         mlt_filter *filters;
  58         pthread_mutex_t mutex;
  59 }
  60 mlt_service_base;
  61
  62 /* Private methods
  63  */
  64
  65 static void mlt_service_disconnect( mlt_service this );
  66 static void mlt_service_connect( mlt_service this, mlt_service that );
  67 static int service_get_frame( mlt_service this, mlt_frame_ptr frame, int index );
  68 static void mlt_service_property_changed( mlt_listener, mlt_properties owner, mlt_service this, void **args );
  69 static void purge_cache( mlt_service self );
  70
  71 /** Initialize a service.
  72  *
  73  * \public \memberof mlt_service_s
  74  * \param this the service structure to initialize
  75  * \param child pointer to the child object for the subclass
  76  * \return true if there was an error
  77  */
  78
  79 int mlt_service_init( mlt_service this, void *child )
  80 {
  81         int error = 0;
  82
  83         // Initialise everything to NULL
  84         memset( this, 0, sizeof( struct mlt_service_s ) );
  85
  86         // Assign the child
  87         this->child = child;
  88
  89         // Generate local space
  90         this->local = calloc( sizeof( mlt_service_base ), 1 );
  91
  92         // Associate the methods
  93         this->get_frame = service_get_frame;
  94
  95         // Initialise the properties
  96         error = mlt_properties_init( &this->parent, this );
  97         if ( error == 0 )
  98         {
  99                 this->parent.close = ( mlt_destructor )mlt_service_close;
 100                 this->parent.close_object = this;
 101
 102                 mlt_events_init( &this->parent );
 103                 mlt_events_register( &this->parent, "service-changed", NULL );
 104                 mlt_events_register( &this->parent, "property-changed", ( mlt_transmitter )mlt_service_property_changed );
 105                 pthread_mutex_init( &( ( mlt_service_base * )this->local )->mutex, NULL );
 106         }
 107
 108         return error;
 109 }
 110
 111 /** The transmitter for property changes.
 112  *
 113  * Invokes the listener.
 114  *
 115  * \private \memberof mlt_service_s
 116  * \param listener a function pointer that will be invoked
 117  * \param owner a properties list that will be passed to \p listener
 118  * \param this a service that will be passed to \p listener
 119  * \param args an array of pointers - the first entry is passed as a string to \p listener
 120  */
 121
 122 static void mlt_service_property_changed( mlt_listener listener, mlt_properties owner, mlt_service this, void **args )
 123 {
 124         if ( listener != NULL )
 125                 listener( owner, this, ( char * )args[ 0 ] );
 126 }
 127
 128 /** Acquire a mutual exclusion lock on this service.
 129  *
 130  * \public \memberof mlt_service_s
 131  * \param this the service to lock
 132  */
 133
 134 void mlt_service_lock( mlt_service this )
 135 {
 136         if ( this != NULL )
 137                 pthread_mutex_lock( &( ( mlt_service_base * )this->local )->mutex );
 138 }
 139
 140 /** Release a mutual exclusion lock on this service.
 141  *
 142  * \public \memberof mlt_service_s
 143  * \param this the service to unlock
 144  */
 145
 146 void mlt_service_unlock( mlt_service this )
 147 {
 148         if ( this != NULL )
 149                 pthread_mutex_unlock( &( ( mlt_service_base * )this->local )->mutex );
 150 }
 151
 152 /** Identify the subclass of the service.
 153  *
 154  * \public \memberof mlt_service_s
 155  * \param this a service
 156  * \return the subclass
 157  */
 158
 159 mlt_service_type mlt_service_identify( mlt_service this )
 160 {
 161         mlt_service_type type = invalid_type;
 162         if ( this != NULL )
 163         {
 164                 mlt_properties properties = MLT_SERVICE_PROPERTIES( this );
 165                 char *mlt_type = mlt_properties_get( properties, "mlt_type" );
 166                 char *resource = mlt_properties_get( properties, "resource" );
 167                 if ( mlt_type == NULL )
 168                         type = unknown_type;
 169                 else if (resource != NULL && !strcmp( resource, "<playlist>" ) )
 170                         type = playlist_type;
 171                 else if (resource != NULL && !strcmp( resource, "<tractor>" ) )
 172                         type = tractor_type;
 173                 else if (resource != NULL && !strcmp( resource, "<multitrack>" ) )
 174                         type = multitrack_type;
 175                 else if ( !strcmp( mlt_type, "producer" ) )
 176                         type = producer_type;
 177                 else if ( !strcmp( mlt_type, "filter" ) )
 178                         type = filter_type;
 179                 else if ( !strcmp( mlt_type, "transition" ) )
 180                         type = transition_type;
 181                 else if ( !strcmp( mlt_type, "consumer" ) )
 182                         type = consumer_type;
 183                 else
 184                         type = unknown_type;
 185         }
 186         return type;
 187 }
 188
 189 /** Connect a producer to the service.
 190  *
 191  * \public \memberof mlt_service_s
 192  * \param this a service
 193  * \param producer a producer
 194  * \param index which of potentially multiple producers to this service (0 based)
 195  * \return > 0 warning, == 0 success, < 0 serious error,
 196  *         1 = this service does not accept input,
 197  *         2 = the producer is invalid,
 198  *         3 = the producer is already registered with this consumer
 199  */
 200
 201 int mlt_service_connect_producer( mlt_service this, mlt_service producer, int index )
 202 {
 203         int i = 0;
 204
 205         // Get the service base
 206         mlt_service_base *base = this->local;
 207
 208         // Special case 'track' index - only works for last filter(s) in a particular chain
 209         // but allows a filter to apply to the output frame regardless of which track it comes from
 210         if ( index == -1 )
 211                 index = 0;
 212
 213         // Check if the producer is already registered with this service
 214         for ( i = 0; i < base->count; i ++ )
 215                 if ( base->in[ i ] == producer )
 216                         return 3;
 217
 218         // Allocate space
 219         if ( index >= base->size )
 220         {
 221                 int new_size = base->size + index + 10;
 222                 base->in = realloc( base->in, new_size * sizeof( mlt_service ) );
 223                 if ( base->in != NULL )
 224                 {
 225                         for ( i = base->size; i < new_size; i ++ )
 226                                 base->in[ i ] = NULL;
 227                         base->size = new_size;
 228                 }
 229         }
 230
 231         // If we have space, assign the input
 232         if ( base->in != NULL && index >= 0 && index < base->size )
 233         {
 234                 // Get the current service
 235                 mlt_service current = base->in[ index ];
 236
 237                 // Increment the reference count on this producer
 238                 if ( producer != NULL )
 239                         mlt_properties_inc_ref( MLT_SERVICE_PROPERTIES( producer ) );
 240
 241                 // Now we disconnect the producer service from its consumer
 242                 mlt_service_disconnect( producer );
 243
 244                 // Add the service to index specified
 245                 base->in[ index ] = producer;
 246
 247                 // Determine the number of active tracks
 248                 if ( index >= base->count )
 249                         base->count = index + 1;
 250
 251                 // Now we connect the producer to its connected consumer
 252                 mlt_service_connect( producer, this );
 253
 254                 // Close the current service
 255                 mlt_service_close( current );
 256
 257                 // Inform caller that all went well
 258                 return 0;
 259         }
 260         else
 261         {
 262                 return -1;
 263         }
 264 }
 265
 266 /** Disconnect this service from its consumer.
 267  *
 268  * \public \memberof mlt_service_s
 269  * \param this a service
 270  */
 271
 272 static void mlt_service_disconnect( mlt_service this )
 273 {
 274         if ( this != NULL )
 275         {
 276                 // Get the service base
 277                 mlt_service_base *base = this->local;
 278
 279                 // Disconnect
 280                 base->out = NULL;
 281         }
 282 }
 283
 284 /** Obtain the consumer this service is connected to.
 285  *
 286  * \public \memberof mlt_service_s
 287  * \param this a service
 288  * \return the consumer
 289  */
 290
 291 mlt_service mlt_service_consumer( mlt_service this )
 292 {
 293         // Get the service base
 294         mlt_service_base *base = this->local;
 295
 296         // Return the connected consumer
 297         return base->out;
 298 }
 299
 300 /** Obtain the producer this service is connected to.
 301  *
 302  * \public \memberof mlt_service_s
 303  * \param this a service
 304  * \return the last-most producer
 305  */
 306
 307 mlt_service mlt_service_producer( mlt_service this )
 308 {
 309         // Get the service base
 310         mlt_service_base *base = this->local;
 311
 312         // Return the connected producer
 313         return base->count > 0 ? base->in[ base->count - 1 ] : NULL;
 314 }
 315
 316 /** Associate this service to a consumer.
 317  *
 318  * Overwrites connection to any existing consumer.
 319  * \private \memberof mlt_service_s
 320  * \param this a service
 321  * \param that a consumer
 322  */
 323
 324 static void mlt_service_connect( mlt_service this, mlt_service that )
 325 {
 326         if ( this != NULL )
 327         {
 328                 // Get the service base
 329                 mlt_service_base *base = this->local;
 330
 331                 // There's a bit more required here...
 332                 base->out = that;
 333         }
 334 }
 335
 336 /** Get the first connected producer.
 337  *
 338  * \public \memberof mlt_service_s
 339  * \param this a service
 340  * \return the first producer
 341  */
 342
 343 mlt_service mlt_service_get_producer( mlt_service this )
 344 {
 345         mlt_service producer = NULL;
 346
 347         // Get the service base
 348         mlt_service_base *base = this->local;
 349
 350         if ( base->in != NULL )
 351                 producer = base->in[ 0 ];
 352
 353         return producer;
 354 }
 355
 356 /** Default implementation of the get_frame virtual function.
 357  *
 358  * \private \memberof mlt_service_s
 359  * \param this a service
 360  * \param[out] frame a frame by reference
 361  * \param index as determined by the producer
 362  * \return false
 363  */
 364
 365 static int service_get_frame( mlt_service this, mlt_frame_ptr frame, int index )
 366 {
 367         mlt_service_base *base = this->local;
 368         if ( index < base->count )
 369         {
 370                 mlt_service producer = base->in[ index ];
 371                 if ( producer != NULL )
 372                         return mlt_service_get_frame( producer, frame, index );
 373         }
 374         *frame = mlt_frame_init( this );
 375         return 0;
 376 }
 377
 378 /** Return the properties object.
 379  *
 380  * \public \memberof mlt_service_s
 381  * \param this a service
 382  * \return the properties
 383  */
 384
 385 mlt_properties mlt_service_properties( mlt_service this )
 386 {
 387         return this != NULL ? &this->parent : NULL;
 388 }
 389
 390 /** Recursively apply attached filters.
 391  *
 392  * \public \memberof mlt_service_s
 393  * \param this a service
 394  * \param frame a frame
 395  * \param index used to track depth of recursion, top caller should supply 0
 396  */
 397
 398 void mlt_service_apply_filters( mlt_service this, mlt_frame frame, int index )
 399 {
 400         int i;
 401         mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
 402         mlt_properties service_properties = MLT_SERVICE_PROPERTIES( this );
 403         mlt_service_base *base = this->local;
 404         mlt_position position = mlt_frame_get_position( frame );
 405         mlt_position this_in = mlt_properties_get_position( service_properties, "in" );
 406         mlt_position this_out = mlt_properties_get_position( service_properties, "out" );
 407
 408         if ( index == 0 || mlt_properties_get_int( service_properties, "_filter_private" ) == 0 )
 409         {
 410                 // Process the frame with the attached filters
 411                 for ( i = 0; i < base->filter_count; i ++ )
 412                 {
 413                         if ( base->filters[ i ] != NULL )
 414                         {
 415                                 mlt_position in = mlt_filter_get_in( base->filters[ i ] );
 416                                 mlt_position out = mlt_filter_get_out( base->filters[ i ] );
 417                                 int disable = mlt_properties_get_int( MLT_FILTER_PROPERTIES( base->filters[ i ] ), "disable" );
 418                                 if ( !disable && ( ( in == 0 && out == 0 ) || ( position >= in && ( position <= out || out == 0 ) ) ) )
 419                                 {
 420                                         mlt_properties_set_position( frame_properties, "in", in == 0 ? this_in : in );
 421                                         mlt_properties_set_position( frame_properties, "out", out == 0 ? this_out : out );
 422                                         mlt_filter_process( base->filters[ i ], frame );
 423                                         mlt_service_apply_filters( MLT_FILTER_SERVICE( base->filters[ i ] ), frame, index + 1 );
 424                                 }
 425                         }
 426                 }
 427         }
 428 }
 429
 430 /** Obtain a frame.
 431  *
 432  * \public \memberof mlt_service_s
 433  * \param this a service
 434  * \param[out] frame a frame by reference
 435  * \param index as determined by the producer
 436  * \return true if there was an error
 437  */
 438
 439 int mlt_service_get_frame( mlt_service this, mlt_frame_ptr frame, int index )
 440 {
 441         int result = 0;
 442
 443         // Lock the service
 444         mlt_service_lock( this );
 445
 446         // Ensure that the frame is NULL
 447         *frame = NULL;
 448
 449         // Only process if we have a valid service
 450         if ( this != NULL && this->get_frame != NULL )
 451         {
 452                 mlt_properties properties = MLT_SERVICE_PROPERTIES( this );
 453                 mlt_position in = mlt_properties_get_position( properties, "in" );
 454                 mlt_position out = mlt_properties_get_position( properties, "out" );
 455
 456                 result = this->get_frame( this, frame, index );
 457
 458                 if ( result == 0 )
 459                 {
 460                         mlt_properties_inc_ref( properties );
 461                         properties = MLT_FRAME_PROPERTIES( *frame );
 462                         if ( in >=0 && out > 0 )
 463                         {
 464                                 mlt_properties_set_position( properties, "in", in );
 465                                 mlt_properties_set_position( properties, "out", out );
 466                         }
 467                         mlt_service_apply_filters( this, *frame, 1 );
 468                         mlt_deque_push_back( MLT_FRAME_SERVICE_STACK( *frame ), this );
 469                 }
 470         }
 471
 472         // Make sure we return a frame
 473         if ( *frame == NULL )
 474                 *frame = mlt_frame_init( this );
 475
 476         // Unlock the service
 477         mlt_service_unlock( this );
 478
 479         return result;
 480 }
 481
 482 /** The service-changed event handler.
 483  *
 484  * \private \memberof mlt_service_s
 485  * \param owner ignored
 486  * \param this the service on which the "service-changed" event is fired
 487  */
 488
 489 static void mlt_service_filter_changed( mlt_service owner, mlt_service this )
 490 {
 491         mlt_events_fire( MLT_SERVICE_PROPERTIES( this ), "service-changed", NULL );
 492 }
 493
 494 /** Attach a filter.
 495  *
 496  * \public \memberof mlt_service_s
 497  * \param this a service
 498  * \param filter the filter to attach
 499  * \return true if there was an error
 500  */
 501
 502 int mlt_service_attach( mlt_service this, mlt_filter filter )
 503 {
 504         int error = this == NULL || filter == NULL;
 505         if ( error == 0 )
 506         {
 507                 int i = 0;
 508                 mlt_properties properties = MLT_SERVICE_PROPERTIES( this );
 509                 mlt_service_base *base = this->local;
 510
 511                 for ( i = 0; error == 0 && i < base->filter_count; i ++ )
 512                         if ( base->filters[ i ] == filter )
 513                                 error = 1;
 514
 515                 if ( error == 0 )
 516                 {
 517                         if ( base->filter_count == base->filter_size )
 518                         {
 519                                 base->filter_size += 10;
 520                                 base->filters = realloc( base->filters, base->filter_size * sizeof( mlt_filter ) );
 521                         }
 522
 523                         if ( base->filters != NULL )
 524                         {
 525                                 mlt_properties props = MLT_FILTER_PROPERTIES( filter );
 526                                 mlt_properties_inc_ref( MLT_FILTER_PROPERTIES( filter ) );
 527                                 base->filters[ base->filter_count ++ ] = filter;
 528                                 mlt_events_fire( properties, "service-changed", NULL );
 529                                 mlt_events_listen( props, this, "service-changed", ( mlt_listener )mlt_service_filter_changed );
 530                                 mlt_events_listen( props, this, "property-changed", ( mlt_listener )mlt_service_filter_changed );
 531                         }
 532                         else
 533                         {
 534                                 error = 2;
 535                         }
 536                 }
 537         }
 538         return error;
 539 }
 540
 541 /** Detach a filter.
 542  *
 543  * \public \memberof mlt_service_s
 544  * \param this a service
 545  * \param filter the filter to detach
 546  * \return true if there was an error
 547  */
 548
 549 int mlt_service_detach( mlt_service this, mlt_filter filter )
 550 {
 551         int error = this == NULL || filter == NULL;
 552         if ( error == 0 )
 553         {
 554                 int i = 0;
 555                 mlt_service_base *base = this->local;
 556                 mlt_properties properties = MLT_SERVICE_PROPERTIES( this );
 557
 558                 for ( i = 0; i < base->filter_count; i ++ )
 559                         if ( base->filters[ i ] == filter )
 560                                 break;
 561
 562                 if ( i < base->filter_count )
 563                 {
 564                         base->filters[ i ] = NULL;
 565                         for ( i ++ ; i < base->filter_count; i ++ )
 566                                 base->filters[ i - 1 ] = base->filters[ i ];
 567                         base->filter_count --;
 568                         mlt_events_disconnect( MLT_FILTER_PROPERTIES( filter ), this );
 569                         mlt_filter_close( filter );
 570                         mlt_events_fire( properties, "service-changed", NULL );
 571                 }
 572         }
 573         return error;
 574 }
 575
 576 /** Retrieve a filter.
 577  *
 578  * \public \memberof mlt_service_s
 579  * \param this a service
 580  * \param index which one of potentially multiple filters
 581  * \return the filter or null if there was an error
 582  */
 583
 584 mlt_filter mlt_service_filter( mlt_service this, int index )
 585 {
 586         mlt_filter filter = NULL;
 587         if ( this != NULL )
 588         {
 589                 mlt_service_base *base = this->local;
 590                 if ( index >= 0 && index < base->filter_count )
 591                         filter = base->filters[ index ];
 592         }
 593         return filter;
 594 }
 595
 596 /** Retrieve the profile.
 597  *
 598  * \public \memberof mlt_service_s
 599  * \param this a service
 600  * \return the profile
 601  */
 602
 603 mlt_profile mlt_service_profile( mlt_service this )
 604 {
 605         return mlt_properties_get_data( MLT_SERVICE_PROPERTIES( this ), "_profile", NULL );
 606 }
 607
 608 /** Destroy a service.
 609  *
 610  * \public \memberof mlt_service_s
 611  * \param this the service to destroy
 612  */
 613
 614 void mlt_service_close( mlt_service this )
 615 {
 616         if ( this != NULL && mlt_properties_dec_ref( MLT_SERVICE_PROPERTIES( this ) ) <= 0 )
 617         {
 618                 if ( this->close != NULL )
 619                 {
 620                         this->close( this->close_object );
 621                 }
 622                 else
 623                 {
 624                         mlt_service_base *base = this->local;
 625                         int i = 0;
 626                         int count = base->filter_count;
 627                         mlt_events_block( MLT_SERVICE_PROPERTIES( this ), this );
 628                         while( count -- )
 629                                 mlt_service_detach( this, base->filters[ 0 ] );
 630                         free( base->filters );
 631                         for ( i = 0; i < base->count; i ++ )
 632                                 if ( base->in[ i ] != NULL )
 633                                         mlt_service_close( base->in[ i ] );
 634                         this->parent.close = NULL;
 635                         free( base->in );
 636                         pthread_mutex_destroy( &base->mutex );
 637                         free( base );
 638                         purge_cache( this );
 639                         mlt_properties_close( &this->parent );
 640                 }
 641         }
 642         else
 643         {
 644                 mlt_service_unlock( this );
 645         }
 646 }
 647
 648 /** Release a service's cache items.
 649  *
 650  * \private \memberof mlt_service_s
 651  * \param self a service
 652  */
 653
 654 static void purge_cache( mlt_service self )
 655 {
 656         mlt_properties caches = mlt_properties_get_data( mlt_global_properties(), "caches", NULL );
 657
 658         if ( caches )
 659         {
 660                 int i = mlt_properties_count( caches );
 661                 while ( i-- )
 662                 {
 663                         mlt_cache_purge( mlt_properties_get_data_at( caches, i, NULL ), self );
 664                         mlt_properties_set_data( mlt_global_properties(), mlt_properties_get_name( caches, i ), NULL, 0, NULL, NULL );
 665                 }
 666         }
 667 }
 668
 669 /** Lookup the cache object for a service.
 670  *
 671  * \private \memberof mlt_service_s
 672  * \param self a service
 673  * \param name a name for the object
 674  * \return a cache
 675  */
 676
 677 static mlt_cache get_cache( mlt_service self, const char *name )
 678 {
 679         mlt_cache result = NULL;
 680         mlt_properties caches = mlt_properties_get_data( mlt_global_properties(), "caches", NULL );
 681
 682         if ( !caches )
 683         {
 684                 caches = mlt_properties_new();
 685                 mlt_properties_set_data( mlt_global_properties(), "caches", caches, 0, ( mlt_destructor )mlt_properties_close, NULL );
 686         }
 687         if ( caches )
 688         {
 689                 result = mlt_properties_get_data( caches, name, NULL );
 690                 if ( !result )
 691                 {
 692                         result = mlt_cache_init();
 693                         mlt_properties_set_data( caches, name, result, 0, ( mlt_destructor )mlt_cache_close, NULL );
 694                 }
 695         }
 696
 697         return result;
 698 }
 699
 700 /** Put an object into a service's cache.
 701  *
 702  * \public \memberof mlt_service_s
 703  * \param self a service
 704  * \param name a name for the object that is unique to the service class, but not to the instance
 705  * \param data an opaque pointer to the object to put into the cache
 706  * \param size the number of bytes pointed to by data
 707  * \param destructor a function that releases the data
 708  */
 709
 710 void mlt_service_cache_put( mlt_service self, const char *name, void* data, int size, mlt_destructor destructor )
 711 {
 712         mlt_log( self, MLT_LOG_DEBUG, "%s: name %s object %p data %p\n", __FUNCTION__, name, self, data );
 713         mlt_cache cache = get_cache( self, name );
 714
 715         if ( cache )
 716                 mlt_cache_put( cache, self, data, size, destructor );
 717 }
 718
 719 /** Get an object from a service's cache.
 720  *
 721  * \public \memberof mlt_service_s
 722  * \param self a service
 723  * \param name a name for the object that is unique to the service class, but not to the instance
 724  * \return a cache item or NULL if an object is not found
 725  * \see mlt_cache_item_data
 726  */
 727
 728 mlt_cache_item mlt_service_cache_get( mlt_service self, const char *name )
 729 {
 730         mlt_log( self, MLT_LOG_DEBUG, "%s: name %s object %p\n", __FUNCTION__, name, self );
 731         mlt_cache_item result = NULL;
 732         mlt_cache cache = get_cache( self, name );
 733
 734         if ( cache )
 735                 result = mlt_cache_get( cache, self );
 736
 737         return result;
 738 }