/*
* Return a single tuple containing the contents of the gen'ed tuple chain.
*/
void
gen_flatten(struct value *gen, struct value *dest)
{
unsigned int dest_size = value_tuple_fetch_integer(gen, GEN_GLOBAL_POS);
struct value *current = value_tuple_fetch(gen, GEN_ROOT_TUPLE);
unsigned int j = 0;
value_tuple_new(dest, value_tuple_get_tag(current), dest_size);
while (!value_is_null(current)) {
unsigned int i = 0;
unsigned int current_size = value_tuple_get_size(current);
struct value *x;
for (i = 0; i < (current_size - 1) && i < dest_size; i++) {
x = value_tuple_fetch(current, i);
#ifdef DEBUG
process_render(process_err, "(flatten %d/%d -> %d/%d: ", i, current_size, j, dest_size);
value_portray(process_err, x);
process_render(process_err, ")\n");
#endif
value_tuple_store(dest, j, x);
j++;
}
current = value_tuple_fetch(current, (current_size - 1));
}
}
static void thread_func(void *userdata) {
struct userdata *u = userdata;
int ret;
pa_usec_t now;
pa_assert(u);
pa_log_debug("Thread starting up");
pa_thread_mq_install(&u->thread_mq);
u->timestamp = pa_rtclock_now();
for (;;) {
if (u->sink->thread_info.state == PA_SINK_RUNNING) {
now = pa_rtclock_now();
if (u->sink->thread_info.rewind_requested) {
if (u->sink->thread_info.rewind_nbytes > 0) {
process_rewind(u, now);
} else {
pa_sink_process_rewind(u->sink, 0);
}
}
if (u->timestamp <= now) {
pa_log_debug("thread_func: calling process_render");
process_render(u, now);
}
pa_rtpoll_set_timer_absolute(u->rtpoll, u->timestamp);
} else {
pa_rtpoll_set_timer_disabled(u->rtpoll);
}
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0) {
goto fail;
}
if (ret == 0) {
goto finish;
}
}
fail:
/* If this was no regular exit from the loop we have to continue
* processing messages until we received PA_MESSAGE_SHUTDOWN */
pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core),
PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0,
NULL, NULL);
pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
finish:
pa_log_debug("Thread shutting down");
}
static void thread_func(void *userdata) {
struct userdata *u = userdata;
pa_assert(u);
pa_log_debug("Thread starting up");
pa_thread_mq_install(&u->thread_mq);
for(;;){
struct pollfd *pollfd;
int ret;
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
/* Render some data and write it to the fifo */
if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
if (u->sink->thread_info.rewind_requested)
pa_sink_process_rewind(u->sink, 0);
if (pollfd->revents) {
if (process_render(u) < 0)
goto fail;
pollfd->revents = 0;
}
}
/* Hmm, nothing to do. Let's sleep */
pollfd->events = (short) (u->sink->thread_info.state == PA_SINK_RUNNING ? POLLOUT : 0);
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
goto fail;
if (ret == 0)
goto finish;
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
if (pollfd->revents & ~POLLOUT) {
pa_log("FIFO shutdown.");
goto fail;
}
}
fail:
/* If this was no regular exit from the loop we have to continue
* processing messages until we received PA_MESSAGE_SHUTDOWN */
pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
pa_log_debug("Shutting down Xen...");
xen_cleanup();
finish:
pa_log_debug("Thread shutting down");
}
static void thread_func(void *userdata) {
struct userdata *u = userdata;
pa_assert(u);
pa_log_debug("Thread starting up");
pa_thread_mq_install(&u->thread_mq);
u->timestamp = pa_rtclock_now();
for (;;) {
pa_usec_t now = 0;
int ret;
if (PA_SINK_IS_OPENED(u->sink->thread_info.state))
now = pa_rtclock_now();
if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
process_rewind(u, now);
/* Render some data and drop it immediately */
if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
if (u->timestamp <= now)
process_render(u, now);
pa_rtpoll_set_timer_absolute(u->rtpoll, u->timestamp);
} else
pa_rtpoll_set_timer_disabled(u->rtpoll);
/* Hmm, nothing to do. Let's sleep */
if ((ret = pa_rtpoll_run(u->rtpoll)) < 0)
goto fail;
if (ret == 0)
goto finish;
}
fail:
/* If this was no regular exit from the loop we have to continue
* processing messages until we received PA_MESSAGE_SHUTDOWN */
pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
finish:
pa_log_debug("Thread shutting down");
}
int
value_save(struct process *p, struct value *value)
{
unsigned char squeeze = (unsigned char)value->type;
#ifdef DEBUG
process_render(process_err, "(save:%s ", type_name_table[(int)squeeze]);
if (value->type == VALUE_SYMBOL) {
process_render(process_err, "[%d] ", value_symbol_get_length(value));
}
value_portray(process_err, value);
process_render(process_err, ")\n");
#endif
stream_write(NULL, p, &squeeze, sizeof(squeeze));
if ((value->type & VALUE_STRUCTURED) == 0) {
stream_write(NULL, p, &value->value, sizeof(value->value));
} else {
unsigned int length, i;
switch (value->type) {
case VALUE_SYMBOL:
{
const char *token = value_symbol_get_token(value);
length = value_symbol_get_length(value);
stream_write(NULL, p, &length, sizeof(length));
stream_write(NULL, p, token, sizeof(char) * length);
break;
}
case VALUE_TUPLE:
{
struct value *tag = value_tuple_get_tag(value);
value_save(p, tag);
/* XXX should eventually dispatch to a handler based on tag. */
if (value_equal(tag, &tag_dict)) {
struct value dict_iter;
struct value *key;
value_dict_new_iter(&dict_iter, value);
length = value_dict_get_layer_size(value);
stream_write(NULL, p, &length, sizeof(length));
length = value_dict_get_length(value);
stream_write(NULL, p, &length, sizeof(length));
key = value_dict_iter_get_current_key(&dict_iter);
while (!value_is_null(key)) {
value_save(p, key);
value_save(p, value_dict_fetch(value, key)); /* XXX not so good; use iter */
value_dict_iter_advance(&dict_iter);
key = value_dict_iter_get_current_key(&dict_iter);
}
} else {
length = value_tuple_get_size(value);
stream_write(NULL, p, &length, sizeof(length));
for (i = 0; i < length; i++) {
value_save(p, value_tuple_fetch(value, i));
}
}
break;
}
default:
assert(value->type == VALUE_SYMBOL ||
value->type == VALUE_TUPLE);
break;
}
}
return 1;
}
static void thread_func(void *userdata)
{
struct context *context = userdata;
int ret;
pa_usec_t now;
pa_assert(context);
pa_log_debug("Thread starting up");
pa_thread_mq_install(&context->thread_mq);
context->timestamp = pa_rtclock_now();
for (;;)
{
if (context->sink->thread_info.state == PA_SINK_RUNNING)
{
now = pa_rtclock_now();
if (context->sink->thread_info.rewind_requested)
{
process_rewind(context, now);
}
if (context->timestamp <= now)
{
pa_log_debug("thread_func: calling process_render");
process_render(context, now);
}
pa_rtpoll_set_timer_absolute(context->rtpoll, context->timestamp);
}
else
{
pa_rtpoll_set_timer_disabled(context->rtpoll);
}
#if PA_CHECK_VERSION(5,0,0)
if ((ret = pa_rtpoll_run(context->rtpoll)) < 0)
#else
if ((ret = pa_rtpoll_run(context->rtpoll, TRUE)) < 0)
#endif
{
goto FAIL;
}
if (ret == 0)
{
goto DONE;
}
}
FAIL:
/* If this was no regular exit from the loop we have to continue
* processing messages until we received PA_MESSAGE_SHUTDOWN */
pa_asyncmsgq_post(context->thread_mq.outq, PA_MSGOBJECT(context->core),
PA_CORE_MESSAGE_UNLOAD_MODULE, context->module, 0, NULL, NULL);
pa_asyncmsgq_wait_for(context->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
DONE:
pa_log_debug("Thread shutting down");
}
