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

   1 /*
   2  * mlt_events.h -- event handling
   3  * Copyright (C) 2004-2005 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 <stdlib.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24 #include <pthread.h>
  25
  26 #include "mlt_properties.h"
  27 #include "mlt_events.h"
  28
  29 /** Memory leak checks.
  30 */
  31
  32 //#define _MLT_EVENT_CHECKS_
  33
  34 #ifdef _MLT_EVENT_CHECKS_
  35 static int events_created = 0;
  36 static int events_destroyed = 0;
  37 #endif
  38
  39 struct mlt_events_struct
  40 {
  41         mlt_properties owner;
  42         mlt_properties list;
  43 };
  44
  45 typedef struct mlt_events_struct *mlt_events;
  46
  47 struct mlt_event_struct
  48 {
  49         mlt_events owner;
  50         int ref_count;
  51         int block_count;
  52         mlt_listener listener;
  53         void *service;
  54 };
  55
  56 /** Increment the reference count on this event.
  57 */
  58
  59 void mlt_event_inc_ref( mlt_event this )
  60 {
  61         if ( this != NULL )
  62                 this->ref_count ++;
  63 }
  64
  65 /** Increment the block count on this event.
  66 */
  67
  68 void mlt_event_block( mlt_event this )
  69 {
  70         if ( this != NULL && this->owner != NULL )
  71                 this->block_count ++;
  72 }
  73
  74 /** Decrement the block count on this event.
  75 */
  76
  77 void mlt_event_unblock( mlt_event this )
  78 {
  79         if ( this != NULL && this->owner != NULL )
  80                 this->block_count --;
  81 }
  82
  83 /** Close this event.
  84 */
  85
  86 void mlt_event_close( mlt_event this )
  87 {
  88         if ( this != NULL )
  89         {
  90                 if ( -- this->ref_count == 1 )
  91                         this->owner = NULL;
  92                 if ( this->ref_count <= 0 )
  93                 {
  94 #ifdef _MLT_EVENT_CHECKS_
  95                         events_destroyed ++;
  96                         fprintf( stderr, "Events created %d, destroyed %d\n", events_created, events_destroyed );
  97 #endif
  98                         free( this );
  99                 }
 100         }
 101 }
 102
 103 /** Forward declaration to private functions.
 104 */
 105
 106 static mlt_events mlt_events_fetch( mlt_properties );
 107 static void mlt_events_store( mlt_properties, mlt_events );
 108 static void mlt_events_close( mlt_events );
 109
 110 /** Initialise the events structure.
 111 */
 112
 113 void mlt_events_init( mlt_properties this )
 114 {
 115         mlt_events events = mlt_events_fetch( this );
 116         if ( events == NULL )
 117         {
 118                 events = malloc( sizeof( struct mlt_events_struct ) );
 119                 events->list = mlt_properties_new( );
 120                 mlt_events_store( this, events );
 121         }
 122 }
 123
 124 /** Register an event and transmitter.
 125 */
 126
 127 int mlt_events_register( mlt_properties this, char *id, mlt_transmitter transmitter )
 128 {
 129         int error = 1;
 130         mlt_events events = mlt_events_fetch( this );
 131         if ( events != NULL )
 132         {
 133                 mlt_properties list = events->list;
 134                 char temp[ 128 ];
 135                 error = mlt_properties_set_data( list, id, transmitter, 0, NULL, NULL );
 136                 sprintf( temp, "list:%s", id );
 137                 if ( mlt_properties_get_data( list, temp, NULL ) == NULL )
 138                         mlt_properties_set_data( list, temp, mlt_properties_new( ), 0, ( mlt_destructor )mlt_properties_close, NULL );
 139         }
 140         return error;
 141 }
 142
 143 /** Fire an event.
 144 */
 145
 146 void mlt_events_fire( mlt_properties this, char *id, ... )
 147 {
 148         mlt_events events = mlt_events_fetch( this );
 149         if ( events != NULL )
 150         {
 151                 int i = 0;
 152                 va_list alist;
 153                 void *args[ 10 ];
 154                 mlt_properties list = events->list;
 155                 mlt_properties listeners = NULL;
 156                 char temp[ 128 ];
 157                 mlt_transmitter transmitter = mlt_properties_get_data( list, id, NULL );
 158                 sprintf( temp, "list:%s", id );
 159                 listeners = mlt_properties_get_data( list, temp, NULL );
 160
 161                 va_start( alist, id );
 162                 do
 163                         args[ i ] = va_arg( alist, void * );
 164                 while( args[ i ++ ] != NULL );
 165                 va_end( alist );
 166
 167                 if ( listeners != NULL )
 168                 {
 169                         for ( i = 0; i < mlt_properties_count( listeners ); i ++ )
 170                         {
 171                                 mlt_event event = mlt_properties_get_data_at( listeners, i, NULL );
 172                                 if ( event != NULL && event->owner != NULL && event->block_count == 0 )
 173                                 {
 174                                         if ( transmitter != NULL )
 175                                                 transmitter( event->listener, event->owner, event->service, args );
 176                                         else
 177                                                 event->listener( event->owner, event->service );
 178                                 }
 179                         }
 180                 }
 181         }
 182 }
 183
 184 /** Register a listener.
 185 */
 186
 187 mlt_event mlt_events_listen( mlt_properties this, void *service, char *id, mlt_listener listener )
 188 {
 189         mlt_event event = NULL;
 190         mlt_events events = mlt_events_fetch( this );
 191         if ( events != NULL )
 192         {
 193                 mlt_properties list = events->list;
 194                 mlt_properties listeners = NULL;
 195                 char temp[ 128 ];
 196                 sprintf( temp, "list:%s", id );
 197                 listeners = mlt_properties_get_data( list, temp, NULL );
 198                 if ( listeners != NULL )
 199                 {
 200                         int first_null = -1;
 201                         int i = 0;
 202                         for ( i = 0; event == NULL && i < mlt_properties_count( listeners ); i ++ )
 203                         {
 204                                 mlt_event entry = mlt_properties_get_data_at( listeners, i, NULL );
 205                                 if ( entry != NULL && entry->owner != NULL )
 206                                 {
 207                                         if ( entry->service == service && entry->listener == listener )
 208                                                 event = entry;
 209                                 }
 210                                 else if ( ( entry == NULL || entry->owner == NULL ) && first_null == -1 )
 211                                 {
 212                                         first_null = i;
 213                                 }
 214                         }
 215
 216                         if ( event == NULL )
 217                         {
 218                                 event = malloc( sizeof( struct mlt_event_struct ) );
 219                                 if ( event != NULL )
 220                                 {
 221 #ifdef _MLT_EVENT_CHECKS_
 222                                         events_created ++;
 223 #endif
 224                                         sprintf( temp, "%d", first_null == -1 ? mlt_properties_count( listeners ) : first_null );
 225                                         event->owner = events;
 226                                         event->ref_count = 0;
 227                                         event->block_count = 0;
 228                                         event->listener = listener;
 229                                         event->service = service;
 230                                         mlt_properties_set_data( listeners, temp, event, 0, ( mlt_destructor )mlt_event_close, NULL );
 231                                 }
 232                         }
 233
 234                         if ( event != NULL )
 235                                 mlt_event_inc_ref( event );
 236                 }
 237         }
 238         return event;
 239 }
 240
 241 /** Block all events for a given service.
 242 */
 243
 244 void mlt_events_block( mlt_properties this, void *service )
 245 {
 246         mlt_events events = mlt_events_fetch( this );
 247         if ( events != NULL )
 248         {
 249                 int i = 0, j = 0;
 250                 mlt_properties list = events->list;
 251                 for ( j = 0; j < mlt_properties_count( list ); j ++ )
 252                 {
 253                         char *temp = mlt_properties_get_name( list, j );
 254                         if ( !strncmp( temp, "list:", 5 ) )
 255                         {
 256                                 mlt_properties listeners = mlt_properties_get_data( list, temp, NULL );
 257                                 for ( i = 0; i < mlt_properties_count( listeners ); i ++ )
 258                                 {
 259                                         mlt_event entry = mlt_properties_get_data_at( listeners, i, NULL );
 260                                         if ( entry != NULL && entry->service == service )
 261                                                 mlt_event_block( entry );
 262                                 }
 263                         }
 264                 }
 265         }
 266 }
 267
 268 /** Unblock all events for a given service.
 269 */
 270
 271 void mlt_events_unblock( mlt_properties this, void *service )
 272 {
 273         mlt_events events = mlt_events_fetch( this );
 274         if ( events != NULL )
 275         {
 276                 int i = 0, j = 0;
 277                 mlt_properties list = events->list;
 278                 for ( j = 0; j < mlt_properties_count( list ); j ++ )
 279                 {
 280                         char *temp = mlt_properties_get_name( list, j );
 281                         if ( !strncmp( temp, "list:", 5 ) )
 282                         {
 283                                 mlt_properties listeners = mlt_properties_get_data( list, temp, NULL );
 284                                 for ( i = 0; i < mlt_properties_count( listeners ); i ++ )
 285                                 {
 286                                         mlt_event entry = mlt_properties_get_data_at( listeners, i, NULL );
 287                                         if ( entry != NULL && entry->service == service )
 288                                                 mlt_event_unblock( entry );
 289                                 }
 290                         }
 291                 }
 292         }
 293 }
 294
 295 /** Disconnect all events for a given service.
 296 */
 297
 298 void mlt_events_disconnect( mlt_properties this, void *service )
 299 {
 300         mlt_events events = mlt_events_fetch( this );
 301         if ( events != NULL )
 302         {
 303                 int i = 0, j = 0;
 304                 mlt_properties list = events->list;
 305                 for ( j = 0; j < mlt_properties_count( list ); j ++ )
 306                 {
 307                         char *temp = mlt_properties_get_name( list, j );
 308                         if ( !strncmp( temp, "list:", 5 ) )
 309                         {
 310                                 mlt_properties listeners = mlt_properties_get_data( list, temp, NULL );
 311                                 for ( i = 0; i < mlt_properties_count( listeners ); i ++ )
 312                                 {
 313                                         mlt_event entry = mlt_properties_get_data_at( listeners, i, NULL );
 314                                         char *name = mlt_properties_get_name( listeners, i );
 315                                         if ( entry != NULL && entry->service == service )
 316                                                 mlt_properties_set_data( listeners, name, NULL, 0, NULL, NULL );
 317                                 }
 318                         }
 319                 }
 320         }
 321 }
 322
 323 typedef struct
 324 {
 325         int done;
 326         pthread_cond_t cond;
 327         pthread_mutex_t mutex;
 328 }
 329 condition_pair;
 330
 331 static void mlt_events_listen_for( mlt_properties this, condition_pair *pair )
 332 {
 333         pthread_mutex_lock( &pair->mutex );
 334         if ( pair->done == 0 )
 335         {
 336                 pthread_cond_signal( &pair->cond );
 337                 pthread_mutex_unlock( &pair->mutex );
 338         }
 339 }
 340
 341 mlt_event mlt_events_setup_wait_for( mlt_properties this, char *id )
 342 {
 343         condition_pair *pair = malloc( sizeof( condition_pair ) );
 344         pair->done = 0;
 345         pthread_cond_init( &pair->cond, NULL );
 346         pthread_mutex_init( &pair->mutex, NULL );
 347         pthread_mutex_lock( &pair->mutex );
 348         return mlt_events_listen( this, pair, id, ( mlt_listener )mlt_events_listen_for );
 349 }
 350
 351 void mlt_events_wait_for( mlt_properties this, mlt_event event )
 352 {
 353         if ( event != NULL )
 354         {
 355                 condition_pair *pair = event->service;
 356                 pthread_cond_wait( &pair->cond, &pair->mutex );
 357         }
 358 }
 359
 360 void mlt_events_close_wait_for( mlt_properties this, mlt_event event )
 361 {
 362         if ( event != NULL )
 363         {
 364                 condition_pair *pair = event->service;
 365                 event->owner = NULL;
 366                 pair->done = 0;
 367                 pthread_mutex_unlock( &pair->mutex );
 368                 pthread_mutex_destroy( &pair->mutex );
 369                 pthread_cond_destroy( &pair->cond );
 370         }
 371 }
 372
 373 /** Fetch the events object.
 374 */
 375
 376 static mlt_events mlt_events_fetch( mlt_properties this )
 377 {
 378         mlt_events events = NULL;
 379         if ( this != NULL )
 380                 events = mlt_properties_get_data( this, "_events", NULL );
 381         return events;
 382 }
 383
 384 /** Store the events object.
 385 */
 386
 387 static void mlt_events_store( mlt_properties this, mlt_events events )
 388 {
 389         if ( this != NULL && events != NULL )
 390                 mlt_properties_set_data( this, "_events", events, 0, ( mlt_destructor )mlt_events_close, NULL );
 391 }
 392
 393 /** Close the events object.
 394 */
 395
 396 static void mlt_events_close( mlt_events events )
 397 {
 398         if ( events != NULL )
 399         {
 400                 mlt_properties_close( events->list );
 401                 free( events );
 402         }
 403 }
 404