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 #include "mlt_producer.h"
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <pthread.h>
  36
  37
  38 /*  IMPORTANT NOTES
  39
  40         The base service implements a null frame producing service - as such,
  41         it is functional without extension and will produce test cards frames
  42         and PAL sized audio frames.
  43
  44         PLEASE DO NOT CHANGE THIS BEHAVIOUR!!! OVERRIDE THE METHODS THAT
  45         CONTROL THIS IN EXTENDING CLASSES.
  46 */
  47
  48 /** \brief private service definition */
  49
  50 typedef struct
  51 {
  52         int size;
  53         int count;
  54         mlt_service *in;
  55         mlt_service out;
  56         int filter_count;
  57         int filter_size;
  58         mlt_filter *filters;
  59         pthread_mutex_t mutex;
  60 }
  61 mlt_service_base;
  62
  63 /* Private methods
  64  */
  65
  66 static void mlt_service_disconnect( mlt_service self );
  67 static void mlt_service_connect( mlt_service self, mlt_service that );
  68 static int service_get_frame( mlt_service self, mlt_frame_ptr frame, int index );
  69 static void mlt_service_property_changed( mlt_listener, mlt_properties owner, mlt_service self, void **args );
  70
  71 /** Initialize a service.
  72  *
  73  * \public \memberof mlt_service_s
  74  * \param self 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 self, void *child )
  80 {
  81         int error = 0;
  82
  83         // Initialise everything to NULL
  84         memset( self, 0, sizeof( struct mlt_service_s ) );
  85
  86         // Assign the child
  87         self->child = child;
  88
  89         // Generate local space
  90         self->local = calloc( sizeof( mlt_service_base ), 1 );
  91
  92         // Associate the methods
  93         self->get_frame = service_get_frame;
  94
  95         // Initialise the properties
  96         error = mlt_properties_init( &self->parent, self );
  97         if ( error == 0 )
  98         {
  99                 self->parent.close = ( mlt_destructor )mlt_service_close;
 100                 self->parent.close_object = self;
 101
 102                 mlt_events_init( &self->parent );
 103                 mlt_events_register( &self->parent, "service-changed", NULL );
 104                 mlt_events_register( &self->parent, "property-changed", ( mlt_transmitter )mlt_service_property_changed );
 105                 pthread_mutex_init( &( ( mlt_service_base * )self->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 self 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 self, void **args )
 123 {
 124         if ( listener != NULL )
 125                 listener( owner, self, ( char * )args[ 0 ] );
 126 }
 127
 128 /** Acquire a mutual exclusion lock on this service.
 129  *
 130  * \public \memberof mlt_service_s
 131  * \param self the service to lock
 132  */
 133
 134 void mlt_service_lock( mlt_service self )
 135 {
 136         if ( self != NULL )
 137                 pthread_mutex_lock( &( ( mlt_service_base * )self->local )->mutex );
 138 }
 139
 140 /** Release a mutual exclusion lock on this service.
 141  *
 142  * \public \memberof mlt_service_s
 143  * \param self the service to unlock
 144  */
 145
 146 void mlt_service_unlock( mlt_service self )
 147 {
 148         if ( self != NULL )
 149                 pthread_mutex_unlock( &( ( mlt_service_base * )self->local )->mutex );
 150 }
 151
 152 /** Identify the subclass of the service.
 153  *
 154  * \public \memberof mlt_service_s
 155  * \param self a service
 156  * \return the subclass
 157  */
 158
 159 mlt_service_type mlt_service_identify( mlt_service self )
 160 {
 161         mlt_service_type type = invalid_type;
 162         if ( self != NULL )
 163         {
 164                 mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
 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 self 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 self consumer
 199  */
 200
 201 int mlt_service_connect_producer( mlt_service self, mlt_service producer, int index )
 202 {
 203         int i = 0;
 204
 205         // Get the service base
 206         mlt_service_base *base = self->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, self );
 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 a service from its consumer.
 267  *
 268  * \public \memberof mlt_service_s
 269  * \param self a service
 270  */
 271
 272 static void mlt_service_disconnect( mlt_service self )
 273 {
 274         if ( self != NULL )
 275         {
 276                 // Get the service base
 277                 mlt_service_base *base = self->local;
 278
 279                 // Disconnect
 280                 base->out = NULL;
 281         }
 282 }
 283
 284 /** Obtain the consumer a service is connected to.
 285  *
 286  * \public \memberof mlt_service_s
 287  * \param self a service
 288  * \return the consumer
 289  */
 290
 291 mlt_service mlt_service_consumer( mlt_service self )
 292 {
 293         // Get the service base
 294         mlt_service_base *base = self->local;
 295
 296         // Return the connected consumer
 297         return base->out;
 298 }
 299
 300 /** Obtain the producer a service is connected to.
 301  *
 302  * \public \memberof mlt_service_s
 303  * \param self a service
 304  * \return the last-most producer
 305  */
 306
 307 mlt_service mlt_service_producer( mlt_service self )
 308 {
 309         // Get the service base
 310         mlt_service_base *base = self->local;
 311
 312         // Return the connected producer
 313         return base->count > 0 ? base->in[ base->count - 1 ] : NULL;
 314 }
 315
 316 /** Associate a service to a consumer.
 317  *
 318  * Overwrites connection to any existing consumer.
 319  * \private \memberof mlt_service_s
 320  * \param self a service
 321  * \param that a consumer
 322  */
 323
 324 static void mlt_service_connect( mlt_service self, mlt_service that )
 325 {
 326         if ( self != NULL )
 327         {
 328                 // Get the service base
 329                 mlt_service_base *base = self->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 self a service
 340  * \return the first producer
 341  */
 342
 343 mlt_service mlt_service_get_producer( mlt_service self )
 344 {
 345         mlt_service producer = NULL;
 346
 347         // Get the service base
 348         mlt_service_base *base = self->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 self 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 self, mlt_frame_ptr frame, int index )
 366 {
 367         mlt_service_base *base = self->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( self );
 375         return 0;
 376 }
 377
 378 /** Return the properties object.
 379  *
 380  * \public \memberof mlt_service_s
 381  * \param self a service
 382  * \return the properties
 383  */
 384
 385 mlt_properties mlt_service_properties( mlt_service self )
 386 {
 387         return self != NULL ? &self->parent : NULL;
 388 }
 389
 390 /** Recursively apply attached filters.
 391  *
 392  * \public \memberof mlt_service_s
 393  * \param self 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 self, 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( self );
 403         mlt_service_base *base = self->local;
 404         mlt_position position = mlt_frame_get_position( frame );
 405         mlt_position self_in = mlt_properties_get_position( service_properties, "in" );
 406         mlt_position self_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 ? self_in : in );
 421                                         mlt_properties_set_position( frame_properties, "out", out == 0 ? self_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 self 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 self, mlt_frame_ptr frame, int index )
 440 {
 441         int result = 0;
 442
 443         // Lock the service
 444         mlt_service_lock( self );
 445
 446         // Ensure that the frame is NULL
 447         *frame = NULL;
 448
 449         // Only process if we have a valid service
 450         if ( self != NULL && self->get_frame != NULL )
 451         {
 452                 mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
 453                 mlt_position in = mlt_properties_get_position( properties, "in" );
 454                 mlt_position out = mlt_properties_get_position( properties, "out" );
 455                 mlt_position position = mlt_service_identify( self ) == producer_type ? mlt_producer_position( MLT_PRODUCER( self ) ) : -1;
 456
 457                 result = self->get_frame( self, frame, index );
 458
 459                 if ( result == 0 )
 460                 {
 461                         mlt_properties_inc_ref( properties );
 462                         properties = MLT_FRAME_PROPERTIES( *frame );
 463
 464                         if ( in >=0 && out > 0 )
 465                         {
 466                                 mlt_properties_set_position( properties, "in", in );
 467                                 mlt_properties_set_position( properties, "out", out );
 468                         }
 469                         mlt_service_apply_filters( self, *frame, 1 );
 470                         mlt_deque_push_back( MLT_FRAME_SERVICE_STACK( *frame ), self );
 471
 472                         if ( mlt_service_identify( self ) == producer_type &&
 473                              mlt_properties_get_int( MLT_SERVICE_PROPERTIES( self ), "_need_previous_next" ) )
 474                         {
 475                                 // Save the new position from self->get_frame
 476                                 mlt_position new_position = mlt_producer_position( MLT_PRODUCER( self ) );
 477
 478                                 // Get the preceding frame, unfiltered
 479                                 mlt_frame previous_frame;
 480                                 mlt_producer_seek( MLT_PRODUCER(self), position - 1 );
 481                                 result = self->get_frame( self, &previous_frame, index );
 482                                 if ( !result )
 483                                         mlt_properties_set_data( properties, "previous frame",
 484                                                 previous_frame, 0, ( mlt_destructor ) mlt_frame_close, NULL );
 485
 486                                 // Get the following frame, unfiltered
 487                                 mlt_frame next_frame;
 488                                 mlt_producer_seek( MLT_PRODUCER(self), position + 1 );
 489                                 result = self->get_frame( self, &next_frame, index );
 490                                 if ( !result )
 491                                 {
 492                                         mlt_properties_set_data( properties, "next frame",
 493                                                 next_frame, 0, ( mlt_destructor ) mlt_frame_close, NULL );
 494                                 }
 495
 496                                 // Restore the new position
 497                                 mlt_producer_seek( MLT_PRODUCER(self), new_position );
 498                         }
 499                 }
 500         }
 501
 502         // Make sure we return a frame
 503         if ( *frame == NULL )
 504                 *frame = mlt_frame_init( self );
 505
 506         // Unlock the service
 507         mlt_service_unlock( self );
 508
 509         return result;
 510 }
 511
 512 /** The service-changed event handler.
 513  *
 514  * \private \memberof mlt_service_s
 515  * \param owner ignored
 516  * \param self the service on which the "service-changed" event is fired
 517  */
 518
 519 static void mlt_service_filter_changed( mlt_service owner, mlt_service self )
 520 {
 521         mlt_events_fire( MLT_SERVICE_PROPERTIES( self ), "service-changed", NULL );
 522 }
 523
 524 /** Attach a filter.
 525  *
 526  * \public \memberof mlt_service_s
 527  * \param self a service
 528  * \param filter the filter to attach
 529  * \return true if there was an error
 530  */
 531
 532 int mlt_service_attach( mlt_service self, mlt_filter filter )
 533 {
 534         int error = self == NULL || filter == NULL;
 535         if ( error == 0 )
 536         {
 537                 int i = 0;
 538                 mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
 539                 mlt_service_base *base = self->local;
 540
 541                 for ( i = 0; error == 0 && i < base->filter_count; i ++ )
 542                         if ( base->filters[ i ] == filter )
 543                                 error = 1;
 544
 545                 if ( error == 0 )
 546                 {
 547                         if ( base->filter_count == base->filter_size )
 548                         {
 549                                 base->filter_size += 10;
 550                                 base->filters = realloc( base->filters, base->filter_size * sizeof( mlt_filter ) );
 551                         }
 552
 553                         if ( base->filters != NULL )
 554                         {
 555                                 mlt_properties props = MLT_FILTER_PROPERTIES( filter );
 556                                 mlt_properties_inc_ref( MLT_FILTER_PROPERTIES( filter ) );
 557                                 base->filters[ base->filter_count ++ ] = filter;
 558                                 mlt_properties_set_data( props, "service", self, 0, NULL, NULL );
 559                                 mlt_events_fire( properties, "service-changed", NULL );
 560                                 mlt_events_fire( props, "service-changed", NULL );
 561                                 mlt_events_listen( props, self, "service-changed", ( mlt_listener )mlt_service_filter_changed );
 562                                 mlt_events_listen( props, self, "property-changed", ( mlt_listener )mlt_service_filter_changed );
 563                         }
 564                         else
 565                         {
 566                                 error = 2;
 567                         }
 568                 }
 569         }
 570         return error;
 571 }
 572
 573 /** Detach a filter.
 574  *
 575  * \public \memberof mlt_service_s
 576  * \param self a service
 577  * \param filter the filter to detach
 578  * \return true if there was an error
 579  */
 580
 581 int mlt_service_detach( mlt_service self, mlt_filter filter )
 582 {
 583         int error = self == NULL || filter == NULL;
 584         if ( error == 0 )
 585         {
 586                 int i = 0;
 587                 mlt_service_base *base = self->local;
 588                 mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
 589
 590                 for ( i = 0; i < base->filter_count; i ++ )
 591                         if ( base->filters[ i ] == filter )
 592                                 break;
 593
 594                 if ( i < base->filter_count )
 595                 {
 596                         base->filters[ i ] = NULL;
 597                         for ( i ++ ; i < base->filter_count; i ++ )
 598                                 base->filters[ i - 1 ] = base->filters[ i ];
 599                         base->filter_count --;
 600                         mlt_events_disconnect( MLT_FILTER_PROPERTIES( filter ), self );
 601                         mlt_filter_close( filter );
 602                         mlt_events_fire( properties, "service-changed", NULL );
 603                 }
 604         }
 605         return error;
 606 }
 607
 608 /** Retrieve a filter.
 609  *
 610  * \public \memberof mlt_service_s
 611  * \param self a service
 612  * \param index which one of potentially multiple filters
 613  * \return the filter or null if there was an error
 614  */
 615
 616 mlt_filter mlt_service_filter( mlt_service self, int index )
 617 {
 618         mlt_filter filter = NULL;
 619         if ( self != NULL )
 620         {
 621                 mlt_service_base *base = self->local;
 622                 if ( index >= 0 && index < base->filter_count )
 623                         filter = base->filters[ index ];
 624         }
 625         return filter;
 626 }
 627
 628 /** Retrieve the profile.
 629  *
 630  * \public \memberof mlt_service_s
 631  * \param self a service
 632  * \return the profile
 633  */
 634
 635 mlt_profile mlt_service_profile( mlt_service self )
 636 {
 637         return self? mlt_properties_get_data( MLT_SERVICE_PROPERTIES( self ), "_profile", NULL ) : NULL;
 638 }
 639
 640 /** Destroy a service.
 641  *
 642  * \public \memberof mlt_service_s
 643  * \param self the service to destroy
 644  */
 645
 646 void mlt_service_close( mlt_service self )
 647 {
 648         if ( self != NULL && mlt_properties_dec_ref( MLT_SERVICE_PROPERTIES( self ) ) <= 0 )
 649         {
 650                 if ( self->close != NULL )
 651                 {
 652                         self->close( self->close_object );
 653                 }
 654                 else
 655                 {
 656                         mlt_service_base *base = self->local;
 657                         int i = 0;
 658                         int count = base->filter_count;
 659                         mlt_events_block( MLT_SERVICE_PROPERTIES( self ), self );
 660                         while( count -- )
 661                                 mlt_service_detach( self, base->filters[ 0 ] );
 662                         free( base->filters );
 663                         for ( i = 0; i < base->count; i ++ )
 664                                 if ( base->in[ i ] != NULL )
 665                                         mlt_service_close( base->in[ i ] );
 666                         self->parent.close = NULL;
 667                         free( base->in );
 668                         pthread_mutex_destroy( &base->mutex );
 669                         free( base );
 670                         mlt_properties_close( &self->parent );
 671                 }
 672         }
 673 }
 674
 675 /** Release a service's cache items.
 676  *
 677  * \private \memberof mlt_service_s
 678  * \param self a service
 679  */
 680
 681 void mlt_service_cache_purge( mlt_service self )
 682 {
 683         mlt_properties caches = mlt_properties_get_data( mlt_global_properties(), "caches", NULL );
 684
 685         if ( caches )
 686         {
 687                 int i = mlt_properties_count( caches );
 688                 while ( i-- )
 689                 {
 690                         mlt_cache_purge( mlt_properties_get_data_at( caches, i, NULL ), self );
 691                         mlt_properties_set_data( mlt_global_properties(), mlt_properties_get_name( caches, i ), NULL, 0, NULL, NULL );
 692                 }
 693         }
 694 }
 695
 696 /** Lookup the cache object for a service.
 697  *
 698  * \private \memberof mlt_service_s
 699  * \param self a service
 700  * \param name a name for the object
 701  * \return a cache
 702  */
 703
 704 static mlt_cache get_cache( mlt_service self, const char *name )
 705 {
 706         mlt_cache result = NULL;
 707         mlt_properties caches = mlt_properties_get_data( mlt_global_properties(), "caches", NULL );
 708
 709         if ( !caches )
 710         {
 711                 caches = mlt_properties_new();
 712                 mlt_properties_set_data( mlt_global_properties(), "caches", caches, 0, ( mlt_destructor )mlt_properties_close, NULL );
 713         }
 714         if ( caches )
 715         {
 716                 result = mlt_properties_get_data( caches, name, NULL );
 717                 if ( !result )
 718                 {
 719                         result = mlt_cache_init();
 720                         mlt_properties_set_data( caches, name, result, 0, ( mlt_destructor )mlt_cache_close, NULL );
 721                 }
 722         }
 723
 724         return result;
 725 }
 726
 727 /** Put an object into a service's cache.
 728  *
 729  * \public \memberof mlt_service_s
 730  * \param self a service
 731  * \param name a name for the object that is unique to the service class, but not to the instance
 732  * \param data an opaque pointer to the object to put into the cache
 733  * \param size the number of bytes pointed to by data
 734  * \param destructor a function that releases the data
 735  */
 736
 737 void mlt_service_cache_put( mlt_service self, const char *name, void* data, int size, mlt_destructor destructor )
 738 {
 739         mlt_log( self, MLT_LOG_DEBUG, "%s: name %s object %p data %p\n", __FUNCTION__, name, self, data );
 740         mlt_cache cache = get_cache( self, name );
 741
 742         if ( cache )
 743                 mlt_cache_put( cache, self, data, size, destructor );
 744 }
 745
 746 /** Get an object from a service's cache.
 747  *
 748  * \public \memberof mlt_service_s
 749  * \param self a service
 750  * \param name a name for the object that is unique to the service class, but not to the instance
 751  * \return a cache item or NULL if an object is not found
 752  * \see mlt_cache_item_data
 753  */
 754
 755 mlt_cache_item mlt_service_cache_get( mlt_service self, const char *name )
 756 {
 757         mlt_log( self, MLT_LOG_DEBUG, "%s: name %s object %p\n", __FUNCTION__, name, self );
 758         mlt_cache_item result = NULL;
 759         mlt_cache cache = get_cache( self, name );
 760
 761         if ( cache )
 762                 result = mlt_cache_get( cache, self );
 763
 764         return result;
 765 }
 766
 767 /** Set the number of items to cache for the named cache.
 768  *
 769  * \public \memberof mlt_service_s
 770  * \param self a service
 771  * \param name a name for the object that is unique to the service class, but not to the instance
 772  * \param size the number of items to cache
 773  */
 774
 775 void mlt_service_cache_set_size( mlt_service self, const char *name, int size )
 776 {
 777         mlt_cache cache = get_cache( self, name );
 778         if ( cache )
 779                 mlt_cache_set_size( cache, size );
 780 }
 781
 782 /** Get the current maximum size of the named cache.
 783  *
 784  * \public \memberof mlt_service_s
 785  * \param self a service
 786  * \param name a name for the object that is unique to the service class, but not to the instance
 787  * \return the current maximum number of items to cache or zero if there is an error
 788  */
 789
 790 int mlt_service_cache_get_size( mlt_service self, const char *name )
 791 {
 792         mlt_cache cache = get_cache( self, name );
 793         if ( cache )
 794                 return mlt_cache_get_size( cache );
 795         else
 796                 return 0;
 797 }