mirrors/alsa-lib
1
0
Fork 0
mirror of https://github.com/alsa-project/alsa-lib.git synced 2025-10-28 05:40:23 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Improved plugin code (simpler, faster and multithread ready)

Browse source
This commit is contained in:
Abramo Bagnara 2001-02-27 13:42:12 +00:00
parent afde2cfab2
commit 3830b168ef
13 changed files with 407 additions and 564 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/pcm/pcm.c
View file

@ -1053,7 +1053,7 @@ snd_pcm_sframes_t snd_pcm_read_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_
if (frames > (snd_pcm_uframes_t) avail)
frames = avail;
assert(frames != 0);
err = func(pcm, areas, offset, frames, 0);
err = func(pcm, areas, offset, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
@ -1130,7 +1130,7 @@ snd_pcm_sframes_t snd_pcm_write_areas(snd_pcm_t *pcm, const snd_pcm_channel_area
if (frames > (snd_pcm_uframes_t) avail)
frames = avail;
assert(frames != 0);
err = func(pcm, areas, offset, frames, 0);
err = func(pcm, areas, offset, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);

90
src/pcm/pcm_adpcm.c
View file

@ -452,74 +452,44 @@ static int snd_pcm_adpcm_init(snd_pcm_t *pcm)
return 0;
}
static snd_pcm_sframes_t snd_pcm_adpcm_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_adpcm_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_adpcm_t *adpcm = pcm->private_data;
snd_pcm_t *slave = adpcm->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_playback_xfer(slave, size - xfer);
adpcm->func(snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
areas, offset,
pcm->channels, frames,
adpcm->getput_idx, adpcm->states);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
adpcm->func(slave_areas, slave_offset,
areas, offset,
pcm->channels, size,
adpcm->getput_idx, adpcm->states);
*slave_sizep = size;
return size;
}
static snd_pcm_sframes_t snd_pcm_adpcm_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_adpcm_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_adpcm_t *adpcm = pcm->private_data;
snd_pcm_t *slave = adpcm->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_capture_xfer(slave, size - xfer);
adpcm->func(areas, offset,
snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
pcm->channels, frames,
adpcm->getput_idx, adpcm->states);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
adpcm->func(areas, offset,
slave_areas, slave_offset,
pcm->channels, size,
adpcm->getput_idx, adpcm->states);
*slave_sizep = size;
return size;
}
static void snd_pcm_adpcm_dump(snd_pcm_t *pcm, snd_output_t *out)

90
src/pcm/pcm_alaw.c
View file

@ -326,74 +326,44 @@ static int snd_pcm_alaw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
return 0;
}
static snd_pcm_sframes_t snd_pcm_alaw_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_alaw_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_alaw_t *alaw = pcm->private_data;
snd_pcm_t *slave = alaw->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_playback_xfer(slave, size - xfer);
alaw->func(snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
areas, offset,
pcm->channels, frames,
alaw->getput_idx);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
alaw->func(slave_areas, slave_offset,
areas, offset,
pcm->channels, size,
alaw->getput_idx);
*slave_sizep = size;
return size;
}
static snd_pcm_sframes_t snd_pcm_alaw_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_alaw_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_alaw_t *alaw = pcm->private_data;
snd_pcm_t *slave = alaw->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_capture_xfer(slave, size - xfer);
alaw->func(areas, offset,
snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
pcm->channels, frames,
alaw->getput_idx);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
alaw->func(areas, offset,
slave_areas, slave_offset,
pcm->channels, size,
alaw->getput_idx);
*slave_sizep = size;
return size;
}
static void snd_pcm_alaw_dump(snd_pcm_t *pcm, snd_output_t *out)

89
src/pcm/pcm_copy.c
View file

@ -90,73 +90,40 @@ static int snd_pcm_copy_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
snd_pcm_plugin_hw_params_slave);
}
static snd_pcm_sframes_t snd_pcm_copy_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_copy_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_copy_t *copy = pcm->private_data;
snd_pcm_t *slave = copy->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_playback_xfer(slave, size - xfer);
snd_pcm_areas_copy(snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
areas, offset,
pcm->channels, frames, pcm->format);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
snd_pcm_areas_copy(slave_areas, slave_offset,
areas, offset,
pcm->channels, size, pcm->format);
*slave_sizep = size;
return size;
}
static snd_pcm_sframes_t snd_pcm_copy_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_copy_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_copy_t *copy = pcm->private_data;
snd_pcm_t *slave = copy->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_capture_xfer(slave, size - xfer);
snd_pcm_areas_copy(areas, offset,
snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
pcm->channels, frames, pcm->format);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
snd_pcm_areas_copy(areas, offset,
slave_areas, slave_offset,
pcm->channels, size, pcm->format);
*slave_sizep = size;
return size;
}
static void snd_pcm_copy_dump(snd_pcm_t *pcm, snd_output_t *out)

