PipeWire: spa/support/loop.h Source File

PipeWire 1.6.6

Loading...
Searching...
No Matches
loop.h
Go to the documentation of this file.
1/* Simple Plugin API */
2/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
3/* SPDX-License-Identifier: MIT */
4
5#ifndef SPA_LOOP_H
6#define SPA_LOOP_H
7
8#include <errno.h>
9
10#include <spa/utils/defs.h>
11#include <spa/utils/hook.h>
12#include <spa/support/system.h>
13
14#ifdef __cplusplus
15extern "C" {
16#endif
17
18#ifndef SPA_API_LOOP
19 #ifdef SPA_API_IMPL
20 #define SPA_API_LOOP SPA_API_IMPL
21 #else
22 #define SPA_API_LOOP static inline
23 #endif
24#endif
25
29
34
35#define SPA_TYPE_INTERFACE_Loop SPA_TYPE_INFO_INTERFACE_BASE "Loop"
36#define SPA_TYPE_INTERFACE_DataLoop SPA_TYPE_INFO_INTERFACE_BASE "DataLoop"
37#define SPA_VERSION_LOOP 0
38struct spa_loop { struct spa_interface iface; };
39
40#define SPA_TYPE_INTERFACE_LoopControl SPA_TYPE_INFO_INTERFACE_BASE "LoopControl"
41#define SPA_VERSION_LOOP_CONTROL 2
42struct spa_loop_control { struct spa_interface iface; };
43
44#define SPA_TYPE_INTERFACE_LoopUtils SPA_TYPE_INFO_INTERFACE_BASE "LoopUtils"
45#define SPA_VERSION_LOOP_UTILS 0
46struct spa_loop_utils { struct spa_interface iface; };
47
48 struct spa_source;
49
50typedef void (*spa_source_func_t) (struct spa_source *source);
51
52struct spa_source {
53 struct spa_loop *loop;
54 spa_source_func_t func;
55 void *data;
56 int fd;
57 uint32_t mask;
58 uint32_t rmask;
59 /* private data for the loop implementer */
60 void *priv;
61};
62
63typedef int (*spa_invoke_func_t) (struct spa_loop *loop,
64 bool async,
65 uint32_t seq,
66 const void *data,
67 size_t size,
68 void *user_data);
69
73 struct spa_loop_methods {
74 /* the version of this structure. This can be used to expand this
75 * structure in the future */
76#define SPA_VERSION_LOOP_METHODS 0
77 uint32_t version;
78
85 int (*add_source) (void *object,
86 struct spa_source *source);
87
88 /** Update the source io mask. Must be called from the loop's own thread.
89 *
90 * \param[in] object The callbacks data.
91 * \param[in] source The source.
92 * \return 0 on success, negative errno-style value on failure.
93 */
94 int (*update_source) (void *object,
95 struct spa_source *source);
96
103 int (*remove_source) (void *object,
104 struct spa_source *source);
105
133 int (*invoke) (void *object,
134 spa_invoke_func_t func,
135 uint32_t seq,
136 const void *data,
137 size_t size,
138 bool block,
139 void *user_data);
140
152 int (*locked) (void *object,
153 spa_invoke_func_t func,
154 uint32_t seq,
155 const void *data,
156 size_t size,
157 void *user_data);
158};
159
160 SPA_API_LOOP int spa_loop_add_source(struct spa_loop *object, struct spa_source *source)
161{
162 return spa_api_method_r(int, -ENOTSUP,
163 spa_loop, &object->iface, add_source, 0, source);
164}
165 SPA_API_LOOP int spa_loop_update_source(struct spa_loop *object, struct spa_source *source)
166{
167 return spa_api_method_r(int, -ENOTSUP,
168 spa_loop, &object->iface, update_source, 0, source);
169}
170 SPA_API_LOOP int spa_loop_remove_source(struct spa_loop *object, struct spa_source *source)
171{
172 return spa_api_method_r(int, -ENOTSUP,
173 spa_loop, &object->iface, remove_source, 0, source);
174}
175 SPA_API_LOOP int spa_loop_invoke(struct spa_loop *object,
176 spa_invoke_func_t func, uint32_t seq, const void *data,
177 size_t size, bool block, void *user_data)
178{
179 return spa_api_method_r(int, -ENOTSUP,
180 spa_loop, &object->iface, invoke, 0, func, seq, data,
181 size, block, user_data);
182}
183 SPA_API_LOOP int spa_loop_locked(struct spa_loop *object,
184 spa_invoke_func_t func, uint32_t seq, const void *data,
185 size_t size, void *user_data)
186{
187 return spa_api_method_r(int, -ENOTSUP,
188 spa_loop, &object->iface, locked, 0, func, seq, data,
189 size, user_data);
190}
191
192
196struct spa_loop_control_hooks {
197#define SPA_VERSION_LOOP_CONTROL_HOOKS 0
198 uint32_t version;
199
199 /** Executed right before waiting for events. It is typically used to
200 * release locks or integrate other fds into the loop. */
201 void (*before) (void *data);
204 void (*after) (void *data);
205};
206
207 SPA_API_LOOP void spa_loop_control_hook_before(struct spa_hook_list *l)
208{
209 struct spa_hook *h;
210 spa_list_for_each_reverse(h, &l->list, link)
211 spa_callbacks_call_fast(&h->cb, struct spa_loop_control_hooks, before, 0);
212}
213
214 SPA_API_LOOP void spa_loop_control_hook_after(struct spa_hook_list *l)
215{
216 struct spa_hook *h;
217 spa_list_for_each(h, &l->list, link)
218 spa_callbacks_call_fast(&h->cb, struct spa_loop_control_hooks, after, 0);
219}
220
223
224 * The event loop control function provide API to run the event loop.
225 *
226 * The below (pseudo)code is a minimal example outlining the use of the loop
227 * control:
228 * \code{.c}
229 * spa_loop_control_enter(loop);
230 * while (running) {
231 * spa_loop_control_iterate(loop, -1);
232 * }
233 * spa_loop_control_leave(loop);
234 * \endcode
235 *
236 * It is also possible to add the loop to an existing event loop by using the
237 * spa_loop_control_get_fd() call. This fd will become readable when activity
238 * has been detected on the sources in the loop. spa_loop_control_iterate() with
239 * a 0 timeout should be called to process the pending sources.
240 *
241 * spa_loop_control_enter() and spa_loop_control_leave() should be called once
242 * from the thread that will run the iterate() function.
243 */
244struct spa_loop_control_methods {
245 /* the version of this structure. This can be used to expand this
246 * structure in the future */
247#define SPA_VERSION_LOOP_CONTROL_METHODS 2
248 uint32_t version;
249
259 int (*get_fd) (void *object);
260
261 /** Add a hook
262 * \param object the control to change
263 * \param hooks the hooks to add
264 *
265 * Adds hooks to the loop controlled by \a ctrl.
266 */
267 void (*add_hook) (void *object,
268 struct spa_hook *hook,
269 const struct spa_loop_control_hooks *hooks,
270 void *data);
271
280 void (*enter) (void *object);
289 void (*leave) (void *object);
290
302 int (*iterate) (void *object, int timeout);
303
312 int (*check) (void *object);
313
321 int (*lock) (void *object);
322
330 int (*unlock) (void *object);
331
338 int (*get_time) (void *object, struct timespec *abstime, int64_t timeout);
339
350 int (*wait) (void *object, const struct timespec *abstime);
351
365 int (*signal) (void *object, bool wait_for_accept);
366
376 int (*accept) (void *object);
377};
378
379 SPA_API_LOOP int spa_loop_control_get_fd(struct spa_loop_control *object)
380{
381 return spa_api_method_r(int, -ENOTSUP,
382 spa_loop_control, &object->iface, get_fd, 0);
383}
384 SPA_API_LOOP void spa_loop_control_add_hook(struct spa_loop_control *object,
385 struct spa_hook *hook, const struct spa_loop_control_hooks *hooks,
386 void *data)
387{
388 spa_api_method_v(spa_loop_control, &object->iface, add_hook, 0,
389 hook, hooks, data);
390}
391 SPA_API_LOOP void spa_loop_control_enter(struct spa_loop_control *object)
392{
393 spa_api_method_v(spa_loop_control, &object->iface, enter, 0);
394}
395 SPA_API_LOOP void spa_loop_control_leave(struct spa_loop_control *object)
396{
397 spa_api_method_v(spa_loop_control, &object->iface, leave, 0);
398}
399 SPA_API_LOOP int spa_loop_control_iterate(struct spa_loop_control *object,
400 int timeout)
401{
402 return spa_api_method_r(int, -ENOTSUP,
403 spa_loop_control, &object->iface, iterate, 0, timeout);
404}
405 SPA_API_LOOP int spa_loop_control_iterate_fast(struct spa_loop_control *object,
406 int timeout)
407{
408 return spa_api_method_fast_r(int, -ENOTSUP,
409 spa_loop_control, &object->iface, iterate, 0, timeout);
410}
411 SPA_API_LOOP int spa_loop_control_check(struct spa_loop_control *object)
412{
413 return spa_api_method_r(int, -ENOTSUP,
414 spa_loop_control, &object->iface, check, 1);
415}
416 SPA_API_LOOP int spa_loop_control_lock(struct spa_loop_control *object)
417{
418 return spa_api_method_r(int, -ENOTSUP,
419 spa_loop_control, &object->iface, lock, 2);
420}
421 SPA_API_LOOP int spa_loop_control_unlock(struct spa_loop_control *object)
422{
423 return spa_api_method_r(int, -ENOTSUP,
424 spa_loop_control, &object->iface, unlock, 2);
425}
426 SPA_API_LOOP int spa_loop_control_get_time(struct spa_loop_control *object,
427 struct timespec *abstime, int64_t timeout)
428{
429 return spa_api_method_r(int, -ENOTSUP,
430 spa_loop_control, &object->iface, get_time, 2, abstime, timeout);
431}
432 SPA_API_LOOP int spa_loop_control_wait(struct spa_loop_control *object,
433 const struct timespec *abstime)
434{
435 return spa_api_method_r(int, -ENOTSUP,
436 spa_loop_control, &object->iface, wait, 2, abstime);
437}
438 SPA_API_LOOP int spa_loop_control_signal(struct spa_loop_control *object, bool wait_for_accept)
439{
440 return spa_api_method_r(int, -ENOTSUP,
441 spa_loop_control, &object->iface, signal, 2, wait_for_accept);
442}
443 SPA_API_LOOP int spa_loop_control_accept(struct spa_loop_control *object)
444{
445 return spa_api_method_r(int, -ENOTSUP,
446 spa_loop_control, &object->iface, accept, 2);
447}
448
449typedef void (*spa_source_io_func_t) (void *data, int fd, uint32_t mask);
450 typedef void (*spa_source_idle_func_t) (void *data);
451typedef void (*spa_source_event_func_t) (void *data, uint64_t count);
452typedef void (*spa_source_timer_func_t) (void *data, uint64_t expirations);
453typedef void (*spa_source_signal_func_t) (void *data, int signal_number);
454
456
456 * Create sources for an event loop
457 */
458struct spa_loop_utils_methods {
459 /* the version of this structure. This can be used to expand this
460 * structure in the future */
461#define SPA_VERSION_LOOP_UTILS_METHODS 0
462 uint32_t version;
463
464 struct spa_source *(*add_io) (void *object,
465 int fd,
466 uint32_t mask,
467 bool close,
468 spa_source_io_func_t func, void *data);
469
470 int (*update_io) (void *object, struct spa_source *source, uint32_t mask);
471
472 struct spa_source *(*add_idle) (void *object,
473 bool enabled,
474 spa_source_idle_func_t func, void *data);
475 int (*enable_idle) (void *object, struct spa_source *source, bool enabled);
476
477 struct spa_source *(*add_event) (void *object,
478 spa_source_event_func_t func, void *data);
479 int (*signal_event) (void *object, struct spa_source *source);
480
481 struct spa_source *(*add_timer) (void *object,
482 spa_source_timer_func_t func, void *data);
483 int (*update_timer) (void *object,
484 struct spa_source *source,
485 struct timespec *value,
486 struct timespec *interval,
487 bool absolute);
488 struct spa_source *(*add_signal) (void *object,
489 int signal_number,
490 spa_source_signal_func_t func, void *data);
491
495 void (*destroy_source) (void *object, struct spa_source *source);
496};
497
498 SPA_API_LOOP struct spa_source *
499 spa_loop_utils_add_io(struct spa_loop_utils *object, int fd, uint32_t mask,
500 bool close, spa_source_io_func_t func, void *data)
501{
502 return spa_api_method_r(struct spa_source *, NULL,
503 spa_loop_utils, &object->iface, add_io, 0, fd, mask, close, func, data);
504}
505 SPA_API_LOOP int spa_loop_utils_update_io(struct spa_loop_utils *object,
506 struct spa_source *source, uint32_t mask)
507{
508 return spa_api_method_r(int, -ENOTSUP,
509 spa_loop_utils, &object->iface, update_io, 0, source, mask);
510}
511 SPA_API_LOOP struct spa_source *
512 spa_loop_utils_add_idle(struct spa_loop_utils *object, bool enabled,
513 spa_source_idle_func_t func, void *data)
514{
515 return spa_api_method_r(struct spa_source *, NULL,
516 spa_loop_utils, &object->iface, add_idle, 0, enabled, func, data);
517}
518 SPA_API_LOOP int spa_loop_utils_enable_idle(struct spa_loop_utils *object,
519 struct spa_source *source, bool enabled)
520{
521 return spa_api_method_r(int, -ENOTSUP,
522 spa_loop_utils, &object->iface, enable_idle, 0, source, enabled);
523}
524 SPA_API_LOOP struct spa_source *
525 spa_loop_utils_add_event(struct spa_loop_utils *object, spa_source_event_func_t func, void *data)
526{
527 return spa_api_method_r(struct spa_source *, NULL,
528 spa_loop_utils, &object->iface, add_event, 0, func, data);
529}
530 SPA_API_LOOP int spa_loop_utils_signal_event(struct spa_loop_utils *object,
531 struct spa_source *source)
532{
533 return spa_api_method_r(int, -ENOTSUP,
534 spa_loop_utils, &object->iface, signal_event, 0, source);
535}
536 SPA_API_LOOP struct spa_source *
537 spa_loop_utils_add_timer(struct spa_loop_utils *object, spa_source_timer_func_t func, void *data)
538{
539 return spa_api_method_r(struct spa_source *, NULL,
540 spa_loop_utils, &object->iface, add_timer, 0, func, data);
541}
542 SPA_API_LOOP int spa_loop_utils_update_timer(struct spa_loop_utils *object,
543 struct spa_source *source, struct timespec *value,
544 struct timespec *interval, bool absolute)
545{
546 return spa_api_method_r(int, -ENOTSUP,
547 spa_loop_utils, &object->iface, update_timer, 0, source,
548 value, interval, absolute);
549}
550 SPA_API_LOOP struct spa_source *
551 spa_loop_utils_add_signal(struct spa_loop_utils *object, int signal_number,
552 spa_source_signal_func_t func, void *data)
553{
554 return spa_api_method_r(struct spa_source *, NULL,
555 spa_loop_utils, &object->iface, add_signal, 0,
556 signal_number, func, data);
557}
558 SPA_API_LOOP void spa_loop_utils_destroy_source(struct spa_loop_utils *object,
559 struct spa_source *source)
560{
561 spa_api_method_v(spa_loop_utils, &object->iface, destroy_source, 0, source);
562}
563
567
568#ifdef __cplusplus
569} /* extern "C" */
570#endif
571
572#endif /* SPA_LOOP_H */
defs.h
spa/utils/defs.h
seq
uint32_t int seq
Definition core.h:432
spa_api_method_r
#define spa_api_method_r(rtype, def, type, o, method, version,...)
Definition hook.h:291
spa_api_method_fast_r
#define spa_api_method_fast_r(rtype, def, type, o, method, version,...)
Definition hook.h:325
spa_callbacks_call_fast
#define spa_callbacks_call_fast(callbacks, type, method, vers,...)
Definition hook.h:184
spa_api_method_v
#define spa_api_method_v(type, o, method, version,...)
Definition hook.h:285
spa_list_for_each_reverse
#define spa_list_for_each_reverse(pos, head, member)
Definition list.h:122
spa_list_for_each
#define spa_list_for_each(pos, head, member)
Definition list.h:119
spa_loop_invoke
SPA_API_LOOP int spa_loop_invoke(struct spa_loop *object, spa_invoke_func_t func, uint32_t seq, const void *data, size_t size, bool block, void *user_data)
Definition loop.h:191
spa_loop_control_hook_before
SPA_API_LOOP void spa_loop_control_hook_before(struct spa_hook_list *l)
Definition loop.h:224
spa_loop_utils_add_idle
SPA_API_LOOP struct spa_source * spa_loop_utils_add_idle(struct spa_loop_utils *object, bool enabled, spa_source_idle_func_t func, void *data)
Definition loop.h:531
spa_loop_utils_add_signal
SPA_API_LOOP struct spa_source * spa_loop_utils_add_signal(struct spa_loop_utils *object, int signal_number, spa_source_signal_func_t func, void *data)
Definition loop.h:570
spa_loop_control_accept
SPA_API_LOOP int spa_loop_control_accept(struct spa_loop_control *object)
Definition loop.h:461
spa_loop_add_source
SPA_API_LOOP int spa_loop_add_source(struct spa_loop *object, struct spa_source *source)
Definition loop.h:176
spa_source_timer_func_t
void(* spa_source_timer_func_t)(void *data, uint64_t expirations)
Definition loop.h:470
spa_loop_utils_add_timer
SPA_API_LOOP struct spa_source * spa_loop_utils_add_timer(struct spa_loop_utils *object, spa_source_timer_func_t func, void *data)
Definition loop.h:556
spa_loop_control_get_fd
SPA_API_LOOP int spa_loop_control_get_fd(struct spa_loop_control *object)
Definition loop.h:397
spa_loop_control_enter
SPA_API_LOOP void spa_loop_control_enter(struct spa_loop_control *object)
Definition loop.h:409
spa_loop_control_signal
SPA_API_LOOP int spa_loop_control_signal(struct spa_loop_control *object, bool wait_for_accept)
Definition loop.h:456
spa_loop_remove_source
SPA_API_LOOP int spa_loop_remove_source(struct spa_loop *object, struct spa_source *source)
Definition loop.h:186
spa_loop_utils_update_timer
SPA_API_LOOP int spa_loop_utils_update_timer(struct spa_loop_utils *object, struct spa_source *source, struct timespec *value, struct timespec *interval, bool absolute)
Definition loop.h:561
spa_loop_utils_enable_idle
SPA_API_LOOP int spa_loop_utils_enable_idle(struct spa_loop_utils *object, struct spa_source *source, bool enabled)
Definition loop.h:537
spa_source_event_func_t
void(* spa_source_event_func_t)(void *data, uint64_t count)
Definition loop.h:469
spa_source_signal_func_t
void(* spa_source_signal_func_t)(void *data, int signal_number)
Definition loop.h:471
spa_loop_control_iterate_fast
SPA_API_LOOP int spa_loop_control_iterate_fast(struct spa_loop_control *object, int timeout)
Definition loop.h:423
spa_loop_control_add_hook
SPA_API_LOOP void spa_loop_control_add_hook(struct spa_loop_control *object, struct spa_hook *hook, const struct spa_loop_control_hooks *hooks, void *data)
Definition loop.h:402
spa_loop_control_wait
SPA_API_LOOP int spa_loop_control_wait(struct spa_loop_control *object, const struct timespec *abstime)
Definition loop.h:450
spa_source_idle_func_t
void(* spa_source_idle_func_t)(void *data)
Definition loop.h:468
spa_loop_control_iterate
SPA_API_LOOP int spa_loop_control_iterate(struct spa_loop_control *object, int timeout)
Definition loop.h:417
spa_loop_control_unlock
SPA_API_LOOP int spa_loop_control_unlock(struct spa_loop_control *object)
Definition loop.h:439
spa_loop_utils_destroy_source
SPA_API_LOOP void spa_loop_utils_destroy_source(struct spa_loop_utils *object, struct spa_source *source)
Definition loop.h:577
spa_source_func_t
void(* spa_source_func_t)(struct spa_source *source)
Definition loop.h:65
spa_loop_control_check
SPA_API_LOOP int spa_loop_control_check(struct spa_loop_control *object)
Definition loop.h:429
spa_loop_control_hook_after
SPA_API_LOOP void spa_loop_control_hook_after(struct spa_hook_list *l)
Definition loop.h:231
spa_loop_utils_add_event
SPA_API_LOOP struct spa_source * spa_loop_utils_add_event(struct spa_loop_utils *object, spa_source_event_func_t func, void *data)
Definition loop.h:544
spa_loop_control_get_time
SPA_API_LOOP int spa_loop_control_get_time(struct spa_loop_control *object, struct timespec *abstime, int64_t timeout)
Definition loop.h:444
spa_invoke_func_t
int(* spa_invoke_func_t)(struct spa_loop *loop, bool async, uint32_t seq, const void *data, size_t size, void *user_data)
Definition loop.h:78
spa_source_io_func_t
void(* spa_source_io_func_t)(void *data, int fd, uint32_t mask)
Definition loop.h:467
spa_loop_control_lock
SPA_API_LOOP int spa_loop_control_lock(struct spa_loop_control *object)
Definition loop.h:434
spa_loop_utils_signal_event
SPA_API_LOOP int spa_loop_utils_signal_event(struct spa_loop_utils *object, struct spa_source *source)
Definition loop.h:549
spa_loop_utils_update_io
SPA_API_LOOP int spa_loop_utils_update_io(struct spa_loop_utils *object, struct spa_source *source, uint32_t mask)
Definition loop.h:524
spa_loop_control_leave
SPA_API_LOOP void spa_loop_control_leave(struct spa_loop_control *object)
Definition loop.h:413
spa_loop_locked
SPA_API_LOOP int spa_loop_locked(struct spa_loop *object, spa_invoke_func_t func, uint32_t seq, const void *data, size_t size, void *user_data)
Definition loop.h:199
spa_loop_update_source
SPA_API_LOOP int spa_loop_update_source(struct spa_loop *object, struct spa_source *source)
Definition loop.h:181
spa_loop_utils_add_io
SPA_API_LOOP struct spa_source * spa_loop_utils_add_io(struct spa_loop_utils *object, int fd, uint32_t mask, bool close, spa_source_io_func_t func, void *data)
Definition loop.h:518
hook.h
spa/utils/hook.h
SPA_API_LOOP
#define SPA_API_LOOP
Definition loop.h:29
spa_hook_list
A list of hooks.
Definition hook.h:416
spa_hook_list::list
struct spa_list list
Definition hook.h:417
spa_hook
A hook, contains the structure with functions and the data passed to the functions.
Definition hook.h:427
spa_hook::cb
struct spa_callbacks cb
Definition hook.h:429
spa_hook::link
struct spa_list link
Definition hook.h:428
spa_interface
Definition hook.h:148
spa_loop_control_hooks
Control hooks.
Definition loop.h:212
spa_loop_control_hooks::before
void(* before)(void *data)
Executed right before waiting for events.
Definition loop.h:218
spa_loop_control_hooks::version
uint32_t version
Definition loop.h:215
spa_loop_control_hooks::after
void(* after)(void *data)
Executed right after waiting for events.
Definition loop.h:221
spa_loop_control_methods
Control an event loop.
Definition loop.h:261
spa_loop_control_methods::accept
int(* accept)(void *object)
Accept signalers Resume the thread that signaled with wait_for accept.
Definition loop.h:394
spa_loop_control_methods::wait
int(* wait)(void *object, const struct timespec *abstime)
Wait for a signal Wait until a thread performs signal.
Definition loop.h:368
spa_loop_control_methods::iterate
int(* iterate)(void *object, int timeout)
Perform one iteration of the loop.
Definition loop.h:320
spa_loop_control_methods::signal
int(* signal)(void *object, bool wait_for_accept)
Signal waiters Wake up all threads blocked in wait.
Definition loop.h:383
spa_loop_control_methods::enter
void(* enter)(void *object)
Enter a loop.
Definition loop.h:298
spa_loop_control_methods::add_hook
void(* add_hook)(void *object, struct spa_hook *hook, const struct spa_loop_control_hooks *hooks, void *data)
Add a hook.
Definition loop.h:285
spa_loop_control_methods::get_time
int(* get_time)(void *object, struct timespec *abstime, int64_t timeout)
get the absolute time Get the current time with timeout that can be used in wait.
Definition loop.h:356
spa_loop_control_methods::lock
int(* lock)(void *object)
Lock the loop.
Definition loop.h:339
spa_loop_control_methods::check
int(* check)(void *object)
Check context of the loop.
Definition loop.h:330
spa_loop_control_methods::unlock
int(* unlock)(void *object)
Unlock the loop.
Definition loop.h:348
spa_loop_control_methods::leave
void(* leave)(void *object)
Leave a loop.
Definition loop.h:307
spa_loop_control
Definition loop.h:54
spa_loop_control::iface
struct spa_interface iface
Definition loop.h:54
spa_loop_methods
Register sources and work items to an event loop.
Definition loop.h:88
spa_loop_methods::add_source
int(* add_source)(void *object, struct spa_source *source)
Add a source to the loop.
Definition loop.h:101
spa_loop_methods::locked
int(* locked)(void *object, spa_invoke_func_t func, uint32_t seq, const void *data, size_t size, void *user_data)
Call a function with the loop lock acquired May be called from any thread and multiple threads at the...
Definition loop.h:168
spa_loop_methods::remove_source
int(* remove_source)(void *object, struct spa_source *source)
Remove a source from the loop.
Definition loop.h:119
spa_loop_methods::invoke
int(* invoke)(void *object, spa_invoke_func_t func, uint32_t seq, const void *data, size_t size, bool block, void *user_data)
Invoke a function in the context of this loop.
Definition loop.h:149
spa_loop_methods::update_source
int(* update_source)(void *object, struct spa_source *source)
Update the source io mask.
Definition loop.h:110
spa_loop_methods::version
uint32_t version
Definition loop.h:93
spa_loop_utils_methods
Create sources for an event loop.
Definition loop.h:476
spa_loop_utils_methods::enable_idle
int(* enable_idle)(void *object, struct spa_source *source, bool enabled)
Definition loop.h:494
spa_loop_utils_methods::add_idle
struct spa_source *(* add_idle)(void *object, bool enabled, spa_source_idle_func_t func, void *data)
Definition loop.h:491
spa_loop_utils_methods::signal_event
int(* signal_event)(void *object, struct spa_source *source)
Definition loop.h:498
spa_loop_utils_methods::update_timer
int(* update_timer)(void *object, struct spa_source *source, struct timespec *value, struct timespec *interval, bool absolute)
Definition loop.h:502
spa_loop_utils_methods::destroy_source
void(* destroy_source)(void *object, struct spa_source *source)
destroy a source allocated with this interface.
Definition loop.h:514
spa_loop_utils_methods::add_io
struct spa_source *(* add_io)(void *object, int fd, uint32_t mask, bool close, spa_source_io_func_t func, void *data)
Definition loop.h:483
spa_loop_utils_methods::version
uint32_t version
Definition loop.h:481
spa_loop_utils
Definition loop.h:60
spa_loop_utils::iface
struct spa_interface iface
Definition loop.h:60
spa_loop
Definition loop.h:48
spa_loop::iface
struct spa_interface iface
Definition loop.h:48
spa_source
Definition loop.h:67
spa_source::rmask
uint32_t rmask
Definition loop.h:73
spa_source::priv
void * priv
Definition loop.h:75
spa_source::mask
uint32_t mask
Definition loop.h:72
spa_source::func
spa_source_func_t func
Definition loop.h:69
spa_source::fd
int fd
Definition loop.h:71
spa_source::loop
struct spa_loop * loop
Definition loop.h:68
system.h
spa/support/system.h