GstTask

typedef struct {
  GstTaskState     state;
  GCond 	  *cond;

  GStaticRecMutex *lock;

  GstTaskFunction  func;
  gpointer 	   data;

  gboolean	   running;
} GstTask;

The GstTask object.

GstTaskFunction ()

void        (*GstTaskFunction)              (void *data);

A function that will repeadedly be called in the thread created by a GstTask.

enum GstTaskState

typedef enum {
  GST_TASK_STARTED,
  GST_TASK_STOPPED,
  GST_TASK_PAUSED,
} GstTaskState;

The different states a task can be in

GST_TASK_BROADCAST()

#define GST_TASK_BROADCAST(task)	g_cond_breadcast(GST_TASK_GET_COND (task))

Send a broadcast signal to all waiting task conds

GST_TASK_GET_COND()

#define GST_TASK_GET_COND(task)		(GST_TASK_CAST(task)->cond)

Get access to the cond of the task.

GST_TASK_GET_LOCK()

#define GST_TASK_GET_LOCK(task)		(GST_TASK_CAST(task)->lock)

Get access to the task lock.

GST_TASK_SIGNAL()

#define GST_TASK_SIGNAL(task)		g_cond_signal(GST_TASK_GET_COND (task))

Signal the task cond

GST_TASK_STATE()

#define GST_TASK_STATE(task)		(GST_TASK_CAST(task)->state)

Get access to the state of the task.

GST_TASK_WAIT()

#define GST_TASK_WAIT(task)		g_cond_wait(GST_TASK_GET_COND (task), GST_OBJECT_GET_LOCK (task))

Wait for the task cond to be signalled

gst_task_cleanup_all ()

void        gst_task_cleanup_all            (void);

Wait for all tasks to be stopped. This is mainly used internally to ensure proper cleanup of internal datastructures in testsuites.

MT safe.

gst_task_create ()

GstTask*    gst_task_create                 (GstTaskFunction func,
                                             gpointer data);

Create a new Task that will repeadedly call the provided func with data as a parameter. Typically the task will run in a new thread.

gst_task_get_state ()

GstTaskState gst_task_get_state             (GstTask *task);

Get the current state of the task.

gst_task_join ()

gboolean    gst_task_join                   (GstTask *task);

Joins task. After this call, it is safe to unref the task and clean up the lock set with gst_task_set_lock().

The task will automatically be stopped with this call.

This function cannot be called from within a task function as this will cause a deadlock.

gst_task_pause ()

gboolean    gst_task_pause                  (GstTask *task);

Pauses task. This method can also be called on a task in the stopped state, in which case a thread will be started and will remain in the paused state. This function does not wait for the task to complete the paused state.

gst_task_set_lock ()

void        gst_task_set_lock               (GstTask *task,
                                             GStaticRecMutex *mutex);

Set the mutex used by the task. The mutex will be acquired before calling the GstTaskFunction.

This function has to be called before calling gst_task_pause() or gst_task_start().

MT safe.

gst_task_start ()

gboolean    gst_task_start                  (GstTask *task);

Starts task. The task must have a lock associated with it using gst_task_set_lock() or thsi function will return FALSE.

gst_task_stop ()

gboolean    gst_task_stop                   (GstTask *task);

Stops task. This method merely schedules the task to stop and will not wait for the task to have completely stopped. Use gst_task_join() to stop and wait for completion.