GstTaskPool

Gst.SharedTaskPool

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──Gst.Object
            ╰──Gst.TaskPool
                ╰──Gst.SharedTaskPool

since : 1.20

Gst.SharedTaskPool.prototype.new

function Gst.SharedTaskPool.prototype.new(): {
    // javascript wrapper for 'gst_shared_task_pool_new'
}

Create a new shared task pool. The shared task pool will queue tasks on a maximum number of threads, 1 by default.

Do not use a Gst.SharedTaskPool to manage potentially inter-dependent tasks such as pad tasks, as having one task waiting on another to return before returning would cause obvious deadlocks if they happen to share the same thread.

Since : 1.20

Gst.SharedTaskPool.prototype.get_max_threads

function Gst.SharedTaskPool.prototype.get_max_threads(): {
    // javascript wrapper for 'gst_shared_task_pool_get_max_threads'
}

Since : 1.20

Gst.SharedTaskPool.prototype.set_max_threads

function Gst.SharedTaskPool.prototype.set_max_threads(max_threads: Number): {
    // javascript wrapper for 'gst_shared_task_pool_set_max_threads'
}

Update the maximal number of threads the pool may spawn. When the maximal number of threads is reduced, existing threads are not immediately shut down, see GLib.ThreadPool.prototype.set_max_threads.

Setting max_threads to 0 effectively freezes the pool.

Since : 1.20

Gst.TaskPool

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──Gst.Object
            ╰──Gst.TaskPool
                ╰──Gst.SharedTaskPool

Gst.TaskPool.prototype.new

function Gst.TaskPool.prototype.new(): {
    // javascript wrapper for 'gst_task_pool_new'
}

Create a new default task pool. The default task pool will use a regular GThreadPool for threads.

Gst.TaskPool.prototype.cleanup

function Gst.TaskPool.prototype.cleanup(): {
    // javascript wrapper for 'gst_task_pool_cleanup'
}

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.

Gst.TaskPool.prototype.dispose_handle

function Gst.TaskPool.prototype.dispose_handle(id: Object): {
    // javascript wrapper for 'gst_task_pool_dispose_handle'
}

Dispose of the handle returned by Gst.TaskPool.prototype.push. This does not need to be called with the default implementation as the default vfunc_push implementation always returns null. This does not need to be called either when calling Gst.TaskPool.prototype.join, but should be called when joining is not necessary, but Gst.TaskPool.prototype.push returned a non-%NULL value.

This method should only be called with the same pool instance that provided id.

Since : 1.20

Gst.TaskPool.prototype.join

function Gst.TaskPool.prototype.join(id: Object): {
    // javascript wrapper for 'gst_task_pool_join'
}

Join a task and/or return it to the pool. id is the id obtained from Gst.TaskPool.prototype.push. The default implementation does nothing, as the default vfunc_push implementation always returns null.

This method should only be called with the same pool instance that provided id.

Gst.TaskPool.prototype.prepare

function Gst.TaskPool.prototype.prepare(): {
    // javascript wrapper for 'gst_task_pool_prepare'
}

Prepare the taskpool for accepting Gst.TaskPool.prototype.push operations.

MT safe.

Gst.TaskPool.prototype.push

function Gst.TaskPool.prototype.push(func: Gst.TaskPoolFunction, user_data: Object): {
    // javascript wrapper for 'gst_task_pool_push'
}

Start the execution of a new thread from pool.

vfunc_cleanup

function vfunc_cleanup(pool: Gst.TaskPool): {
    // javascript implementation of the 'cleanup' virtual method
}

make sure all threads are stopped

vfunc_dispose_handle

function vfunc_dispose_handle(pool: Gst.TaskPool, id: Object): {
    // javascript implementation of the 'dispose_handle' virtual method
}

free / unref the handle returned in GstTaskPoolClass::push.

Since : 1.20

vfunc_join

function vfunc_join(pool: Gst.TaskPool, id: Object): {
    // javascript implementation of the 'join' virtual method
}

join a thread

vfunc_prepare

function vfunc_prepare(pool: Gst.TaskPool): {
    // javascript implementation of the 'prepare' virtual method
}

prepare the threadpool

vfunc_push

function vfunc_push(pool: Gst.TaskPool, func: Gst.TaskPoolFunction, user_data: Object): {
    // javascript implementation of the 'push' virtual method
}

start a new thread

Gst.TASK_POOL_CONTEXT_TYPE

The well-known context type for sharing a Gst.TaskPool between elements in a pipeline.

Elements that support this context will post a Gst.MessageType.NEED_CONTEXT message on the bus when they need a task pool. Applications can respond by setting the context on the element or the pipeline. Elements will not query neighbors for this context type as the task pool is optional and elements will fall back to their default behavior if no pool is provided.

Since : 1.28

Gst.TaskPoolFunction

function Gst.TaskPoolFunction(user_data: Object): {
    // javascript wrapper for 'GstTaskPoolFunction'
}

Task function, see Gst.TaskPool.prototype.push.