gst/gstthread.c

   1 /* Gnome-Streamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <gst/gst.h>
  21 #include <gst/gstthread.h>
  22
  23 #include "config.h"
  24
  25 GstElementDetails gst_thread_details = {
  26   "Threaded container",
  27   "Bin",
  28   "Container that creates/manages a thread",
  29   VERSION,
  30   "Erik Walthinsen <omega@cse.ogi.edu>",
  31   "(C) 1999",
  32 };
  33
  34
  35 /* Thread signals and args */
  36 enum {
  37   /* FILL ME */
  38   LAST_SIGNAL
  39 };
  40
  41 enum {
  42   ARG_0,
  43   ARG_CREATE_THREAD,
  44 };
  45
  46
  47 static void gst_thread_class_init(GstThreadClass *klass);
  48 static void gst_thread_init(GstThread *thread);
  49
  50 static void gst_thread_set_arg(GtkObject *object,GtkArg *arg,guint id);
  51 static void gst_thread_get_arg(GtkObject *object,GtkArg *arg,guint id);
  52 static GstElementStateReturn gst_thread_change_state(GstElement *element);
  53
  54 static xmlNodePtr gst_thread_save_thyself(GstElement *element,xmlNodePtr parent);
  55 static void gst_thread_restore_thyself(GstElement *element,xmlNodePtr parent, GHashTable *elements);
  56
  57 static void gst_thread_signal_thread(GstThread *thread);
  58 static void gst_thread_create_plan_dummy(GstBin *bin);
  59
  60 static void *gst_thread_main_loop(void *arg);
  61
  62 static GstBin *parent_class = NULL;
  63 //static guint gst_thread_signals[LAST_SIGNAL] = { 0 };
  64
  65 GtkType
  66 gst_thread_get_type(void) {
  67   static GtkType thread_type = 0;
  68
  69   if (!thread_type) {
  70     static const GtkTypeInfo thread_info = {
  71       "GstThread",
  72       sizeof(GstThread),
  73       sizeof(GstThreadClass),
  74       (GtkClassInitFunc)gst_thread_class_init,
  75       (GtkObjectInitFunc)gst_thread_init,
  76       (GtkArgSetFunc)NULL,
  77       (GtkArgGetFunc)NULL,
  78       (GtkClassInitFunc)NULL,
  79     };
  80     thread_type = gtk_type_unique(GST_TYPE_BIN,&thread_info);
  81   }
  82   return thread_type;
  83 }
  84
  85 static void
  86 gst_thread_class_init(GstThreadClass *klass) {
  87   GtkObjectClass *gtkobject_class;
  88   GstObjectClass *gstobject_class;
  89   GstElementClass *gstelement_class;
  90   GstBinClass *gstbin_class;
  91
  92   gtkobject_class = (GtkObjectClass*)klass;
  93   gstobject_class = (GstObjectClass*)klass;
  94   gstelement_class = (GstElementClass*)klass;
  95   gstbin_class = (GstBinClass*)klass;
  96
  97   parent_class = gtk_type_class(GST_TYPE_BIN);
  98
  99   gtk_object_add_arg_type("GstThread::create_thread", GTK_TYPE_BOOL,
 100                           GTK_ARG_READWRITE, ARG_CREATE_THREAD);
 101
 102   gstelement_class->change_state = gst_thread_change_state;
 103   gstelement_class->save_thyself = gst_thread_save_thyself;
 104   gstelement_class->restore_thyself = gst_thread_restore_thyself;
 105   gstelement_class->elementfactory = gst_elementfactory_find("thread");
 106
 107   gstbin_class->create_plan = gst_thread_create_plan_dummy;
 108
 109   gtkobject_class->set_arg = gst_thread_set_arg;
 110   gtkobject_class->get_arg = gst_thread_get_arg;
 111
 112 }
 113
 114 static void gst_thread_init(GstThread *thread) {
 115   GST_FLAG_SET(thread,GST_THREAD_CREATE);
 116
 117   thread->lock = g_mutex_new();
 118   thread->cond = g_cond_new();
 119 }
 120
 121 static void gst_thread_create_plan_dummy(GstBin *bin) {
 122   gst_info("gstthread: create plan delayed until thread starts\n");
 123 }
 124
 125 static void gst_thread_set_arg(GtkObject *object,GtkArg *arg,guint id) {
 126   /* it's not null if we got it, but it might not be ours */
 127   g_return_if_fail(GST_IS_THREAD(object));
 128
 129   switch(id) {
 130     case ARG_CREATE_THREAD:
 131       if (GTK_VALUE_BOOL(*arg)) {
 132         gst_info("gstthread: turning ON the creation of the thread\n");
 133         GST_FLAG_SET(object,GST_THREAD_CREATE);
 134         gst_info("gstthread: flags are 0x%08x\n",GST_FLAGS(object));
 135       } else {
 136         gst_info("gstthread: turning OFF the creation of the thread\n");
 137         GST_FLAG_UNSET(object,GST_THREAD_CREATE);
 138         gst_info("gstthread: flags are 0x%08x\n",GST_FLAGS(object));
 139       }
 140       break;
 141     default:
 142       break;
 143   }
 144 }
 145
 146 static void gst_thread_get_arg(GtkObject *object,GtkArg *arg,guint id) {
 147   /* it's not null if we got it, but it might not be ours */
 148   g_return_if_fail(GST_IS_THREAD(object));
 149
 150   switch(id) {
 151     case ARG_CREATE_THREAD:
 152       GTK_VALUE_BOOL(*arg) = GST_FLAG_IS_SET(object,GST_THREAD_CREATE);
 153       break;
 154     default:
 155       break;
 156   }
 157 }
 158
 159
 160 /**
 161  * gst_thread_new:
 162  * @name: the name of the thread
 163  *
 164  * Create a new thrad with the given name
 165  *
 166  * Returns; The new thread
 167  */
 168 GstElement *gst_thread_new(guchar *name) {
 169   GstThread *thread;
 170
 171   thread = gtk_type_new(gst_thread_get_type());
 172   gst_element_set_name(GST_ELEMENT(thread),name);
 173   return GST_ELEMENT(thread);
 174 }
 175
 176
 177
 178 static GstElementStateReturn gst_thread_change_state(GstElement *element) {
 179   GstThread *thread;
 180   gboolean stateset = TRUE;
 181   gint pending;
 182
 183   g_return_val_if_fail(GST_IS_THREAD(element), FALSE);
 184   thread = GST_THREAD(element);
 185
 186   gst_info("gstthread: thread \"%s\" change state %d\n",
 187                gst_element_get_name(GST_ELEMENT(element)), GST_STATE_PENDING(element));
 188
 189   pending = GST_STATE_PENDING(element);
 190
 191   if (pending == GST_STATE(element)) return GST_STATE_SUCCESS;
 192
 193   if (GST_ELEMENT_CLASS(parent_class)->change_state)
 194     stateset = GST_ELEMENT_CLASS(parent_class)->change_state(element);
 195
 196   gst_info("gstthread: stateset %d %d %d\n", GST_STATE(element), stateset, GST_STATE_PENDING(element));
 197
 198
 199   switch (pending) {
 200     case GST_STATE_READY:
 201       if (!stateset) return FALSE;
 202       // we want to prepare our internal state for doing the iterations
 203       gst_info("gstthread: preparing thread \"%s\" for iterations:\n",
 204                gst_element_get_name(GST_ELEMENT(element)));
 205
 206       // set the state to idle
 207       GST_FLAG_UNSET(thread,GST_THREAD_STATE_SPINNING);
 208       GST_FLAG_UNSET(thread,GST_THREAD_STATE_REAPING);
 209       // create the thread if that's what we're supposed to do
 210       gst_info("gstthread: flags are 0x%08x\n",GST_FLAGS(thread));
 211       if (GST_FLAG_IS_SET(thread,GST_THREAD_CREATE)) {
 212         gst_info("gstthread: starting thread \"%s\"\n",
 213                  gst_element_get_name(GST_ELEMENT(element)));
 214         pthread_create(&thread->thread_id,NULL,
 215                        gst_thread_main_loop,thread);
 216       } else {
 217         gst_info("gstthread: NOT starting thread \"%s\"\n",
 218                 gst_element_get_name(GST_ELEMENT(element)));
 219       }
 220       return GST_STATE_SUCCESS;
 221       break;
 222     case GST_STATE_PLAYING:
 223       if (!stateset) return FALSE;
 224       gst_info("gstthread: starting thread \"%s\"\n",
 225               gst_element_get_name(GST_ELEMENT(element)));
 226       GST_FLAG_SET(thread,GST_THREAD_STATE_SPINNING);
 227       GST_FLAG_UNSET(thread,GST_THREAD_STATE_REAPING);
 228       gst_thread_signal_thread(thread);
 229       break;
 230     case GST_STATE_PAUSED:
 231       gst_info("gstthread: pausing thread \"%s\"\n",
 232               gst_element_get_name(GST_ELEMENT(element)));
 233       GST_FLAG_UNSET(thread,GST_THREAD_STATE_SPINNING);
 234       GST_FLAG_UNSET(thread,GST_THREAD_STATE_REAPING);
 235       gst_thread_signal_thread(thread);
 236       break;
 237     case GST_STATE_NULL:
 238       gst_info("gstthread: stopping thread \"%s\"\n",
 239               gst_element_get_name(GST_ELEMENT(element)));
 240       GST_FLAG_SET(thread,GST_THREAD_STATE_REAPING);
 241       gst_thread_signal_thread(thread);
 242       break;
 243     default:
 244       break;
 245   }
 246
 247   return stateset;
 248 }
 249
 250 /**
 251  * gst_thread_main_loop:
 252  * @arg: the thread to start
 253  *
 254  * The main loop of the thread. The thread will iterate
 255  * while the state is GST_THREAD_STATE_SPINNING
 256  */
 257 static void *gst_thread_main_loop(void *arg) {
 258   GstThread *thread = GST_THREAD(arg);
 259
 260   gst_info("gstthread: thread \"%s\" is running with PID %d\n",
 261                   gst_element_get_name(GST_ELEMENT(thread)), getpid());
 262
 263   if (GST_BIN_CLASS(parent_class)->create_plan)
 264     GST_BIN_CLASS(parent_class)->create_plan(GST_BIN(thread));
 265
 266   while(!GST_FLAG_IS_SET(thread,GST_THREAD_STATE_REAPING)) {
 267     if (GST_FLAG_IS_SET(thread,GST_THREAD_STATE_SPINNING))
 268       gst_bin_iterate(GST_BIN(thread));
 269     else {
 270       g_mutex_lock(thread->lock);
 271       g_cond_wait(thread->cond,thread->lock);
 272       g_mutex_unlock(thread->lock);
 273     }
 274   }
 275
 276   GST_FLAG_UNSET(thread,GST_THREAD_STATE_REAPING);
 277   pthread_join(thread->thread_id,0);
 278
 279   gst_info("gstthread: thread \"%s\" is stopped\n",
 280                   gst_element_get_name(GST_ELEMENT(thread)));
 281   return NULL;
 282 }
 283
 284 static void gst_thread_signal_thread(GstThread *thread) {
 285   g_mutex_lock(thread->lock);
 286   g_cond_signal(thread->cond);
 287   g_mutex_unlock(thread->lock);
 288 }
 289
 290 static void gst_thread_restore_thyself(GstElement *element,xmlNodePtr parent, GHashTable *elements) {
 291
 292   g_print("gstthread: restore\n");
 293
 294   if (GST_ELEMENT_CLASS(parent_class)->restore_thyself)
 295     GST_ELEMENT_CLASS(parent_class)->restore_thyself(element,parent, elements);
 296 }
 297
 298 static xmlNodePtr gst_thread_save_thyself(GstElement *element,xmlNodePtr parent) {
 299
 300   if (GST_ELEMENT_CLASS(parent_class)->save_thyself)
 301     GST_ELEMENT_CLASS(parent_class)->save_thyself(element,parent);
 302   return NULL;
 303 }