src/event.c

   1 /* gAlan - Graphical Audio Language
   2  * Copyright (C) 1999 Tony Garnock-Jones
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <stdio.h>
  22
  23 #include "global.h"
  24 #include "generator.h"
  25
  26 typedef struct event_callback {
  27   Generator *g;
  28   AEvent_handler_t fn;
  29 } event_callback;
  30
  31 typedef struct EventQ EventQ;
  32
  33 struct EventQ {
  34   EventQ *next;
  35   AEvent e;
  36 };
  37
  38 PRIVATE EventQ *event_q = NULL; /* list of AEvents */
  39 PRIVATE GList *rtfuncs = NULL;  /* list of event_callbacks */
  40
  41 PRIVATE GAsyncQueue *event_queue;
  42 PRIVATE GAsyncQueue *addrt_queue;
  43
  44 PUBLIC SAMPLETIME gen_current_sampletime = 0;   /* current time */
  45
  46
  47 PRIVATE void aevent_copy( AEvent *src, AEvent *dst ) {
  48
  49     if( dst && src ) {
  50
  51         *dst = *src;
  52         switch( src->kind ) {
  53             case AE_STRING:
  54                 dst->d.string = safe_string_dup( src->d.string );
  55                 break;
  56             case AE_NUMARRAY:
  57                 dst->d.array.numbers = safe_malloc( sizeof(SAMPLE) * dst->d.array.len );
  58                 memcpy( dst->d.array.numbers, src->d.array.numbers, src->d.array.len * sizeof(SAMPLE) );
  59                 break;
  60             case AE_DBLARRAY:
  61                 dst->d.darray.numbers = safe_malloc( sizeof(gdouble) * dst->d.darray.len );
  62                 memcpy( dst->d.darray.numbers, src->d.darray.numbers, src->d.darray.len * sizeof(gdouble) );
  63                 break;
  64             default:
  65                 break;
  66         }
  67     }
  68
  69 }
  70
  71 PRIVATE void eventq_free( EventQ *evq ) {
  72
  73     if( evq ) {
  74         switch( evq->e.kind ) {
  75             case AE_STRING:
  76                 if( evq->e.d.string != NULL )
  77                     safe_free( evq->e.d.string );
  78                 break;
  79             case AE_NUMARRAY:
  80                 if( evq->e.d.array.numbers != NULL )
  81                     safe_free( evq->e.d.array.numbers );
  82                 break;
  83             case AE_DBLARRAY:
  84                 if( evq->e.d.darray.numbers != NULL )
  85                     safe_free( evq->e.d.darray.numbers );
  86                 break;
  87             default:
  88                 break;
  89         }
  90         g_slice_free1( sizeof(EventQ), evq );
  91     }
  92 }
  93
  94 /**
  95  * \brief Put an AEvent into the main event queue.
  96  *
  97  * \param e The Event which shall be copied into the EventQueue
  98  *
  99  * this would use an async queue to make this operation thread safe.
 100  * the main event processor will pop all events from the queue and
 101  * sort them into the main list.
 102  *
 103  * with this function threadsafe control_emit() gets threadsafe as well.
 104  *
 105  * i believe this is the problem XXX XXX
 106  */
 107
 108 PUBLIC void gen_post_aevent(AEvent *e) {
 109   EventQ *q = g_slice_alloc(sizeof(EventQ));
 110
 111   aevent_copy( e, &(q->e) );
 112
 113   g_async_queue_push( event_queue, q );
 114 }
 115
 116 /**
 117  * \brief sort in all posted aevents
 118  *
 119  * XXX: ok... this has to be modified, to support for
 120  *      local event queues on the generators...
 121  *
 122  *      if( g->has_local_queue )
 123  *         deliver_directly( e );
 124  *      else
 125  *         deliver normally( e );
 126  *
 127  *      this seems thread safe... lets see if that
 128  *      brings us some advantage...
 129  */
 130
 131 PRIVATE void gen_sortin_aevents(void) {
 132   EventQ *q;
 133
 134   while( (q=g_async_queue_try_pop( event_queue )) != NULL )
 135   {
 136       EventQ *prev = NULL, *curr = event_q;
 137
 138       while (curr != NULL) {
 139           if (q->e.time < curr->e.time)
 140               break;
 141
 142           prev = curr;
 143           curr = curr->next;
 144       }
 145
 146       q->next = curr;
 147
 148       if (prev == NULL)
 149           event_q = q;
 150       else
 151           prev->next = q;
 152   }
 153 }
 154 /**
 155  * \brief Remove all events for Generator \a g from the global queue
 156  *
 157  * \param g The Generator
 158  *
 159  * To make this function threadsafe i need to add a command queue.
 160  * The mainloop will execute all commands in the queue when its time.
 161  *
 162  * the event insertion queue should be the same as the command queue.
 163  * i also need commands for inserting and removing Eventlinks.
 164  *
 165  * also a command for removing generators is needed because
 166  * i dont know when the Removal of an EventLink occurs.
 167  *
 168  * At the Moment this function may only be called from the audiothread.
 169  * This is ok for all current plugins.
 170  *
 171  */
 172
 173 PUBLIC void gen_purge_event_queue_refs(Generator *g) {
 174   EventQ *prev = NULL, *curr = event_q;
 175
 176   while (curr != NULL) {
 177     EventQ *next = curr->next;
 178
 179     if (curr->e.src == g || curr->e.dst == g) {
 180       if (prev == NULL)
 181         event_q = next;
 182       else
 183         prev->next = next;
 184
 185       //free(curr);
 186       eventq_free( curr );
 187       curr = next;
 188       continue;
 189     }
 190
 191     prev = curr;
 192     curr = next;
 193   }
 194 }
 195
 196 PUBLIC void gen_purge_inputevent_queue_refs(Generator *g) {
 197   EventQ *prev = NULL, *curr = event_q;
 198
 199   while (curr != NULL) {
 200     EventQ *next = curr->next;
 201
 202     if (curr->e.dst == g) {
 203       if (prev == NULL)
 204         event_q = next;
 205       else
 206         prev->next = next;
 207
 208       //free(curr);
 209       eventq_free( curr );
 210       curr = next;
 211       continue;
 212     }
 213
 214     prev = curr;
 215     curr = next;
 216   }
 217 }
 218
 219 /**
 220  * \brief insert a function into \a list
 221  *
 222  * \param list pointer to a GList *
 223  * \param g The Generator which will be a paramter of \a func
 224  *
 225  * If this was threadsafe gen_register_realtime_fn() would be threadsafe
 226  * also.
 227  *
 228  * i need a Mutex for the rtfuncs struct.
 229  */
 230
 231 //PRIVATE void insert_fn(GList **lst, Generator *g, AEvent_handler_t func) {
 232 //  event_callback *ec = safe_malloc(sizeof(event_callback));
 233 //
 234 //  ec->g = g;
 235 //  ec->fn = func;
 236 //
 237 //  *lst = g_list_prepend(*lst, ec);
 238 //}
 239
 240 /**
 241  * \brief insert an event_callback into \a list
 242  *
 243  * \param list pointer to a GList *
 244  * \param ec pointer to the eventcallback.
 245  *
 246  * If this was threadsafe gen_register_realtime_fn() would be threadsafe
 247  * also.
 248  *
 249  * i need a Mutex for the rtfuncs struct.
 250  *
 251  * no ... make it a GSList.
 252  */
 253
 254 PRIVATE void insert_fn_ec(GList **lst, event_callback *ec) {
 255
 256   *lst = g_list_prepend(*lst, ec);
 257 }
 258 PRIVATE gint event_callback_cmp(event_callback *a, event_callback *b) {
 259   return !(a->g == b->g);
 260 }
 261
 262 PRIVATE void remove_all_fns(GList **lst, Generator *g) {
 263   event_callback ec;
 264   GList *link;
 265
 266   ec.g = g;
 267   link = g_list_find_custom(*lst, &ec, (GCompareFunc) event_callback_cmp);
 268
 269   if (link != NULL) {
 270     free(link->data);
 271     link->data = NULL;
 272     *lst = g_list_remove_link(*lst, link);
 273   }
 274 }
 275
 276 /**
 277  * \brief Register a realtime function
 278  *
 279  * \param g The Genrator wishing to receive Realtime Events
 280  * \param func The function which should be called on receive of a Realtime Event
 281  *
 282  * The Realtime functions are the entry points into the graph.
 283  *
 284  * this function is sometimes (scope, outputs) called by the init_instance()
 285  * of a Generator to have it realtime_handler installed.
 286  *
 287  * This function must be threadsafe.
 288  * an async queue is a good way to accomplish this.
 289  *
 290  * The deregister_realtime_fn function is changed to a noop.
 291  * it gets removed during generator destruction.
 292  *
 293  */
 294
 295 PUBLIC void gen_register_realtime_fn(Generator *g, AEvent_handler_t func) {
 296     event_callback *ec = safe_malloc( sizeof(event_callback) );
 297     ec->g = g;
 298     ec->fn = func;
 299
 300     g_async_queue_push( addrt_queue, ec );
 301 }
 302
 303 /**
 304  * \brief deregister a realtime function
 305  *
 306  * \param g The Generator
 307  * \param func The callback that should be removed
 308  *
 309  * i will make this a no-op.
 310  * its only called in destructors and
 311  * i will remove all functions for a generator in the RT stage of removal.
 312  */
 313
 314 PUBLIC void gen_deregister_realtime_fn(Generator *g, AEvent_handler_t func) {
 315   //remove_fn(&rtfuncs, g, func);
 316 }
 317
 318 PUBLIC void gen_purge_realtime_fns( Generator *g )
 319 {
 320     remove_all_fns( &rtfuncs, g );
 321 }
 322
 323 PRIVATE void sortin_rtevents(void) {
 324   event_callback *ec;
 325
 326   while( (ec=g_async_queue_try_pop( addrt_queue )) != NULL )
 327       insert_fn_ec( &rtfuncs, ec );
 328 }
 329
 330 PRIVATE void send_rt_event(event_callback *ec, AEvent *rtevent) {
 331     // why a local copy ? because the generator can modify an event passed.
 332     // warning this only works for REALTIME events.
 333     AEvent local_copy = *rtevent;
 334     ec->fn(ec->g, &local_copy);
 335 }
 336
 337 /**
 338  * \brief Call all Realtime functions which have registered themselves
 339  *        with gen_register_realtime_fn()
 340  *
 341  * \param e an AEvent of type AE_REALTIME
 342  *
 343  * this is called when the eventprocessing is done
 344  * and the data must be computed.
 345  *
 346  * needs to insert realtime functions from the queue
 347  * deletion of functions will be done from the audio thread so
 348  * it does not need to be safe.
 349  */
 350
 351 PUBLIC void gen_send_realtime_fns(AEvent *e) {
 352     sortin_rtevents();
 353
 354     g_list_foreach(rtfuncs, (GFunc) send_rt_event, e);
 355 }
 356
 357 /**
 358  * \brief process AEvents pending
 359  *
 360  * \return time until next event has to be processed
 361  *         (At Maximum MAXIMUM_REALTIME_STEP)
 362  *
 363  * This Functions inserts all new aevents and then processes all
 364  * pending events from the queue.
 365  * it also calls do_checks to make the changes to the connection graph.
 366  */
 367
 368 PUBLIC gint gen_mainloop_once(void) {
 369   int loopcheck_counter=0;
 370
 371   gen_sortin_aevents();
 372   gen_mainloop_do_checks();
 373
 374   while (1) {
 375     EventQ *e = event_q;
 376
 377     if (e == NULL || e->e.time > gen_get_sampletime()) {
 378       SAMPLETIME delta = (e == NULL) ? MAXIMUM_REALTIME_STEP : e->e.time - gen_get_sampletime();
 379       delta = MIN(delta, MAXIMUM_REALTIME_STEP);
 380
 381       /* Notice that the clock is *not* advanced here. That's up to the master-clock
 382          routine - it should call gen_advance_clock() with the result of this routine. */
 383       return delta;
 384     }
 385
 386     event_q = e->next;
 387     e->e.dst->klass->in_handlers[e->e.dst_q](e->e.dst, &e->e);
 388     //free(e);
 389     eventq_free( e );
 390     gen_sortin_aevents();
 391     loopcheck_counter += 1;
 392     if( loopcheck_counter > 1000 ) {
 393             // We processed 1000 events now.
 394             // this seems to be an event loop.
 395             // let break out and, let events processing
 396             // lag behind.
 397             return MAXIMUM_REALTIME_STEP;
 398     }
 399   }
 400 }
 401
 402 PUBLIC void gen_advance_clock(gint delta) {
 403   gen_current_sampletime += delta;
 404 }
 405
 406 PUBLIC void init_event( void ) {
 407     if (!g_thread_supported ()) g_thread_init (NULL);
 408     event_queue = g_async_queue_new();
 409     addrt_queue = g_async_queue_new();
 410 }