mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-27 04:01:08 +00:00
2143a02a13
Original commit message from CVS: Revert again, this time without post-commit reindent hooks to put back the indentation :-)
223 lines
7.2 KiB
C
223 lines
7.2 KiB
C
/* GStreamer
|
|
* Copyright (C) 2003 Benjamin Otte <in7y118@public.uni-hamburg.de>
|
|
*
|
|
* gthread-cothreads.c: cothreads implemented via GThread for compatibility
|
|
* They're probably slooooooow
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <glib.h>
|
|
#include <gst/gstthread.h>
|
|
|
|
/* the name of this cothreads */
|
|
#define COTHREADS_NAME "gthread"
|
|
#define COTHREADS_NAME_CAPITAL "GThread"
|
|
|
|
/*
|
|
* Theory of operation:
|
|
* Instead of using cothreads, GThreads and 1 mutex are used.
|
|
* Every thread may only run if it holds the mutex. Otherwise it holds its own
|
|
* cond which has to be signaled to wakeit up.
|
|
*/
|
|
|
|
/* define "cothread", "cothread_context" and "cothread_func" */
|
|
typedef int (*cothread_func) (int, char **);
|
|
|
|
typedef struct _cothread cothread;
|
|
typedef struct _cothread_context cothread_context;
|
|
|
|
struct _cothread_context {
|
|
GSList * cothreads; /* contains all threads but main */
|
|
cothread * main;
|
|
cothread * current;
|
|
GMutex * mutex;
|
|
GstThread * gst_thread; /* the GstThread we're running from */
|
|
};
|
|
|
|
struct _cothread {
|
|
GThread * thread;
|
|
GCond * cond;
|
|
cothread_func run;
|
|
int argc;
|
|
char ** argv;
|
|
cothread * creator;
|
|
gboolean die;
|
|
cothread_context * context;
|
|
};
|
|
|
|
/* define functions
|
|
* Functions starting with "do_" are used by the scheduler.
|
|
*/
|
|
static void do_cothreads_init (void *unused);
|
|
static cothread_context *do_cothread_context_init (void);
|
|
static void do_cothread_context_destroy (cothread_context *context);
|
|
static cothread * cothread_create (cothread_context *context,
|
|
cothread_func func,
|
|
int argc,
|
|
char **argv);
|
|
#define do_cothread_create(new_cothread, context, func, argc, argv) \
|
|
G_STMT_START{ \
|
|
new_cothread = cothread_create ((context), (func), argc, (char**) (argv)); \
|
|
}G_STMT_END
|
|
static void do_cothread_switch (cothread *to);
|
|
static void do_cothread_setfunc (cothread *thread,
|
|
cothread_context *context,
|
|
cothread_func func,
|
|
int argc,
|
|
char **argv);
|
|
static void do_cothread_destroy (cothread *thread);
|
|
#define do_cothread_lock(cothread) /* FIXME */
|
|
#define do_cothread_unlock(cothread) /* FIXME */
|
|
#define do_cothread_get_current(context) ((context)->current)
|
|
#define do_cothread_get_main(context) ((context)->main)
|
|
|
|
static void
|
|
do_cothreads_init (void *unused)
|
|
{
|
|
if (!g_thread_supported ()) g_thread_init (NULL);
|
|
}
|
|
static cothread_context *
|
|
do_cothread_context_init (void)
|
|
{
|
|
cothread_context *ret = g_new0 (cothread_context, 1);
|
|
|
|
ret->main = g_new0 (cothread, 1);
|
|
ret->main->thread = g_thread_self ();
|
|
ret->main->cond = g_cond_new ();
|
|
ret->main->die = FALSE;
|
|
ret->main->context = ret;
|
|
ret->mutex = g_mutex_new ();
|
|
ret->cothreads = NULL;
|
|
ret->current = ret->main;
|
|
ret->gst_thread = gst_thread_get_current();
|
|
g_mutex_lock (ret->mutex);
|
|
|
|
return ret;
|
|
}
|
|
static void
|
|
do_cothread_context_destroy (cothread_context *context)
|
|
{
|
|
g_assert (g_thread_self() == context->main->thread);
|
|
|
|
while (context->cothreads) {
|
|
do_cothread_destroy ((cothread *) context->cothreads->data);
|
|
}
|
|
g_mutex_unlock (context->mutex);
|
|
g_mutex_free (context->mutex);
|
|
|
|
g_free (context);
|
|
}
|
|
static void
|
|
die (cothread *to_die) {
|
|
g_cond_free (to_die->cond);
|
|
to_die->context->cothreads = g_slist_remove (to_die->context->cothreads, to_die);
|
|
g_free (to_die);
|
|
g_thread_exit (to_die);
|
|
/* don't unlock the mutex here, the thread waiting for us to die is gonna take it */
|
|
}
|
|
static gpointer
|
|
run_new_thread (gpointer data)
|
|
{
|
|
cothread *self = (cothread *) data;
|
|
|
|
g_mutex_lock (self->context->mutex);
|
|
g_private_set (gst_thread_current, self->context->gst_thread);
|
|
g_cond_signal (self->creator->cond);
|
|
g_cond_wait (self->cond, self->context->mutex);
|
|
if (self->die)
|
|
die (self);
|
|
while (TRUE) {
|
|
self->run (self->argc, self->argv);
|
|
/* compatibility */
|
|
do_cothread_switch (do_cothread_get_main (self->context));
|
|
}
|
|
g_assert_not_reached ();
|
|
return NULL;
|
|
}
|
|
static cothread *
|
|
cothread_create (cothread_context *context, cothread_func func, int argc, char **argv)
|
|
{
|
|
cothread *ret;
|
|
|
|
if ((ret = g_new (cothread, 1)) == NULL) {
|
|
goto out1;
|
|
}
|
|
ret->cond = g_cond_new ();
|
|
ret->run = func;
|
|
ret->argc = argc;
|
|
ret->argv = argv;
|
|
ret->creator = do_cothread_get_current (context);
|
|
ret->die = FALSE;
|
|
ret->context = context;
|
|
context->cothreads = g_slist_prepend (context->cothreads, ret);
|
|
ret->thread = g_thread_create (run_new_thread, ret, TRUE, NULL);
|
|
if (ret->thread == NULL) goto out2;
|
|
g_cond_wait (do_cothread_get_current (context)->cond, context->mutex);
|
|
return ret;
|
|
|
|
out2:
|
|
context->cothreads = g_slist_remove (context->cothreads, ret);
|
|
g_free (ret);
|
|
out1:
|
|
return NULL;
|
|
}
|
|
|
|
static void do_cothread_switch (cothread *to)
|
|
{
|
|
cothread *self = do_cothread_get_current(to->context);
|
|
|
|
if (self == to) {
|
|
g_warning ("trying to switch to the same cothread, not allowed");
|
|
} else {
|
|
self->context->current = to;
|
|
g_cond_signal (to->cond);
|
|
g_cond_wait (self->cond, self->context->mutex);
|
|
if (self->die)
|
|
die (self);
|
|
}
|
|
}
|
|
|
|
static void
|
|
do_cothread_setfunc (cothread *thread, cothread_context *context,
|
|
cothread_func func, int argc, char **argv)
|
|
{
|
|
thread->run = func;
|
|
thread->argc = argc;
|
|
thread->argv = argv;
|
|
}
|
|
static void
|
|
do_cothread_destroy (cothread *thread)
|
|
{
|
|
GThread *join;
|
|
cothread_context *context;
|
|
g_return_if_fail (thread != thread->context->main);
|
|
g_return_if_fail (thread != thread->context->current);
|
|
|
|
thread->die = TRUE;
|
|
join = thread->thread;
|
|
context = thread->context;
|
|
g_cond_signal (thread->cond);
|
|
g_mutex_unlock (thread->context->mutex);
|
|
g_thread_join (join);
|
|
/* the mutex was locked by the thread that we joined, no need to lock again */
|
|
}
|
|
|
|
#define do_cothread_lock(cothread) /* FIXME */
|
|
#define do_cothread_unlock(cothread) /* FIXME */
|
|
|
|
#define do_cothread_get_current(context) ((context)->current)
|
|
#define do_cothread_get_main(context) ((context)->main)
|