Changeset bb67def in mainline

Timestamp:

2012-07-16T21:06:11Z (12 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

389ef25

Parents:

50fa3f7

Message:

hound: Implement audio format covnersion.

No resampling yet.

Location:

uspace/srv/audio/hound

Files:

• audio_format.c (modified) (4 diffs)
• audio_source.c (modified) (1 diff)

uspace/srv/audio/hound/audio_format.c

@@ -38 +38 @@
 #include <errno.h>
 #include <macros.h>
+#include <stdio.h>
 
 #include "audio_format.h"
@@ -63 +64 @@
 #define int32_t_be2host(x) uint32_t_be2host(x)
 #define host2int32_t_be(x) host2uint32_t_be(x)
+
+// TODO float endian?
+#define float_le2host(x) (x)
+#define float_be2host(x) (x)
+
+#define host2float_le(x) (x)
+#define host2float_be(x) (x)
+
+#define from(x, type, endian) (float)(type ## _ ## endian ## 2host(x))
+#define to(x, type, endian) (float)(host2 ## type ## _ ## endian(x))
+
+static float get_normalized_sample(const void *buffer, size_t size,
+    unsigned frame, unsigned channel, const audio_format_t *f);
 
 bool audio_format_same(const audio_format_t *a, const audio_format_t* b)
@@ -84 +98 @@
         /* This is so ugly it eats kittens, and puppies, and ducklings,
          * and all little fluffy things...
-         * AND it does not check for overflows (FIXME)*/
-#define LOOP_ADD(type, endian, max) \
+         */
+#define LOOP_ADD(type, endian, low, high) \
 do { \
-        const type *src_buff = src; \
-        type *dst_buff = dst; \
-        for (size_t i = 0; i < size / sizeof(type); ++i) { \
-                const float a = type ## _ ## endian ##2host(dst_buff[i]); \
-                const float b = type ## _ ## endian ##2host(src_buff[i]); \
-                float c = min((a + b), max); \
-                if (c <= (float)-max) c = -max + 1.0; \
-                dst_buff[i] = host2 ## type ## _ ## endian(c); \
+        const unsigned frame_size = audio_format_frame_size(f); \
+        const unsigned frame_count = size / frame_size; \
+        for (size_t i = 0; i < frame_count; ++i) { \
+                for (unsigned j = 0; j < f->channels; ++j) { \
+                        const float a = \
+                            get_normalized_sample(dst, size, i, j, f);\
+                        const float b = \
+                            get_normalized_sample(src, size, i, j, f);\
+                        float c = (a + b); \
+                        if (c < -1.0) c = -1.0; \
+                        if (c > 1.0) c = 1.0; \
+                        c += 1.0; \
+                        c *= ((float)(type)high - (float)(type)low) / 2; \
+                        c += (float)(type)low; \
+                        if (c > (float)(type)high) { \
+                                printf("SCALE HIGH failed\n"); \
+                        } \
+                        if (c < (float)(type)low) { \
+                                printf("SCALE LOW failed\n"); \
+                        } \
+                        type *dst_buf = dst; \
+                        const unsigned pos = i * f->channels  + j; \
+                        if (pos < (size / sizeof(type))) \
+                                dst_buf[pos] = to((type)c, type, endian); \
+                } \
         } \
 } while (0)
 
         switch (f->sample_format) {
-        case PCM_SAMPLE_UINT8: {
-                const uint8_t *src_buff = src;
-                uint8_t *dst_buff = dst;
-                for (size_t i = 0; i < size; ++i )
-                        dst_buff[i] += src_buff[i];
-                break;
-                }
-        case PCM_SAMPLE_SINT8: {
-                const int8_t *src_buff = src;
-                int8_t *dst_buff = dst;
-                for (size_t i = 0; i < size; ++i)
-                        dst_buff[i] += src_buff[i];
-                break;
-                }
+        case PCM_SAMPLE_UINT8:
+                LOOP_ADD(uint8_t, le, UINT8_MIN, UINT8_MAX); break;
+        case PCM_SAMPLE_SINT8:
+                LOOP_ADD(uint8_t, le, INT8_MIN, INT8_MAX); break;
         case PCM_SAMPLE_UINT16_LE:
-                LOOP_ADD(uint16_t, le, UINT16_MAX); break;
+                LOOP_ADD(uint16_t, le, UINT16_MIN, UINT16_MAX); break;
         case PCM_SAMPLE_SINT16_LE:
-                LOOP_ADD(int16_t, le, INT16_MAX); break;
+                LOOP_ADD(int16_t, le, INT16_MIN, INT16_MAX); break;
         case PCM_SAMPLE_UINT16_BE:
-                LOOP_ADD(uint16_t, be, UINT16_MAX); break;
+                LOOP_ADD(uint16_t, be, UINT16_MIN, UINT16_MAX); break;
         case PCM_SAMPLE_SINT16_BE:
-                LOOP_ADD(int16_t, be, INT16_MAX); break;
+                LOOP_ADD(int16_t, be, INT16_MIN, INT16_MAX); break;
         case PCM_SAMPLE_UINT24_32_LE:
-        case PCM_SAMPLE_UINT32_LE:
-                LOOP_ADD(uint32_t, le, UINT32_MAX); break;
+        case PCM_SAMPLE_UINT32_LE: // TODO this are not right for 24bit
+                LOOP_ADD(uint32_t, le, UINT32_MIN, UINT32_MAX); break;
         case PCM_SAMPLE_SINT24_32_LE:
         case PCM_SAMPLE_SINT32_LE:
-                LOOP_ADD(int32_t, le, INT32_MAX); break;
+                LOOP_ADD(int32_t, le, INT32_MIN, INT32_MAX); break;
         case PCM_SAMPLE_UINT24_32_BE:
         case PCM_SAMPLE_UINT32_BE:
-                LOOP_ADD(uint32_t, be, UINT32_MAX); break;
+                LOOP_ADD(uint32_t, be, UINT32_MIN, UINT32_MAX); break;
         case PCM_SAMPLE_SINT24_32_BE:
         case PCM_SAMPLE_SINT32_BE:
-                LOOP_ADD(int32_t, be, INT32_MAX); break;
+                LOOP_ADD(int32_t, be, INT32_MIN, INT32_MAX); break;
         case PCM_SAMPLE_UINT24_LE:
         case PCM_SAMPLE_SINT24_LE:
@@ -142 +163 @@
         }
         return EOK;
+#undef LOOP_ADD
 }
 
+/** Converts all sample formats to float <-1,1> */
+static float get_normalized_sample(const void *buffer, size_t size,
+    unsigned frame, unsigned channel, const audio_format_t *f)
+{
+        assert(f);
+        if (channel >= f->channels)
+                return 0.0f;
+#define GET(type, endian, low, high) \
+do { \
+        const type *src = buffer; \
+        const size_t sample_count = size / sizeof(type); \
+        const size_t sample_pos = frame * f->channels + channel; \
+        if (sample_pos >= sample_count) {\
+                return 0.0f; \
+        } \
+        float sample = from(src[sample_pos], type, endian); \
+        /* This makes it positive */ \
+        sample -= (float)(type)low; \
+        if (sample < 0.0f) { \
+                printf("SUB MIN failed\n"); \
+        } \
+        /* This makes it <0,2> */ \
+        sample /= (((float)(type)high - (float)(type)low) / 2.0f); \
+        if (sample > 2.0) { \
+                printf("DIV RANGE failed\n"); \
+        } \
+        return sample - 1.0f; \
+} while (0)
+
+        switch (f->sample_format) {
+        case PCM_SAMPLE_UINT8:
+                GET(uint8_t, le, UINT8_MIN, UINT8_MAX);
+        case PCM_SAMPLE_SINT8:
+                GET(int8_t, le, INT8_MIN, INT8_MAX);
+        case PCM_SAMPLE_UINT16_LE:
+                GET(uint16_t, le, UINT16_MIN, UINT16_MAX);
+        case PCM_SAMPLE_SINT16_LE:
+                GET(int16_t, le, INT16_MIN, INT16_MAX);
+        case PCM_SAMPLE_UINT16_BE:
+                GET(uint16_t, be, UINT16_MIN, UINT16_MAX);
+        case PCM_SAMPLE_SINT16_BE:
+                GET(int16_t, be, INT16_MIN, INT16_MAX);
+        case PCM_SAMPLE_UINT24_32_LE:
+        case PCM_SAMPLE_UINT32_LE:
+                GET(uint32_t, le, UINT32_MIN, UINT32_MAX);
+        case PCM_SAMPLE_SINT24_32_LE:
+        case PCM_SAMPLE_SINT32_LE:
+                GET(int32_t, le, INT32_MIN, INT32_MAX);
+        case PCM_SAMPLE_UINT24_32_BE:
+        case PCM_SAMPLE_UINT32_BE:
+                GET(uint32_t, be, UINT32_MIN, UINT32_MAX);
+        case PCM_SAMPLE_SINT24_32_BE:
+        case PCM_SAMPLE_SINT32_BE:
+                GET(int32_t, le, INT32_MIN, INT32_MAX);
+        case PCM_SAMPLE_UINT24_LE:
+        case PCM_SAMPLE_SINT24_LE:
+        case PCM_SAMPLE_UINT24_BE:
+        case PCM_SAMPLE_SINT24_BE:
+        case PCM_SAMPLE_FLOAT32:
+        default: ;
+        }
+        return 0;
+#undef GET
+}
 /**
  * @}

uspace/srv/audio/hound/audio_source.c

@@ -116 +116 @@
                 return EINVAL;
         }
-        if (!audio_format_same(&source->format, f)) {
-                log_debug("Format conversion is not supported yet");
+        if (source->format.sampling_rate != f->sampling_rate) {
+                log_debug("Resampling is not supported, yet");
                 return ENOTSUP;
         }