Fixed constness wrt snd_pcm_channel_area_t

diff --git a/include/pcm.h b/include/pcm.h
index 89b6d17..b85d524 100644 (file)
--- a/include/pcm.h
+++ b/include/pcm.h
@@ -135,9 +135,9 @@ int snd_pcm_hw_info_try_explain_failure(snd_pcm_t *pcm,
                                        FILE *fp);
 
 /* mmap */
-snd_pcm_channel_area_t *snd_pcm_mmap_areas(snd_pcm_t *pcm);
-snd_pcm_channel_area_t *snd_pcm_mmap_running_areas(snd_pcm_t *pcm);
-snd_pcm_channel_area_t *snd_pcm_mmap_stopped_areas(snd_pcm_t *pcm);
+const snd_pcm_channel_area_t *snd_pcm_mmap_areas(snd_pcm_t *pcm);
+const snd_pcm_channel_area_t *snd_pcm_mmap_running_areas(snd_pcm_t *pcm);
+const snd_pcm_channel_area_t *snd_pcm_mmap_stopped_areas(snd_pcm_t *pcm);
 ssize_t snd_pcm_mmap_forward(snd_pcm_t *pcm, size_t size);
 size_t snd_pcm_mmap_offset(snd_pcm_t *pcm);
 size_t snd_pcm_mmap_xfer(snd_pcm_t *pcm, size_t size);
@@ -150,15 +150,15 @@ const char *snd_pcm_format_name(unsigned int format);
 const char *snd_pcm_format_description(unsigned int format);
 int snd_pcm_format_value(const char* name);
 
-int snd_pcm_area_silence(snd_pcm_channel_area_t *dst_channel, size_t dst_offset,
+int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_channel, size_t dst_offset,
                         size_t samples, int format);
