struct pollfd *pollfd, *pollfd2;
unsigned n_pollfd_alloc, n_pollfd_used;
- int timer_enabled;
+ pa_bool_t timer_enabled;
struct timespec next_elapse;
pa_usec_t period;
- int scan_for_dead;
- int running, installed, rebuild_needed, quit;
+ pa_bool_t scan_for_dead;
+ pa_bool_t running, installed, rebuild_needed, quit;
#ifdef HAVE_PPOLL
int rtsig;
sigset_t sigset_unblocked;
timer_t timer;
#ifdef __linux__
- int dont_use_ppoll;
+ pa_bool_t dont_use_ppoll;
#endif
#endif
struct pa_rtpoll_item {
pa_rtpoll *rtpoll;
- int dead;
+ pa_bool_t dead;
pa_rtpoll_priority_t priority;
#ifdef __linux__
/* ppoll is broken on Linux < 2.6.16 */
+ p->dont_use_ppoll = FALSE;
- p->dont_use_ppoll = 0;
-
{
struct utsname u;
unsigned major, minor, micro;
(major == 2 && minor < 6) ||
(major == 2 && minor == 6 && micro < 16))
- p->dont_use_ppoll = 1;
+ p->dont_use_ppoll = TRUE;
}
#endif
p->period = 0;
memset(&p->next_elapse, 0, sizeof(p->next_elapse));
- p->timer_enabled = 0;
+ p->timer_enabled = FALSE;
- p->running = 0;
- p->installed = 0;
- p->scan_for_dead = 0;
- p->rebuild_needed = 0;
- p->quit = 0;
+ p->running = FALSE;
+ p->installed = FALSE;
+ p->scan_for_dead = FALSE;
+ p->rebuild_needed = FALSE;
+ p->quit = FALSE;
PA_LLIST_HEAD_INIT(pa_rtpoll_item, p->items);
pa_assert(p);
- p->rebuild_needed = 0;
+ p->rebuild_needed = FALSE;
if (p->n_pollfd_used > p->n_pollfd_alloc) {
/* Hmm, we have to allocate some more space */
if (pa_flist_push(PA_STATIC_FLIST_GET(items), i) < 0)
pa_xfree(i);
- p->rebuild_needed = 1;
+ p->rebuild_needed = TRUE;
}
void pa_rtpoll_free(pa_rtpoll *p) {
}
}
-int pa_rtpoll_run(pa_rtpoll *p, int wait) {
+int pa_rtpoll_run(pa_rtpoll *p, pa_bool_t wait) {
pa_rtpoll_item *i;
int r = 0;
struct timespec timeout;
pa_assert(!p->running);
pa_assert(p->installed);
- p->running = 1;
+ p->running = TRUE;
/* First, let's do some work */
for (i = p->items; i && i->priority < PA_RTPOLL_NEVER; i = i->next) {
if (i->dead)
continue;
- if (!i->before_cb)
+ if (!i->work_cb)
continue;
if (p->quit)
finish:
- p->running = 0;
+ p->running = FALSE;
if (p->scan_for_dead) {
pa_rtpoll_item *n;
- p->scan_for_dead = 0;
+ p->scan_for_dead = FALSE;
for (i = p->items; i; i = n) {
n = i->next;
p->next_elapse = *ts;
p->period = 0;
- p->timer_enabled = 1;
+ p->timer_enabled = TRUE;
update_timer(p);
}
p->period = usec;
pa_rtclock_get(&p->next_elapse);
pa_timespec_add(&p->next_elapse, usec);
- p->timer_enabled = 1;
+ p->timer_enabled = TRUE;
update_timer(p);
}
p->period = 0;
pa_rtclock_get(&p->next_elapse);
pa_timespec_add(&p->next_elapse, usec);
- p->timer_enabled = 1;
+ p->timer_enabled = TRUE;
update_timer(p);
}
p->period = 0;
memset(&p->next_elapse, 0, sizeof(p->next_elapse));
- p->timer_enabled = 0;
+ p->timer_enabled = FALSE;
update_timer(p);
}
i = pa_xnew(pa_rtpoll_item, 1);
i->rtpoll = p;
- i->dead = 0;
+ i->dead = FALSE;
i->n_pollfd = n_fds;
i->pollfd = NULL;
i->priority = prio;
pa_assert(i);
if (i->rtpoll->running) {
- i->dead = 1;
- i->rtpoll->scan_for_dead = 1;
+ i->dead = TRUE;
+ i->rtpoll->scan_for_dead = TRUE;
return;
}
void pa_rtpoll_quit(pa_rtpoll *p) {
pa_assert(p);
- p->quit = 1;
+ p->quit = TRUE;
}
#include <pulse/sample.h>
#include <pulsecore/asyncmsgq.h>
#include <pulsecore/fdsem.h>
+#include <pulsecore/macro.h>
/* An implementation of a "real-time" poll loop. Basically, this is
* yet another wrapper around poll(). However it has certain
* struct pollfd. Returns negative on error, positive if the loop
* should continue to run, 0 when the loop should be terminated
* cleanly. */
-int pa_rtpoll_run(pa_rtpoll *f, int wait);
+int pa_rtpoll_run(pa_rtpoll *f, pa_bool_t wait);
void pa_rtpoll_set_timer_absolute(pa_rtpoll *p, const struct timespec *ts);
void pa_rtpoll_set_timer_periodic(pa_rtpoll *p, pa_usec_t usec);