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

   1 /*
   2  * mlt_service.c -- interface for all service classes
   3  * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
   4  * Author: Charles Yates <charles.yates@pandora.be>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #include "mlt_service.h"
  23 #include "mlt_filter.h"
  24 #include "mlt_frame.h"
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 /** IMPORTANT NOTES
  30
  31         The base service implements a null frame producing service - as such,
  32         it is functional without extension and will produce test cards frames
  33         and PAL sized audio frames.
  34
  35         PLEASE DO NOT CHANGE THIS BEHAVIOUR!!! OVERRIDE THE METHODS THAT
  36         CONTROL THIS IN EXTENDING CLASSES.
  37 */
  38
  39 /** Private service definition.
  40 */
  41
  42 typedef struct
  43 {
  44         int size;
  45         int count;
  46         mlt_service *in;
  47         mlt_service out;
  48         int filter_count;
  49         int filter_size;
  50         mlt_filter *filters;
  51 }
  52 mlt_service_base;
  53
  54 /** Private methods
  55 */
  56
  57 static void mlt_service_disconnect( mlt_service this );
  58 static void mlt_service_connect( mlt_service this, mlt_service that );
  59 static int service_get_frame( mlt_service this, mlt_frame_ptr frame, int index );
  60 static void mlt_service_property_changed( mlt_listener, mlt_properties owner, mlt_service this, void **args );
  61
  62 /** Constructor
  63 */
  64
  65 int mlt_service_init( mlt_service this, void *child )
  66 {
  67         int error = 0;
  68
  69         // Initialise everything to NULL
  70         memset( this, 0, sizeof( struct mlt_service_s ) );
  71
  72         // Assign the child
  73         this->child = child;
  74
  75         // Generate local space
  76         this->local = calloc( sizeof( mlt_service_base ), 1 );
  77
  78         // Associate the methods
  79         this->get_frame = service_get_frame;
  80
  81         // Initialise the properties
  82         error = mlt_properties_init( &this->parent, this );
  83         if ( error == 0 )
  84         {
  85                 this->parent.close = ( mlt_destructor )mlt_service_close;
  86                 this->parent.close_object = this;
  87
  88                 mlt_events_init( &this->parent );
  89                 mlt_events_register( &this->parent, "service-changed", NULL );
  90                 mlt_events_register( &this->parent, "property-changed", ( mlt_transmitter )mlt_service_property_changed );
  91         }
  92
  93         return error;
  94 }
  95
  96 static void mlt_service_property_changed( mlt_listener listener, mlt_properties owner, mlt_service this, void **args )
  97 {
  98         if ( listener != NULL )
  99                 listener( owner, this, ( char * )args[ 0 ] );
 100 }
 101
 102 /** Connect a producer service.
 103         Returns: > 0 warning, == 0 success, < 0 serious error
 104                          1 = this service does not accept input
 105                          2 = the producer is invalid
 106                          3 = the producer is already registered with this consumer
 107 */
 108
 109 int mlt_service_connect_producer( mlt_service this, mlt_service producer, int index )
 110 {
 111         int i = 0;
 112
 113         // Get the service base
 114         mlt_service_base *base = this->local;
 115
 116         // Check if the producer is already registered with this service
 117         for ( i = 0; i < base->count; i ++ )
 118                 if ( base->in[ i ] == producer )
 119                         return 3;
 120
 121         // Allocate space
 122         if ( index >= base->size )
 123         {
 124                 int new_size = base->size + index + 10;
 125                 base->in = realloc( base->in, new_size * sizeof( mlt_service ) );
 126                 if ( base->in != NULL )
 127                 {
 128                         for ( i = base->size; i < new_size; i ++ )
 129                                 base->in[ i ] = NULL;
 130                         base->size = new_size;
 131                 }
 132         }
 133
 134         // If we have space, assign the input
 135         if ( base->in != NULL && index >= 0 && index < base->size )
 136         {
 137                 // Get the current service
 138                 mlt_service current = base->in[ index ];
 139
 140                 // Increment the reference count on this producer
 141                 if ( producer != NULL )
 142                         mlt_properties_inc_ref( mlt_service_properties( producer ) );
 143
 144                 // Now we disconnect the producer service from its consumer
 145                 mlt_service_disconnect( producer );
 146
 147                 // Add the service to index specified
 148                 base->in[ index ] = producer;
 149
 150                 // Determine the number of active tracks
 151                 if ( index >= base->count )
 152                         base->count = index + 1;
 153
 154                 // Now we connect the producer to its connected consumer
 155                 mlt_service_connect( producer, this );
 156
 157                 // Close the current service
 158                 mlt_service_close( current );
 159
 160                 // Inform caller that all went well
 161                 return 0;
 162         }
 163         else
 164         {
 165                 return -1;
 166         }
 167 }
 168
 169 /** Disconnect this service from its consumer.
 170 */
 171
 172 static void mlt_service_disconnect( mlt_service this )
 173 {
 174         if ( this != NULL )
 175         {
 176                 // Get the service base
 177                 mlt_service_base *base = this->local;
 178
 179                 // Disconnect
 180                 base->out = NULL;
 181         }
 182 }
 183
 184 /** Obtain the consumer this service is connected to.
 185 */
 186
 187 mlt_service mlt_service_consumer( mlt_service this )
 188 {
 189         // Get the service base
 190         mlt_service_base *base = this->local;
 191
 192         // Return the connected consumer
 193         return base->out;
 194 }
 195
 196 /** Obtain the producer this service is connected to.
 197 */
 198
 199 mlt_service mlt_service_producer( mlt_service this )
 200 {
 201         // Get the service base
 202         mlt_service_base *base = this->local;
 203
 204         // Return the connected producer
 205         return base->count > 0 ? base->in[ base->count - 1 ] : NULL;
 206 }
 207
 208 /** Associate this service to the consumer.
 209 */
 210
 211 static void mlt_service_connect( mlt_service this, mlt_service that )
 212 {
 213         if ( this != NULL )
 214         {
 215                 // Get the service base
 216                 mlt_service_base *base = this->local;
 217
 218                 // There's a bit more required here...
 219                 base->out = that;
 220         }
 221 }
 222
 223 /** Get the first connected producer service.
 224 */
 225
 226 mlt_service mlt_service_get_producer( mlt_service this )
 227 {
 228         mlt_service producer = NULL;
 229
 230         // Get the service base
 231         mlt_service_base *base = this->local;
 232
 233         if ( base->in != NULL )
 234                 producer = base->in[ 0 ];
 235
 236         return producer;
 237 }
 238
 239 /** Default implementation of get_frame.
 240 */
 241
 242 static int service_get_frame( mlt_service this, mlt_frame_ptr frame, int index )
 243 {
 244         mlt_service_base *base = this->local;
 245         if ( index < base->count )
 246         {
 247                 mlt_service producer = base->in[ index ];
 248                 if ( producer != NULL )
 249                         return mlt_service_get_frame( producer, frame, index );
 250         }
 251         *frame = mlt_frame_init( );
 252         return 0;
 253 }
 254
 255 /** Return the properties object.
 256 */
 257
 258 mlt_properties mlt_service_properties( mlt_service self )
 259 {
 260         return self != NULL ? &self->parent : NULL;
 261 }
 262
 263 /** Recursively apply attached filters
 264 */
 265
 266 void mlt_service_apply_filters( mlt_service this, mlt_frame frame, int index )
 267 {
 268         int i;
 269         mlt_properties frame_properties = mlt_frame_properties( frame );
 270         mlt_properties service_properties = mlt_service_properties( this );
 271         mlt_service_base *base = this->local;
 272         mlt_position position = mlt_frame_get_position( frame );
 273         mlt_position this_in = mlt_properties_get_position( service_properties, "in" );
 274         mlt_position this_out = mlt_properties_get_position( service_properties, "out" );
 275
 276         // Hmm - special case for cuts - apply filters from the parent first
 277         if ( mlt_properties_get_int( service_properties, "_cut" ) )
 278         {
 279                 mlt_service_apply_filters( ( mlt_service )mlt_properties_get_data( service_properties, "_cut_parent", NULL ), frame, 0 );
 280                 position -= this_in;
 281                 mlt_frame_set_position( frame, position );
 282         }
 283
 284         if ( index == 0 || mlt_properties_get_int( service_properties, "_filter_private" ) == 0 )
 285         {
 286                 // Process the frame with the attached filters
 287                 for ( i = 0; i < base->filter_count; i ++ )
 288                 {
 289                         if ( base->filters[ i ] != NULL )
 290                         {
 291                                 mlt_position in = mlt_filter_get_in( base->filters[ i ] );
 292                                 mlt_position out = mlt_filter_get_out( base->filters[ i ] );
 293                                 if ( ( in == 0 && out == 0 ) || ( position >= in && ( position <= out || out == 0 ) ) )
 294                                 {
 295                                         mlt_properties_set_position( frame_properties, "in", 0 );
 296                                         mlt_properties_set_position( frame_properties, "out", out == 0 ? this_out - this_in : out - in );
 297                                         mlt_frame_set_position( frame, position - in );
 298                                         mlt_filter_process( base->filters[ i ], frame );
 299                                         mlt_service_apply_filters( mlt_filter_service( base->filters[ i ] ), frame, index + 1 );
 300                                         mlt_frame_set_position( frame, position + in );
 301                                 }
 302                         }
 303                 }
 304         }
 305
 306         if ( mlt_properties_get_int( service_properties, "_cut" ) )
 307         {
 308                 mlt_properties_set_position( frame_properties, "in", this_in );
 309                 mlt_properties_set_position( frame_properties, "out", this_out );
 310                 mlt_frame_set_position( frame, position + this_in );
 311         }
 312 }
 313
 314 /** Obtain a frame.
 315 */
 316
 317 int mlt_service_get_frame( mlt_service this, mlt_frame_ptr frame, int index )
 318 {
 319         if ( this != NULL && this->get_frame != NULL )
 320         {
 321                 int result = 0;
 322                 mlt_properties properties = mlt_service_properties( this );
 323                 mlt_position in = mlt_properties_get_position( properties, "in" );
 324                 mlt_position out = mlt_properties_get_position( properties, "out" );
 325                 result = this->get_frame( this, frame, index );
 326                 if ( result == 0 )
 327                 {
 328                         if ( in >=0 && out > 0 )
 329                         {
 330                                 properties = mlt_frame_properties( *frame );
 331                                 mlt_properties_set_position( properties, "in", in );
 332                                 mlt_properties_set_position( properties, "out", out );
 333                         }
 334                         mlt_service_apply_filters( this, *frame, 1 );
 335                 }
 336                 return result;
 337         }
 338         *frame = mlt_frame_init( );
 339         return 0;
 340 }
 341
 342 static void mlt_service_filter_changed( mlt_service owner, mlt_service this )
 343 {
 344         mlt_events_fire( mlt_service_properties( this ), "service-changed", NULL );
 345 }
 346
 347 /** Attach a filter.
 348 */
 349
 350 int mlt_service_attach( mlt_service this, mlt_filter filter )
 351 {
 352         int error = this == NULL || filter == NULL;
 353         if ( error == 0 )
 354         {
 355                 int i = 0;
 356                 mlt_properties properties = mlt_service_properties( this );
 357                 mlt_service_base *base = this->local;
 358
 359                 for ( i = 0; error == 0 && i < base->filter_count; i ++ )
 360                         if ( base->filters[ i ] == filter )
 361                                 error = 1;
 362
 363                 if ( error == 0 )
 364                 {
 365                         if ( base->filter_count == base->filter_size )
 366                         {
 367                                 base->filter_size += 10;
 368                                 base->filters = realloc( base->filters, base->filter_size * sizeof( mlt_filter ) );
 369                         }
 370
 371                         if ( base->filters != NULL )
 372                         {
 373                                 mlt_properties props = mlt_filter_properties( filter );
 374                                 mlt_properties_inc_ref( mlt_filter_properties( filter ) );
 375                                 base->filters[ base->filter_count ++ ] = filter;
 376                                 mlt_events_fire( properties, "service-changed", NULL );
 377                                 mlt_events_listen( props, this, "service-changed", ( mlt_listener )mlt_service_filter_changed );
 378                                 mlt_events_listen( props, this, "property-changed", ( mlt_listener )mlt_service_filter_changed );
 379                         }
 380                         else
 381                         {
 382                                 error = 2;
 383                         }
 384                 }
 385         }
 386         return error;
 387 }
 388
 389 /** Detach a filter.
 390 */
 391
 392 int mlt_service_detach( mlt_service this, mlt_filter filter )
 393 {
 394         int error = this == NULL || filter == NULL;
 395         if ( error == 0 )
 396         {
 397                 int i = 0;
 398                 mlt_service_base *base = this->local;
 399                 mlt_properties properties = mlt_service_properties( this );
 400
 401                 for ( i = 0; i < base->filter_count; i ++ )
 402                         if ( base->filters[ i ] == filter )
 403                                 break;
 404
 405                 if ( i < base->filter_count )
 406                 {
 407                         base->filters[ i ] = NULL;
 408                         for ( i ++ ; i < base->filter_count; i ++ )
 409                                 base->filters[ i - 1 ] = base->filters[ i ];
 410                         base->filter_count --;
 411                         mlt_events_disconnect( mlt_filter_properties( filter ), this );
 412                         mlt_filter_close( filter );
 413                         mlt_events_fire( properties, "service-changed", NULL );
 414                 }
 415         }
 416         return error;
 417 }
 418
 419 /** Retrieve a filter.
 420 */
 421
 422 mlt_filter mlt_service_filter( mlt_service this, int index )
 423 {
 424         mlt_filter filter = NULL;
 425         if ( this != NULL )
 426         {
 427                 mlt_service_base *base = this->local;
 428                 if ( index >= 0 && index < base->filter_count )
 429                         filter = base->filters[ index ];
 430         }
 431         return filter;
 432 }
 433
 434 /** Close the service.
 435 */
 436
 437 void mlt_service_close( mlt_service this )
 438 {
 439         if ( this != NULL && mlt_properties_dec_ref( mlt_service_properties( this ) ) <= 0 )
 440         {
 441                 if ( this->close != NULL )
 442                 {
 443                         this->close( this->close_object );
 444                 }
 445                 else
 446                 {
 447                         mlt_service_base *base = this->local;
 448                         int i = 0;
 449                         int count = base->filter_count;
 450                         mlt_events_block( mlt_service_properties( this ), this );
 451                         while( count -- )
 452                                 mlt_service_detach( this, base->filters[ 0 ] );
 453                         free( base->filters );
 454                         for ( i = 0; i < base->count; i ++ )
 455                                 if ( base->in[ i ] != NULL )
 456                                         mlt_service_close( base->in[ i ] );
 457                         this->parent.close = NULL;
 458                         free( base->in );
 459                         free( base );
 460                         mlt_properties_close( &this->parent );
 461                 }
 462         }
 463 }
 464