-int snd_pcm_areas_silence(snd_pcm_channel_area_t *dst_channels, size_t dst_offset,
+int snd_pcm_areas_silence(const snd_pcm_channel_area_t *dst_channels, size_t dst_offset,
                          size_t vcount, size_t frames, int format);
-int snd_pcm_area_copy(snd_pcm_channel_area_t *src_channel, size_t src_offset,
-                     snd_pcm_channel_area_t *dst_channel, size_t dst_offset,
+int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_channel, size_t src_offset,
+                     const snd_pcm_channel_area_t *dst_channel, size_t dst_offset,
                      size_t samples, int format);
-int snd_pcm_areas_copy(snd_pcm_channel_area_t *src_channels, size_t src_offset,
-                      snd_pcm_channel_area_t *dst_channels, size_t dst_offset,
+int snd_pcm_areas_copy(const snd_pcm_channel_area_t *src_channels, size_t src_offset,
+                      const snd_pcm_channel_area_t *dst_channels, size_t dst_offset,
                       size_t channels, size_t frames, int format);
 
 ssize_t snd_pcm_bytes_to_frames(snd_pcm_t *pcm, ssize_t bytes);

diff --git a/src/pcm/pcm.c b/src/pcm/pcm.c
index eb449b1..92d82c5 100644 (file)
--- a/src/pcm/pcm.c
+++ b/src/pcm/pcm.c
@@ -953,7 +953,7 @@ ssize_t snd_pcm_mmap_forward(snd_pcm_t *pcm, size_t size)
        return pcm->fast_ops->mmap_forward(pcm->fast_op_arg, size);
 }
 
-int snd_pcm_area_silence(snd_pcm_channel_area_t *dst_area, size_t dst_offset,
+int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offset,
                         size_t samples, int format)
 {
        /* FIXME: sub byte resolution and odd dst_offset */
@@ -1035,14 +1035,14 @@ int snd_pcm_area_silence(snd_pcm_channel_area_t *dst_area, size_t dst_offset,
        return 0;
 }
 
-int snd_pcm_areas_silence(snd_pcm_channel_area_t *dst_areas, size_t dst_offset,
+int snd_pcm_areas_silence(const snd_pcm_channel_area_t *dst_areas, size_t dst_offset,
                          size_t channels, size_t frames, int format)
 {
        int width = snd_pcm_format_physical_width(format);
        while (channels > 0) {
                void *addr = dst_areas->addr;
                unsigned int step = dst_areas->step;
-               snd_pcm_channel_area_t *begin = dst_areas;
+               const snd_pcm_channel_area_t *begin = dst_areas;
                int channels1 = channels;
                unsigned int chns = 0;
                int err;
@@ -1076,8 +1076,8 @@ int snd_pcm_areas_silence(snd_pcm_channel_area_t *dst_areas, size_t dst_offset,
 }
 
 
-int snd_pcm_area_copy(snd_pcm_channel_area_t *src_area, size_t src_offset,
-                     snd_pcm_channel_area_t *dst_area, size_t dst_offset,
+int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_area, size_t src_offset,
+                     const snd_pcm_channel_area_t *dst_area, size_t dst_offset,
                      size_t samples, int format)
 {
        /* FIXME: sub byte resolution and odd dst_offset */
@@ -1171,17 +1171,17 @@ int snd_pcm_area_copy(snd_pcm_channel_area_t *src_area, size_t src_offset,
        return 0;
 }
 
-int snd_pcm_areas_copy(snd_pcm_channel_area_t *src_areas, size_t src_offset,
-                      snd_pcm_channel_area_t *dst_areas, size_t dst_offset,
+int snd_pcm_areas_copy(const snd_pcm_channel_area_t *src_areas, size_t src_offset,
+                      const snd_pcm_channel_area_t *dst_areas, size_t dst_offset,
                       size_t channels, size_t frames, int format)
 {
        int width = snd_pcm_format_physical_width(format);
        while (channels > 0) {
                unsigned int step = src_areas->step;
                void *src_addr = src_areas->addr;
-               snd_pcm_channel_area_t *src_start = src_areas;
+               const snd_pcm_channel_area_t *src_start = src_areas;
                void *dst_addr = dst_areas->addr;
-               snd_pcm_channel_area_t *dst_start = dst_areas;
+               const snd_pcm_channel_area_t *dst_start = dst_areas;
                int channels1 = channels;
                unsigned int chns = 0;
                while (dst_areas->step == step) {
@@ -1218,7 +1218,7 @@ int snd_pcm_areas_copy(snd_pcm_channel_area_t *src_areas, size_t src_offset,
        return 0;
 }
 
-ssize_t snd_pcm_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
+ssize_t snd_pcm_read_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas,
                           size_t offset, size_t size,
                           snd_pcm_xfer_areas_func_t func)
 {
@@ -1273,7 +1273,7 @@ ssize_t snd_pcm_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
        return err;
 }
 
-ssize_t snd_pcm_write_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
+ssize_t snd_pcm_write_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas,
                            size_t offset, size_t size,
                            snd_pcm_xfer_areas_func_t func)
 {

diff --git a/src/pcm/pcm_adpcm.c b/src/pcm/pcm_adpcm.c
index 6a45d76..0690cc8 100644 (file)
--- a/src/pcm/pcm_adpcm.c
+++ b/src/pcm/pcm_adpcm.c
@@ -56,9 +56,9 @@ typedef struct {
        int step_idx;           /* Previous StepSize lookup index */
 } adpcm_state_t;
 
-typedef void (*adpcm_f)(snd_pcm_channel_area_t *src_areas,
+typedef void (*adpcm_f)(const snd_pcm_channel_area_t *src_areas,
                        size_t src_offset,
-                       snd_pcm_channel_area_t *dst_areas,
+                       const snd_pcm_channel_area_t *dst_areas,
                        size_t dst_offset,
                        size_t frames, size_t channels, int getputidx,
                        adpcm_state_t *states);
@@ -195,9 +195,9 @@ static int adpcm_decoder(unsigned char code, adpcm_state_t * state)
        return (state->pred_val);
 }
 
-static void adpcm_decode(snd_pcm_channel_area_t *src_areas,
+static void adpcm_decode(const snd_pcm_channel_area_t *src_areas,
                         size_t src_offset,
-                        snd_pcm_channel_area_t *dst_areas,
+                        const snd_pcm_channel_area_t *dst_areas,
                         size_t dst_offset,
                         size_t frames, size_t channels, int putidx,
                         adpcm_state_t *states)
@@ -213,8 +213,8 @@ static void adpcm_decode(snd_pcm_channel_area_t *src_areas,
                char *dst;
                int src_step, srcbit_step, dst_step;
                size_t frames1;
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 #if 0
                if (!src_area->enabled) {
                        if (dst_area->wanted)
@@ -256,9 +256,9 @@ static void adpcm_decode(snd_pcm_channel_area_t *src_areas,
        }
 }
 
-static void adpcm_encode(snd_pcm_channel_area_t *src_areas,
+static void adpcm_encode(const snd_pcm_channel_area_t *src_areas,
                         size_t src_offset,
-                        snd_pcm_channel_area_t *dst_areas,
+                        const snd_pcm_channel_area_t *dst_areas,
                         size_t dst_offset,
                         size_t frames, size_t channels, int getidx,
                         adpcm_state_t *states)
@@ -275,8 +275,8 @@ static void adpcm_encode(snd_pcm_channel_area_t *src_areas,
                int dstbit;
                int src_step, dst_step, dstbit_step;
                size_t frames1;
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 #if 0
                if (!src_area->enabled) {
                        if (dst_area->wanted)
@@ -410,7 +410,7 @@ static int snd_pcm_adpcm_init(snd_pcm_t *pcm)
 }
 
 static ssize_t snd_pcm_adpcm_write_areas(snd_pcm_t *pcm,
-                                        snd_pcm_channel_area_t *areas,
+                                        const snd_pcm_channel_area_t *areas,
                                         size_t offset,
                                         size_t size,
                                         size_t *slave_sizep)
@@ -445,7 +445,7 @@ static ssize_t snd_pcm_adpcm_write_areas(snd_pcm_t *pcm,
 }
 
 static ssize_t snd_pcm_adpcm_read_areas(snd_pcm_t *pcm,
-                                       snd_pcm_channel_area_t *areas,
+                                       const snd_pcm_channel_area_t *areas,
                                        size_t offset,
                                        size_t size,
                                        size_t *slave_sizep)

diff --git a/src/pcm/pcm_alaw.c b/src/pcm/pcm_alaw.c
index 4ea75ec..0b6c777 100644 (file)
--- a/src/pcm/pcm_alaw.c
+++ b/src/pcm/pcm_alaw.c
@@ -23,9 +23,9 @@
 #include "pcm_local.h"
 #include "pcm_plugin.h"
 
-typedef void (*alaw_f)(snd_pcm_channel_area_t *src_areas,
+typedef void (*alaw_f)(const snd_pcm_channel_area_t *src_areas,
                        size_t src_offset,
-                       snd_pcm_channel_area_t *dst_areas,
+                       const snd_pcm_channel_area_t *dst_areas,
                        size_t dst_offset,
                        size_t frames, size_t channels, int getputidx);
 
@@ -120,9 +120,9 @@ static int alaw_to_s16(unsigned char a_val)
        return ((a_val & 0x80) ? t : -t);
 }
 
-static void alaw_decode(snd_pcm_channel_area_t *src_areas,
+static void alaw_decode(const snd_pcm_channel_area_t *src_areas,
                        size_t src_offset,
-                       snd_pcm_channel_area_t *dst_areas,
+                       const snd_pcm_channel_area_t *dst_areas,
                        size_t dst_offset,
                        size_t frames, size_t channels, int putidx)
 {
@@ -136,8 +136,8 @@ static void alaw_decode(snd_pcm_channel_area_t *src_areas,
                char *dst;
                int src_step, dst_step;
                size_t frames1;
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 #if 0
                if (!src_area->enabled) {
                        if (dst_area->wanted)
@@ -165,9 +165,9 @@ static void alaw_decode(snd_pcm_channel_area_t *src_areas,
        }
 }
 
-static void alaw_encode(snd_pcm_channel_area_t *src_areas,
+static void alaw_encode(const snd_pcm_channel_area_t *src_areas,
                         size_t src_offset,
-                        snd_pcm_channel_area_t *dst_areas,
+                        const snd_pcm_channel_area_t *dst_areas,
                         size_t dst_offset,
                         size_t frames, size_t channels, int getidx)
 {
@@ -182,8 +182,8 @@ static void alaw_encode(snd_pcm_channel_area_t *src_areas,
                char *dst;
                int src_step, dst_step;
                size_t frames1;
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 #if 0
                if (!src_area->enabled) {
                        if (dst_area->wanted)
@@ -278,7 +278,7 @@ static int snd_pcm_alaw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
 }
 
 static ssize_t snd_pcm_alaw_write_areas(snd_pcm_t *pcm,
-                                       snd_pcm_channel_area_t *areas,
+                                       const snd_pcm_channel_area_t *areas,
                                        size_t offset,
                                        size_t size,
                                        size_t *slave_sizep)
@@ -313,7 +313,7 @@ static ssize_t snd_pcm_alaw_write_areas(snd_pcm_t *pcm,
 }
 
 static ssize_t snd_pcm_alaw_read_areas(snd_pcm_t *pcm,
-                                      snd_pcm_channel_area_t *areas,
+                                      const snd_pcm_channel_area_t *areas,
                                       size_t offset,
                                       size_t size,
                                       size_t *slave_sizep)

diff --git a/src/pcm/pcm_file.c b/src/pcm/pcm_file.c
index bebc751..2b563c3 100644 (file)
--- a/src/pcm/pcm_file.c
+++ b/src/pcm/pcm_file.c
@@ -142,7 +142,7 @@ static ssize_t snd_pcm_file_rewind(snd_pcm_t *pcm, size_t frames)
 }
 
 static void snd_pcm_file_write_areas(snd_pcm_t *pcm, 
-                                    snd_pcm_channel_area_t *areas,
+                                    const snd_pcm_channel_area_t *areas,
                                     size_t offset, size_t frames)
 {
        snd_pcm_file_t *file = pcm->private;

diff --git a/src/pcm/pcm_linear.c b/src/pcm/pcm_linear.c
index 5a608d4..b7f1440 100644 (file)
--- a/src/pcm/pcm_linear.c
+++ b/src/pcm/pcm_linear.c
@@ -30,8 +30,8 @@ typedef struct {
        int sformat;
 } snd_pcm_linear_t;
 
-static void linear_transfer(snd_pcm_channel_area_t *src_areas, size_t src_offset,
-                           snd_pcm_channel_area_t *dst_areas, size_t dst_offset,
+static void linear_transfer(const snd_pcm_channel_area_t *src_areas, size_t src_offset,
+                           const snd_pcm_channel_area_t *dst_areas, size_t dst_offset,
                            size_t frames, size_t channels, int convidx)
 {
 #define CONV_LABELS
@@ -44,8 +44,8 @@ static void linear_transfer(snd_pcm_channel_area_t *src_areas, size_t src_offset
                char *dst;
                int src_step, dst_step;
                size_t frames1;
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 #if 0
                if (!src_area->enabled) {
                        if (dst_area->wanted)
@@ -125,7 +125,7 @@ static int snd_pcm_linear_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 }
 
 static ssize_t snd_pcm_linear_write_areas(snd_pcm_t *pcm,
-                                         snd_pcm_channel_area_t *areas,
+                                         const snd_pcm_channel_area_t *areas,
                                          size_t offset,
                                          size_t size,
                                          size_t *slave_sizep)
@@ -159,7 +159,7 @@ static ssize_t snd_pcm_linear_write_areas(snd_pcm_t *pcm,
 }
 
 static ssize_t snd_pcm_linear_read_areas(snd_pcm_t *pcm,
-                                        snd_pcm_channel_area_t *areas,
+                                        const snd_pcm_channel_area_t *areas,
                                         size_t offset,
                                         size_t size,
                                         size_t *slave_sizep)

diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h
index df8af73..ba94da8 100644 (file)
--- a/src/pcm/pcm_local.h
+++ b/src/pcm/pcm_local.h
@@ -156,14 +156,14 @@ size_t snd_pcm_mmap_playback_xfer(snd_pcm_t *pcm, size_t frames);
 size_t snd_pcm_mmap_capture_xfer(snd_pcm_t *pcm, size_t frames);
 
 typedef ssize_t (*snd_pcm_xfer_areas_func_t)(snd_pcm_t *pcm, 
-                                            snd_pcm_channel_area_t *areas,
+                                            const snd_pcm_channel_area_t *areas,
                                             size_t offset, size_t size,
                                             size_t *slave_sizep);
 
-ssize_t snd_pcm_read_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
+ssize_t snd_pcm_read_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas,
                           size_t offset, size_t size,
                           snd_pcm_xfer_areas_func_t func);
-ssize_t snd_pcm_write_areas(snd_pcm_t *pcm, snd_pcm_channel_area_t *areas,
+ssize_t snd_pcm_write_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_t *areas,
                            size_t offset, size_t size,
                            snd_pcm_xfer_areas_func_t func);
 ssize_t snd_pcm_read_mmap(snd_pcm_t *pcm, size_t size);
@@ -243,14 +243,14 @@ static inline ssize_t snd_pcm_mmap_delay(snd_pcm_t *pcm)
                return snd_pcm_mmap_capture_delay(pcm);
 }
 
-static inline void *snd_pcm_channel_area_addr(snd_pcm_channel_area_t *area, size_t offset)
+static inline void *snd_pcm_channel_area_addr(const snd_pcm_channel_area_t *area, size_t offset)
 {
        size_t bitofs = area->first + area->step * offset;
        assert(bitofs % 8 == 0);
        return area->addr + bitofs / 8;
 }
 
-static inline size_t snd_pcm_channel_area_step(snd_pcm_channel_area_t *area)
+static inline size_t snd_pcm_channel_area_step(const snd_pcm_channel_area_t *area)
 {
        assert(area->step % 8 == 0);
        return area->step / 8;

diff --git a/src/pcm/pcm_mmap.c b/src/pcm/pcm_mmap.c
index cec3e19..a713471 100644 (file)
--- a/src/pcm/pcm_mmap.c
+++ b/src/pcm/pcm_mmap.c
@@ -34,7 +34,7 @@
 #endif
 
 
-snd_pcm_channel_area_t *snd_pcm_mmap_areas(snd_pcm_t *pcm)
+const snd_pcm_channel_area_t *snd_pcm_mmap_areas(snd_pcm_t *pcm)
 {
        if (pcm->stopped_areas &&
            snd_pcm_state(pcm) != SND_PCM_STATE_RUNNING) 
@@ -124,7 +124,7 @@ void snd_pcm_mmap_hw_forward(snd_pcm_t *pcm, size_t frames)
 }
 
 ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm,
-                                snd_pcm_channel_area_t *areas,
+                                const snd_pcm_channel_area_t *areas,
                                 size_t offset,
                                 size_t size,
                                 size_t *slave_sizep)
@@ -151,7 +151,7 @@ ssize_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm,
 }
 
 ssize_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm,
-                               snd_pcm_channel_area_t *areas,
+                               const snd_pcm_channel_area_t *areas,
                                size_t offset,
                                size_t size,
                                size_t *slave_sizep)
@@ -400,7 +400,9 @@ int snd_pcm_munmap(snd_pcm_t *pcm)
        if (err < 0)
                return err;
        free(pcm->mmap_channels);
+       free(pcm->running_areas);
        pcm->mmap_channels = 0;
+       pcm->running_areas = 0;
        return 0;
 }
 
@@ -418,7 +420,7 @@ ssize_t snd_pcm_write_mmap(snd_pcm_t *pcm, size_t size)
                switch (pcm->access) {
                case SND_PCM_ACCESS_MMAP_INTERLEAVED:
                {
-                       snd_pcm_channel_area_t *a = snd_pcm_mmap_areas(pcm);
+                       const snd_pcm_channel_area_t *a = snd_pcm_mmap_areas(pcm);
                        char *buf = snd_pcm_channel_area_addr(a, offset);
                        err = _snd_pcm_writei(pcm, buf, size);
                        break;
@@ -428,9 +430,9 @@ ssize_t snd_pcm_write_mmap(snd_pcm_t *pcm, size_t size)
                        size_t channels = pcm->channels;
                        unsigned int c;
                        void *bufs[channels];
-                       snd_pcm_channel_area_t *areas = snd_pcm_mmap_areas(pcm);
+                       const snd_pcm_channel_area_t *areas = snd_pcm_mmap_areas(pcm);
                        for (c = 0; c < channels; ++c) {
-                               snd_pcm_channel_area_t *a = &areas[c];
+                               const snd_pcm_channel_area_t *a = &areas[c];
                                bufs[c] = snd_pcm_channel_area_addr(a, offset);
                        }
                        err = _snd_pcm_writen(pcm, bufs, size);
@@ -464,7 +466,7 @@ ssize_t snd_pcm_read_mmap(snd_pcm_t *pcm, size_t size)
                switch (pcm->access) {
                case SND_PCM_ACCESS_MMAP_INTERLEAVED:
                {
-                       snd_pcm_channel_area_t *a = snd_pcm_mmap_areas(pcm);
+                       const snd_pcm_channel_area_t *a = snd_pcm_mmap_areas(pcm);
                        char *buf = snd_pcm_channel_area_addr(a, offset);
                        err = _snd_pcm_readi(pcm, buf, size);
                        break;
@@ -474,9 +476,9 @@ ssize_t snd_pcm_read_mmap(snd_pcm_t *pcm, size_t size)
                        size_t channels = pcm->channels;
                        unsigned int c;
                        void *bufs[channels];
-                       snd_pcm_channel_area_t *areas = snd_pcm_mmap_areas(pcm);
+                       const snd_pcm_channel_area_t *areas = snd_pcm_mmap_areas(pcm);
                        for (c = 0; c < channels; ++c) {
-                               snd_pcm_channel_area_t *a = &areas[c];
+                               const snd_pcm_channel_area_t *a = &areas[c];
                                bufs[c] = snd_pcm_channel_area_addr(a, offset);
                        }
                        err = _snd_pcm_readn(pcm->fast_op_arg, bufs, size);

diff --git a/src/pcm/pcm_mulaw.c b/src/pcm/pcm_mulaw.c
index 489a697..3f114bd 100644 (file)
--- a/src/pcm/pcm_mulaw.c
+++ b/src/pcm/pcm_mulaw.c
@@ -23,9 +23,9 @@
 #include "pcm_local.h"
 #include "pcm_plugin.h"
 
-typedef void (*mulaw_f)(snd_pcm_channel_area_t *src_areas,
+typedef void (*mulaw_f)(const snd_pcm_channel_area_t *src_areas,
                        size_t src_offset,
-                       snd_pcm_channel_area_t *dst_areas,
+                       const snd_pcm_channel_area_t *dst_areas,
                        size_t dst_offset,
                        size_t frames, size_t channels, int getputidx);
 
@@ -137,9 +137,9 @@ static int ulaw_to_s16(unsigned char u_val)
        return ((u_val & 0x80) ? (0x84 - t) : (t - 0x84));
 }
 
-static void mulaw_decode(snd_pcm_channel_area_t *src_areas,
+static void mulaw_decode(const snd_pcm_channel_area_t *src_areas,
                         size_t src_offset,
-                        snd_pcm_channel_area_t *dst_areas,
+                        const snd_pcm_channel_area_t *dst_areas,
                         size_t dst_offset,
                         size_t frames, size_t channels, int putidx)
 {
@@ -153,8 +153,8 @@ static void mulaw_decode(snd_pcm_channel_area_t *src_areas,
                char *dst;
                int src_step, dst_step;
                size_t frames1;
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 #if 0
                if (!src_area->enabled) {
                        if (dst_area->wanted)
@@ -182,9 +182,9 @@ static void mulaw_decode(snd_pcm_channel_area_t *src_areas,
        }
 }
 
-static void mulaw_encode(snd_pcm_channel_area_t *src_areas,
+static void mulaw_encode(const snd_pcm_channel_area_t *src_areas,
                         size_t src_offset,
-                        snd_pcm_channel_area_t *dst_areas,
+                        const snd_pcm_channel_area_t *dst_areas,
                         size_t dst_offset,
                         size_t frames, size_t channels, int getidx)
 {
@@ -199,8 +199,8 @@ static void mulaw_encode(snd_pcm_channel_area_t *src_areas,
                char *dst;
                int src_step, dst_step;
                size_t frames1;
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 #if 0
                if (!src_area->enabled) {
                        if (dst_area->wanted)
@@ -295,7 +295,7 @@ static int snd_pcm_mulaw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
 }
 
 static ssize_t snd_pcm_mulaw_write_areas(snd_pcm_t *pcm,
-                                        snd_pcm_channel_area_t *areas,
+                                        const snd_pcm_channel_area_t *areas,
                                         size_t offset,
                                         size_t size,
                                         size_t *slave_sizep)
@@ -330,7 +330,7 @@ static ssize_t snd_pcm_mulaw_write_areas(snd_pcm_t *pcm,
 }
 
 static ssize_t snd_pcm_mulaw_read_areas(snd_pcm_t *pcm,
-                                       snd_pcm_channel_area_t *areas,
+                                       const snd_pcm_channel_area_t *areas,
                                        size_t offset,
                                        size_t size,
                                        size_t *slave_sizep)

diff --git a/src/pcm/pcm_rate.c b/src/pcm/pcm_rate.c
index 8bdb51f..f64ab88 100644 (file)
--- a/src/pcm/pcm_rate.c
+++ b/src/pcm/pcm_rate.c
@@ -32,9 +32,9 @@ typedef struct {
        unsigned int pos;
 } rate_state_t;
  
-typedef size_t (*rate_f)(snd_pcm_channel_area_t *src_areas,
+typedef size_t (*rate_f)(const snd_pcm_channel_area_t *src_areas,
                         size_t src_offset, size_t src_frames,
-                        snd_pcm_channel_area_t *dst_areas,
+                        const snd_pcm_channel_area_t *dst_areas,
                         size_t dst_offset, size_t *dst_framesp,
                         size_t channels,
                         int getidx, int putidx,
@@ -53,9 +53,9 @@ typedef struct {
        rate_state_t *states;
 } snd_pcm_rate_t;
 
-static size_t resample_expand(snd_pcm_channel_area_t *src_areas,
+static size_t resample_expand(const snd_pcm_channel_area_t *src_areas,
                              size_t src_offset, size_t src_frames,
-                             snd_pcm_channel_area_t *dst_areas,
+                             const snd_pcm_channel_area_t *dst_areas,
                              size_t dst_offset, size_t *dst_framesp,
                              size_t channels,
                              int getidx, int putidx,
@@ -79,8 +79,8 @@ static size_t resample_expand(snd_pcm_channel_area_t *src_areas,
            dst_frames == 0)
                return 0;
        for (channel = 0; channel < channels; ++channel) {
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
                char *src, *dst;
                int src_step, dst_step;
                int16_t old_sample = states->sample;
@@ -135,9 +135,9 @@ static size_t resample_expand(snd_pcm_channel_area_t *src_areas,
        return src_frames1;
 }
 
-static size_t resample_shrink(snd_pcm_channel_area_t *src_areas,
+static size_t resample_shrink(const snd_pcm_channel_area_t *src_areas,
                              size_t src_offset, size_t src_frames,
-                             snd_pcm_channel_area_t *dst_areas,
+                             const snd_pcm_channel_area_t *dst_areas,
                              size_t dst_offset, size_t *dst_framesp,
                              size_t channels,
                              int getidx, int putidx,
@@ -161,8 +161,8 @@ static size_t resample_shrink(snd_pcm_channel_area_t *src_areas,
            dst_frames == 0)
                return 0;
        for (channel = 0; channel < channels; ++channel) {
-               snd_pcm_channel_area_t *src_area = &src_areas[channel];
-               snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[channel];
+               const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
                unsigned int pos;
                int sum;
                char *src, *dst;
@@ -400,7 +400,7 @@ static int snd_pcm_rate_init(snd_pcm_t *pcm)
 }
 
 static ssize_t snd_pcm_rate_write_areas(snd_pcm_t *pcm,
-                                       snd_pcm_channel_area_t *areas,
+                                       const snd_pcm_channel_area_t *areas,
                                        size_t client_offset,
                                        size_t client_size,
                                        size_t *slave_sizep)
@@ -445,7 +445,7 @@ static ssize_t snd_pcm_rate_write_areas(snd_pcm_t *pcm,
 }
 
 static ssize_t snd_pcm_rate_read_areas(snd_pcm_t *pcm,
-                                      snd_pcm_channel_area_t *areas,
+                                      const snd_pcm_channel_area_t *areas,
                                       size_t client_offset,
                                       size_t client_size,
                                       size_t *slave_sizep)

diff --git a/src/pcm/pcm_route.c b/src/pcm/pcm_route.c
index 7f6785b..8d1cb64 100644 (file)
--- a/src/pcm/pcm_route.c
+++ b/src/pcm/pcm_route.c
@@ -55,13 +55,13 @@ typedef struct {
 } route_params_t;
 
 
-typedef void (*route_f)(snd_pcm_channel_area_t *src_areas,
+typedef void (*route_f)(const snd_pcm_channel_area_t *src_areas,
                        size_t src_offset,
-                       snd_pcm_channel_area_t *dst_area,
+                       const snd_pcm_channel_area_t *dst_area,
                        size_t dst_offset,
                        size_t frames,
-                       ttable_dst_t *ttable,
-                       route_params_t *params);
+                       const ttable_dst_t *ttable,
+                       const route_params_t *params);
 
 struct ttable_dst {
        int att;        /* Attenuated */
@@ -87,13 +87,13 @@ typedef struct {
 } snd_pcm_route_t;
 
 
-static void route1_zero(snd_pcm_channel_area_t *src_areas ATTRIBUTE_UNUSED,
+static void route1_zero(const snd_pcm_channel_area_t *src_areas ATTRIBUTE_UNUSED,
                        size_t src_offset ATTRIBUTE_UNUSED,
-                       snd_pcm_channel_area_t *dst_area,
+                       const snd_pcm_channel_area_t *dst_area,
                        size_t dst_offset,
                        size_t frames,
-                       ttable_dst_t* ttable ATTRIBUTE_UNUSED,
-                       route_params_t *params)
+                       const ttable_dst_t* ttable ATTRIBUTE_UNUSED,
+                       const route_params_t *params)
 {
 #if 0
        if (dst_area->wanted)
@@ -104,19 +104,19 @@ static void route1_zero(snd_pcm_channel_area_t *src_areas ATTRIBUTE_UNUSED,
 #endif
 }
 
-static void route1_one(snd_pcm_channel_area_t *src_areas,
+static void route1_one(const snd_pcm_channel_area_t *src_areas,
                       size_t src_offset,
-                      snd_pcm_channel_area_t *dst_area,
+                      const snd_pcm_channel_area_t *dst_area,
                       size_t dst_offset,
                       size_t frames,
-                      ttable_dst_t* ttable,
-                      route_params_t *params)
+                      const ttable_dst_t* ttable,
+                      const route_params_t *params)
 {
 #define CONV_LABELS
 #include "plugin_ops.h"
 #undef CONV_LABELS
        void *conv;
-       snd_pcm_channel_area_t *src_area = 0;
+       const snd_pcm_channel_area_t *src_area = 0;
        unsigned int srcidx;
        char *src, *dst;
        int src_step, dst_step;
@@ -149,13 +149,13 @@ static void route1_one(snd_pcm_channel_area_t *src_areas,
        }
 }
 
-static void route1_many(snd_pcm_channel_area_t *src_areas,
+static void route1_many(const snd_pcm_channel_area_t *src_areas,
                        size_t src_offset,
-                       snd_pcm_channel_area_t *dst_area,
+                       const snd_pcm_channel_area_t *dst_area,
                        size_t dst_offset,
                        size_t frames,
-                       ttable_dst_t* ttable,
-                       route_params_t *params)
+                       const ttable_dst_t* ttable,
+                       const route_params_t *params)
 {
 #define GET_LABELS
 #define PUT32_LABELS
@@ -212,7 +212,7 @@ static void route1_many(snd_pcm_channel_area_t *src_areas,
        u_int32_t sample = 0;
        int srcidx, srcidx1 = 0;
        for (srcidx = 0; srcidx < nsrcs; ++srcidx) {
-               snd_pcm_channel_area_t *src_area = &src_areas[ttable->srcs[srcidx].channel];
+               const snd_pcm_channel_area_t *src_area = &src_areas[ttable->srcs[srcidx].channel];
 #if 0
                if (!src_area->enabled)
                        continue;
@@ -382,9 +382,9 @@ static void route1_many(snd_pcm_channel_area_t *src_areas,
        }
 }
 
-static void route_transfer(snd_pcm_channel_area_t *src_areas,
+static void route_transfer(const snd_pcm_channel_area_t *src_areas,
                           size_t src_offset,
-                          snd_pcm_channel_area_t *dst_areas,
+                          const snd_pcm_channel_area_t *dst_areas,
                           size_t dst_offset,
                           size_t frames,
                           size_t dst_channels,
@@ -392,7 +392,7 @@ static void route_transfer(snd_pcm_channel_area_t *src_areas,
 {
        size_t dst_channel;
        ttable_dst_t *dstp;
-       snd_pcm_channel_area_t *dst_area;
+       const snd_pcm_channel_area_t *dst_area;
 
        dstp = params->dsts;
        dst_area = dst_areas;
@@ -514,7 +514,7 @@ static int snd_pcm_route_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
 }
 
 static ssize_t snd_pcm_route_write_areas(snd_pcm_t *pcm,
-                                        snd_pcm_channel_area_t *areas,
+                                        const snd_pcm_channel_area_t *areas,
                                         size_t offset,
                                         size_t size,
                                         size_t *slave_sizep)
@@ -548,7 +548,7 @@ static ssize_t snd_pcm_route_write_areas(snd_pcm_t *pcm,
 }
 
 static ssize_t snd_pcm_route_read_areas(snd_pcm_t *pcm,
-                                        snd_pcm_channel_area_t *areas,
+                                        const snd_pcm_channel_area_t *areas,
                                         size_t offset,
                                         size_t size,
                                         size_t *slave_sizep)