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

pcm_share cleaning

Browse source
This commit is contained in:
Abramo Bagnara 2001-03-21 16:31:31 +00:00
parent 5e44a3114d
commit 82fcfe1ab5
12 changed files with 70 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/pcm/pcm_adpcm.c
View file

@ -298,7 +298,7 @@ static int snd_pcm_adpcm_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_adpcm_t *adpcm = pcm->private_data;
int err;
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_PLUGIN };
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_SHM };
err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
&access_mask);
if (err < 0)

2
src/pcm/pcm_alaw.c
View file

@ -197,7 +197,7 @@ static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *
{
snd_pcm_alaw_t *alaw = pcm->private_data;
int err;
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_PLUGIN };
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_SHM };
err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
&access_mask);
if (err < 0)

2
src/pcm/pcm_copy.c
View file

@ -31,7 +31,7 @@ typedef struct {
static int snd_pcm_copy_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_PLUGIN };
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_SHM };
err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
&access_mask);
if (err < 0)

2
src/pcm/pcm_linear.c
View file

@ -124,7 +124,7 @@ void snd_pcm_linear_convert(const snd_pcm_channel_area_t *dst_areas, snd_pcm_ufr
static int snd_pcm_linear_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_PLUGIN };
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_SHM };
snd_pcm_format_mask_t format_mask = { SND_PCM_FMTBIT_LINEAR };
err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
&access_mask);

22
src/pcm/pcm_local.h
View file

@ -512,3 +512,25 @@ int snd_pcm_slave_conf(snd_config_t *conf, const char **namep,
(1 << (unsigned long) SND_PCM_ACCESS_MMAP_NONINTERLEAVED) | \
(1 << (unsigned long) SND_PCM_ACCESS_MMAP_COMPLEX))
#define SND_PCM_ACCBIT_SHM ((1 << (unsigned long) SND_PCM_ACCESS_MMAP_INTERLEAVED) | \
(1 << (unsigned long) SND_PCM_ACCESS_RW_INTERLEAVED) | \
(1 << (unsigned long) SND_PCM_ACCESS_MMAP_NONINTERLEAVED) | \
(1 << (unsigned long) SND_PCM_ACCESS_RW_NONINTERLEAVED))
#define SND_PCM_FMTBIT_LINEAR \
((1 << (unsigned long) SND_PCM_FORMAT_S8) | \
(1 << (unsigned long) SND_PCM_FORMAT_U8) | \
(1 << (unsigned long) SND_PCM_FORMAT_S16_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S16_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U16_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U16_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S24_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S24_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U24_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U24_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S32_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S32_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U32_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U32_BE))

8
src/pcm/pcm_meter.c
View file

@ -417,7 +417,7 @@ static snd_pcm_sframes_t snd_pcm_meter_avail_update(snd_pcm_t *pcm)
static int snd_pcm_meter_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_PLUGIN };
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_SHM };
err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
&access_mask);
if (err < 0)
@ -500,7 +500,13 @@ static int snd_pcm_meter_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
buf_size_bytes = snd_pcm_frames_to_bytes(slave, meter->buf_size);
assert(!meter->buf);
meter->buf = malloc(buf_size_bytes);
if (!meter->buf)
return -ENOMEM;
meter->buf_areas = malloc(sizeof(*meter->buf_areas) * slave->channels);
if (!meter->buf_areas) {
free(meter->buf);
return -ENOMEM;
}
for (channel = 0; channel < slave->channels; ++channel) {
snd_pcm_channel_area_t *a = &meter->buf_areas[channel];
a->addr = meter->buf + buf_size_bytes / slave->channels * channel;

2
src/pcm/pcm_mulaw.c
View file

@ -214,7 +214,7 @@ static int snd_pcm_mulaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_mulaw_t *mulaw = pcm->private_data;
int err;
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_PLUGIN };
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_SHM };
err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
&access_mask);
if (err < 0)

21
src/pcm/pcm_plugin.h
View file

