mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-06-26 09:50:39 +00:00
Original commit message from CVS: Merge with the main trunk. GstPlay needed some changes for the dynamic pads in the avidecoder since the new autoplugger doesn't know about the outher elements. The next version of the autoplugger will also handle the audfio/videosink connections and will do a complete end-to-end autoplugging.
373 lines
11 KiB
C
373 lines
11 KiB
C
/* GStreamer
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
*
|
|
* gstthread.c: Threaded container object
|
|
*
|
|
* 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 <unistd.h>
|
|
|
|
//#define GST_DEBUG_ENABLED
|
|
#include "gst_private.h"
|
|
|
|
#include "gstthread.h"
|
|
|
|
|
|
GstElementDetails gst_thread_details = {
|
|
"Threaded container",
|
|
"Bin",
|
|
"Container that creates/manages a thread",
|
|
VERSION,
|
|
"Erik Walthinsen <omega@cse.ogi.edu>",
|
|
"(C) 1999, 2000",
|
|
};
|
|
|
|
|
|
/* Thread signals and args */
|
|
enum {
|
|
/* FILL ME */
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum {
|
|
ARG_0,
|
|
ARG_CREATE_THREAD,
|
|
};
|
|
|
|
|
|
static void gst_thread_class_init (GstThreadClass *klass);
|
|
static void gst_thread_init (GstThread *thread);
|
|
|
|
static void gst_thread_set_arg (GtkObject *object, GtkArg *arg, guint id);
|
|
static void gst_thread_get_arg (GtkObject *object, GtkArg *arg, guint id);
|
|
|
|
static GstElementStateReturn gst_thread_change_state (GstElement *element);
|
|
|
|
static xmlNodePtr gst_thread_save_thyself (GstObject *object, xmlNodePtr parent);
|
|
static void gst_thread_restore_thyself (GstObject *object, xmlNodePtr self);
|
|
|
|
static void gst_thread_signal_thread (GstThread *thread);
|
|
static void gst_thread_wait_thread (GstThread *thread);
|
|
static void gst_thread_schedule_dummy (GstBin *bin);
|
|
|
|
static void* gst_thread_main_loop (void *arg);
|
|
|
|
static GstBinClass *parent_class = NULL;
|
|
//static guint gst_thread_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
GtkType
|
|
gst_thread_get_type(void) {
|
|
static GtkType thread_type = 0;
|
|
|
|
if (!thread_type) {
|
|
static const GtkTypeInfo thread_info = {
|
|
"GstThread",
|
|
sizeof(GstThread),
|
|
sizeof(GstThreadClass),
|
|
(GtkClassInitFunc)gst_thread_class_init,
|
|
(GtkObjectInitFunc)gst_thread_init,
|
|
(GtkArgSetFunc)NULL,
|
|
(GtkArgGetFunc)NULL,
|
|
(GtkClassInitFunc)NULL,
|
|
};
|
|
thread_type = gtk_type_unique(GST_TYPE_BIN,&thread_info);
|
|
}
|
|
return thread_type;
|
|
}
|
|
|
|
static void
|
|
gst_thread_class_init (GstThreadClass *klass)
|
|
{
|
|
GtkObjectClass *gtkobject_class;
|
|
GstObjectClass *gstobject_class;
|
|
GstElementClass *gstelement_class;
|
|
GstBinClass *gstbin_class;
|
|
|
|
gtkobject_class = (GtkObjectClass*)klass;
|
|
gstobject_class = (GstObjectClass*)klass;
|
|
gstelement_class = (GstElementClass*)klass;
|
|
gstbin_class = (GstBinClass*)klass;
|
|
|
|
parent_class = gtk_type_class (GST_TYPE_BIN);
|
|
|
|
gtk_object_add_arg_type ("GstThread::create_thread", GTK_TYPE_BOOL,
|
|
GTK_ARG_READWRITE, ARG_CREATE_THREAD);
|
|
|
|
gstobject_class->save_thyself = gst_thread_save_thyself;
|
|
gstobject_class->restore_thyself = gst_thread_restore_thyself;
|
|
|
|
gstelement_class->change_state = gst_thread_change_state;
|
|
|
|
gstbin_class->schedule = gst_thread_schedule_dummy;
|
|
|
|
gtkobject_class->set_arg = gst_thread_set_arg;
|
|
gtkobject_class->get_arg = gst_thread_get_arg;
|
|
|
|
}
|
|
|
|
static void
|
|
gst_thread_init (GstThread *thread)
|
|
{
|
|
GST_DEBUG (0,"initializing thread '%s'\n",GST_ELEMENT_NAME (thread));
|
|
|
|
// we're a manager by default
|
|
GST_FLAG_SET (thread, GST_BIN_FLAG_MANAGER);
|
|
|
|
// default is to create a thread
|
|
GST_FLAG_SET (thread, GST_THREAD_CREATE);
|
|
GST_FLAG_UNSET (thread, GST_THREAD_STATE_REAPING);
|
|
|
|
thread->lock = g_mutex_new();
|
|
thread->cond = g_cond_new();
|
|
}
|
|
|
|
static void
|
|
gst_thread_schedule_dummy (GstBin *bin)
|
|
{
|
|
g_return_if_fail (GST_IS_THREAD (bin));
|
|
|
|
if (!GST_FLAG_IS_SET (GST_THREAD (bin), GST_THREAD_STATE_SPINNING))
|
|
GST_INFO (GST_CAT_THREAD,"gstthread: scheduling delayed until thread starts");
|
|
}
|
|
|
|
static void
|
|
gst_thread_set_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint id)
|
|
{
|
|
/* it's not null if we got it, but it might not be ours */
|
|
g_return_if_fail (GST_IS_THREAD (object));
|
|
|
|
switch(id) {
|
|
case ARG_CREATE_THREAD:
|
|
if (GTK_VALUE_BOOL (*arg)) {
|
|
GST_INFO (GST_CAT_THREAD,"gstthread: turning ON the creation of the thread");
|
|
GST_FLAG_SET (object, GST_THREAD_CREATE);
|
|
GST_DEBUG (0,"gstthread: flags are 0x%08x\n", GST_FLAGS (object));
|
|
} else {
|
|
GST_INFO (GST_CAT_THREAD,"gstthread: turning OFF the creation of the thread");
|
|
GST_FLAG_UNSET (object, GST_THREAD_CREATE);
|
|
GST_DEBUG (0,"gstthread: flags are 0x%08x\n", GST_FLAGS (object));
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_thread_get_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint id)
|
|
{
|
|
/* it's not null if we got it, but it might not be ours */
|
|
g_return_if_fail (GST_IS_THREAD (object));
|
|
|
|
switch (id) {
|
|
case ARG_CREATE_THREAD:
|
|
GTK_VALUE_BOOL (*arg) = GST_FLAG_IS_SET (object, GST_THREAD_CREATE);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* gst_thread_new:
|
|
* @name: the name of the thread
|
|
*
|
|
* Create a new thread with the given name.
|
|
*
|
|
* Returns: The new thread
|
|
*/
|
|
GstElement*
|
|
gst_thread_new (guchar *name)
|
|
{
|
|
return gst_elementfactory_make ("thread", name);
|
|
}
|
|
|
|
|
|
|
|
static GstElementStateReturn
|
|
gst_thread_change_state (GstElement *element)
|
|
{
|
|
GstThread *thread;
|
|
gboolean stateset = GST_STATE_SUCCESS;
|
|
gint pending, transition;
|
|
|
|
g_return_val_if_fail (GST_IS_THREAD(element), FALSE);
|
|
GST_DEBUG_ENTER("(\"%s\")",GST_ELEMENT_NAME(element));
|
|
|
|
thread = GST_THREAD (element);
|
|
|
|
GST_INFO (GST_CAT_THREAD,"gstthread: thread \"%s\" change state %d",
|
|
GST_ELEMENT_NAME (GST_ELEMENT (element)),
|
|
GST_STATE_PENDING (element));
|
|
|
|
pending = GST_STATE_PENDING (element);
|
|
transition = GST_STATE_TRANSITION (element);
|
|
|
|
// if (pending == GST_STATE (element)) return GST_STATE_SUCCESS;
|
|
|
|
GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
|
|
|
|
if (GST_ELEMENT_CLASS (parent_class)->change_state)
|
|
stateset = GST_ELEMENT_CLASS (parent_class)->change_state (element);
|
|
|
|
GST_INFO (GST_CAT_THREAD, "gstthread: stateset %d %d %d %02x", GST_STATE (element), stateset,
|
|
GST_STATE_PENDING (element), GST_STATE_TRANSITION (element));
|
|
|
|
switch (transition) {
|
|
case GST_STATE_NULL_TO_READY:
|
|
// if (!stateset) return FALSE;
|
|
// we want to prepare our internal state for doing the iterations
|
|
GST_INFO (GST_CAT_THREAD, "gstthread: preparing thread \"%s\" for iterations:",
|
|
GST_ELEMENT_NAME (GST_ELEMENT (element)));
|
|
|
|
// set the state to idle
|
|
GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
|
|
// create the thread if that's what we're supposed to do
|
|
GST_INFO (GST_CAT_THREAD, "gstthread: flags are 0x%08x", GST_FLAGS (thread));
|
|
|
|
if (GST_FLAG_IS_SET (thread, GST_THREAD_CREATE)) {
|
|
GST_INFO (GST_CAT_THREAD, "gstthread: starting thread \"%s\"",
|
|
GST_ELEMENT_NAME (GST_ELEMENT (element)));
|
|
|
|
// create the thread
|
|
pthread_create (&thread->thread_id, NULL,
|
|
gst_thread_main_loop, thread);
|
|
|
|
// wait for it to 'spin up'
|
|
//gst_thread_wait_thread (thread);
|
|
} else {
|
|
GST_INFO (GST_CAT_THREAD, "gstthread: NOT starting thread \"%s\"",
|
|
GST_ELEMENT_NAME (GST_ELEMENT (element)));
|
|
}
|
|
break;
|
|
case GST_STATE_PAUSED_TO_PLAYING:
|
|
case GST_STATE_READY_TO_PLAYING:
|
|
if (!stateset) return FALSE;
|
|
GST_INFO (GST_CAT_THREAD, "gstthread: starting thread \"%s\"",
|
|
GST_ELEMENT_NAME (GST_ELEMENT (element)));
|
|
|
|
GST_FLAG_SET (thread, GST_THREAD_STATE_SPINNING);
|
|
gst_thread_signal_thread (thread);
|
|
break;
|
|
case GST_STATE_PLAYING_TO_PAUSED:
|
|
GST_INFO (GST_CAT_THREAD,"gstthread: pausing thread \"%s\"",
|
|
GST_ELEMENT_NAME (GST_ELEMENT (element)));
|
|
|
|
//GST_FLAG_UNSET(thread,GST_THREAD_STATE_SPINNING);
|
|
gst_thread_signal_thread (thread);
|
|
break;
|
|
case GST_STATE_READY_TO_NULL:
|
|
GST_INFO (GST_CAT_THREAD,"gstthread: stopping thread \"%s\"",
|
|
GST_ELEMENT_NAME (GST_ELEMENT (element)));
|
|
|
|
GST_FLAG_SET (thread, GST_THREAD_STATE_REAPING);
|
|
gst_thread_signal_thread (thread);
|
|
pthread_join(thread->thread_id,NULL);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return stateset;
|
|
}
|
|
|
|
/**
|
|
* gst_thread_main_loop:
|
|
* @arg: the thread to start
|
|
*
|
|
* The main loop of the thread. The thread will iterate
|
|
* while the state is GST_THREAD_STATE_SPINNING
|
|
*/
|
|
static void *
|
|
gst_thread_main_loop (void *arg)
|
|
{
|
|
GstThread *thread = GST_THREAD (arg);
|
|
|
|
GST_INFO (GST_CAT_THREAD,"gstthread: thread \"%s\" is running with PID %d",
|
|
GST_ELEMENT_NAME (GST_ELEMENT (thread)), getpid ());
|
|
|
|
// construct the plan and signal back
|
|
if (GST_BIN_CLASS (parent_class)->schedule)
|
|
GST_BIN_CLASS (parent_class)->schedule (GST_BIN (thread));
|
|
|
|
gst_thread_signal_thread (thread);
|
|
|
|
while (!GST_FLAG_IS_SET (thread, GST_THREAD_STATE_REAPING)) {
|
|
if (GST_FLAG_IS_SET (thread, GST_THREAD_STATE_SPINNING)) {
|
|
if (!gst_bin_iterate (GST_BIN (thread))) {
|
|
GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
|
|
}
|
|
}
|
|
else {
|
|
GST_DEBUG (0, "thread \"%s\" waiting\n", GST_ELEMENT_NAME (GST_ELEMENT (thread)));
|
|
gst_thread_wait_thread (thread);
|
|
}
|
|
}
|
|
|
|
GST_FLAG_UNSET (thread, GST_THREAD_STATE_REAPING);
|
|
// FIXME this should be removed (why's it here???)
|
|
// //pthread_join (thread->thread_id, 0);
|
|
|
|
GST_INFO (GST_CAT_THREAD, "gstthread: thread \"%s\" is stopped",
|
|
GST_ELEMENT_NAME (thread));
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
gst_thread_signal_thread (GstThread *thread)
|
|
{
|
|
GST_DEBUG (0,"signaling thread\n");
|
|
g_mutex_lock (thread->lock);
|
|
g_cond_signal (thread->cond);
|
|
g_mutex_unlock (thread->lock);
|
|
}
|
|
|
|
static void
|
|
gst_thread_wait_thread (GstThread *thread)
|
|
{
|
|
GST_DEBUG (0,"waiting for thread\n");
|
|
g_mutex_lock (thread->lock);
|
|
g_cond_wait (thread->cond, thread->lock);
|
|
g_mutex_unlock (thread->lock);
|
|
}
|
|
|
|
|
|
static void
|
|
gst_thread_restore_thyself (GstObject *object,
|
|
xmlNodePtr self)
|
|
{
|
|
GST_DEBUG (0,"gstthread: restore\n");
|
|
|
|
if (GST_OBJECT_CLASS (parent_class)->restore_thyself)
|
|
GST_OBJECT_CLASS (parent_class)->restore_thyself (object, self);
|
|
}
|
|
|
|
static xmlNodePtr
|
|
gst_thread_save_thyself (GstObject *object,
|
|
xmlNodePtr self)
|
|
{
|
|
if (GST_OBJECT_CLASS (parent_class)->save_thyself)
|
|
GST_OBJECT_CLASS (parent_class)->save_thyself (object, self);
|
|
return NULL;
|
|
}
|