git.sesse.net Git - vlc/blob - src/control/event_async.c

   1 /*****************************************************************************
   2  * event.c: New libvlc event control API
   3  *****************************************************************************
   4  * Copyright (C) 2007 the VideoLAN team
   5  * $Id $
   6  *
   7  * Authors: Filippo Carone <filippo@carone.org>
   8  *          Pierre d'Herbemont <pdherbemont # videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #include <assert.h>
  26
  27 #include <vlc/libvlc.h>
  28
  29 #include "libvlc_internal.h"
  30 #include "event_internal.h"
  31
  32 struct queue_elmt {
  33     libvlc_event_listener_t listener;
  34     libvlc_event_t event;
  35     struct queue_elmt * next;
  36 };
  37
  38 struct libvlc_event_async_queue {
  39     struct queue_elmt * elements;
  40     vlc_mutex_t lock;
  41     vlc_cond_t signal;
  42     vlc_thread_t thread;
  43     bool is_idle;
  44     vlc_cond_t signal_idle;
  45     vlc_threadvar_t is_asynch_dispatch_thread_var;
  46 };
  47
  48 /*
  49  * Utilities
  50  */
  51
  52 static void*  event_async_loop(void * arg);
  53
  54 static inline struct libvlc_event_async_queue * queue(libvlc_event_manager_t * p_em)
  55 {
  56     return p_em->async_event_queue;
  57 }
  58
  59 static inline bool is_queue_initialized(libvlc_event_manager_t * p_em)
  60 {
  61     return queue(p_em) != NULL;
  62 }
  63
  64 static inline bool current_thread_is_asynch_thread(libvlc_event_manager_t * p_em)
  65 {
  66     return vlc_threadvar_get(queue(p_em)->is_asynch_dispatch_thread_var);
  67 }
  68
  69 /* Lock must be held */
  70 static void push(libvlc_event_manager_t * p_em, libvlc_event_listener_t * listener, libvlc_event_t * event)
  71 {
  72 #ifndef NDEBUG
  73     static const long MaxQueuedItem = 300000;
  74     long count = 0;
  75 #endif
  76
  77     struct queue_elmt * elmt = malloc(sizeof(struct queue_elmt));
  78     elmt->listener = *listener;
  79     elmt->event = *event;
  80     elmt->next = NULL;
  81
  82     /* Append to the end of the queue */
  83     struct queue_elmt * iter = queue(p_em)->elements;
  84     if(!iter)
  85     {
  86         queue(p_em)->elements = elmt;
  87         return;
  88     }
  89
  90     while (iter->next) {
  91         iter = iter->next;
  92 #ifndef NDEBUG
  93         if(count++ > MaxQueuedItem)
  94         {
  95             fprintf(stderr, "Warning: libvlc event overflow.\n");
  96             abort();
  97         }
  98 #endif
  99     }
 100     iter->next = elmt;
 101 }
 102
 103 static inline void queue_lock(libvlc_event_manager_t * p_em)
 104 {
 105     vlc_mutex_lock(&queue(p_em)->lock);
 106 }
 107
 108 static inline void queue_unlock(libvlc_event_manager_t * p_em)
 109 {
 110     vlc_mutex_unlock(&queue(p_em)->lock);
 111 }
 112
 113 /* Lock must be held */
 114 static bool pop(libvlc_event_manager_t * p_em, libvlc_event_listener_t * listener, libvlc_event_t * event)
 115 {
 116     if(!queue(p_em)->elements)
 117         return false; /* No elements */
 118
 119     *listener = queue(p_em)->elements->listener;
 120     *event = queue(p_em)->elements->event;
 121
 122     struct queue_elmt * elmt = queue(p_em)->elements;
 123     queue(p_em)->elements = elmt->next;
 124     free(elmt);
 125     return true;
 126 }
 127
 128 /* Lock must be held */
 129 static void pop_listener(libvlc_event_manager_t * p_em, libvlc_event_listener_t * listener)
 130 {
 131     struct queue_elmt * iter = queue(p_em)->elements;
 132     struct queue_elmt * prev = NULL;
 133     while (iter) {
 134         if(listeners_are_equal(&iter->listener, listener))
 135         {
 136             struct queue_elmt * to_delete = iter;
 137             if(!prev)
 138                 queue(p_em)->elements = to_delete->next;
 139             else
 140                 prev->next = to_delete->next;
 141             iter = to_delete->next;
 142             free(to_delete);
 143         }
 144         else {
 145             prev = iter;
 146             iter = iter->next;
 147         }
 148     }
 149 }
 150
 151 /**************************************************************************
 152  *       libvlc_event_async_fini (internal) :
 153  *
 154  * Destroy what might have been created by.
 155  **************************************************************************/
 156 void
 157 libvlc_event_async_fini(libvlc_event_manager_t * p_em)
 158 {
 159     if(!is_queue_initialized(p_em)) return;
 160
 161     if(current_thread_is_asynch_thread(p_em))
 162     {
 163         fprintf(stderr, "*** Error: releasing the last reference of the observed object from its callback thread is not (yet!) supported\n");
 164         abort();
 165     }
 166
 167     vlc_thread_t thread = queue(p_em)->thread;
 168     if(thread)
 169     {
 170         vlc_cancel(thread);
 171         vlc_join(thread, NULL);
 172     }
 173
 174     vlc_mutex_destroy(&queue(p_em)->lock);
 175     vlc_cond_destroy(&queue(p_em)->signal);
 176     vlc_cond_destroy(&queue(p_em)->signal_idle);
 177     vlc_threadvar_delete(&queue(p_em)->is_asynch_dispatch_thread_var);
 178
 179     struct queue_elmt * iter = queue(p_em)->elements;
 180     while (iter) {
 181         struct queue_elmt * elemt_to_delete = iter;
 182         iter = iter->next;
 183         free(elemt_to_delete);
 184     }
 185
 186     free(queue(p_em));
 187 }
 188
 189 /**************************************************************************
 190  *       libvlc_event_async_init (private) :
 191  *
 192  * Destroy what might have been created by.
 193  **************************************************************************/
 194 static void
 195 libvlc_event_async_init(libvlc_event_manager_t * p_em)
 196 {
 197     p_em->async_event_queue = calloc(1, sizeof(struct libvlc_event_async_queue));
 198
 199     int error = vlc_clone (&queue(p_em)->thread, event_async_loop, p_em, VLC_THREAD_PRIORITY_LOW);
 200     if(error)
 201     {
 202         free(p_em->async_event_queue);
 203         p_em->async_event_queue = NULL;
 204         return;
 205     }
 206
 207     vlc_mutex_init(&queue(p_em)->lock);
 208     vlc_cond_init(&queue(p_em)->signal);
 209     vlc_cond_init(&queue(p_em)->signal_idle);
 210     error = vlc_threadvar_create(&queue(p_em)->is_asynch_dispatch_thread_var, NULL);
 211     assert(!error);
 212 }
 213
 214 /**************************************************************************
 215  *       libvlc_event_async_ensure_listener_removal (internal) :
 216  *
 217  * Make sure no more message will be issued to the listener.
 218  **************************************************************************/
 219 void
 220 libvlc_event_async_ensure_listener_removal(libvlc_event_manager_t * p_em, libvlc_event_listener_t * listener)
 221 {
 222     if(!is_queue_initialized(p_em)) return;
 223
 224     queue_lock(p_em);
 225     pop_listener(p_em, listener);
 226
 227     // Wait for the asynch_loop to have processed all events.
 228     if(!current_thread_is_asynch_thread(p_em))
 229     {
 230         while(!queue(p_em)->is_idle)
 231             vlc_cond_wait(&queue(p_em)->signal_idle, &queue(p_em)->lock);
 232     }
 233     queue_unlock(p_em);
 234 }
 235
 236 /**************************************************************************
 237  *       libvlc_event_async_dispatch (internal) :
 238  *
 239  * Send an event in an asynchronous way.
 240  **************************************************************************/
 241 void
 242 libvlc_event_async_dispatch(libvlc_event_manager_t * p_em, libvlc_event_listener_t * listener, libvlc_event_t * event)
 243 {
 244     // We do a lazy init here, to prevent constructing the thread when not needed.
 245     vlc_mutex_lock(&p_em->object_lock);
 246     if(!queue(p_em))
 247         libvlc_event_async_init(p_em);
 248     vlc_mutex_unlock(&p_em->object_lock);
 249
 250     queue_lock(p_em);
 251     push(p_em, listener, event);
 252     vlc_cond_signal(&queue(p_em)->signal);
 253     queue_unlock(p_em);
 254 }
 255
 256 /**************************************************************************
 257  *       event_async_loop (private) :
 258  *
 259  * Send queued events.
 260  **************************************************************************/
 261 static void * event_async_loop(void * arg)
 262 {
 263     libvlc_event_manager_t * p_em = arg;
 264     libvlc_event_listener_t listener;
 265     libvlc_event_t event;
 266
 267     vlc_threadvar_set(queue(p_em)->is_asynch_dispatch_thread_var, (void*)true);
 268
 269     queue_lock(p_em);
 270     while (true) {
 271         int has_listener = pop(p_em, &listener, &event);
 272
 273         if (has_listener)
 274         {
 275             queue_unlock(p_em);
 276             listener.pf_callback(&event, listener.p_user_data); // This might edit the queue
 277             queue_lock(p_em);
 278         }
 279         else
 280         {
 281             queue(p_em)->is_idle = true;
 282
 283             mutex_cleanup_push(&queue(p_em)->lock);
 284             vlc_cond_broadcast(&queue(p_em)->signal_idle); // We'll be idle
 285             vlc_cond_wait(&queue(p_em)->signal, &queue(p_em)->lock);
 286             vlc_cleanup_pop();
 287
 288             queue(p_em)->is_idle = false;
 289         }
 290     }
 291     queue_unlock(p_em);
 292     return NULL;
 293 }