2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3 * 2000 Wim Taymans <wtay@chello.be>
5 * gstthread.c: Threaded container object
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
25 //#define GST_DEBUG_ENABLED
26 #include "gst_private.h"
28 #include "gstthread.h"
29 #include "gstscheduler.h"
32 GstElementDetails gst_thread_details = {
35 "Container that creates/manages a thread",
37 "Erik Walthinsen <omega@cse.ogi.edu>",
42 /* Thread signals and args */
61 static void gst_thread_class_init (GstThreadClass *klass);
62 static void gst_thread_init (GstThread *thread);
64 static void gst_thread_real_destroy (GObject *object);
66 static void gst_thread_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
67 static void gst_thread_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
69 static GstElementStateReturn gst_thread_change_state (GstElement *element);
71 #ifndef GST_DISABLE_LOADSAVE
72 static xmlNodePtr gst_thread_save_thyself (GstObject *object, xmlNodePtr parent);
73 static void gst_thread_restore_thyself (GstObject *object, xmlNodePtr self);
76 static void gst_thread_signal_thread (GstThread *thread, gboolean spinning);
78 static void* gst_thread_main_loop (void *arg);
80 static GstBinClass *parent_class = NULL;
81 //static guint gst_thread_signals[LAST_SIGNAL] = { 0 };
84 gst_thread_get_type(void) {
85 static GType thread_type = 0;
88 static const GTypeInfo thread_info = {
89 sizeof(GstThreadClass),
92 (GClassInitFunc)gst_thread_class_init,
97 (GInstanceInitFunc)gst_thread_init,
100 thread_type = g_type_register_static(GST_TYPE_BIN, "GstThread", &thread_info, 0);
106 gst_thread_class_init (GstThreadClass *klass)
108 GObjectClass *gobject_class;
109 GstObjectClass *gstobject_class;
110 GstElementClass *gstelement_class;
111 GstBinClass *gstbin_class;
113 gobject_class = (GObjectClass*)klass;
114 gstobject_class = (GstObjectClass*)klass;
115 gstelement_class = (GstElementClass*)klass;
116 gstbin_class = (GstBinClass*)klass;
118 parent_class = g_type_class_ref (GST_TYPE_BIN);
120 g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CREATE_THREAD,
121 g_param_spec_boolean("create_thread", "Create Thread", "Whether to create a thread.",
122 TRUE,G_PARAM_READWRITE));
125 // gobject_class->destroy = gst_thread_real_destroy;
127 #ifndef GST_DISABLE_LOADSAVE
128 gstobject_class->save_thyself = gst_thread_save_thyself;
129 gstobject_class->restore_thyself = gst_thread_restore_thyself;
132 gstelement_class->change_state = gst_thread_change_state;
134 // gstbin_class->schedule = gst_thread_schedule_dummy;
136 gobject_class->set_property = gst_thread_set_property;
137 gobject_class->get_property = gst_thread_get_property;
142 gst_thread_init (GstThread *thread)
145 GST_DEBUG (GST_CAT_THREAD,"initializing thread\n");
147 // we're a manager by default
148 GST_FLAG_SET (thread, GST_BIN_FLAG_MANAGER);
150 // default is to create a thread
151 GST_FLAG_SET (thread, GST_THREAD_CREATE);
153 thread->lock = g_mutex_new();
154 thread->cond = g_cond_new();
156 GST_ELEMENT_SCHED(thread) = gst_schedule_new(GST_ELEMENT(thread));
157 GST_DEBUG(GST_CAT_THREAD, "thread's scheduler is %p\n",GST_ELEMENT_SCHED(thread));
159 thread->ppid = getpid();
161 // gst_element_set_manager(GST_ELEMENT(thread),GST_ELEMENT(thread));
165 gst_thread_real_destroy (GObject *object)
167 GstThread *thread = GST_THREAD (object);
169 GST_DEBUG (GST_CAT_REFCOUNTING,"destroy()\n");
171 g_mutex_free (thread->lock);
172 g_cond_free (thread->cond);
175 // if (G_OBJECT_CLASS (parent_class)->destroy)
176 // G_OBJECT_CLASS (parent_class)->destroy (object);
178 gst_object_destroy (GST_OBJECT (GST_ELEMENT_SCHED (thread)));
179 gst_object_unref (GST_OBJECT (GST_ELEMENT_SCHED (thread)));
183 gst_thread_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
185 /* it's not null if we got it, but it might not be ours */
186 g_return_if_fail (GST_IS_THREAD (object));
189 case ARG_CREATE_THREAD:
190 if (g_value_get_boolean(value)) {
191 GST_INFO (GST_CAT_THREAD,"turning ON the creation of the thread");
192 GST_FLAG_SET (object, GST_THREAD_CREATE);
193 // GST_DEBUG (GST_CAT_THREAD,"flags are 0x%08x\n", GST_FLAGS (object));
195 GST_INFO (GST_CAT_THREAD,"gstthread: turning OFF the creation of the thread");
196 GST_FLAG_UNSET (object, GST_THREAD_CREATE);
197 // GST_DEBUG (GST_CAT_THREAD,"gstthread: flags are 0x%08x\n", GST_FLAGS (object));
201 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
207 gst_thread_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
209 /* it's not null if we got it, but it might not be ours */
210 g_return_if_fail (GST_IS_THREAD (object));
213 case ARG_CREATE_THREAD:
214 g_value_set_boolean(value, GST_FLAG_IS_SET (object, GST_THREAD_CREATE));
217 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
225 * @name: the name of the thread
227 * Create a new thread with the given name.
229 * Returns: The new thread
232 gst_thread_new (const guchar *name)
234 return gst_elementfactory_make ("thread", name);
238 #define THR_INFO(format,args...) \
239 GST_INFO_ELEMENT(GST_CAT_THREAD, thread, "sync(" GST_DEBUG_THREAD_FORMAT "): " format , \
240 GST_DEBUG_THREAD_ARGS(thread->pid) , ## args )
241 #define THR_DEBUG(format,args...) \
242 GST_DEBUG_ELEMENT(GST_CAT_THREAD, thread, "sync(" GST_DEBUG_THREAD_FORMAT "): " format , \
243 GST_DEBUG_THREAD_ARGS(thread->pid) , ## args )
245 #define THR_INFO_MAIN(format,args...) \
246 GST_INFO_ELEMENT(GST_CAT_THREAD, thread, "sync-main(" GST_DEBUG_THREAD_FORMAT "): " format , \
247 GST_DEBUG_THREAD_ARGS(thread->ppid) , ## args )
248 #define THR_DEBUG_MAIN(format,args...) \
249 GST_DEBUG_ELEMENT(GST_CAT_THREAD, thread, "sync-main(" GST_DEBUG_THREAD_FORMAT "): " format , \
250 GST_DEBUG_THREAD_ARGS(thread->ppid) , ## args )
253 static GstElementStateReturn
254 gst_thread_change_state (GstElement *element)
257 gboolean stateset = GST_STATE_SUCCESS;
259 pthread_t self = pthread_self();
261 g_return_val_if_fail (GST_IS_THREAD(element), FALSE);
262 // GST_DEBUG_ENTER("(\"%s\")",GST_ELEMENT_NAME(element));
264 thread = GST_THREAD (element);
265 // GST_DEBUG (GST_CAT_THREAD, "**** THREAD %ld changing THREAD %ld ****\n",self,thread->thread_id);
266 // GST_DEBUG (GST_CAT_THREAD, "**** current pid=%d\n",getpid());
268 transition = GST_STATE_TRANSITION (element);
270 THR_INFO("changing state from %s to %s",
271 gst_element_statename(GST_STATE (element)),
272 gst_element_statename(GST_STATE_PENDING (element)));
274 //GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
276 switch (transition) {
277 case GST_STATE_NULL_TO_READY:
278 // set the state to idle
279 GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
280 GST_FLAG_UNSET (thread, GST_THREAD_STATE_REAPING);
282 // create the thread if that's what we're supposed to do
283 if (GST_FLAG_IS_SET (thread, GST_THREAD_CREATE)) {
284 THR_DEBUG ("creating thread \"%s\"\n",
285 GST_ELEMENT_NAME (element));
287 g_mutex_lock (thread->lock);
290 pthread_create (&thread->thread_id, NULL,
291 gst_thread_main_loop, thread);
293 // wait for it to 'spin up'
294 THR_DEBUG("waiting for child thread spinup\n");
295 g_cond_wait(thread->cond,thread->lock);
296 THR_DEBUG("thread claims to be up\n");
297 g_mutex_unlock(thread->lock);
299 GST_INFO (GST_CAT_THREAD, "NOT creating thread \"%s\"",
300 GST_ELEMENT_NAME (GST_ELEMENT (element)));
302 // punt and change state on all the children
303 if (GST_ELEMENT_CLASS (parent_class)->change_state)
304 stateset = GST_ELEMENT_CLASS (parent_class)->change_state (element);
307 case GST_STATE_READY_TO_PAUSED:
308 THR_INFO("readying thread");
310 // check to see if the thread is somehow changing its own state.
311 // FIXME this is currently illegal, but must somehow be made legal at some point.
312 if (pthread_equal(self, thread->thread_id))
314 //FIXME this should not happen
315 g_assert(!pthread_equal(self, thread->thread_id));
316 GST_FLAG_SET(thread, GST_THREAD_STATE_SPINNING);
317 GST_DEBUG(GST_CAT_THREAD,"no sync(" GST_DEBUG_THREAD_FORMAT "): setting own thread's state to spinning\n",
318 GST_DEBUG_THREAD_ARGS(thread->pid));
322 g_mutex_lock(thread->lock);
323 gst_thread_signal_thread(thread,FALSE);
326 case GST_STATE_PAUSED_TO_PLAYING:
327 THR_INFO("starting thread");
329 // check to see if the thread is somehow changing its own state.
330 // FIXME this is currently illegal, but must somehow be made legal at some point.
331 if (pthread_equal(self, thread->thread_id))
333 //FIXME this should not happen
334 g_assert(!pthread_equal(self, thread->thread_id));
335 GST_FLAG_SET(thread, GST_THREAD_STATE_SPINNING);
336 GST_DEBUG(GST_CAT_THREAD,"no sync(" GST_DEBUG_THREAD_FORMAT "): setting own thread's state to spinning\n",
337 GST_DEBUG_THREAD_ARGS(thread->pid));
341 THR_DEBUG("telling thread to start spinning\n");
342 g_mutex_lock(thread->lock);
343 gst_thread_signal_thread(thread,TRUE);
346 case GST_STATE_PLAYING_TO_PAUSED:
347 THR_INFO("pausing thread");
349 // check to see if the thread is somehow changing its own state.
350 // FIXME this is currently illegal, but must somehow be made legal at some point.
351 if (pthread_equal(self, thread->thread_id))
353 //FIXME this should not happen
354 GST_DEBUG(GST_CAT_THREAD,"no sync(" GST_DEBUG_THREAD_FORMAT "): setting own thread's state to paused\n",
355 GST_DEBUG_THREAD_ARGS(thread->pid));
356 GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
357 g_assert(!pthread_equal(self, thread->thread_id));
361 GList *elements = (element->sched)->elements;
363 // the following code ensures that the bottom half of thread will run
364 // to perform each elements' change_state() (by calling gstbin.c::
366 // + the pending state was already set by gstelement.c::set_state()
367 // + find every queue we manage, and signal its empty and full conditions
369 g_mutex_lock(thread->lock);
371 GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
375 GstElement *e = GST_ELEMENT(elements->data);
377 THR_DEBUG(" element \"%s\"\n",GST_ELEMENT_NAME(e));
378 elements = g_list_next(elements);
381 //FIXME make this more efficient by only waking queues that are asleep
382 //FIXME and only waking the appropriate condition (depending on if it's
383 //FIXME on up- or down-stream side)
385 //FIXME also make this more efficient by keeping list of managed queues
386 THR_DEBUG("waking queue \"%s\"\n",GST_ELEMENT_NAME(e));
388 g_cond_signal((GST_QUEUE(e)->emptycond));
389 g_cond_signal((GST_QUEUE(e)->fullcond));
394 GList *pads = GST_ELEMENT_PADS(e);
398 GstElement *peerelement;
399 GstPad *p = GST_PAD(pads->data);
400 pads = g_list_next(pads);
402 peer = GST_PAD_PEER(p);
405 peerelement = GST_PAD_PARENT(peer);
406 if (!peerelement) continue; // deal with case where there's no peer
408 if (!GST_FLAG_IS_SET(peerelement,GST_ELEMENT_DECOUPLED)) {
409 GST_DEBUG(GST_CAT_THREAD,"peer element isn't DECOUPLED\n");
413 // FIXME this needs to go away eventually
414 if (!GST_IS_QUEUE(peerelement)) {
415 GST_DEBUG(GST_CAT_THREAD,"peer element isn't a Queue\n");
419 if (GST_ELEMENT_SCHED(peerelement) != GST_ELEMENT_SCHED(thread))
421 THR_DEBUG(" element \"%s\" has pad cross sched boundary\n",GST_ELEMENT_NAME(e));
422 GST_LOCK(peerelement);
423 g_cond_signal(GST_QUEUE(peerelement)->emptycond);
424 g_cond_signal(GST_QUEUE(peerelement)->fullcond);
425 GST_UNLOCK(peerelement);
430 THR_DEBUG("waiting for thread to stop spinning\n");
431 g_cond_wait (thread->cond, thread->lock);
432 THR_DEBUG("telling thread to pause\n");
433 gst_thread_signal_thread(thread,FALSE);
436 case GST_STATE_READY_TO_NULL:
437 THR_INFO("stopping thread");
439 GST_FLAG_SET (thread, GST_THREAD_STATE_REAPING);
441 // check to see if the thread is somehow changing its own state.
442 // FIXME this is currently illegal, but must somehow be made legal at some point.
443 if (pthread_equal(self, thread->thread_id))
445 //FIXME this should not happen
446 g_assert(!pthread_equal(self, thread->thread_id));
447 THR_DEBUG("setting own thread's state to NULL (paused)\n");
448 GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
452 THR_DEBUG("telling thread to pause (null) - and joining\n");
453 //MattH FIXME revisit
454 g_mutex_lock(thread->lock);
455 gst_thread_signal_thread(thread,FALSE);
456 pthread_join(thread->thread_id,NULL);
459 GST_FLAG_UNSET(thread,GST_THREAD_STATE_REAPING);
460 GST_FLAG_UNSET(thread,GST_THREAD_STATE_STARTED);
461 GST_FLAG_UNSET(thread,GST_THREAD_STATE_SPINNING);
462 GST_FLAG_UNSET(thread,GST_THREAD_STATE_ELEMENT_CHANGED);
465 case GST_STATE_PAUSED_TO_READY:
466 THR_INFO("stopping thread");
468 // check to see if the thread is somehow changing its own state.
469 // FIXME this is currently illegal, but must somehow be made legal at some point.
470 if (pthread_equal(self, thread->thread_id))
472 //FIXME this should not happen
473 g_assert(!pthread_equal(self, thread->thread_id));
474 GST_FLAG_SET(thread, GST_THREAD_STATE_SPINNING);
475 GST_DEBUG(GST_CAT_THREAD,"no sync(" GST_DEBUG_THREAD_FORMAT "): setting own thread's state to spinning\n",
476 GST_DEBUG_THREAD_ARGS(thread->pid));
480 THR_DEBUG("telling thread to stop spinning\n");
481 g_mutex_lock(thread->lock);
482 gst_thread_signal_thread(thread,FALSE);
487 GST_DEBUG_ELEMENT(GST_CAT_THREAD, element, "UNHANDLED STATE CHANGE! %x\n",transition);
494 static void gst_thread_update_state (GstThread *thread)
496 // check for state change
497 if (GST_STATE_PENDING(thread) != GST_STATE_VOID_PENDING) {
498 // punt and change state on all the children
499 if (GST_ELEMENT_CLASS (parent_class)->change_state)
500 GST_ELEMENT_CLASS (parent_class)->change_state (GST_ELEMENT(thread));
505 * gst_thread_main_loop:
506 * @arg: the thread to start
508 * The main loop of the thread. The thread will iterate
509 * while the state is GST_THREAD_STATE_SPINNING
512 gst_thread_main_loop (void *arg)
514 GstThread *thread = GST_THREAD (arg);
517 thread->pid = getpid();
518 THR_INFO_MAIN("thread is running");
520 // first we need to change the state of all the children
521 if (GST_ELEMENT_CLASS (parent_class)->change_state)
522 stateset = GST_ELEMENT_CLASS (parent_class)->change_state (GST_ELEMENT(thread));
524 // construct the plan and signal back
525 /* DEPRACATED for INCSCHED1
526 THR_DEBUG_MAIN("creating plan for thread\n");
527 if (GST_BIN_CLASS (parent_class)->schedule)
528 GST_BIN_CLASS (parent_class)->schedule (GST_BIN (thread));
531 // THR_DEBUG_MAIN("indicating spinup\n");
532 g_mutex_lock (thread->lock);
533 g_cond_signal (thread->cond);
534 // don't unlock the mutex because we hold it into the top of the while loop
535 THR_DEBUG_MAIN("thread has indicated spinup to parent process\n");
537 /***** THREAD IS NOW IN READY STATE *****/
539 while (!GST_FLAG_IS_SET (thread, GST_THREAD_STATE_REAPING)) {
540 // NOTE we hold the thread lock at this point
541 // what we do depends on what state we're in
542 switch (GST_STATE(thread)) {
543 // NOTE: cannot be in NULL, we're not running in that state at all
544 case GST_STATE_READY:
545 // wait to be set to either the NULL or PAUSED states
546 THR_DEBUG_MAIN("thread in %s state, waiting for either %s or %s\n",
547 gst_element_statename(GST_STATE_READY),
548 gst_element_statename(GST_STATE_NULL),
549 gst_element_statename(GST_STATE_PAUSED));
550 g_cond_wait(thread->cond,thread->lock);
551 // been signaled, we need to state transition now and signal back
552 gst_thread_update_state(thread);
553 THR_DEBUG_MAIN("done with state transition, signaling back to parent process\n");
554 g_cond_signal(thread->cond);
555 // g_mutex_unlock(thread->lock);
556 // now we decide what to do next (FIXME can be collapsed to a continue)
557 if (GST_STATE(thread) == GST_STATE_NULL) {
558 // REAPING must be set, we can simply break this iteration
561 // PAUSED is the next state, we can wait for that next
565 case GST_STATE_PAUSED:
566 // wait to be set to either the READY or PLAYING states
567 THR_DEBUG_MAIN("thread in %s state, waiting for either %s or %s\n",
568 gst_element_statename(GST_STATE_PAUSED),
569 gst_element_statename(GST_STATE_READY),
570 gst_element_statename(GST_STATE_PLAYING));
571 g_cond_wait(thread->cond,thread->lock);
572 // been signaled, we need to state transition now and signal back
573 gst_thread_update_state(thread);
574 g_cond_signal(thread->cond);
575 // g_mutex_unlock(thread->lock);
576 // now we decide what to do next
577 if (GST_STATE(thread) == GST_STATE_READY) {
578 // READY is the next state, we can wait for that next
581 g_mutex_unlock(thread->lock);
582 // PLAYING is coming up, so we can now start spinning
583 while (GST_FLAG_IS_SET (thread, GST_THREAD_STATE_SPINNING)) {
584 if (!gst_bin_iterate (GST_BIN (thread))) {
585 // GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
586 // THR_DEBUG_MAIN("removed spinning state due to failed iteration!\n");
587 // FIXME FIXME FIXME this is ugly!
588 THR_DEBUG_MAIN("iteration failed, something very wrong, spinning to let parent sync\n");
589 while (GST_FLAG_IS_SET(thread, GST_THREAD_STATE_SPINNING)) ;
592 g_mutex_lock(thread->lock);
593 // once we're here, SPINNING has stopped, we should signal that we're done
594 THR_DEBUG_MAIN("SPINNING stopped, signaling back to parent process\n");
595 g_cond_signal (thread->cond);
596 // now we can wait for PAUSED
600 case GST_STATE_PLAYING:
601 // wait to be set to PAUSED
602 THR_DEBUG_MAIN("thread in %s state, waiting for %s\n",
603 gst_element_statename(GST_STATE_PLAYING),
604 gst_element_statename(GST_STATE_PAUSED));
605 g_cond_wait(thread->cond,thread->lock);
606 // been signaled, we need to state transition now and signal back
607 gst_thread_update_state(thread);
608 g_cond_signal(thread->cond);
609 // g_mutex_unlock(thread->lock);
610 // now we decide what to do next
611 // there's only PAUSED, we we just wait for it
616 // need to grab the lock so we're ready for the top of the loop
617 // g_mutex_lock(thread->lock);
621 while (!GST_FLAG_IS_SET (thread, GST_THREAD_STATE_REAPING)) {
622 // start out by waiting for a state change into spinning
623 THR_DEBUG_MAIN("waiting for signal from parent process (at top of while())\n");
624 g_cond_wait (thread->cond,thread->lock);
625 THR_DEBUG_MAIN("woken up with %s pending\n",gst_element_statename(GST_STATE(thread)));
626 // now is a good time to change the state of the children and the thread itself
627 gst_thread_update_state (thread);
628 THR_DEBUG_MAIN("done changing state, signaling back\n");
629 g_cond_signal (thread->cond);
630 g_mutex_unlock (thread->lock);
631 THR_DEBUG_MAIN("finished sycnronizing with main process\n");
633 while (GST_FLAG_IS_SET (thread, GST_THREAD_STATE_SPINNING)) {
634 if (!gst_bin_iterate (GST_BIN (thread))) {
635 GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
636 THR_DEBUG_MAIN("removed spinning state due to failed iteration!\n");
640 g_mutex_lock (thread->lock);
642 if (GST_STATE_PENDING(thread) == GST_STATE_PAUSED) {
643 // we've stopped spinning, because of PLAYING->PAUSED
644 THR_DEBUG_MAIN("SPINNING flag unset, signaling parent process we're stopped\n");
645 // we need to signal back that we've stopped spinning
646 g_cond_signal (thread->cond);
649 // THR_DEBUG_MAIN("signaling that the thread is out of the SPINNING loop\n");
650 // g_cond_signal (thread->cond);
651 // g_cond_wait (thread->cond, thread->lock);
652 // THR_DEBUG_MAIN("parent process has signaled at bottom of while\n");
653 // // now change the children's and thread's state
654 // gst_thread_update_state (thread);
655 // THR_DEBUG_MAIN("done changing state, signaling back to parent process\n");
656 // g_cond_signal (thread->cond);
657 // // don't release the mutex, we hold that into the top of the loop
658 // THR_DEBUG_MAIN("done syncing with parent process at bottom of while\n");
662 // since we don't unlock at the end of the while loop, do it here
663 g_mutex_unlock (thread->lock);
665 GST_INFO (GST_CAT_THREAD, "gstthread: thread \"%s\" is stopped",
666 GST_ELEMENT_NAME (thread));
670 // the set flag is to say whether it should set TRUE or FALSE
672 // WARNING: this has synchronization built in! if you remove or add any
673 // locks, waits, signals, or unlocks you need to be sure they match the
674 // code above (in gst_thread_main_loop()). basically, don't change anything.
676 gst_thread_signal_thread (GstThread *thread, gboolean spinning)
678 // set the spinning state
679 if (spinning) GST_FLAG_SET(thread,GST_THREAD_STATE_SPINNING);
680 else GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
682 THR_DEBUG("thread locked\n");
683 // g_mutex_lock(thread->lock);
686 // THR_DEBUG("waiting for spindown\n");
687 // g_cond_wait (thread->cond, thread->lock);
689 THR_DEBUG("signaling\n");
690 g_cond_signal (thread->cond);
691 THR_DEBUG("waiting for ack\n");
692 g_cond_wait (thread->cond,thread->lock);
693 THR_DEBUG("got ack\n");
695 THR_DEBUG("unlocking\n");
696 g_mutex_unlock(thread->lock);
697 THR_DEBUG("unlocked\n");
701 #ifndef GST_DISABLE_LOADSAVE
703 gst_thread_save_thyself (GstObject *object,
706 if (GST_OBJECT_CLASS (parent_class)->save_thyself)
707 GST_OBJECT_CLASS (parent_class)->save_thyself (object, self);
712 gst_thread_restore_thyself (GstObject *object,
715 GST_DEBUG (GST_CAT_THREAD,"gstthread: restore\n");
717 if (GST_OBJECT_CLASS (parent_class)->restore_thyself)
718 GST_OBJECT_CLASS (parent_class)->restore_thyself (object, self);
720 #endif // GST_DISABLE_LOADSAVE