@ -77,22 +77,6 @@ int snd_pcm_plugin_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, unsigne
int snd_pcm_plugin_hw_params_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
int snd_pcm_plugin_hw_refine_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
#define SND_PCM_FMTBIT_LINEAR \
((1 << (unsigned long) SND_PCM_FORMAT_S8) | \
(1 << (unsigned long) SND_PCM_FORMAT_U8) | \
(1 << (unsigned long) SND_PCM_FORMAT_S16_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S16_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U16_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U16_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S24_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S24_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U24_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U24_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S32_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_S32_BE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U32_LE) | \
(1 << (unsigned long) SND_PCM_FORMAT_U32_BE))
extern snd_pcm_fast_ops_t snd_pcm_plugin_fast_ops;
#define RATE_MIN 4000
@ -119,11 +103,6 @@ int snd_pcm_route_open(snd_pcm_t **pcmp, const char *name,
int snd_pcm_rate_open(snd_pcm_t **pcmp, const char *name, snd_pcm_format_t sformat, int srate, snd_pcm_t *slave, int close_slave);
#define SND_PCM_ACCBIT_PLUGIN ((1 << (unsigned long) SND_PCM_ACCESS_MMAP_INTERLEAVED) | \
(1 << (unsigned long) SND_PCM_ACCESS_RW_INTERLEAVED) | \
(1 << (unsigned long) SND_PCM_ACCESS_MMAP_NONINTERLEAVED) | \
(1 << (unsigned long) SND_PCM_ACCESS_RW_NONINTERLEAVED))
void snd_pcm_linear_convert(const snd_pcm_channel_area_t *dst_areas, snd_pcm_uframes_t dst_offset,
const snd_pcm_channel_area_t *src_areas, snd_pcm_uframes_t src_offset,
unsigned int channels, snd_pcm_uframes_t frames, int convidx);

2
src/pcm/pcm_rate.c
View file

@ -210,7 +210,7 @@ snd_pcm_uframes_t snd_pcm_rate_shrink(const snd_pcm_channel_area_t *dst_areas,
static int snd_pcm_rate_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_PLUGIN };
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_SHM };
snd_pcm_format_mask_t format_mask = { SND_PCM_FMTBIT_LINEAR };
err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
&access_mask);

2
src/pcm/pcm_route.c
View file

@ -426,7 +426,7 @@ static int snd_pcm_route_close(snd_pcm_t *pcm)
static int snd_pcm_route_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_PLUGIN };
snd_pcm_access_mask_t access_mask = { SND_PCM_ACCBIT_SHM };
snd_pcm_format_mask_t format_mask = { SND_PCM_FMTBIT_LINEAR };
err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
&access_mask);

64
src/pcm/pcm_share.c
View file