86
src/pcm/pcm_linear.c
View file

@ -227,72 +227,42 @@ static int snd_pcm_linear_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
return 0;
}
static snd_pcm_sframes_t snd_pcm_linear_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_linear_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_linear_t *linear = pcm->private_data;
snd_pcm_t *slave = linear->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_playback_xfer(slave, size - xfer);
snd_pcm_linear_convert(snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
areas, offset,
pcm->channels, frames, linear->conv_idx);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
snd_pcm_linear_convert(slave_areas, slave_offset,
areas, offset,
pcm->channels, size, linear->conv_idx);
*slave_sizep = size;
return size;
}
static snd_pcm_sframes_t snd_pcm_linear_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_linear_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_linear_t *linear = pcm->private_data;
snd_pcm_t *slave = linear->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_capture_xfer(slave, size - xfer);
snd_pcm_linear_convert(areas, offset,
snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
pcm->channels, frames, linear->conv_idx);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
snd_pcm_linear_convert(areas, offset,
slave_areas, slave_offset,
pcm->channels, size, linear->conv_idx);
*slave_sizep = size;
return size;
}
static void snd_pcm_linear_dump(snd_pcm_t *pcm, snd_output_t *out)

16
src/pcm/pcm_local.h
View file

@ -187,17 +187,17 @@ snd_pcm_uframes_t snd_pcm_mmap_hw_offset(snd_pcm_t *pcm);
snd_pcm_uframes_t snd_pcm_mmap_playback_xfer(snd_pcm_t *pcm, snd_pcm_uframes_t frames);
snd_pcm_uframes_t snd_pcm_mmap_capture_xfer(snd_pcm_t *pcm, snd_pcm_uframes_t frames);
typedef snd_pcm_sframes_t (*snd_pcm_xfer_areas_func_t)(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset, snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep);
typedef snd_pcm_uframes_t (*snd_pcm_xfer_areas_func_t)(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size);
snd_pcm_sframes_t snd_pcm_read_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset, snd_pcm_uframes_t size,
snd_pcm_xfer_areas_func_t func);
snd_pcm_uframes_t offset, snd_pcm_uframes_t size,
snd_pcm_xfer_areas_func_t func);
snd_pcm_sframes_t snd_pcm_write_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset, snd_pcm_uframes_t size,
snd_pcm_xfer_areas_func_t func);
snd_pcm_uframes_t offset, snd_pcm_uframes_t size,
snd_pcm_xfer_areas_func_t func);
snd_pcm_sframes_t snd_pcm_read_mmap(snd_pcm_t *pcm, snd_pcm_uframes_t size);
snd_pcm_sframes_t snd_pcm_write_mmap(snd_pcm_t *pcm, snd_pcm_uframes_t size);
int snd_pcm_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t *info);

68
src/pcm/pcm_mmap.c
View file

