pcm_share cleaning

diff --git a/src/pcm/pcm_adpcm.c b/src/pcm/pcm_adpcm.c
index 1d1b831..c56b87f 100644 (file)
--- a/src/pcm/pcm_adpcm.c
+++ b/src/pcm/pcm_adpcm.c
@@ -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)

diff --git a/src/pcm/pcm_alaw.c b/src/pcm/pcm_alaw.c
index 714a987..936e1b9 100644 (file)
--- a/src/pcm/pcm_alaw.c
+++ b/src/pcm/pcm_alaw.c
@@ -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)

diff --git a/src/pcm/pcm_copy.c b/src/pcm/pcm_copy.c
index e0b2d89..64f33c7 100644 (file)
--- a/src/pcm/pcm_copy.c
+++ b/src/pcm/pcm_copy.c
@@ -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)

diff --git a/src/pcm/pcm_linear.c b/src/pcm/pcm_linear.c
index b10dc0e..b17d59f 100644 (file)
--- a/src/pcm/pcm_linear.c
+++ b/src/pcm/pcm_linear.c
@@ -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);

diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h
index 4b6e86f..83e3156 100644 (file)
--- a/src/pcm/pcm_local.h
+++ b/src/pcm/pcm_local.h
@@ -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))
+
+

diff --git a/src/pcm/pcm_meter.c b/src/pcm/pcm_meter.c
index 88dd825..8b8ced5 100644 (file)
--- a/src/pcm/pcm_meter.c
+++ b/src/pcm/pcm_meter.c
@@ -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;

diff --git a/src/pcm/pcm_mulaw.c b/src/pcm/pcm_mulaw.c
index 79a35e1..0ab4826 100644 (file)
--- a/src/pcm/pcm_mulaw.c
+++ b/src/pcm/pcm_mulaw.c
@@ -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)

diff --git a/src/pcm/pcm_plugin.h b/src/pcm/pcm_plugin.h
index 76aaeb4..feef373 100644 (file)
--- a/src/pcm/pcm_plugin.h
+++ b/src/pcm/pcm_plugin.h
@@ -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);

diff --git a/src/pcm/pcm_rate.c b/src/pcm/pcm_rate.c
index 6d3251a..8def792 100644 (file)
--- a/src/pcm/pcm_rate.c
+++ b/src/pcm/pcm_rate.c
@@ -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);

diff --git a/src/pcm/pcm_route.c b/src/pcm/pcm_route.c
index cbe9f55..7934798 100644 (file)
--- a/src/pcm/pcm_route.c
+++ b/src/pcm/pcm_route.c
@@ -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);

diff --git a/src/pcm/pcm_share.c b/src/pcm/pcm_share.c
index 242796f..c43103e 100644 (file)
--- a/src/pcm/pcm_share.c
+++ b/src/pcm/pcm_share.c
@@ -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;

diff --git a/src/pcm/plugin_ops.h b/src/pcm/plugin_ops.h
index a9f6854..9c96105 100644 (file)
--- a/src/pcm/plugin_ops.h
+++ b/src/pcm/plugin_ops.h
@@ -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);