@ -67,11 +67,10 @@ typedef struct {
snd_pcm_format_t format;
int rate;
unsigned int channels;
int period_time;
int buffer_time;
snd_pcm_sframes_t period_time;
snd_pcm_sframes_t buffer_time;
unsigned int open_count;
unsigned int setup_count;
unsigned int mmap_count;
unsigned int prepared_count;
unsigned int running_count;
snd_pcm_uframes_t safety_threshold;
@ -92,8 +91,8 @@ typedef struct {
struct list_head list;
snd_pcm_t *pcm;
snd_pcm_share_slave_t *slave;
unsigned int channels_count;
int *slave_channels;
unsigned int channels;
unsigned int *slave_channels;
int drain_silenced;
struct timeval trigger_tstamp;
snd_pcm_state_t state;
@ -453,7 +452,7 @@ static int snd_pcm_share_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
if (err < 0)
return err;
err = _snd_pcm_hw_param_set(params, SND_PCM_HW_PARAM_CHANNELS,
share->channels_count, 0);
share->channels, 0);
if (err < 0)
return err;
if (slave->format != SND_PCM_FORMAT_UNKNOWN) {
@ -589,8 +588,7 @@ static int snd_pcm_share_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
snd_pcm_t *spcm = slave->pcm;
int err = 0;
Pthread_mutex_lock(&slave->mutex);
if (slave->setup_count > 1 ||
(slave->setup_count == 1 && !pcm->setup)) {
if (slave->setup_count) {
err = _snd_pcm_hw_params_set_format(params, spcm->format);
if (err < 0)
goto _err;
@ -613,7 +611,7 @@ static int snd_pcm_share_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
spcm->tick_time, 0);
_err:
if (err < 0) {
SNDERR("slave is already running with different setup");
SNDERR("slave is already running with incompatible setup");
err = -EBUSY;
goto _end;
}
@ -964,10 +962,12 @@ static void _snd_pcm_share_stop(snd_pcm_t *pcm, snd_pcm_state_t state)
{
snd_pcm_share_t *share = pcm->private_data;
snd_pcm_share_slave_t *slave = share->slave;
#if 0
if (!pcm->mmap_channels) {
/* PCM closing already begun in the main thread */
return;
}
#endif
gettimeofday(&share->trigger_tstamp, 0);
if (pcm->stream == SND_PCM_STREAM_CAPTURE) {
snd_pcm_areas_copy(pcm->stopped_areas, 0,
@ -1097,11 +1097,11 @@ static int snd_pcm_share_close(snd_pcm_t *pcm)
Pthread_mutex_lock(&slave->mutex);
slave->open_count--;
if (slave->open_count == 0) {
err = snd_pcm_close(slave->pcm);
pthread_cond_signal(&slave->poll_cond);
Pthread_mutex_unlock(&slave->mutex);
err = pthread_join(slave->thread, 0);
assert(err == 0);
err = snd_pcm_close(slave->pcm);
pthread_mutex_destroy(&slave->mutex);
pthread_cond_destroy(&slave->poll_cond);
list_del(&slave->list);
@ -1136,7 +1136,7 @@ static void snd_pcm_share_dump(snd_pcm_t *pcm, snd_output_t *out)
unsigned int k;
snd_output_printf(out, "Share PCM\n");
snd_output_printf(out, "\nChannel bindings:\n");
for (k = 0; k < share->channels_count; ++k)
for (k = 0; k < share->channels; ++k)
snd_output_printf(out, "%d: %d\n", k, share->slave_channels[k]);
if (pcm->setup) {
snd_output_printf(out, "\nIts setup is:\n");
@ -1182,9 +1182,9 @@ snd_pcm_fast_ops_t snd_pcm_share_fast_ops = {
int snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, const char *sname,
snd_pcm_format_t sformat, int srate,
unsigned int schannels_count,
unsigned int schannels,
int speriod_time, int sbuffer_time,
unsigned int channels_count, int *channels_map,
unsigned int channels, unsigned int *channels_map,
snd_pcm_stream_t stream, int mode)
{
snd_pcm_t *pcm;
@ -1197,10 +1197,10 @@ int snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, const char *sname,
int sd[2];
assert(pcmp);
assert(channels_count > 0 && sname && channels_map);
assert(channels > 0 && sname && channels_map);
for (k = 0; k < channels_count; ++k) {
if (channels_map[k] < 0 || channels_map[k] > 31) {
for (k = 0; k < channels; ++k) {
if (channels_map[k] >= sizeof(slave_map) / sizeof(slave_map[0])) {
SNDERR("Invalid slave channel (%d) in binding", channels_map[k]);
return -EINVAL;
}
@ -1209,20 +1209,20 @@ int snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, const char *sname,
return -EINVAL;
}
slave_map[channels_map[k]] = 1;
assert((unsigned)channels_map[k] < schannels_count);
assert((unsigned)channels_map[k] < schannels);
}
share = calloc(1, sizeof(snd_pcm_share_t));
if (!share)
return -ENOMEM;
share->channels_count = channels_count;
share->slave_channels = calloc(channels_count, sizeof(*share->slave_channels));
share->channels = channels;
share->slave_channels = calloc(channels, sizeof(*share->slave_channels));
if (!share->slave_channels) {
free(share);
return -ENOMEM;
}
memcpy(share->slave_channels, channels_map, channels_count * sizeof(*share->slave_channels));
memcpy(share->slave_channels, channels_map, channels * sizeof(*share->slave_channels));
pcm = calloc(1, sizeof(snd_pcm_t));
if (!pcm) {
@ -1297,7 +1297,7 @@ int snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, const char *sname,
}
INIT_LIST_HEAD(&slave->clients);
slave->pcm = spcm;
slave->channels = schannels_count;
slave->channels = schannels;
slave->format = sformat;
slave->rate = srate;
slave->period_time = speriod_time;
@ -1315,7 +1315,7 @@ int snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, const char *sname,
list_for_each(i, &slave->clients) {
snd_pcm_share_t *sh = list_entry(i, snd_pcm_share_t, list);
unsigned int k;
for (k = 0; k < sh->channels_count; ++k) {
for (k = 0; k < sh->channels; ++k) {
if (slave_map[sh->slave_channels[k]]) {
SNDERR("Slave channel %d is already in use", sh->slave_channels[k]);
Pthread_mutex_unlock(&slave->mutex);
@ -1367,9 +1367,8 @@ int _snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, snd_config_t *conf,
snd_config_t *bindings = NULL;
int err;
snd_config_t *slave = NULL;
unsigned int idx;
int *channels_map;
unsigned int channels_count = 0;
unsigned int *channels_map;
unsigned int channels = 0;
snd_pcm_format_t sformat = SND_PCM_FORMAT_UNKNOWN;
int schannels = -1;
int srate = -1;
@ -1408,8 +1407,8 @@ int _snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, snd_config_t *conf,
return -EINVAL;
}
err = snd_pcm_slave_conf(slave, &sname, 5,
SND_PCM_HW_PARAM_FORMAT, 0, &sformat,
SND_PCM_HW_PARAM_CHANNELS, 0, &schannels,
SND_PCM_HW_PARAM_FORMAT, 0, &sformat,
SND_PCM_HW_PARAM_RATE, 0, &srate,
SND_PCM_HW_PARAM_PERIOD_TIME, 0, &speriod_time,
SND_PCM_HW_PARAM_BUFFER_TIME, 0, &sbuffer_time);
@ -1430,16 +1429,14 @@ int _snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, snd_config_t *conf,
SNDERR("Invalid client channel in binding: %s", id);
return -EINVAL;
}
if ((unsigned)cchannel >= channels_count)
channels_count = cchannel + 1;
if ((unsigned)cchannel >= channels)
channels = cchannel + 1;
}
if (channels_count == 0) {
if (channels == 0) {
SNDERR("No bindings defined");
return -EINVAL;
}
channels_map = calloc(channels_count, sizeof(*channels_map));
for (idx = 0; idx < channels_count; ++idx)
channels_map[idx] = -1;
channels_map = calloc(channels, sizeof(*channels_map));
snd_config_for_each(i, next, bindings) {
snd_config_t *n = snd_config_iterator_entry(i);
@ -1450,6 +1447,7 @@ int _snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, snd_config_t *conf,
err = snd_config_get_integer(n, &schannel);
if (err < 0)
goto _free;
assert(schannel >= 0);
assert(schannels <= 0 || schannel < schannels);
channels_map[cchannel] = schannel;
if ((unsigned)schannel > schannel_max)
@ -1459,7 +1457,7 @@ int _snd_pcm_share_open(snd_pcm_t **pcmp, const char *name, snd_config_t *conf,
schannels = schannel_max + 1;
err = snd_pcm_share_open(pcmp, name, sname, sformat, srate,
schannels, speriod_time, sbuffer_time,
channels_count, channels_map, stream, mode);
channels, channels_map, stream, mode);
_free:
free(channels_map);
return err;

3
src/pcm/plugin_ops.h
View file

@ -544,6 +544,9 @@ static inline int32_t getS(const void *src, int src_sign, int src_wid, int src_e
if (src_end)
s = bswap_32(s);
break;
default:
assert(0);
return 0;
}
if (!src_sign)
s -= 1U << (src_wid - 1);