/**
* gst_task_pool_join:
* @pool: a #GstTaskPool
* @id: the id
*
* Join a task and/or return it to the pool. @id is the id obtained from
* gst_task_pool_push().
*/
void
gst_task_pool_join (GstTaskPool * pool, gpointer id)
{
GstTaskPoolClass *klass;
g_return_if_fail (GST_IS_TASK_POOL (pool));
klass = GST_TASK_POOL_GET_CLASS (pool);
if (klass->join)
klass->join (pool, id);
}
/**
* gst_task_pool_cleanup:
* @pool: a #GstTaskPool
*
* Wait for all tasks to be stopped. This is mainly used internally
* to ensure proper cleanup of internal data structures in test suites.
*
* MT safe.
*/
void
gst_task_pool_cleanup (GstTaskPool * pool)
{
GstTaskPoolClass *klass;
g_return_if_fail (GST_IS_TASK_POOL (pool));
klass = GST_TASK_POOL_GET_CLASS (pool);
if (klass->cleanup)
klass->cleanup (pool);
}
/**
* gst_task_pool_prepare:
* @pool: a #GstTaskPool
* @error: an error return location
*
* Prepare the taskpool for accepting gst_task_pool_push() operations.
*
* MT safe.
*/
void
gst_task_pool_prepare (GstTaskPool * pool, GError ** error)
{
GstTaskPoolClass *klass;
g_return_if_fail (GST_IS_TASK_POOL (pool));
klass = GST_TASK_POOL_GET_CLASS (pool);
if (klass->prepare)
klass->prepare (pool, error);
}
GMainContext *
gst_task_pool_get_schedule_context (GstTaskPool * pool)
{
GMainContext *context;
g_return_val_if_fail (GST_IS_TASK_POOL (pool), NULL);
g_return_val_if_fail (pool->priv->need_schedule_thread > 0, NULL);
g_mutex_lock (&pool->priv->schedule_lock);
context = pool->priv->schedule_context;
if (context)
g_main_context_ref (context);
g_mutex_unlock (&pool->priv->schedule_lock);
return context;
}
gboolean
gst_task_pool_need_schedule_thread (GstTaskPool * pool, gboolean needed)
{
gboolean ret;
g_return_val_if_fail (GST_IS_TASK_POOL (pool), FALSE);
g_return_val_if_fail (needed || pool->priv->need_schedule_thread > 0, FALSE);
/* We don't allow this for the default pool */
if (pool == gst_task_pool_get_default ()) {
gst_object_unref (pool);
return FALSE;
}
g_mutex_lock (&pool->priv->schedule_lock);
if (needed) {
ret = TRUE;
if (pool->priv->need_schedule_thread == 0) {
pool->priv->schedule_context = g_main_context_new ();
pool->priv->schedule_loop =
g_main_loop_new (pool->priv->schedule_context, FALSE);
pool->priv->schedule_thread =
g_thread_new (GST_OBJECT_NAME (pool), gst_task_pool_schedule_func,
pool);
g_cond_wait (&pool->priv->schedule_cond, &pool->priv->schedule_lock);
}
pool->priv->need_schedule_thread++;
} else {
ret = FALSE;
pool->priv->need_schedule_thread--;
if (pool->priv->need_schedule_thread == 0) {
g_main_loop_quit (pool->priv->schedule_loop);
g_thread_join (pool->priv->schedule_thread);
g_main_loop_unref (pool->priv->schedule_loop);
pool->priv->schedule_loop = NULL;
g_main_context_unref (pool->priv->schedule_context);
pool->priv->schedule_context = NULL;
pool->priv->schedule_thread = NULL;
}
}
g_mutex_unlock (&pool->priv->schedule_lock);
return ret;
}
/**
* gst_task_pool_push:
* @pool: a #GstTaskPool
* @func: (scope async): the function to call
* @user_data: (closure): data to pass to @func
* @error: return location for an error
*
* Start the execution of a new thread from @pool.
*
* Returns: (transfer none) (nullable): a pointer that should be used
* for the gst_task_pool_join function. This pointer can be %NULL, you
* must check @error to detect errors.
*/
gpointer
gst_task_pool_push (GstTaskPool * pool, GstTaskPoolFunction func,
gpointer user_data, GError ** error)
{
GstTaskPoolClass *klass;
g_return_val_if_fail (GST_IS_TASK_POOL (pool), NULL);
klass = GST_TASK_POOL_GET_CLASS (pool);
if (klass->push == NULL)
goto not_supported;
return klass->push (pool, func, user_data, error);
/* ERRORS */
not_supported:
{
g_warning ("pushing tasks on pool %p is not supported", pool);
return NULL;
}
}
/**
* gst_task_set_pool:
* @task: a #GstTask
* @pool: a #GstTaskPool
*
* Set @pool as the new GstTaskPool for @task. Any new streaming threads that
* will be created by @task will now use @pool.
*
* MT safe.
*
* Since: 0.10.24
*/
void
gst_task_set_pool (GstTask * task, GstTaskPool * pool)
{
GstTaskPool *old;
GstTaskPrivate *priv;
g_return_if_fail (GST_IS_TASK (task));
g_return_if_fail (GST_IS_TASK_POOL (pool));
priv = task->priv;
GST_OBJECT_LOCK (task);
if (priv->pool != pool) {
old = priv->pool;
priv->pool = gst_object_ref (pool);
} else
old = NULL;
GST_OBJECT_UNLOCK (task);
if (old)
gst_object_unref (old);
}
