[PATCH 15/23] core: mix: Split pa_mix() code using function table

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



have individual function for mixing stream with different sample format instead
of huge case block in pa_mix()

shorter functions, prepare for optimized code path

Signed-off-by: Peter Meerwald <pmeerw at pmeerw.net>
---
 src/pulsecore/mix.c |  674 +++++++++++++++++++++++++--------------------------
 1 file changed, 330 insertions(+), 344 deletions(-)

diff --git a/src/pulsecore/mix.c b/src/pulsecore/mix.c
index af854cc..2a132e1 100644
--- a/src/pulsecore/mix.c
+++ b/src/pulsecore/mix.c
@@ -122,490 +122,476 @@ static const pa_calc_stream_volumes_func_t calc_stream_volumes_table[] = {
   [PA_SAMPLE_S24_32BE]  = (pa_calc_stream_volumes_func_t) calc_linear_integer_stream_volumes
 };
 
-size_t pa_mix(
-        pa_mix_info streams[],
-        unsigned nstreams,
-        void *data,
-        size_t length,
-        const pa_sample_spec *spec,
-        const pa_cvolume *volume,
-        pa_bool_t mute) {
-
-    pa_cvolume full_volume;
-    unsigned k;
-    unsigned z;
-    void *end;
-
-    pa_assert(streams);
-    pa_assert(data);
-    pa_assert(length);
-    pa_assert(spec);
-
-    if (!volume)
-        volume = pa_cvolume_reset(&full_volume, spec->channels);
+static void pa_mix_s16ne_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-    if (mute || pa_cvolume_is_muted(volume) || nstreams <= 0) {
-        pa_silence_memory(data, length, spec);
-        return length;
-    }
-
-    for (k = 0; k < nstreams; k++)
-        streams[k].ptr = pa_memblock_acquire_chunk(&streams[k].chunk);
+    while (data < end) {
+        int32_t sum = 0;
+        unsigned i;
 
-    for (z = 0; z < nstreams; z++)
-        if (length > streams[z].chunk.length)
-            length = streams[z].chunk.length;
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t v, lo, hi, cv = m->linear[channel].i;
 
-    end = (uint8_t*) data + length;
+            if (PA_LIKELY(cv > 0)) {
 
-    calc_stream_volumes_table[spec->format](streams, nstreams, volume, spec);
+                /* Multiplying the 32bit volume factor with the
+                 * 16bit sample might result in an 48bit value. We
+                 * want to do without 64 bit integers and hence do
+                 * the multiplication independently for the HI and
+                 * LO part of the volume. */
 
-    switch (spec->format) {
+                hi = cv >> 16;
+                lo = cv & 0xFFFF;
 
-        case PA_SAMPLE_S16NE:{
-            unsigned channel = 0;
+                v = *((int16_t*) m->ptr);
+                v = ((v * lo) >> 16) + (v * hi);
+                sum += v;
+            }
+            m->ptr = (uint8_t*) m->ptr + sizeof(int16_t);
+        }
 
-            while (data < end) {
-                int32_t sum = 0;
-                unsigned i;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
+        *((int16_t*) data) = (int16_t) sum;
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t v, lo, hi, cv = m->linear[channel].i;
+        data = (uint8_t*) data + sizeof(int16_t);
 
-                    if (PA_LIKELY(cv > 0)) {
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                        /* Multiplying the 32bit volume factor with the
-                         * 16bit sample might result in an 48bit value. We
-                         * want to do without 64 bit integers and hence do
-                         * the multiplication independently for the HI and
-                         * LO part of the volume. */
+static void pa_mix_s16re_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        hi = cv >> 16;
-                        lo = cv & 0xFFFF;
+    while (data < end) {
+        int32_t sum = 0;
+        unsigned i;
 
-                        v = *((int16_t*) m->ptr);
-                        v = ((v * lo) >> 16) + (v * hi);
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + sizeof(int16_t);
-                }
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t v, lo, hi, cv = m->linear[channel].i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
-                *((int16_t*) data) = (int16_t) sum;
+            if (PA_LIKELY(cv > 0)) {
 
-                data = (uint8_t*) data + sizeof(int16_t);
+                hi = cv >> 16;
+                lo = cv & 0xFFFF;
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = PA_INT16_SWAP(*((int16_t*) m->ptr));
+                v = ((v * lo) >> 16) + (v * hi);
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + sizeof(int16_t);
         }
 
-        case PA_SAMPLE_S16RE:{
-            unsigned channel = 0;
-
-            while (data < end) {
-                int32_t sum = 0;
-                unsigned i;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
+        *((int16_t*) data) = PA_INT16_SWAP((int16_t) sum);
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t v, lo, hi, cv = m->linear[channel].i;
+        data = (uint8_t*) data + sizeof(int16_t);
 
-                    if (PA_LIKELY(cv > 0)) {
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                        hi = cv >> 16;
-                        lo = cv & 0xFFFF;
+static void pa_mix_s32ne_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = PA_INT16_SWAP(*((int16_t*) m->ptr));
-                        v = ((v * lo) >> 16) + (v * hi);
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + sizeof(int16_t);
-                }
+    while (data < end) {
+        int64_t sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
-                *((int16_t*) data) = PA_INT16_SWAP((int16_t) sum);
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t cv = m->linear[channel].i;
+            int64_t v;
 
-                data = (uint8_t*) data + sizeof(int16_t);
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = *((int32_t*) m->ptr);
+                v = (v * cv) >> 16;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + sizeof(int32_t);
         }
 
-        case PA_SAMPLE_S32NE:{
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
+        *((int32_t*) data) = (int32_t) sum;
 
-            while (data < end) {
-                int64_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + sizeof(int32_t);
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t cv = m->linear[channel].i;
-                    int64_t v;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_s32re_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = *((int32_t*) m->ptr);
-                        v = (v * cv) >> 16;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + sizeof(int32_t);
-                }
+    while (data < end) {
+        int64_t sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
-                *((int32_t*) data) = (int32_t) sum;
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t cv = m->linear[channel].i;
+            int64_t v;
 
-                data = (uint8_t*) data + sizeof(int32_t);
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = PA_INT32_SWAP(*((int32_t*) m->ptr));
+                v = (v * cv) >> 16;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + sizeof(int32_t);
         }
 
-        case PA_SAMPLE_S32RE:{
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
+        *((int32_t*) data) = PA_INT32_SWAP((int32_t) sum);
 
-            while (data < end) {
-                int64_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + sizeof(int32_t);
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t cv = m->linear[channel].i;
-                    int64_t v;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_s24ne_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = PA_INT32_SWAP(*((int32_t*) m->ptr));
-                        v = (v * cv) >> 16;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + sizeof(int32_t);
-                }
+    while (data < end) {
+        int64_t sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
-                *((int32_t*) data) = PA_INT32_SWAP((int32_t) sum);
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t cv = m->linear[channel].i;
+            int64_t v;
 
-                data = (uint8_t*) data + sizeof(int32_t);
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = (int32_t) (PA_READ24NE(m->ptr) << 8);
+                v = (v * cv) >> 16;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + 3;
         }
 
-        case PA_SAMPLE_S24NE: {
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
+        PA_WRITE24NE(data, ((uint32_t) sum) >> 8);
 
-            while (data < end) {
-                int64_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + 3;
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t cv = m->linear[channel].i;
-                    int64_t v;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_s24re_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = (int32_t) (PA_READ24NE(m->ptr) << 8);
-                        v = (v * cv) >> 16;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + 3;
-                }
+    while (data < end) {
+        int64_t sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
-                PA_WRITE24NE(data, ((uint32_t) sum) >> 8);
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t cv = m->linear[channel].i;
+            int64_t v;
 
-                data = (uint8_t*) data + 3;
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = (int32_t) (PA_READ24RE(m->ptr) << 8);
+                v = (v * cv) >> 16;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + 3;
         }
 
-        case PA_SAMPLE_S24RE: {
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
+        PA_WRITE24RE(data, ((uint32_t) sum) >> 8);
 
-            while (data < end) {
-                int64_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + 3;
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t cv = m->linear[channel].i;
-                    int64_t v;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_s24_32ne_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = (int32_t) (PA_READ24RE(m->ptr) << 8);
-                        v = (v * cv) >> 16;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + 3;
-                }
+    while (data < end) {
+        int64_t sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
-                PA_WRITE24RE(data, ((uint32_t) sum) >> 8);
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t cv = m->linear[channel].i;
+            int64_t v;
 
-                data = (uint8_t*) data + 3;
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = (int32_t) (*((uint32_t*)m->ptr) << 8);
+                v = (v * cv) >> 16;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + sizeof(int32_t);
         }
 
-        case PA_SAMPLE_S24_32NE: {
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
+        *((uint32_t*) data) = ((uint32_t) (int32_t) sum) >> 8;
 
-            while (data < end) {
-                int64_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + sizeof(uint32_t);
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t cv = m->linear[channel].i;
-                    int64_t v;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_s24_32re_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = (int32_t) (*((uint32_t*)m->ptr) << 8);
-                        v = (v * cv) >> 16;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + sizeof(int32_t);
-                }
+    while (data < end) {
+        int64_t sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
-                *((uint32_t*) data) = ((uint32_t) (int32_t) sum) >> 8;
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t cv = m->linear[channel].i;
+            int64_t v;
 
-                data = (uint8_t*) data + sizeof(uint32_t);
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = (int32_t) (PA_UINT32_SWAP(*((uint32_t*) m->ptr)) << 8);
+                v = (v * cv) >> 16;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + 3;
         }
 
-        case PA_SAMPLE_S24_32RE: {
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
+        *((uint32_t*) data) = PA_INT32_SWAP(((uint32_t) (int32_t) sum) >> 8);
 
-            while (data < end) {
-                int64_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + sizeof(uint32_t);
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t cv = m->linear[channel].i;
-                    int64_t v;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_u8_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = (int32_t) (PA_UINT32_SWAP(*((uint32_t*) m->ptr)) << 8);
-                        v = (v * cv) >> 16;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + 3;
-                }
+    while (data < end) {
+        int32_t sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x80000000LL, 0x7FFFFFFFLL);
-                *((uint32_t*) data) = PA_INT32_SWAP(((uint32_t) (int32_t) sum) >> 8);
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t v, cv = m->linear[channel].i;
 
-                data = (uint8_t*) data + sizeof(uint32_t);
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = (int32_t) *((uint8_t*) m->ptr) - 0x80;
+                v = (v * cv) >> 16;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + 1;
         }
 
-        case PA_SAMPLE_U8: {
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x80, 0x7F);
+        *((uint8_t*) data) = (uint8_t) (sum + 0x80);
 
-            while (data < end) {
-                int32_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + 1;
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t v, cv = m->linear[channel].i;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_ulaw_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = (int32_t) *((uint8_t*) m->ptr) - 0x80;
-                        v = (v * cv) >> 16;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + 1;
-                }
+    while (data < end) {
+        int32_t sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x80, 0x7F);
-                *((uint8_t*) data) = (uint8_t) (sum + 0x80);
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t v, hi, lo, cv = m->linear[channel].i;
 
-                data = (uint8_t*) data + 1;
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
-            }
+                hi = cv >> 16;
+                lo = cv & 0xFFFF;
 
-            break;
+                v = (int32_t) st_ulaw2linear16(*((uint8_t*) m->ptr));
+                v = ((v * lo) >> 16) + (v * hi);
+                sum += v;
+            }
+            m->ptr = (uint8_t*) m->ptr + 1;
         }
 
-        case PA_SAMPLE_ULAW: {
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
+        *((uint8_t*) data) = (uint8_t) st_14linear2ulaw((int16_t) sum >> 2);
 
-            while (data < end) {
-                int32_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + 1;
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t v, hi, lo, cv = m->linear[channel].i;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_alaw_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        hi = cv >> 16;
-                        lo = cv & 0xFFFF;
+    while (data < end) {
+        int32_t sum = 0;
+        unsigned i;
 
-                        v = (int32_t) st_ulaw2linear16(*((uint8_t*) m->ptr));
-                        v = ((v * lo) >> 16) + (v * hi);
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + 1;
-                }
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            int32_t v, hi, lo, cv = m->linear[channel].i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
-                *((uint8_t*) data) = (uint8_t) st_14linear2ulaw((int16_t) sum >> 2);
+            if (PA_LIKELY(cv > 0)) {
 
-                data = (uint8_t*) data + 1;
+                hi = cv >> 16;
+                lo = cv & 0xFFFF;
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = (int32_t) st_alaw2linear16(*((uint8_t*) m->ptr));
+                v = ((v * lo) >> 16) + (v * hi);
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + 1;
         }
 
-        case PA_SAMPLE_ALAW: {
-            unsigned channel = 0;
+        sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
+        *((uint8_t*) data) = (uint8_t) st_13linear2alaw((int16_t) sum >> 3);
 
-            while (data < end) {
-                int32_t sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + 1;
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    int32_t v, hi, lo, cv = m->linear[channel].i;
-
-                    if (PA_LIKELY(cv > 0)) {
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                        hi = cv >> 16;
-                        lo = cv & 0xFFFF;
+static void pa_mix_float32ne_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = (int32_t) st_alaw2linear16(*((uint8_t*) m->ptr));
-                        v = ((v * lo) >> 16) + (v * hi);
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + 1;
-                }
+    while (data < end) {
+        float sum = 0;
+        unsigned i;
 
-                sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
-                *((uint8_t*) data) = (uint8_t) st_13linear2alaw((int16_t) sum >> 3);
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            float v, cv = m->linear[channel].f;
 
-                data = (uint8_t*) data + 1;
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = *((float*) m->ptr);
+                v *= cv;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + sizeof(float);
         }
 
-        case PA_SAMPLE_FLOAT32NE: {
-            unsigned channel = 0;
+        *((float*) data) = sum;
 
-            while (data < end) {
-                float sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + sizeof(float);
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    float v, cv = m->linear[channel].f;
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                    if (PA_LIKELY(cv > 0)) {
+static void pa_mix_float32re_c(pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end) {
+    unsigned channel = 0;
 
-                        v = *((float*) m->ptr);
-                        v *= cv;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + sizeof(float);
-                }
+    while (data < end) {
+        float sum = 0;
+        unsigned i;
 
-                *((float*) data) = sum;
+        for (i = 0; i < nstreams; i++) {
+            pa_mix_info *m = streams + i;
+            float v, cv = m->linear[channel].f;
 
-                data = (uint8_t*) data + sizeof(float);
+            if (PA_LIKELY(cv > 0)) {
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
+                v = PA_FLOAT32_SWAP(*(float*) m->ptr);
+                v *= cv;
+                sum += v;
             }
-
-            break;
+            m->ptr = (uint8_t*) m->ptr + sizeof(float);
         }
 
-        case PA_SAMPLE_FLOAT32RE: {
-            unsigned channel = 0;
+        *((float*) data) = PA_FLOAT32_SWAP(sum);
 
-            while (data < end) {
-                float sum = 0;
-                unsigned i;
+        data = (uint8_t*) data + sizeof(float);
 
-                for (i = 0; i < nstreams; i++) {
-                    pa_mix_info *m = streams + i;
-                    float v, cv = m->linear[channel].f;
-
-                    if (PA_LIKELY(cv > 0)) {
+        if (PA_UNLIKELY(++channel >= channels))
+            channel = 0;
+    }
+}
 
-                        v = PA_FLOAT32_SWAP(*(float*) m->ptr);
-                        v *= cv;
-                        sum += v;
-                    }
-                    m->ptr = (uint8_t*) m->ptr + sizeof(float);
-                }
+typedef void (*pa_do_mix_func_t) (pa_mix_info streams[], unsigned nstreams, unsigned channels, void *data, void *end);
+
+static pa_do_mix_func_t do_mix_table[] = {
+    [PA_SAMPLE_U8]        = (pa_do_mix_func_t) pa_mix_u8_c,
+    [PA_SAMPLE_ALAW]      = (pa_do_mix_func_t) pa_mix_alaw_c,
+    [PA_SAMPLE_ULAW]      = (pa_do_mix_func_t) pa_mix_ulaw_c,
+    [PA_SAMPLE_S16NE]     = (pa_do_mix_func_t) pa_mix_s16ne_c,
+    [PA_SAMPLE_S16RE]     = (pa_do_mix_func_t) pa_mix_s16re_c,
+    [PA_SAMPLE_FLOAT32NE] = (pa_do_mix_func_t) pa_mix_float32ne_c,
+    [PA_SAMPLE_FLOAT32RE] = (pa_do_mix_func_t) pa_mix_float32re_c,
+    [PA_SAMPLE_S32NE]     = (pa_do_mix_func_t) pa_mix_s32ne_c,
+    [PA_SAMPLE_S32RE]     = (pa_do_mix_func_t) pa_mix_s32re_c,
+    [PA_SAMPLE_S24NE]     = (pa_do_mix_func_t) pa_mix_s24ne_c,
+    [PA_SAMPLE_S24RE]     = (pa_do_mix_func_t) pa_mix_s24re_c,
+    [PA_SAMPLE_S24_32NE]  = (pa_do_mix_func_t) pa_mix_s24_32ne_c,
+    [PA_SAMPLE_S24_32RE]  = (pa_do_mix_func_t) pa_mix_s24_32re_c
+};
 
-                *((float*) data) = PA_FLOAT32_SWAP(sum);
+size_t pa_mix(
+        pa_mix_info streams[],
+        unsigned nstreams,
+        void *data,
+        size_t length,
+        const pa_sample_spec *spec,
+        const pa_cvolume *volume,
+        pa_bool_t mute) {
 
-                data = (uint8_t*) data + sizeof(float);
+    pa_cvolume full_volume;
+    unsigned k;
+    unsigned z;
+    void *end;
 
-                if (PA_UNLIKELY(++channel >= spec->channels))
-                    channel = 0;
-            }
+    pa_assert(streams);
+    pa_assert(data);
+    pa_assert(length);
+    pa_assert(spec);
 
-            break;
-        }
+    if (!volume)
+        volume = pa_cvolume_reset(&full_volume, spec->channels);
 
-        default:
-            pa_log_error("Unable to mix audio data of format %s.", pa_sample_format_to_string(spec->format));
-            pa_assert_not_reached();
+    if (mute || pa_cvolume_is_muted(volume) || nstreams <= 0) {
+        pa_silence_memory(data, length, spec);
+        return length;
     }
 
     for (k = 0; k < nstreams; k++)
+        streams[k].ptr = pa_memblock_acquire_chunk(&streams[k].chunk);
+
+    for (z = 0; z < nstreams; z++)
+        if (length > streams[z].chunk.length)
+            length = streams[z].chunk.length;
+
+    end = (uint8_t*) data + length;
+
+    calc_stream_volumes_table[spec->format](streams, nstreams, volume, spec);
+    do_mix_table[spec->format](streams, nstreams, spec->channels, data, end);
+
+    for (k = 0; k < nstreams; k++)
         pa_memblock_release(streams[k].chunk.memblock);
 
     return length;
-- 
1.7.9.5



[Index of Archives]     [Linux Audio Users]     [AMD Graphics]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux