dlls/winegstreamer/gst_cbs.c

   1 /*
   2  * Copyright 2015 Andrew Eikum for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <gst/gst.h>
  22
  23 #include "objbase.h"
  24
  25 #include "wine/list.h"
  26
  27 #include "gst_cbs.h"
  28
  29 static pthread_key_t wine_gst_key;
  30
  31 void mark_wine_thread(void)
  32 {
  33     /* set it to non-NULL to indicate that this is a Wine thread */
  34     pthread_setspecific(wine_gst_key, &wine_gst_key);
  35 }
  36
  37 static BOOL is_wine_thread(void)
  38 {
  39     return pthread_getspecific(wine_gst_key) != NULL;
  40 }
  41
  42 static pthread_mutex_t cb_list_lock = PTHREAD_MUTEX_INITIALIZER;
  43 static pthread_cond_t cb_list_cond = PTHREAD_COND_INITIALIZER;
  44 static struct list cb_list = LIST_INIT(cb_list);
  45
  46 static void CALLBACK perform_cb(TP_CALLBACK_INSTANCE *instance, void *user)
  47 {
  48     struct cb_data *cbdata = user;
  49
  50     if (cbdata->type < GSTDEMUX_MAX)
  51         perform_cb_gstdemux(cbdata);
  52
  53     pthread_mutex_lock(&cbdata->lock);
  54     cbdata->finished = 1;
  55     pthread_cond_broadcast(&cbdata->cond);
  56     pthread_mutex_unlock(&cbdata->lock);
  57 }
  58
  59 static DWORD WINAPI dispatch_thread(void *user)
  60 {
  61     struct cb_data *cbdata;
  62
  63     CoInitializeEx(NULL, COINIT_MULTITHREADED);
  64
  65     pthread_mutex_lock(&cb_list_lock);
  66
  67     while (1)
  68     {
  69         while (list_empty(&cb_list)) pthread_cond_wait(&cb_list_cond, &cb_list_lock);
  70
  71         cbdata = LIST_ENTRY(list_head(&cb_list), struct cb_data, entry);
  72         list_remove(&cbdata->entry);
  73         TrySubmitThreadpoolCallback(&perform_cb, cbdata, NULL);
  74     }
  75
  76     pthread_mutex_unlock(&cb_list_lock);
  77
  78     CoUninitialize();
  79
  80     return 0;
  81 }
  82
  83 void start_dispatch_thread(void)
  84 {
  85     pthread_key_create(&wine_gst_key, NULL);
  86     CloseHandle(CreateThread(NULL, 0, &dispatch_thread, NULL, 0, NULL));
  87 }
  88
  89 /* gstreamer calls our callbacks from threads that Wine did not create. Some
  90  * callbacks execute code which requires Wine to have created the thread
  91  * (critical sections, debug logging, dshow client code). Since gstreamer can't
  92  * provide an API to override its thread creation, we have to intercept all
  93  * callbacks in code which avoids the Wine thread requirement, and then
  94  * dispatch those callbacks on a thread that is known to be created by Wine.
  95  *
  96  * This thread must not run any code that depends on the Wine TEB!
  97  */
  98
  99 static void call_cb(struct cb_data *cbdata)
 100 {
 101     pthread_mutex_init(&cbdata->lock, NULL);
 102     pthread_cond_init(&cbdata->cond, NULL);
 103     cbdata->finished = 0;
 104
 105     if(is_wine_thread()){
 106         /* The thread which triggered gstreamer to call this callback may
 107          * already hold a critical section. If so, executing the callback on a
 108          * worker thread can cause a deadlock. If  we are already on a Wine
 109          * thread, then there is no need to run this callback on a worker
 110          * thread anyway, which avoids the deadlock issue. */
 111         perform_cb(NULL, cbdata);
 112
 113         pthread_cond_destroy(&cbdata->cond);
 114         pthread_mutex_destroy(&cbdata->lock);
 115
 116         return;
 117     }
 118
 119     pthread_mutex_lock(&cb_list_lock);
 120
 121     list_add_tail(&cb_list, &cbdata->entry);
 122     pthread_cond_broadcast(&cb_list_cond);
 123
 124     pthread_mutex_lock(&cbdata->lock);
 125
 126     pthread_mutex_unlock(&cb_list_lock);
 127
 128     while(!cbdata->finished)
 129         pthread_cond_wait(&cbdata->cond, &cbdata->lock);
 130
 131     pthread_mutex_unlock(&cbdata->lock);
 132
 133     pthread_cond_destroy(&cbdata->cond);
 134     pthread_mutex_destroy(&cbdata->lock);
 135 }
 136
 137 GstBusSyncReply watch_bus_wrapper(GstBus *bus, GstMessage *msg, gpointer user)
 138 {
 139     struct cb_data cbdata = { WATCH_BUS };
 140
 141     cbdata.u.watch_bus_data.bus = bus;
 142     cbdata.u.watch_bus_data.msg = msg;
 143     cbdata.u.watch_bus_data.user = user;
 144
 145     call_cb(&cbdata);
 146
 147     return cbdata.u.watch_bus_data.ret;
 148 }
 149
 150 void existing_new_pad_wrapper(GstElement *bin, GstPad *pad, gpointer user)
 151 {
 152     struct cb_data cbdata = { EXISTING_NEW_PAD };
 153
 154     cbdata.u.pad_added_data.element = bin;
 155     cbdata.u.pad_added_data.pad = pad;
 156     cbdata.u.pad_added_data.user = user;
 157
 158     call_cb(&cbdata);
 159 }
 160
 161 gboolean query_function_wrapper(GstPad *pad, GstObject *parent, GstQuery *query)
 162 {
 163     struct cb_data cbdata = { QUERY_FUNCTION };
 164
 165     cbdata.u.query_function_data.pad = pad;
 166     cbdata.u.query_function_data.parent = parent;
 167     cbdata.u.query_function_data.query = query;
 168
 169     call_cb(&cbdata);
 170
 171     return cbdata.u.query_function_data.ret;
 172 }
 173
 174 gboolean activate_mode_wrapper(GstPad *pad, GstObject *parent, GstPadMode mode, gboolean activate)
 175 {
 176     struct cb_data cbdata = { ACTIVATE_MODE };
 177
 178     cbdata.u.activate_mode_data.pad = pad;
 179     cbdata.u.activate_mode_data.parent = parent;
 180     cbdata.u.activate_mode_data.mode = mode;
 181     cbdata.u.activate_mode_data.activate = activate;
 182
 183     call_cb(&cbdata);
 184
 185     return cbdata.u.activate_mode_data.ret;
 186 }
 187
 188 void no_more_pads_wrapper(GstElement *element, gpointer user)
 189 {
 190     struct cb_data cbdata = { NO_MORE_PADS };
 191
 192     cbdata.u.no_more_pads_data.element = element;
 193     cbdata.u.no_more_pads_data.user = user;
 194
 195     call_cb(&cbdata);
 196 }
 197
 198 GstFlowReturn request_buffer_src_wrapper(GstPad *pad, GstObject *parent, guint64 ofs, guint len,
 199         GstBuffer **buf)
 200 {
 201     struct cb_data cbdata = { REQUEST_BUFFER_SRC };
 202
 203     cbdata.u.getrange_data.pad = pad;
 204     cbdata.u.getrange_data.parent = parent;
 205     cbdata.u.getrange_data.ofs = ofs;
 206     cbdata.u.getrange_data.len = len;
 207     cbdata.u.getrange_data.buf = buf;
 208
 209     call_cb(&cbdata);
 210
 211     return cbdata.u.getrange_data.ret;
 212 }
 213
 214 gboolean event_src_wrapper(GstPad *pad, GstObject *parent, GstEvent *event)
 215 {
 216     struct cb_data cbdata = { EVENT_SRC };
 217
 218     cbdata.u.event_src_data.pad = pad;
 219     cbdata.u.event_src_data.parent = parent;
 220     cbdata.u.event_src_data.event = event;
 221
 222     call_cb(&cbdata);
 223
 224     return cbdata.u.event_src_data.ret;
 225 }
 226
 227 gboolean event_sink_wrapper(GstPad *pad, GstObject *parent, GstEvent *event)
 228 {
 229     struct cb_data cbdata = { EVENT_SINK };
 230
 231     cbdata.u.event_sink_data.pad = pad;
 232     cbdata.u.event_sink_data.parent = parent;
 233     cbdata.u.event_sink_data.event = event;
 234
 235     call_cb(&cbdata);
 236
 237     return cbdata.u.event_sink_data.ret;
 238 }
 239
 240 GstFlowReturn got_data_sink_wrapper(GstPad *pad, GstObject *parent, GstBuffer *buf)
 241 {
 242     struct cb_data cbdata = { GOT_DATA_SINK };
 243
 244     cbdata.u.got_data_sink_data.pad = pad;
 245     cbdata.u.got_data_sink_data.parent = parent;
 246     cbdata.u.got_data_sink_data.buf = buf;
 247
 248     call_cb(&cbdata);
 249
 250     return cbdata.u.got_data_sink_data.ret;
 251 }
 252
 253 void removed_decoded_pad_wrapper(GstElement *bin, GstPad *pad, gpointer user)
 254 {
 255     struct cb_data cbdata = { REMOVED_DECODED_PAD };
 256
 257     cbdata.u.pad_removed_data.element = bin;
 258     cbdata.u.pad_removed_data.pad = pad;
 259     cbdata.u.pad_removed_data.user = user;
 260
 261     call_cb(&cbdata);
 262 }
 263
 264 GstAutoplugSelectResult autoplug_blacklist_wrapper(GstElement *bin, GstPad *pad,
 265         GstCaps *caps, GstElementFactory *fact, gpointer user)
 266 {
 267     struct cb_data cbdata = { AUTOPLUG_BLACKLIST };
 268
 269     cbdata.u.autoplug_blacklist_data.bin = bin;
 270     cbdata.u.autoplug_blacklist_data.pad = pad;
 271     cbdata.u.autoplug_blacklist_data.caps = caps;
 272     cbdata.u.autoplug_blacklist_data.fact = fact;
 273     cbdata.u.autoplug_blacklist_data.user = user;
 274
 275     call_cb(&cbdata);
 276
 277     return cbdata.u.autoplug_blacklist_data.ret;
 278 }
 279
 280 void unknown_type_wrapper(GstElement *bin, GstPad *pad, GstCaps *caps, gpointer user)
 281 {
 282     struct cb_data cbdata = { UNKNOWN_TYPE };
 283
 284     cbdata.u.unknown_type_data.bin = bin;
 285     cbdata.u.unknown_type_data.pad = pad;
 286     cbdata.u.unknown_type_data.caps = caps;
 287     cbdata.u.unknown_type_data.user = user;
 288
 289     call_cb(&cbdata);
 290 }
 291
 292 gboolean query_sink_wrapper(GstPad *pad, GstObject *parent, GstQuery *query)
 293 {
 294     struct cb_data cbdata = { QUERY_SINK };
 295
 296     cbdata.u.query_sink_data.pad = pad;
 297     cbdata.u.query_sink_data.parent = parent;
 298     cbdata.u.query_sink_data.query = query;
 299
 300     call_cb(&cbdata);
 301
 302     return cbdata.u.query_sink_data.ret;
 303 }