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( 1, sizeof( mlt_service_base ) );
  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  * \private \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 /** The property-changed event handler.
 525  *
 526  * \private \memberof mlt_service_s
 527  * \param owner ignored
 528  * \param self the service on which the "property-changed" event is fired
 529  * \param name the name of the property that changed
 530  */
 531
 532 static void mlt_service_filter_property_changed( mlt_service owner, mlt_service self, char *name )
 533 {
 534     mlt_events_fire( MLT_SERVICE_PROPERTIES( self ), "property-changed", name, NULL );
 535 }
 536
 537 /** Attach a filter.
 538  *
 539  * \public \memberof mlt_service_s
 540  * \param self a service
 541  * \param filter the filter to attach
 542  * \return true if there was an error
 543  */
 544
 545 int mlt_service_attach( mlt_service self, mlt_filter filter )
 546 {
 547         int error = self == NULL || filter == NULL;
 548         if ( error == 0 )
 549         {
 550                 int i = 0;
 551                 mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
 552                 mlt_service_base *base = self->local;
 553
 554                 for ( i = 0; error == 0 && i < base->filter_count; i ++ )
 555                         if ( base->filters[ i ] == filter )
 556                                 error = 1;
 557
 558                 if ( error == 0 )
 559                 {
 560                         if ( base->filter_count == base->filter_size )
 561                         {
 562                                 base->filter_size += 10;
 563                                 base->filters = realloc( base->filters, base->filter_size * sizeof( mlt_filter ) );
 564                         }
 565
 566                         if ( base->filters != NULL )
 567                         {
 568                                 mlt_properties props = MLT_FILTER_PROPERTIES( filter );
 569                                 mlt_properties_inc_ref( MLT_FILTER_PROPERTIES( filter ) );
 570                                 base->filters[ base->filter_count ++ ] = filter;
 571                                 mlt_properties_set_data( props, "service", self, 0, NULL, NULL );
 572                                 mlt_events_fire( properties, "service-changed", NULL );
 573                                 mlt_events_fire( props, "service-changed", NULL );
 574                                 mlt_events_listen( props, self, "service-changed", ( mlt_listener )mlt_service_filter_changed );
 575                                 mlt_events_listen( props, self, "property-changed", ( mlt_listener )mlt_service_filter_property_changed );
 576                         }
 577                         else
 578                         {
 579                                 error = 2;
 580                         }
 581                 }
 582         }
 583         return error;
 584 }
 585
 586 /** Detach a filter.
 587  *
 588  * \public \memberof mlt_service_s
 589  * \param self a service
 590  * \param filter the filter to detach
 591  * \return true if there was an error
 592  */
 593
 594 int mlt_service_detach( mlt_service self, mlt_filter filter )
 595 {
 596         int error = self == NULL || filter == NULL;
 597         if ( error == 0 )
 598         {
 599                 int i = 0;
 600                 mlt_service_base *base = self->local;
 601                 mlt_properties properties = MLT_SERVICE_PROPERTIES( self );
 602
 603                 for ( i = 0; i < base->filter_count; i ++ )
 604                         if ( base->filters[ i ] == filter )
 605                                 break;
 606
 607                 if ( i < base->filter_count )
 608                 {
 609                         base->filters[ i ] = NULL;
 610                         for ( i ++ ; i < base->filter_count; i ++ )
 611                                 base->filters[ i - 1 ] = base->filters[ i ];
 612                         base->filter_count --;
 613                         mlt_events_disconnect( MLT_FILTER_PROPERTIES( filter ), self );
 614                         mlt_filter_close( filter );
 615                         mlt_events_fire( properties, "service-changed", NULL );
 616                 }
 617         }
 618         return error;
 619 }
 620
 621 /** Get the number of filters attached.
 622  *
 623  * \public \memberof mlt_service_s
 624  * \param self a service
 625  * \return the number of attached filters or -1 if there was an error
 626  */
 627
 628 int mlt_service_filter_count( mlt_service self )
 629 {
 630         int result = -1;
 631         if ( self )
 632         {
 633                 mlt_service_base *base = self->local;
 634                 result = base->filter_count;
 635         }
 636         return result;
 637 }
 638
 639 /** Reorder the attached filters.
 640  *
 641  * \public \memberof mlt_service_s
 642  * \param self a service
 643  * \param from the current index value of the filter to move
 644  * \param to the new index value for the filter specified in \p from
 645  * \return true if there was an error
 646  */
 647
 648 int mlt_service_move_filter( mlt_service self, int from, int to )
 649 {
 650         int error = -1;
 651         if ( self )
 652         {
 653                 mlt_service_base *base = self->local;
 654                 if ( from < 0 ) from = 0;
 655                 if ( from >= base->filter_count ) from = base->filter_count - 1;
 656                 if ( to < 0 ) to = 0;
 657                 if ( to >= base->filter_count ) to = base->filter_count - 1;
 658                 if ( from != to && base->filter_count > 1 )
 659                 {
 660                         mlt_filter filter = base->filters[from];
 661                         int i;
 662                         if ( from > to )
 663                         {
 664                                 for ( i = from; i > to; i-- )
 665                                         base->filters[i] = base->filters[i - 1];
 666                         }
 667                         else
 668                         {
 669                                 for ( i = from; i < to; i++ )
 670                                         base->filters[i] = base->filters[i + 1];
 671                         }
 672                         base->filters[to] = filter;
 673                         error = 0;
 674                 }
 675         }
 676         return error;
 677 }
 678
 679 /** Retrieve an attached filter.
 680  *
 681  * \public \memberof mlt_service_s
 682  * \param self a service
 683  * \param index which one of potentially multiple filters
 684  * \return the filter or null if there was an error
 685  */
 686
 687 mlt_filter mlt_service_filter( mlt_service self, int index )
 688 {
 689         mlt_filter filter = NULL;
 690         if ( self != NULL )
 691         {
 692                 mlt_service_base *base = self->local;
 693                 if ( index >= 0 && index < base->filter_count )
 694                         filter = base->filters[ index ];
 695         }
 696         return filter;
 697 }
 698
 699 /** Retrieve the profile.
 700  *
 701  * \public \memberof mlt_service_s
 702  * \param self a service
 703  * \return the profile
 704  */
 705
 706 mlt_profile mlt_service_profile( mlt_service self )
 707 {
 708         return self? mlt_properties_get_data( MLT_SERVICE_PROPERTIES( self ), "_profile", NULL ) : NULL;
 709 }
 710
 711 /** Set the profile for a service.
 712  *
 713  * \public \memberof mlt_service_s
 714  * \param self a service
 715  * \param profile the profile to set onto the service
 716  */
 717
 718 void mlt_service_set_profile( mlt_service self, mlt_profile profile )
 719 {
 720     mlt_properties_set_data( MLT_SERVICE_PROPERTIES( self ), "_profile", profile, 0, NULL, NULL );
 721 }
 722
 723 /** Destroy a service.
 724  *
 725  * \public \memberof mlt_service_s
 726  * \param self the service to destroy
 727  */
 728
 729 void mlt_service_close( mlt_service self )
 730 {
 731         if ( self != NULL && mlt_properties_dec_ref( MLT_SERVICE_PROPERTIES( self ) ) <= 0 )
 732         {
 733                 if ( self->close != NULL )
 734                 {
 735                         self->close( self->close_object );
 736                 }
 737                 else
 738                 {
 739                         mlt_service_base *base = self->local;
 740                         int i = 0;
 741                         int count = base->filter_count;
 742                         mlt_events_block( MLT_SERVICE_PROPERTIES( self ), self );
 743                         while( count -- )
 744                                 mlt_service_detach( self, base->filters[ 0 ] );
 745                         free( base->filters );
 746                         for ( i = 0; i < base->count; i ++ )
 747                                 if ( base->in[ i ] != NULL )
 748                                         mlt_service_close( base->in[ i ] );
 749                         self->parent.close = NULL;
 750                         free( base->in );
 751                         pthread_mutex_destroy( &base->mutex );
 752                         free( base );
 753                         mlt_properties_close( &self->parent );
 754                 }
 755         }
 756 }
 757
 758 /** Release a service's cache items.
 759  *
 760  * \private \memberof mlt_service_s
 761  * \param self a service
 762  */
 763
 764 void mlt_service_cache_purge( mlt_service self )
 765 {
 766         mlt_properties caches = mlt_properties_get_data( mlt_global_properties(), "caches", NULL );
 767
 768         if ( caches )
 769         {
 770                 int i = mlt_properties_count( caches );
 771                 while ( i-- )
 772                 {
 773                         mlt_cache_purge( mlt_properties_get_data_at( caches, i, NULL ), self );
 774                         mlt_properties_set_data( mlt_global_properties(), mlt_properties_get_name( caches, i ), NULL, 0, NULL, NULL );
 775                 }
 776         }
 777 }
 778
 779 /** Lookup the cache object for a service.
 780  *
 781  * \private \memberof mlt_service_s
 782  * \param self a service
 783  * \param name a name for the object
 784  * \return a cache
 785  */
 786
 787 static mlt_cache get_cache( mlt_service self, const char *name )
 788 {
 789         mlt_cache result = NULL;
 790         mlt_properties caches = mlt_properties_get_data( mlt_global_properties(), "caches", NULL );
 791
 792         if ( !caches )
 793         {
 794                 caches = mlt_properties_new();
 795                 mlt_properties_set_data( mlt_global_properties(), "caches", caches, 0, ( mlt_destructor )mlt_properties_close, NULL );
 796         }
 797         if ( caches )
 798         {
 799                 result = mlt_properties_get_data( caches, name, NULL );
 800                 if ( !result )
 801                 {
 802                         result = mlt_cache_init();
 803                         mlt_properties_set_data( caches, name, result, 0, ( mlt_destructor )mlt_cache_close, NULL );
 804                 }
 805         }
 806
 807         return result;
 808 }
 809
 810 /** Put an object into a service's cache.
 811  *
 812  * \public \memberof mlt_service_s
 813  * \param self a service
 814  * \param name a name for the object that is unique to the service class, but not to the instance
 815  * \param data an opaque pointer to the object to put into the cache
 816  * \param size the number of bytes pointed to by data
 817  * \param destructor a function that releases the data
 818  */
 819
 820 void mlt_service_cache_put( mlt_service self, const char *name, void* data, int size, mlt_destructor destructor )
 821 {
 822         mlt_log( self, MLT_LOG_DEBUG, "%s: name %s object %p data %p\n", __FUNCTION__, name, self, data );
 823         mlt_cache cache = get_cache( self, name );
 824
 825         if ( cache )
 826                 mlt_cache_put( cache, self, data, size, destructor );
 827 }
 828
 829 /** Get an object from a service's cache.
 830  *
 831  * \public \memberof mlt_service_s
 832  * \param self a service
 833  * \param name a name for the object that is unique to the service class, but not to the instance
 834  * \return a cache item or NULL if an object is not found
 835  * \see mlt_cache_item_data
 836  */
 837
 838 mlt_cache_item mlt_service_cache_get( mlt_service self, const char *name )
 839 {
 840         mlt_log( self, MLT_LOG_DEBUG, "%s: name %s object %p\n", __FUNCTION__, name, self );
 841         mlt_cache_item result = NULL;
 842         mlt_cache cache = get_cache( self, name );
 843
 844         if ( cache )
 845                 result = mlt_cache_get( cache, self );
 846
 847         return result;
 848 }
 849
 850 /** Set the number of items to cache for the named cache.
 851  *
 852  * \public \memberof mlt_service_s
 853  * \param self a service
 854  * \param name a name for the object that is unique to the service class, but not to the instance
 855  * \param size the number of items to cache
 856  */
 857
 858 void mlt_service_cache_set_size( mlt_service self, const char *name, int size )
 859 {
 860         mlt_cache cache = get_cache( self, name );
 861         if ( cache )
 862                 mlt_cache_set_size( cache, size );
 863 }
 864
 865 /** Get the current maximum size of the named cache.
 866  *
 867  * \public \memberof mlt_service_s
 868  * \param self a service
 869  * \param name a name for the object that is unique to the service class, but not to the instance
 870  * \return the current maximum number of items to cache or zero if there is an error
 871  */
 872
 873 int mlt_service_cache_get_size( mlt_service self, const char *name )
 874 {
 875         mlt_cache cache = get_cache( self, name );
 876         if ( cache )
 877                 return mlt_cache_get_size( cache );
 878         else
 879                 return 0;
 880 }