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.TaskPoolFunction

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

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