Accept a signal from the event thread issued with * pa_threaded_mainloop_signal(). This call should only be used in * conjunction with pa_threaded_mainloop_signal() with a non-zero * wait_for_accept value.
Free a threaded main loop object. If the event loop thread is * still running, terminate it with pa_threaded_mainloop_stop() * first.
Return the main loop abstraction layer vtable for this main loop. * There is no need to free this object as it is owned by the loop * and is destroyed when the loop is freed.
Return the return value as specified with the main loop's * pa_mainloop_quit() routine.
Returns non-zero when called from within the event loop thread. \since 0.9.7
Lock the event loop object, effectively blocking the event loop * thread from processing events. You can use this to enforce * exclusive access to all objects attached to the event loop. This * lock is recursive. This function may not be called inside the event * loop thread. Events that are dispatched from the event loop thread * are executed with this lock held.
Allocate a new threaded main loop object. You have to call * pa_threaded_mainloop_start() before the event loop thread starts * running. Free with pa_threaded_mainloop_free.
Runs the given callback in the mainloop thread without the lock held. The * caller is responsible for ensuring that PulseAudio data structures are only * accessed in a thread-safe way (that is, APIs that take pa_context and * pa_stream are not thread-safe, and should not accessed without some * synchronisation). This is the only situation in which * pa_threaded_mainloop_lock() and pa_threaded_mainloop_unlock() may be used * in the mainloop thread context. \since 13.0
Sets the name of the thread. \since 5.0
Signal all threads waiting for a signalling event in * pa_threaded_mainloop_wait(). If wait_for_accept is non-zero, do * not return before the signal was accepted by a * pa_threaded_mainloop_accept() call. While waiting for that condition * the event loop object is unlocked.
Start the event loop thread. Returns zero on success, negative on error.
Terminate the event loop thread cleanly. Make sure to unlock the * mainloop object before calling this function.
Unlock the event loop object, inverse of pa_threaded_mainloop_lock().
Wait for an event to be signalled by the event loop thread. You * can use this to pass data from the event loop thread to the main * thread in a synchronized fashion. This function may not be called * inside the event loop thread. Prior to this call the event loop * object needs to be locked using pa_threaded_mainloop_lock(). While * waiting the lock will be released. Immediately before returning it * will be acquired again. This function may spuriously wake up even * without pa_threaded_mainloop_signal() being called. You need to * make sure to handle that!
An opaque threaded main loop object