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     else if (cbdata->type < MEDIA_SOURCE_MAX)
  53         perform_cb_media_source(cbdata);
  54
  55     pthread_mutex_lock(&cbdata->lock);
  56     cbdata->finished = 1;
  57     pthread_cond_broadcast(&cbdata->cond);
  58     pthread_mutex_unlock(&cbdata->lock);
  59 }
  60
  61 static DWORD WINAPI dispatch_thread(void *user)
  62 {
  63     struct cb_data *cbdata;
  64
  65     CoInitializeEx(NULL, COINIT_MULTITHREADED);
  66
  67     pthread_mutex_lock(&cb_list_lock);
  68
  69     while (1)
  70     {
  71         while (list_empty(&cb_list)) pthread_cond_wait(&cb_list_cond, &cb_list_lock);
  72
  73         cbdata = LIST_ENTRY(list_head(&cb_list), struct cb_data, entry);
  74         list_remove(&cbdata->entry);
  75         TrySubmitThreadpoolCallback(&perform_cb, cbdata, NULL);
  76     }
  77
  78     pthread_mutex_unlock(&cb_list_lock);
  79
  80     CoUninitialize();
  81
  82     return 0;
  83 }
  84
  85 void start_dispatch_thread(void)
  86 {
  87     pthread_key_create(&wine_gst_key, NULL);
  88     CloseHandle(CreateThread(NULL, 0, &dispatch_thread, NULL, 0, NULL));
  89 }
  90
  91 /* gstreamer calls our callbacks from threads that Wine did not create. Some
  92  * callbacks execute code which requires Wine to have created the thread
  93  * (critical sections, debug logging, dshow client code). Since gstreamer can't
  94  * provide an API to override its thread creation, we have to intercept all
  95  * callbacks in code which avoids the Wine thread requirement, and then
  96  * dispatch those callbacks on a thread that is known to be created by Wine.
  97  *
  98  * This thread must not run any code that depends on the Wine TEB!
  99  */
 100
 101 static void call_cb(struct cb_data *cbdata)
 102 {
 103     pthread_mutex_init(&cbdata->lock, NULL);
 104     pthread_cond_init(&cbdata->cond, NULL);
 105     cbdata->finished = 0;
 106
 107     if(is_wine_thread()){
 108         /* The thread which triggered gstreamer to call this callback may
 109          * already hold a critical section. If so, executing the callback on a
 110          * worker thread can cause a deadlock. If  we are already on a Wine
 111          * thread, then there is no need to run this callback on a worker
 112          * thread anyway, which avoids the deadlock issue. */
 113         perform_cb(NULL, cbdata);
 114
 115         pthread_cond_destroy(&cbdata->cond);
 116         pthread_mutex_destroy(&cbdata->lock);
 117
 118         return;
 119     }
 120
 121     pthread_mutex_lock(&cb_list_lock);
 122
 123     list_add_tail(&cb_list, &cbdata->entry);
 124     pthread_cond_broadcast(&cb_list_cond);
 125
 126     pthread_mutex_lock(&cbdata->lock);
 127
 128     pthread_mutex_unlock(&cb_list_lock);
 129
 130     while(!cbdata->finished)
 131         pthread_cond_wait(&cbdata->cond, &cbdata->lock);
 132
 133     pthread_mutex_unlock(&cbdata->lock);
 134
 135     pthread_cond_destroy(&cbdata->cond);
 136     pthread_mutex_destroy(&cbdata->lock);
 137 }
 138
 139 GstBusSyncReply watch_bus_wrapper(GstBus *bus, GstMessage *msg, gpointer user)
 140 {
 141     struct cb_data cbdata = { WATCH_BUS };
 142
 143     cbdata.u.watch_bus_data.bus = bus;
 144     cbdata.u.watch_bus_data.msg = msg;
 145     cbdata.u.watch_bus_data.user = user;
 146
 147     call_cb(&cbdata);
 148
 149     return cbdata.u.watch_bus_data.ret;
 150 }
 151
 152 void existing_new_pad_wrapper(GstElement *bin, GstPad *pad, gpointer user)
 153 {
 154     struct cb_data cbdata = { EXISTING_NEW_PAD };
 155
 156     cbdata.u.pad_added_data.element = bin;
 157     cbdata.u.pad_added_data.pad = pad;
 158     cbdata.u.pad_added_data.user = user;
 159
 160     call_cb(&cbdata);
 161 }
 162
 163 gboolean query_function_wrapper(GstPad *pad, GstObject *parent, GstQuery *query)
 164 {
 165     struct cb_data cbdata = { QUERY_FUNCTION };
 166
 167     cbdata.u.query_function_data.pad = pad;
 168     cbdata.u.query_function_data.parent = parent;
 169     cbdata.u.query_function_data.query = query;
 170
 171     call_cb(&cbdata);
 172
 173     return cbdata.u.query_function_data.ret;
 174 }
 175
 176 gboolean activate_mode_wrapper(GstPad *pad, GstObject *parent, GstPadMode mode, gboolean activate)
 177 {
 178     struct cb_data cbdata = { ACTIVATE_MODE };
 179
 180     cbdata.u.activate_mode_data.pad = pad;
 181     cbdata.u.activate_mode_data.parent = parent;
 182     cbdata.u.activate_mode_data.mode = mode;
 183     cbdata.u.activate_mode_data.activate = activate;
 184
 185     call_cb(&cbdata);
 186
 187     return cbdata.u.activate_mode_data.ret;
 188 }
 189
 190 void no_more_pads_wrapper(GstElement *element, gpointer user)
 191 {
 192     struct cb_data cbdata = { NO_MORE_PADS };
 193
 194     cbdata.u.no_more_pads_data.element = element;
 195     cbdata.u.no_more_pads_data.user = user;
 196
 197     call_cb(&cbdata);
 198 }
 199
 200 GstFlowReturn request_buffer_src_wrapper(GstPad *pad, GstObject *parent, guint64 ofs, guint len,
 201         GstBuffer **buf)
 202 {
 203     struct cb_data cbdata = { REQUEST_BUFFER_SRC };
 204
 205     cbdata.u.getrange_data.pad = pad;
 206     cbdata.u.getrange_data.parent = parent;
 207     cbdata.u.getrange_data.ofs = ofs;
 208     cbdata.u.getrange_data.len = len;
 209     cbdata.u.getrange_data.buf = buf;
 210
 211     call_cb(&cbdata);
 212
 213     return cbdata.u.getrange_data.ret;
 214 }
 215
 216 gboolean event_src_wrapper(GstPad *pad, GstObject *parent, GstEvent *event)
 217 {
 218     struct cb_data cbdata = { EVENT_SRC };
 219
 220     cbdata.u.event_src_data.pad = pad;
 221     cbdata.u.event_src_data.parent = parent;
 222     cbdata.u.event_src_data.event = event;
 223
 224     call_cb(&cbdata);
 225
 226     return cbdata.u.event_src_data.ret;
 227 }
 228
 229 gboolean event_sink_wrapper(GstPad *pad, GstObject *parent, GstEvent *event)
 230 {
 231     struct cb_data cbdata = { EVENT_SINK };
 232
 233     cbdata.u.event_sink_data.pad = pad;
 234     cbdata.u.event_sink_data.parent = parent;
 235     cbdata.u.event_sink_data.event = event;
 236
 237     call_cb(&cbdata);
 238
 239     return cbdata.u.event_sink_data.ret;
 240 }
 241
 242 GstFlowReturn got_data_sink_wrapper(GstPad *pad, GstObject *parent, GstBuffer *buf)
 243 {
 244     struct cb_data cbdata = { GOT_DATA_SINK };
 245
 246     cbdata.u.got_data_sink_data.pad = pad;
 247     cbdata.u.got_data_sink_data.parent = parent;
 248     cbdata.u.got_data_sink_data.buf = buf;
 249
 250     call_cb(&cbdata);
 251
 252     return cbdata.u.got_data_sink_data.ret;
 253 }
 254
 255 void removed_decoded_pad_wrapper(GstElement *bin, GstPad *pad, gpointer user)
 256 {
 257     struct cb_data cbdata = { REMOVED_DECODED_PAD };
 258
 259     cbdata.u.pad_removed_data.element = bin;
 260     cbdata.u.pad_removed_data.pad = pad;
 261     cbdata.u.pad_removed_data.user = user;
 262
 263     call_cb(&cbdata);
 264 }
 265
 266 GstAutoplugSelectResult autoplug_blacklist_wrapper(GstElement *bin, GstPad *pad,
 267         GstCaps *caps, GstElementFactory *fact, gpointer user)
 268 {
 269     struct cb_data cbdata = { AUTOPLUG_BLACKLIST };
 270
 271     cbdata.u.autoplug_blacklist_data.bin = bin;
 272     cbdata.u.autoplug_blacklist_data.pad = pad;
 273     cbdata.u.autoplug_blacklist_data.caps = caps;
 274     cbdata.u.autoplug_blacklist_data.fact = fact;
 275     cbdata.u.autoplug_blacklist_data.user = user;
 276
 277     call_cb(&cbdata);
 278
 279     return cbdata.u.autoplug_blacklist_data.ret;
 280 }
 281
 282 void unknown_type_wrapper(GstElement *bin, GstPad *pad, GstCaps *caps, gpointer user)
 283 {
 284     struct cb_data cbdata = { UNKNOWN_TYPE };
 285
 286     cbdata.u.unknown_type_data.bin = bin;
 287     cbdata.u.unknown_type_data.pad = pad;
 288     cbdata.u.unknown_type_data.caps = caps;
 289     cbdata.u.unknown_type_data.user = user;
 290
 291     call_cb(&cbdata);
 292 }
 293
 294 gboolean query_sink_wrapper(GstPad *pad, GstObject *parent, GstQuery *query)
 295 {
 296     struct cb_data cbdata = { QUERY_SINK };
 297
 298     cbdata.u.query_sink_data.pad = pad;
 299     cbdata.u.query_sink_data.parent = parent;
 300     cbdata.u.query_sink_data.query = query;
 301
 302     call_cb(&cbdata);
 303
 304     return cbdata.u.query_sink_data.ret;
 305 }
 306
 307 GstFlowReturn bytestream_wrapper_pull_wrapper(GstPad *pad, GstObject *parent, guint64 ofs, guint len,
 308         GstBuffer **buf)
 309 {
 310     struct cb_data cbdata = { BYTESTREAM_WRAPPER_PULL };
 311
 312     cbdata.u.getrange_data.pad = pad;
 313     cbdata.u.getrange_data.parent = parent;
 314     cbdata.u.getrange_data.ofs = ofs;
 315     cbdata.u.getrange_data.len = len;
 316     cbdata.u.getrange_data.buf = buf;
 317
 318     call_cb(&cbdata);
 319
 320     return cbdata.u.getrange_data.ret;
 321 }
 322
 323 gboolean bytestream_query_wrapper(GstPad *pad, GstObject *parent, GstQuery *query)
 324 {
 325     struct cb_data cbdata = { BYTESTREAM_QUERY };
 326
 327     cbdata.u.query_function_data.pad = pad;
 328     cbdata.u.query_function_data.parent = parent;
 329     cbdata.u.query_function_data.query = query;
 330
 331     call_cb(&cbdata);
 332
 333     return cbdata.u.query_function_data.ret;
 334 }
 335
 336 gboolean bytestream_pad_mode_activate_wrapper(GstPad *pad, GstObject *parent, GstPadMode mode, gboolean activate)
 337 {
 338     struct cb_data cbdata = { BYTESTREAM_PAD_MODE_ACTIVATE };
 339
 340     cbdata.u.activate_mode_data.pad = pad;
 341     cbdata.u.activate_mode_data.parent = parent;
 342     cbdata.u.activate_mode_data.mode = mode;
 343     cbdata.u.activate_mode_data.activate = activate;
 344
 345     call_cb(&cbdata);
 346
 347     return cbdata.u.activate_mode_data.ret;
 348 }
 349
 350 gboolean bytestream_pad_event_process_wrapper(GstPad *pad, GstObject *parent, GstEvent *event)
 351 {
 352     struct cb_data cbdata = { BYTESTREAM_PAD_EVENT_PROCESS };
 353
 354     cbdata.u.event_src_data.pad = pad;
 355     cbdata.u.event_src_data.parent = parent;
 356     cbdata.u.event_src_data.event = event;
 357
 358     call_cb(&cbdata);
 359
 360     return cbdata.u.event_src_data.ret;
 361 }
 362
 363 GstBusSyncReply mf_src_bus_watch_wrapper(GstBus *bus, GstMessage *message, gpointer user)
 364 {
 365     struct cb_data cbdata = { MF_SRC_BUS_WATCH };
 366
 367     cbdata.u.watch_bus_data.bus = bus;
 368     cbdata.u.watch_bus_data.msg = message;
 369     cbdata.u.watch_bus_data.user = user;
 370
 371     call_cb(&cbdata);
 372
 373     return cbdata.u.watch_bus_data.ret;
 374 }
 375
 376 void mf_src_stream_added_wrapper(GstElement *bin, GstPad *pad, gpointer user)
 377 {
 378     struct cb_data cbdata = { MF_SRC_STREAM_ADDED };
 379
 380     cbdata.u.pad_added_data.element = bin;
 381     cbdata.u.pad_added_data.pad = pad;
 382     cbdata.u.pad_added_data.user = user;
 383
 384     call_cb(&cbdata);
 385 }
 386
 387 void mf_src_stream_removed_wrapper(GstElement *element, GstPad *pad, gpointer user)
 388 {
 389     struct cb_data cbdata = { MF_SRC_STREAM_REMOVED };
 390
 391     cbdata.u.pad_removed_data.element = element;
 392     cbdata.u.pad_removed_data.pad = pad;
 393     cbdata.u.pad_removed_data.user = user;
 394
 395     call_cb(&cbdata);
 396 }
 397
 398 void mf_src_no_more_pads_wrapper(GstElement *element, gpointer user)
 399 {
 400     struct cb_data cbdata = { MF_SRC_NO_MORE_PADS };
 401
 402     cbdata.u.no_more_pads_data.element = element;
 403     cbdata.u.no_more_pads_data.user = user;
 404
 405     call_cb(&cbdata);
 406 }