@ -143,57 +143,69 @@ void snd_pcm_mmap_hw_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
*pcm->hw_ptr = hw_ptr;
}
snd_pcm_sframes_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm,
snd_pcm_uframes_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
snd_pcm_uframes_t size)
{
snd_pcm_uframes_t xfer;
if (slave_sizep && *slave_sizep < size)
size = *slave_sizep;
xfer = 0;
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_playback_xfer(pcm, size - xfer);
snd_pcm_sframes_t err;
snd_pcm_areas_copy(snd_pcm_mmap_areas(pcm), snd_pcm_mmap_offset(pcm),
const snd_pcm_channel_area_t *pcm_areas;
snd_pcm_uframes_t pcm_offset;
snd_pcm_uframes_t xfer = size;
assert(snd_pcm_mmap_playback_avail(pcm) >= size);
pcm_areas = snd_pcm_mmap_areas(pcm);
pcm_offset = snd_pcm_mmap_offset(pcm);
while (size > 0) {
snd_pcm_uframes_t frames = size;
snd_pcm_uframes_t cont = pcm->buffer_size - pcm_offset;
int err;
if (frames > cont)
frames = cont;
snd_pcm_areas_copy(pcm_areas, pcm_offset,
areas, offset,
pcm->channels,
frames, pcm->format);
err = snd_pcm_mmap_forward(pcm, frames);
assert(err == (snd_pcm_sframes_t)frames);
if (frames == cont)
pcm_offset = 0;
else
pcm_offset += frames;
offset += frames;
xfer += frames;
size -= frames;
}
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
snd_pcm_sframes_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm,
snd_pcm_uframes_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
snd_pcm_uframes_t size)
{
snd_pcm_uframes_t xfer;
if (slave_sizep && *slave_sizep < size)
size = *slave_sizep;
xfer = 0;
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_capture_xfer(pcm, size - xfer);
snd_pcm_sframes_t err;
const snd_pcm_channel_area_t *pcm_areas;
snd_pcm_uframes_t pcm_offset;
snd_pcm_uframes_t xfer = size;
assert(snd_pcm_mmap_capture_avail(pcm) >= size);
pcm_areas = snd_pcm_mmap_areas(pcm);
pcm_offset = snd_pcm_mmap_offset(pcm);
while (size > 0) {
snd_pcm_uframes_t frames = size;
snd_pcm_uframes_t cont = pcm->buffer_size - pcm_offset;
int err;
if (frames > cont)
frames = cont;
snd_pcm_areas_copy(areas, offset,
snd_pcm_mmap_areas(pcm), snd_pcm_mmap_offset(pcm),
pcm_areas, pcm_offset,
pcm->channels,
frames, pcm->format);
err = snd_pcm_mmap_forward(pcm, frames);
assert(err == (snd_pcm_sframes_t)frames);
if (frames == cont)
pcm_offset = 0;
else
pcm_offset += frames;
offset += frames;
xfer += frames;
size -= frames;
}
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}

90
src/pcm/pcm_mulaw.c
View file

@ -341,74 +341,44 @@ static int snd_pcm_mulaw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
return 0;
}
static snd_pcm_sframes_t snd_pcm_mulaw_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_mulaw_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_mulaw_t *mulaw = pcm->private_data;
snd_pcm_t *slave = mulaw->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_playback_xfer(slave, size - xfer);
mulaw->func(snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
areas, offset,
pcm->channels, frames,
mulaw->getput_idx);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
mulaw->func(slave_areas, slave_offset,
areas, offset,
pcm->channels, size,
mulaw->getput_idx);
*slave_sizep = size;
return size;
}
static snd_pcm_sframes_t snd_pcm_mulaw_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_mulaw_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_mulaw_t *mulaw = pcm->private_data;
snd_pcm_t *slave = mulaw->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_capture_xfer(slave, size - xfer);
mulaw->func(areas, offset,
snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
pcm->channels, frames,
mulaw->getput_idx);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
mulaw->func(areas, offset,
slave_areas, slave_offset,
pcm->channels, size,
mulaw->getput_idx);
*slave_sizep = size;
return size;
}
static void snd_pcm_mulaw_dump(snd_pcm_t *pcm, snd_output_t *out)

2
src/pcm/pcm_multi.c
View file

@ -408,7 +408,7 @@ static snd_pcm_sframes_t snd_pcm_multi_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t
snd_pcm_t *slave_i = multi->slaves[i].pcm;
snd_pcm_uframes_t f = pos[i] - frames;
if (f > 0)
snd_pcm_mmap_appl_forward(slave_i, f);
snd_pcm_mmap_forward(slave_i, f);
}
return frames;
}

217
src/pcm/pcm_plugin.c
View file

@ -188,100 +188,159 @@ snd_pcm_sframes_t snd_pcm_plugin_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames
return n;
}
snd_pcm_sframes_t snd_pcm_plugin_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size)
snd_pcm_uframes_t snd_pcm_plugin_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size)
{
snd_pcm_plugin_t *plugin = pcm->private_data;
snd_pcm_channel_area_t areas[pcm->channels];
snd_pcm_sframes_t frames;
snd_pcm_areas_from_buf(pcm, areas, (void*)buffer);
frames = snd_pcm_write_areas(pcm, areas, 0, size, plugin->write);
if (frames > 0)
snd_pcm_t *slave = plugin->slave;
const snd_pcm_channel_area_t *slave_areas;
snd_pcm_uframes_t slave_offset;
snd_pcm_uframes_t xfer = size;
slave_areas = snd_pcm_mmap_areas(slave);
slave_offset = snd_pcm_mmap_offset(slave);
while (size > 0) {
snd_pcm_uframes_t frames = size;
snd_pcm_uframes_t slave_cont = slave->buffer_size - slave_offset;
snd_pcm_uframes_t slave_frames = slave_cont;
frames = plugin->write(pcm, areas, offset, frames,
slave_areas, slave_offset, &slave_frames);
assert(slave_frames <= snd_pcm_mmap_playback_avail(slave));
snd_pcm_mmap_appl_forward(pcm, frames);
return frames;
snd_pcm_mmap_hw_forward(pcm, frames);
snd_pcm_mmap_forward(slave, slave_frames);
offset += frames;
size -= frames;
if (slave_frames == slave_cont)
slave_offset = 0;
else
slave_offset += slave_frames;
}
return xfer;
}
snd_pcm_uframes_t snd_pcm_plugin_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size)
{
snd_pcm_plugin_t *plugin = pcm->private_data;
snd_pcm_t *slave = plugin->slave;
const snd_pcm_channel_area_t *slave_areas;
snd_pcm_uframes_t slave_offset;
snd_pcm_uframes_t xfer = size;
slave_areas = snd_pcm_mmap_areas(slave);
slave_offset = snd_pcm_mmap_offset(slave);
while (size > 0) {
snd_pcm_uframes_t frames = size;
snd_pcm_uframes_t slave_cont = slave->buffer_size - slave_offset;
snd_pcm_uframes_t slave_frames = slave_cont;
frames = plugin->write(pcm, areas, offset, frames,
slave_areas, slave_offset, &slave_frames);
assert(slave_frames <= snd_pcm_mmap_capture_avail(slave));
snd_pcm_mmap_appl_forward(pcm, frames);
snd_pcm_mmap_hw_forward(pcm, frames);
snd_pcm_mmap_forward(slave, slave_frames);
offset += frames;
size -= frames;
if (slave_frames == slave_cont)
slave_offset = 0;
else
slave_offset += slave_frames;
}
return xfer;
}
snd_pcm_sframes_t snd_pcm_plugin_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size)
{
snd_pcm_channel_area_t areas[pcm->channels];
snd_pcm_areas_from_buf(pcm, areas, (void*)buffer);
return snd_pcm_write_areas(pcm, areas, 0, size,
snd_pcm_plugin_write_areas);
}
snd_pcm_sframes_t snd_pcm_plugin_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size)
{
snd_pcm_plugin_t *plugin = pcm->private_data;
snd_pcm_channel_area_t areas[pcm->channels];
snd_pcm_sframes_t frames;
snd_pcm_areas_from_bufs(pcm, areas, bufs);
frames = snd_pcm_write_areas(pcm, areas, 0, size, plugin->write);
if (frames > 0)
snd_pcm_mmap_appl_forward(pcm, frames);
return frames;
return snd_pcm_write_areas(pcm, areas, 0, size,
snd_pcm_plugin_write_areas);
}
snd_pcm_sframes_t snd_pcm_plugin_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_uframes_t size)
{
snd_pcm_plugin_t *plugin = pcm->private_data;
snd_pcm_channel_area_t areas[pcm->channels];
snd_pcm_sframes_t frames;
snd_pcm_areas_from_buf(pcm, areas, buffer);
frames = snd_pcm_read_areas(pcm, areas, 0, size, plugin->read);
if (frames > 0)
snd_pcm_mmap_appl_forward(pcm, frames);
return frames;
return snd_pcm_read_areas(pcm, areas, 0, size,
snd_pcm_plugin_read_areas);
}
snd_pcm_sframes_t snd_pcm_plugin_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size)
{
snd_pcm_plugin_t *plugin = pcm->private_data;
snd_pcm_channel_area_t areas[pcm->channels];
snd_pcm_sframes_t frames;
snd_pcm_areas_from_bufs(pcm, areas, bufs);
frames = snd_pcm_read_areas(pcm, areas, 0, size, plugin->read);
if (frames > 0)
snd_pcm_mmap_appl_forward(pcm, frames);
return frames;
return snd_pcm_read_areas(pcm, areas, 0, size,
snd_pcm_plugin_read_areas);
}
snd_pcm_sframes_t snd_pcm_plugin_mmap_forward(snd_pcm_t *pcm, snd_pcm_uframes_t client_size)
snd_pcm_sframes_t snd_pcm_plugin_mmap_forward(snd_pcm_t *pcm, snd_pcm_uframes_t size)
{
snd_pcm_plugin_t *plugin = pcm->private_data;
snd_pcm_t *slave = plugin->slave;
snd_pcm_uframes_t client_xfer = 0;
snd_pcm_uframes_t slave_xfer = 0;
snd_pcm_sframes_t err = 0;
snd_pcm_sframes_t slave_size;
const snd_pcm_channel_area_t *areas, *slave_areas;
snd_pcm_uframes_t xfer, offset;
snd_pcm_uframes_t slave_offset, slave_size;
if (pcm->stream == SND_PCM_STREAM_CAPTURE) {
snd_pcm_mmap_appl_forward(pcm, client_size);
// snd_pcm_plugin_avail_update(pcm);
return client_size;
snd_pcm_mmap_appl_forward(pcm, size);
return size;
}
slave_size = snd_pcm_avail_update(slave);
if (slave_size <= 0)
return slave_size;
while (client_xfer < client_size &&
slave_xfer < (snd_pcm_uframes_t)slave_size) {
snd_pcm_uframes_t slave_frames = slave_size - slave_xfer;
snd_pcm_uframes_t client_frames = client_size - client_xfer;
snd_pcm_uframes_t offset = snd_pcm_mmap_hw_offset(pcm);
areas = snd_pcm_mmap_areas(pcm);
offset = snd_pcm_mmap_hw_offset(pcm);
slave_areas = snd_pcm_mmap_areas(slave);
slave_offset = snd_pcm_mmap_offset(slave);
xfer = 0;
while (size && slave_size) {
snd_pcm_uframes_t frames = size;
snd_pcm_uframes_t cont = pcm->buffer_size - offset;
if (cont < client_frames)
client_frames = cont;
err = plugin->write(pcm, pcm->running_areas, offset,
client_frames, &slave_frames);
if (err < 0)
break;
snd_pcm_mmap_appl_forward(pcm, err);
client_xfer += err;
slave_xfer += slave_frames;
snd_pcm_uframes_t slave_frames = slave_size;
snd_pcm_uframes_t slave_cont = slave->buffer_size - slave_offset;
if (frames > cont)
frames = cont;
if (slave_frames > slave_cont)
slave_frames = slave_cont;
frames = plugin->write(pcm, areas, offset, frames,
slave_areas, slave_offset, &slave_frames);
snd_pcm_mmap_appl_forward(pcm, frames);
snd_pcm_mmap_hw_forward(pcm, frames);
snd_pcm_mmap_forward(slave, slave_frames);
xfer += frames;
if (frames == cont)
offset = 0;
else
offset += frames;
size -= frames;
if (slave_frames == slave_cont)
slave_offset = 0;
else
slave_offset += slave_frames;
slave_size -= slave_frames;
}
if (client_xfer > 0)
return client_xfer;
return err;
return xfer;
}
snd_pcm_sframes_t snd_pcm_plugin_avail_update(snd_pcm_t *pcm)
{
snd_pcm_plugin_t *plugin = pcm->private_data;
snd_pcm_t *slave = plugin->slave;
snd_pcm_uframes_t client_xfer;
snd_pcm_uframes_t slave_xfer = 0;
snd_pcm_sframes_t err = 0;
snd_pcm_uframes_t client_size;
snd_pcm_sframes_t slave_size = snd_pcm_avail_update(slave);
const snd_pcm_channel_area_t *areas, *slave_areas;
snd_pcm_uframes_t xfer, offset, size;
snd_pcm_uframes_t slave_offset, slave_size;
slave_size = snd_pcm_avail_update(slave);
if (slave_size <= 0)
return slave_size;
if (pcm->stream == SND_PCM_STREAM_PLAYBACK ||
@ -289,26 +348,38 @@ snd_pcm_sframes_t snd_pcm_plugin_avail_update(snd_pcm_t *pcm)
pcm->access == SND_PCM_ACCESS_RW_NONINTERLEAVED)
return plugin->client_frames ?
plugin->client_frames(pcm, slave_size) : slave_size;
client_xfer = snd_pcm_mmap_capture_avail(pcm);
client_size = pcm->buffer_size;
while (slave_xfer < (snd_pcm_uframes_t)slave_size &&
client_xfer < client_size) {
snd_pcm_uframes_t slave_frames = slave_size - slave_xfer;
snd_pcm_uframes_t client_frames = client_size - client_xfer;
snd_pcm_uframes_t offset = snd_pcm_mmap_hw_offset(pcm);
xfer = snd_pcm_mmap_capture_avail(pcm);
size = pcm->buffer_size - xfer;
areas = snd_pcm_mmap_areas(pcm);
offset = snd_pcm_mmap_hw_offset(pcm);
slave_areas = snd_pcm_mmap_areas(slave);
slave_offset = snd_pcm_mmap_offset(slave);
while (size && slave_size) {
snd_pcm_uframes_t frames = size;
snd_pcm_uframes_t cont = pcm->buffer_size - offset;
if (cont < client_frames)
client_frames = cont;
err = plugin->read(pcm, pcm->running_areas, offset,
client_frames, &slave_frames);
if (err < 0)
break;
client_xfer += err;
slave_xfer += slave_frames;
snd_pcm_uframes_t slave_frames = slave_size;
snd_pcm_uframes_t slave_cont = slave->buffer_size - slave_offset;
if (frames > cont)
frames = cont;
if (slave_frames > slave_cont)
slave_frames = slave_cont;
frames = plugin->read(pcm, areas, offset, frames,
slave_areas, slave_offset, &slave_frames);
snd_pcm_mmap_hw_forward(pcm, frames);
snd_pcm_mmap_forward(slave, slave_frames);
xfer += frames;
if (frames == cont)
offset = 0;
else
offset += frames;
size -= frames;
if (slave_frames == slave_cont)
slave_offset = 0;
else
slave_offset += slave_frames;
slave_size -= slave_frames;
}
if (client_xfer > 0)
return client_xfer;
return err;
return xfer;
}
int snd_pcm_plugin_mmap(snd_pcm_t *pcm)

13
src/pcm/pcm_plugin.h
View file

@ -19,11 +19,20 @@
*
*/
typedef snd_pcm_uframes_t (*snd_pcm_slave_xfer_areas_func_t)
(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep);
typedef struct {
snd_pcm_t *slave;
int close_slave;
snd_pcm_xfer_areas_func_t read;
snd_pcm_xfer_areas_func_t write;
snd_pcm_slave_xfer_areas_func_t read;
snd_pcm_slave_xfer_areas_func_t write;
snd_pcm_sframes_t (*client_frames)(snd_pcm_t *pcm, snd_pcm_sframes_t frames);
snd_pcm_sframes_t (*slave_frames)(snd_pcm_t *pcm, snd_pcm_sframes_t frames);
int (*init)(snd_pcm_t *pcm);

121
src/pcm/pcm_rate.c
View file

@ -419,106 +419,39 @@ static int snd_pcm_rate_init(snd_pcm_t *pcm)
return 0;
}
static snd_pcm_sframes_t snd_pcm_rate_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t client_offset,
snd_pcm_uframes_t client_size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_rate_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_rate_t *rate = pcm->private_data;
snd_pcm_t *slave = rate->plug.slave;
snd_pcm_uframes_t client_xfer = 0;
snd_pcm_uframes_t slave_xfer = 0;
snd_pcm_sframes_t err = 0;
snd_pcm_uframes_t slave_size;
if (slave_sizep)
slave_size = *slave_sizep;
else
slave_size = INT_MAX;
assert(client_size > 0 && slave_size > 0);
while (client_xfer < client_size &&
slave_xfer < slave_size) {
snd_pcm_uframes_t src_frames, dst_frames;
src_frames = client_size - client_xfer;
dst_frames = snd_pcm_mmap_playback_xfer(slave, slave_size - slave_xfer);
src_frames = rate->func(snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
&dst_frames,
areas, client_offset, src_frames,
pcm->channels,
rate->get_idx, rate->put_idx,
rate->pitch, rate->states);
assert(src_frames || dst_frames);
if (dst_frames > 0) {
err = snd_pcm_mmap_forward(slave, dst_frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == dst_frames);
slave_xfer += dst_frames;
}
if (src_frames > 0) {
client_offset += src_frames;
client_xfer += src_frames;
snd_pcm_mmap_hw_forward(pcm, src_frames);
}
}
if (client_xfer > 0 || slave_xfer > 0) {
if (slave_sizep)
*slave_sizep = slave_xfer;
return client_xfer;
}
return err;
return rate->func(slave_areas, slave_offset, slave_sizep,
areas, offset, size,
pcm->channels,
rate->get_idx, rate->put_idx,
rate->pitch, rate->states);
}
static snd_pcm_sframes_t snd_pcm_rate_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t client_offset,
snd_pcm_uframes_t client_size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_rate_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_rate_t *rate = pcm->private_data;
snd_pcm_t *slave = rate->plug.slave;
snd_pcm_uframes_t client_xfer = 0;
snd_pcm_uframes_t slave_xfer = 0;
snd_pcm_sframes_t err = 0;
snd_pcm_uframes_t slave_size;
if (slave_sizep)
slave_size = *slave_sizep;
else
slave_size = INT_MAX;
assert(client_size > 0 && slave_size > 0);
while (client_xfer < client_size &&
slave_xfer < slave_size) {
snd_pcm_uframes_t src_frames, dst_frames;
dst_frames = client_size - client_xfer;
src_frames = snd_pcm_mmap_capture_xfer(slave, slave_size - slave_xfer);
src_frames = rate->func(areas, client_offset, &dst_frames,
snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
src_frames,
pcm->channels,
rate->get_idx, rate->put_idx,
rate->pitch, rate->states);
assert(src_frames || dst_frames);
if (src_frames > 0) {
err = snd_pcm_mmap_forward(slave, src_frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == src_frames);
slave_xfer += src_frames;
}
if (dst_frames > 0) {
client_offset += dst_frames;
client_xfer += dst_frames;
snd_pcm_mmap_hw_forward(pcm, dst_frames);
}
}
if (client_xfer > 0 || slave_xfer > 0) {
if (slave_sizep)
*slave_sizep = slave_xfer;
return client_xfer;
}
return err;
*slave_sizep = rate->func(areas, offset, &size,
slave_areas, slave_offset, *slave_sizep,
pcm->channels,
rate->get_idx, rate->put_idx,
rate->pitch, rate->states);
return size;
}
snd_pcm_sframes_t snd_pcm_rate_client_frames(snd_pcm_t *pcm, snd_pcm_sframes_t frames)

85
src/pcm/pcm_route.c
View file

@ -571,72 +571,43 @@ static int snd_pcm_route_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
return 0;
}
static snd_pcm_sframes_t snd_pcm_route_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_route_write_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_route_t *route = pcm->private_data;
snd_pcm_t *slave = route->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_playback_xfer(slave, size - xfer);
snd_pcm_route_convert(snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
areas, offset,
slave->channels, frames, &route->params);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
snd_pcm_route_convert(slave_areas, slave_offset,
areas, offset,
slave->channels, size, &route->params);
*slave_sizep = size;
return size;
}
static snd_pcm_sframes_t snd_pcm_route_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
snd_pcm_uframes_t *slave_sizep)
static snd_pcm_uframes_t
snd_pcm_route_read_areas(snd_pcm_t *pcm,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size,
const snd_pcm_channel_area_t *slave_areas,
snd_pcm_uframes_t slave_offset,
snd_pcm_uframes_t *slave_sizep)
{
snd_pcm_route_t *route = pcm->private_data;
snd_pcm_t *slave = route->plug.slave;
snd_pcm_uframes_t xfer = 0;
snd_pcm_sframes_t err = 0;
if (slave_sizep && *slave_sizep < size)
if (size > *slave_sizep)
size = *slave_sizep;
assert(size > 0);
while (xfer < size) {
snd_pcm_uframes_t frames = snd_pcm_mmap_capture_xfer(slave, size - xfer);
snd_pcm_route_convert(areas, offset,
snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
pcm->channels, frames, &route->params);
err = snd_pcm_mmap_forward(slave, frames);
if (err < 0)
break;
assert((snd_pcm_uframes_t)err == frames);
offset += err;
xfer += err;
snd_pcm_mmap_hw_forward(pcm, err);
}
if (xfer > 0) {
if (slave_sizep)
*slave_sizep = xfer;
return xfer;
}
return err;
snd_pcm_route_convert(areas, offset,
slave_areas, slave_offset,
pcm->channels, size, &route->params);
*slave_sizep = size;
return size;
}
static void snd_pcm_route_dump(snd_pcm_t *pcm, snd_output_t *out)