pa_memchunk* pa_memchunk_make_writable(pa_memchunk *c, size_t min) {
pa_memblock *n;
size_t l;
void *tdata, *sdata;
pa_assert(c);
pa_assert(c->memblock);
if (pa_memblock_ref_is_one(c->memblock) &&
!pa_memblock_is_read_only(c->memblock) &&
pa_memblock_get_length(c->memblock) >= c->index+min)
return c;
l = PA_MAX(c->length, min);
n = pa_memblock_new(pa_memblock_get_pool(c->memblock), l);
sdata = pa_memblock_acquire(c->memblock);
tdata = pa_memblock_acquire(n);
memcpy(tdata, (uint8_t*) sdata + c->index, c->length);
pa_memblock_release(c->memblock);
pa_memblock_release(n);
pa_memblock_unref(c->memblock);
c->memblock = n;
c->index = 0;
return c;
}
static pa_cvolume* set_balance(pa_cvolume *v, const pa_channel_map *map, float new_balance,
bool (*on_l)(pa_channel_position_t), bool (*on_r)(pa_channel_position_t)) {
pa_volume_t left, nleft, right, nright, m;
unsigned c;
get_avg(map, v, &left, &right, on_l, on_r);
m = PA_MAX(left, right);
if (new_balance <= 0) {
nright = (new_balance + 1.0f) * m;
nleft = m;
} else {
nleft = (1.0f - new_balance) * m;
nright = m;
}
for (c = 0; c < map->channels; c++) {
if (on_l(map->map[c])) {
if (left == 0)
v->values[c] = nleft;
else
v->values[c] = (pa_volume_t) PA_CLAMP_VOLUME(((uint64_t) v->values[c] * (uint64_t) nleft) / (uint64_t) left);
} else if (on_r(map->map[c])) {
if (right == 0)
v->values[c] = nright;
else
v->values[c] = (pa_volume_t) PA_CLAMP_VOLUME(((uint64_t) v->values[c] * (uint64_t) nright) / (uint64_t) right);
}
}
return v;
}
static int do_write(struct userdata *u) {
ssize_t r;
pa_assert(u);
if (!pa_iochannel_is_writable(u->io))
return 0;
if (u->write_data) {
pa_assert(u->write_index < u->write_length);
if ((r = pa_iochannel_write(u->io, (uint8_t*) u->write_data + u->write_index, u->write_length - u->write_index)) <= 0) {
pa_log("write() failed: %s", pa_cstrerror(errno));
return -1;
}
u->write_index += (size_t) r;
pa_assert(u->write_index <= u->write_length);
if (u->write_index == u->write_length) {
pa_xfree(u->write_data);
u->write_data = NULL;
u->write_index = u->write_length = 0;
}
}
if (!u->write_data && u->state == STATE_PREPARE) {
int so_sndbuf = 0;
socklen_t sl = sizeof(int);
/* OK, we're done with sending all control data we need to, so
* let's hand the socket over to the IO thread now */
pa_assert(u->fd < 0);
u->fd = pa_iochannel_get_send_fd(u->io);
pa_iochannel_set_noclose(u->io, TRUE);
pa_iochannel_free(u->io);
u->io = NULL;
pa_make_tcp_socket_low_delay(u->fd);
if (getsockopt(u->fd, SOL_SOCKET, SO_SNDBUF, &so_sndbuf, &sl) < 0)
pa_log_warn("getsockopt(SO_SNDBUF) failed: %s", pa_cstrerror(errno));
else {
pa_log_debug("SO_SNDBUF is %zu.", (size_t) so_sndbuf);
pa_sink_set_max_request(u->sink, PA_MAX((size_t) so_sndbuf, u->block_size));
}
pa_log_debug("Connection authenticated, handing fd to IO thread...");
pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_PASS_SOCKET, NULL, 0, NULL, NULL);
u->state = STATE_RUNNING;
}
return 0;
}
size_t pa_context_get_tile_size(pa_context *c, const pa_sample_spec *ss) {
size_t fs, mbs;
pa_assert(c);
pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_ANY(c, !pa_detect_fork(), PA_ERR_FORKED, (size_t) -1);
PA_CHECK_VALIDITY_RETURN_ANY(c, !ss || pa_sample_spec_valid(ss), PA_ERR_INVALID, (size_t) -1);
fs = ss ? pa_frame_size(ss) : 1;
mbs = PA_ROUND_DOWN(pa_mempool_block_size_max(c->mempool), fs);
return PA_MAX(mbs, fs);
}
void pa_dynarray_append(pa_dynarray *array, void *p) {
pa_assert(array);
pa_assert(p);
if (array->n_entries == array->n_allocated) {
unsigned n = PA_MAX(array->n_allocated * 2, 25U);
array->data = pa_xrealloc(array->data, sizeof(void *) * n);
array->n_allocated = n;
}
array->data[array->n_entries++] = p;
}
pa_cvolume* pa_cvolume_merge(pa_cvolume *dest, const pa_cvolume *a, const pa_cvolume *b) {
unsigned i;
pa_assert(dest);
pa_assert(a);
pa_assert(b);
pa_return_val_if_fail(pa_cvolume_valid(a), NULL);
pa_return_val_if_fail(pa_cvolume_valid(b), NULL);
for (i = 0; i < a->channels && i < b->channels; i++)
dest->values[i] = PA_MAX(a->values[i], b->values[i]);
dest->channels = (uint8_t) i;
return dest;
}
pa_cvolume* pa_cvolume_set_fade(pa_cvolume *v, const pa_channel_map *map, float new_fade) {
pa_volume_t front, nfront, rear, nrear, m;
unsigned c;
pa_assert(map);
pa_assert(v);
pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), NULL);
pa_return_val_if_fail(new_fade >= -1.0f, NULL);
pa_return_val_if_fail(new_fade <= 1.0f, NULL);
if (!pa_channel_map_can_fade(map))
return v;
get_avg_fr(map, v, &front, &rear);
m = PA_MAX(front, rear);
if (new_fade <= 0) {
nfront = (new_fade + 1.0f) * m;
nrear = m;
} else {
nrear = (1.0f - new_fade) * m;
nfront = m;
}
for (c = 0; c < map->channels; c++) {
if (on_front(map->map[c])) {
if (front == 0)
v->values[c] = nfront;
else
v->values[c] = (pa_volume_t) PA_CLAMP_VOLUME(((uint64_t) v->values[c] * (uint64_t) nfront) / (uint64_t) front);
} else if (on_rear(map->map[c])) {
if (rear == 0)
v->values[c] = nrear;
else
v->values[c] = (pa_volume_t) PA_CLAMP_VOLUME(((uint64_t) v->values[c] * (uint64_t) nrear) / (uint64_t) rear);
}
}
return v;
}
pa_cvolume* pa_cvolume_set_balance(pa_cvolume *v, const pa_channel_map *map, float new_balance) {
pa_volume_t left, nleft, right, nright, m;
unsigned c;
pa_assert(map);
pa_assert(v);
pa_return_val_if_fail(pa_cvolume_compatible_with_channel_map(v, map), NULL);
pa_return_val_if_fail(new_balance >= -1.0f, NULL);
pa_return_val_if_fail(new_balance <= 1.0f, NULL);
if (!pa_channel_map_can_balance(map))
return v;
get_avg_lr(map, v, &left, &right);
m = PA_MAX(left, right);
if (new_balance <= 0) {
nright = (new_balance + 1.0f) * m;
nleft = m;
} else {
nleft = (1.0f - new_balance) * m;
nright = m;
}
for (c = 0; c < map->channels; c++) {
if (on_left(map->map[c])) {
if (left == 0)
v->values[c] = nleft;
else
v->values[c] = (pa_volume_t) PA_CLAMP_VOLUME(((uint64_t) v->values[c] * (uint64_t) nleft) / (uint64_t) left);
} else if (on_right(map->map[c])) {
if (right == 0)
v->values[c] = nright;
else
v->values[c] = (pa_volume_t) PA_CLAMP_VOLUME(((uint64_t) v->values[c] * (uint64_t) nright) / (uint64_t) right);
}
}
return v;
}
pa_prioq_item* pa_prioq_put(pa_prioq *q, void *p) {
pa_prioq_item *i;
pa_assert(q);
if (q->n_items >= q->n_allocated) {
q->n_allocated = PA_MAX(q->n_items+1, q->n_allocated)*2;
q->items = pa_xrealloc(q->items, sizeof(pa_prioq_item*) * q->n_allocated);
}
if (!(i = pa_flist_pop(PA_STATIC_FLIST_GET(items))))
i = pa_xnew(pa_prioq_item, 1);
i->value = p;
i->idx = q->n_items++;
shuffle_up(q, i);
return i;
}
static void on_connection(int fd, void*userdata) {
int so_sndbuf = 0;
socklen_t sl = sizeof(int);
struct userdata *u = userdata;
pa_assert(u);
pa_assert(u->fd < 0);
u->fd = fd;
if (getsockopt(u->fd, SOL_SOCKET, SO_SNDBUF, &so_sndbuf, &sl) < 0)
pa_log_warn("getsockopt(SO_SNDBUF) failed: %s", pa_cstrerror(errno));
else {
pa_log_debug("SO_SNDBUF is %zu.", (size_t) so_sndbuf);
pa_sink_set_max_request(u->sink, PA_MAX((size_t) so_sndbuf, u->block_size));
}
/* Set the initial volume */
sink_set_volume_cb(u->sink);
pa_log_debug("Connection authenticated, handing fd to IO thread...");
pa_asyncmsgq_post(u->thread_mq.inq, PA_MSGOBJECT(u->sink), SINK_MESSAGE_PASS_SOCKET, NULL, 0, NULL, NULL);
}
void pa_log_levelv_meta(
pa_log_level_t level,
const char*file,
int line,
const char *func,
const char *format,
va_list ap) {
char *t, *n;
int saved_errno = errno;
char *bt = NULL;
pa_log_target_t _target;
pa_log_level_t _maximum_level;
unsigned _show_backtrace;
pa_log_flags_t _flags;
/* We don't use dynamic memory allocation here to minimize the hit
* in RT threads */
char text[16*1024], location[128], timestamp[32];
pa_assert(level < PA_LOG_LEVEL_MAX);
pa_assert(format);
PA_ONCE_BEGIN {
init_defaults();
} PA_ONCE_END;
_target = target_override_set ? target_override : target;
_maximum_level = PA_MAX(maximum_level, maximum_level_override);
_show_backtrace = PA_MAX(show_backtrace, show_backtrace_override);
_flags = flags | flags_override;
if (PA_LIKELY(level > _maximum_level)) {
errno = saved_errno;
return;
}
pa_vsnprintf(text, sizeof(text), format, ap);
if ((_flags & PA_LOG_PRINT_META) && file && line > 0 && func)
pa_snprintf(location, sizeof(location), "[%s:%i %s()] ", file, line, func);
else if ((_flags & (PA_LOG_PRINT_META|PA_LOG_PRINT_FILE)) && file)
pa_snprintf(location, sizeof(location), "%s: ", pa_path_get_filename(file));
else
location[0] = 0;
if (_flags & PA_LOG_PRINT_TIME) {
static pa_usec_t start, last;
pa_usec_t u, a, r;
u = pa_rtclock_now();
PA_ONCE_BEGIN {
start = u;
last = u;
} PA_ONCE_END;
r = u - last;
a = u - start;
/* This is not thread safe, but this is a debugging tool only
* anyway. */
last = u;
pa_snprintf(timestamp, sizeof(timestamp), "(%4llu.%03llu|%4llu.%03llu) ",
(unsigned long long) (a / PA_USEC_PER_SEC),
(unsigned long long) (((a / PA_USEC_PER_MSEC)) % 1000),
(unsigned long long) (r / PA_USEC_PER_SEC),
(unsigned long long) (((r / PA_USEC_PER_MSEC)) % 1000));
} else
