mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-07 13:30:03 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

rework memory block management to be thread-safe and mostly lock-free.

Browse source 
pa_memblock is now an opaque structure. Access to its fields is now done
through various accessor functions in a thread-safe manner.

pa_memblock_acquire() and pa_memblock_release() are now used to access the
attached audio data. Why? To allow safe manipulation of the memory pointer
maintained by the memory block. Internally _acquire() and _release() maintain a
reference counter. Please do not confuse this reference counter whith the one
maintained by pa_memblock_ref()/_unref()!

As a side effect this patch removes all direct usages of AO_t and replaces it
with pa_atomic_xxx based code.

This stuff needs some serious testing love. Especially if threads are actively
used.



git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@1404 fefdeb5f-60dc-0310-8127-8f9354f1896f
This commit is contained in:
Lennart Poettering 2006-09-26 23:50:56 +00:00
parent 5ad143b3ab
commit d210ebbb09
36 changed files with 991 additions and 500 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/modules/module-alsa-sink.c
View file

@ -144,6 +144,7 @@ static void do_write(struct userdata *u) {
update_usage(u);
for (;;) {
void *p;
pa_memchunk *memchunk = NULL;
snd_pcm_sframes_t frames;
@ -156,9 +157,15 @@ static void do_write(struct userdata *u) {
memchunk = &u->memchunk;
}
assert(memchunk->memblock && memchunk->memblock->data && memchunk->length && memchunk->memblock->length && (memchunk->length % u->frame_size) == 0);
assert(memchunk->memblock);
assert(memchunk->length);
assert((memchunk->length % u->frame_size) == 0);
if ((frames = snd_pcm_writei(u->pcm_handle, (uint8_t*) memchunk->memblock->data + memchunk->index, memchunk->length / u->frame_size)) < 0) {
p = pa_memblock_acquire(memchunk->memblock);
if ((frames = snd_pcm_writei(u->pcm_handle, (uint8_t*) p + memchunk->index, memchunk->length / u->frame_size)) < 0) {
pa_memblock_release(memchunk->memblock);
if (frames == -EAGAIN)
return;
@ -176,6 +183,9 @@ static void do_write(struct userdata *u) {
return;
}
pa_memblock_release(memchunk->memblock);
if (memchunk == &u->memchunk) {
size_t l = frames * u->frame_size;
memchunk->index += l;

10
src/modules/module-alsa-source.c
View file

@ -149,6 +149,7 @@ static void do_read(struct userdata *u) {
pa_memchunk post_memchunk;
snd_pcm_sframes_t frames;
size_t l;
void *p;
if (!u->memchunk.memblock) {
u->memchunk.memblock = pa_memblock_new(u->source->core->mempool, u->memchunk.length = u->fragment_size);
@ -157,11 +158,13 @@ static void do_read(struct userdata *u) {
assert(u->memchunk.memblock);
assert(u->memchunk.length);
assert(u->memchunk.memblock->data);
assert(u->memchunk.memblock->length);
assert(u->memchunk.length % u->frame_size == 0);
if ((frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) u->memchunk.memblock->data + u->memchunk.index, u->memchunk.length / u->frame_size)) < 0) {
p = pa_memblock_acquire(u->memchunk.memblock);
if ((frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p + u->memchunk.index, u->memchunk.length / u->frame_size)) < 0) {
pa_memblock_release(u->memchunk.memblock);
if (frames == -EAGAIN)
return;
@ -178,6 +181,7 @@ static void do_read(struct userdata *u) {
pa_module_unload_request(u->module);
return;
}
pa_memblock_release(u->memchunk.memblock);
l = frames * u->frame_size;

11
src/modules/module-esound-sink.c
View file

@ -142,18 +142,25 @@ static int do_write(struct userdata *u) {
u->write_index = u->write_length = 0;
}
} else if (u->state == STATE_RUNNING) {
void *p;
pa_module_set_used(u->module, pa_sink_used_by(u->sink));
if (!u->memchunk.length)
if (pa_sink_render(u->sink, 8192, &u->memchunk) < 0)
return 0;
assert(u->memchunk.memblock && u->memchunk.length);
assert(u->memchunk.memblock);
assert(u->memchunk.length);
p = pa_memblock_acquire(u->memchunk.memblock);
if ((r = pa_iochannel_write(u->io, (uint8_t*) u->memchunk.memblock->data + u->memchunk.index, u->memchunk.length)) < 0) {
if ((r = pa_iochannel_write(u->io, (uint8_t*) p + u->memchunk.index, u->memchunk.length)) < 0) {
pa_memblock_release(u->memchunk.memblock);
pa_log("write() failed: %s", pa_cstrerror(errno));
return -1;
}
pa_memblock_release(u->memchunk.memblock);
u->memchunk.index += r;
u->memchunk.length -= r;

5
src/modules/module-jack-sink.c
View file

@ -135,22 +135,25 @@ static void io_event_cb(pa_mainloop_api *m, pa_io_event *e, int fd, pa_io_event_
unsigned fs;
jack_nframes_t frame_idx;
pa_memchunk chunk;
void *p;
fs = pa_frame_size(&u->sink->sample_spec);
pa_sink_render_full(u->sink, u->frames_requested * fs, &chunk);
p = pa_memblock_acquire(chunk.memblock);
for (frame_idx = 0; frame_idx < u->frames_requested; frame_idx ++) {
unsigned c;
for (c = 0; c < u->channels; c++) {
float *s = ((float*) ((uint8_t*) chunk.memblock->data + chunk.index)) + (frame_idx * u->channels) + c;
float *s = ((float*) ((uint8_t*) p + chunk.index)) + (frame_idx * u->channels) + c;
float *d = ((float*) u->buffer[c]) + frame_idx;
*d = *s;
}
}
pa_memblock_release(chunk.memblock);
pa_memblock_unref(chunk.memblock);
u->frames_requested = 0;

7
src/modules/module-jack-source.c
View file

@ -134,23 +134,28 @@ static void io_event_cb(pa_mainloop_api *m, pa_io_event *e, int fd, pa_io_event_
unsigned fs;
jack_nframes_t frame_idx;
pa_memchunk chunk;
void *p;
fs = pa_frame_size(&u->source->sample_spec);
chunk.memblock = pa_memblock_new(u->core->mempool, chunk.length = u->frames_posted * fs);
chunk.index = 0;
p = pa_memblock_acquire(chunk.memblock);
for (frame_idx = 0; frame_idx < u->frames_posted; frame_idx ++) {
unsigned c;
for (c = 0; c < u->channels; c++) {
float *s = ((float*) u->buffer[c]) + frame_idx;
float *d = ((float*) ((uint8_t*) chunk.memblock->data + chunk.index)) + (frame_idx * u->channels) + c;
float *d = ((float*) ((uint8_t*) p + chunk.index)) + (frame_idx * u->channels) + c;
*d = *s;
}
}
pa_memblock_release(chunk.memblock);
pa_source_post(u->source, &chunk);
pa_memblock_unref(chunk.memblock);

4
src/modules/module-oss-mmap.c
View file

@ -170,7 +170,7 @@ static void out_fill_memblocks(struct userdata *u, unsigned n) {
u->out_fragment_size,
1);
assert(chunk.memblock);
chunk.length = chunk.memblock->length;
chunk.length = pa_memblock_get_length(chunk.memblock);
chunk.index = 0;
pa_sink_render_into_full(u->sink, &chunk);
@ -214,7 +214,7 @@ static void in_post_memblocks(struct userdata *u, unsigned n) {
if (!u->in_memblocks[u->in_current]) {
chunk.memblock = u->in_memblocks[u->in_current] = pa_memblock_new_fixed(u->core->mempool, (uint8_t*) u->in_mmap+u->in_fragment_size*u->in_current, u->in_fragment_size, 1);
chunk.length = chunk.memblock->length;
chunk.length = pa_memblock_get_length(chunk.memblock);
chunk.index = 0;
pa_source_post(u->source, &chunk);

22
src/modules/module-oss.c
View file

@ -155,6 +155,7 @@ static void do_write(struct userdata *u) {
}
do {
void *p;
memchunk = &u->memchunk;
if (!memchunk->length)
@ -162,16 +163,18 @@ static void do_write(struct userdata *u) {
memchunk = &u->silence;
assert(memchunk->memblock);
assert(memchunk->memblock->data);
assert(memchunk->length);
if ((r = pa_iochannel_write(u->io, (uint8_t*) memchunk->memblock->data + memchunk->index, memchunk->length)) < 0) {
p = pa_memblock_acquire(memchunk->memblock);
if ((r = pa_iochannel_write(u->io, (uint8_t*) p + memchunk->index, memchunk->length)) < 0) {
pa_memblock_release(memchunk->memblock);
pa_log("write() failed: %s", pa_cstrerror(errno));
clear_up(u);
pa_module_unload_request(u->module);
break;
}
pa_memblock_release(memchunk->memblock);
if (memchunk == &u->silence)
assert(r % u->sample_size == 0);
@ -217,9 +220,13 @@ static void do_read(struct userdata *u) {
}
do {
void *p;
memchunk.memblock = pa_memblock_new(u->core->mempool, l);
assert(memchunk.memblock);
if ((r = pa_iochannel_read(u->io, memchunk.memblock->data, memchunk.memblock->length)) < 0) {
p = pa_memblock_acquire(memchunk.memblock);
if ((r = pa_iochannel_read(u->io, p, pa_memblock_get_length(memchunk.memblock))) < 0) {
pa_memblock_release(memchunk.memblock);
pa_memblock_unref(memchunk.memblock);
if (errno != EAGAIN) {
pa_log("read() failed: %s", pa_cstrerror(errno));
@ -228,9 +235,10 @@ static void do_read(struct userdata *u) {
}
break;
}
pa_memblock_release(memchunk.memblock);
assert(r <= (ssize_t) memchunk.memblock->length);
memchunk.length = memchunk.memblock->length = r;
assert(r <= (ssize_t) pa_memblock_get_length(memchunk.memblock));
memchunk.length = r;
memchunk.index = 0;
pa_source_post(u->source, &memchunk);

11
src/modules/module-pipe-sink.c
View file

@ -84,6 +84,8 @@ static const char* const valid_modargs[] = {
static void do_write(struct userdata *u) {
ssize_t r;
void *p;
assert(u);
u->core->mainloop->defer_enable(u->defer_event, 0);
@ -97,12 +99,17 @@ static void do_write(struct userdata *u) {
if (pa_sink_render(u->sink, PIPE_BUF, &u->memchunk) < 0)
return;
assert(u->memchunk.memblock && u->memchunk.length);
assert(u->memchunk.memblock);
assert(u->memchunk.length);
p = pa_memblock_acquire(u->memchunk.memblock);
if ((r = pa_iochannel_write(u->io, (uint8_t*) u->memchunk.memblock->data + u->memchunk.index, u->memchunk.length)) < 0) {
if ((r = pa_iochannel_write(u->io, (uint8_t*) p + u->memchunk.index, u->memchunk.length)) < 0) {
pa_memblock_release(u->memchunk.memblock);
pa_log("write(): %s", pa_cstrerror(errno));
return;
}
pa_memblock_release(u->memchunk.memblock);
u->memchunk.index += r;
u->memchunk.length -= r;

13
src/modules/module-pipe-source.c
View file

@ -82,7 +82,9 @@ static const char* const valid_modargs[] = {
static void do_read(struct userdata *u) {
ssize_t r;
void *p;
pa_memchunk chunk;
assert(u);
if (!pa_iochannel_is_readable(u->io))
@ -95,17 +97,22 @@ static void do_read(struct userdata *u) {
u->chunk.index = chunk.length = 0;
}
assert(u->chunk.memblock && u->chunk.memblock->length > u->chunk.index);
if ((r = pa_iochannel_read(u->io, (uint8_t*) u->chunk.memblock->data + u->chunk.index, u->chunk.memblock->length - u->chunk.index)) <= 0) {
assert(u->chunk.memblock);
assert(pa_memblock_get_length(u->chunk.memblock) > u->chunk.index);
p = pa_memblock_acquire(u->chunk.memblock);
if ((r = pa_iochannel_read(u->io, (uint8_t*) p + u->chunk.index, pa_memblock_get_length(u->chunk.memblock) - u->chunk.index)) <= 0) {
pa_memblock_release(u->chunk.memblock);
pa_log("read(): %s", pa_cstrerror(errno));
return;
}
pa_memblock_release(u->chunk.memblock);
u->chunk.length = r;
pa_source_post(u->source, &u->chunk);
u->chunk.index += r;
if (u->chunk.index >= u->chunk.memblock->length) {
if (u->chunk.index >= pa_memblock_get_length(u->chunk.memblock)) {
u->chunk.index = u->chunk.length = 0;
pa_memblock_unref(u->chunk.memblock);
u->chunk.memblock = NULL;

14
src/modules/module-sine.c
View file

@ -63,7 +63,7 @@ static int sink_input_peek(pa_sink_input *i, pa_memchunk *chunk) {
chunk->memblock = pa_memblock_ref(u->memblock);
chunk->index = u->peek_index;
chunk->length = u->memblock->length - u->peek_index;
chunk->length = pa_memblock_get_length(u->memblock) - u->peek_index;
return 0;
}
@ -72,11 +72,12 @@ static void sink_input_drop(pa_sink_input *i, const pa_memchunk *chunk, size_t l
assert(i && chunk && length && i->userdata);
u = i->userdata;
assert(chunk->memblock == u->memblock && length <= u->memblock->length-u->peek_index);
assert(chunk->memblock == u->memblock);
assert(length <= pa_memblock_get_length(u->memblock)-u->peek_index);
u->peek_index += length;
if (u->peek_index >= u->memblock->length)
if (u->peek_index >= pa_memblock_get_length(u->memblock))
u->peek_index = 0;
}
@ -109,6 +110,7 @@ int pa__init(pa_core *c, pa_module*m) {
pa_sample_spec ss;
uint32_t frequency;
char t[256];
void *p;
pa_sink_input_new_data data;
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
@ -140,8 +142,10 @@ int pa__init(pa_core *c, pa_module*m) {
}
u->memblock = pa_memblock_new(c->mempool, pa_bytes_per_second(&ss));
calc_sine(u->memblock->data, u->memblock->length, frequency);
p = pa_memblock_acquire(u->memblock);
calc_sine(p, pa_memblock_get_length(u->memblock), frequency);
pa_memblock_release(u->memblock);
snprintf(t, sizeof(t), "Sine Generator at %u Hz", frequency);
pa_sink_input_new_data_init(&data);

18
src/modules/rtp/rtp.c
View file

@ -79,7 +79,7 @@ int pa_rtp_send(pa_rtp_context *c, size_t size, pa_memblockq *q) {
size_t k = n + chunk.length > size ? size - n : chunk.length;
if (chunk.memblock) {
iov[iov_idx].iov_base = (void*)((uint8_t*) chunk.memblock->data + chunk.index);
iov[iov_idx].iov_base = (void*)((uint8_t*) pa_memblock_acquire(chunk.memblock) + chunk.index);
iov[iov_idx].iov_len = k;
mb[iov_idx] = chunk.memblock;
iov_idx ++;
@ -114,8 +114,10 @@ int pa_rtp_send(pa_rtp_context *c, size_t size, pa_memblockq *q) {
k = sendmsg(c->fd, &m, MSG_DONTWAIT);
for (i = 1; i < iov_idx; i++)
for (i = 1; i < iov_idx; i++) {
pa_memblock_release(mb[i]);
pa_memblock_unref(mb[i]);
}
c->sequence++;
} else
@ -172,7 +174,7 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
chunk->memblock = pa_memblock_new(pool, size);
iov.iov_base = chunk->memblock->data;
iov.iov_base = pa_memblock_acquire(chunk->memblock);
iov.iov_len = size;
m.msg_name = NULL;
@ -193,9 +195,9 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
goto fail;
}
memcpy(&header, chunk->memblock->data, sizeof(uint32_t));
memcpy(&c->timestamp, (uint8_t*) chunk->memblock->data + 4, sizeof(uint32_t));
memcpy(&c->ssrc, (uint8_t*) chunk->memblock->data + 8, sizeof(uint32_t));
memcpy(&header, iov.iov_base, sizeof(uint32_t));
memcpy(&c->timestamp, (uint8_t*) iov.iov_base + 4, sizeof(uint32_t));
memcpy(&c->ssrc, (uint8_t*) iov.iov_base + 8, sizeof(uint32_t));
header = ntohl(header);
c->timestamp = ntohl(c->timestamp);
@ -236,8 +238,10 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
return 0;
fail:
if (chunk->memblock)
if (chunk->memblock) {
pa_memblock_release(chunk->memblock);
pa_memblock_unref(chunk->memblock);
}
return -1;
}