-/* $Id$ */
-
/***
This file is part of PulseAudio.
-
+
+ Copyright 2004-2006 Lennart Poettering
+ Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
+
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
- by the Free Software Foundation; either version 2 of the License,
+ by the Free Software Foundation; either version 2.1 of the License,
or (at your option) any later version.
-
+
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
-
+
You should have received a copy of the GNU Lesser General Public License
along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
#include <stdio.h>
#include <stdlib.h>
-#include <assert.h>
-
-#include <liboil/liboilfuncs.h>
-#include <liboil/liboil.h>
+#include <math.h>
#include <pulsecore/g711.h>
+#include <pulsecore/macro.h>
+#include <pulsecore/endianmacros.h>
-#include "endianmacros.h"
-#include "sconv-s16le.h"
-#include "sconv-s16be.h"
+#include <pulsecore/sconv-s16le.h>
+#include <pulsecore/sconv-s16be.h>
#include "sconv.h"
-static void u8_to_float32ne(unsigned n, const void *a, float *b) {
- const uint8_t *ca = a;
- static const double add = -128.0/127.0, factor = 1.0/127.0;
-
- assert(a);
- assert(b);
+/* u8 */
+static void u8_to_float32ne(unsigned n, const uint8_t *a, float *b) {
+ pa_assert(a);
+ pa_assert(b);
- oil_scaleconv_f32_u8(b, ca, n, &add, &factor);
-}
+ for (; n > 0; n--, a++, b++)
+ *b = (*a * 1.0/128.0) - 1.0;
+}
+
+static void u8_from_float32ne(unsigned n, const float *a, uint8_t *b) {
+ pa_assert(a);
+ pa_assert(b);
-static void u8_from_float32ne(unsigned n, const float *a, void *b) {
- uint8_t *cb = b;
- static const double add = 128.0, factor = 127.0;
+ for (; n > 0; n--, a++, b++) {
+ float v;
+ v = (*a * 127.0) + 128.0;
+ v = PA_CLAMP_UNLIKELY (v, 0.0, 255.0);
+ *b = rint (v);
+ }
+}
- assert(a);
- assert(b);
+static void u8_to_s16ne(unsigned n, const uint8_t *a, int16_t *b) {
+ pa_assert(a);
+ pa_assert(b);
- oil_scaleconv_u8_f32(cb, a, n, &add, &factor);
+ for (; n > 0; n--, a++, b++)
+ *b = (((int16_t)*a) - 128) << 8;
}
-static void float32ne_to_float32ne(unsigned n, const void *a, float *b) {
- assert(a);
- assert(b);
+static void u8_from_s16ne(unsigned n, const int16_t *a, uint8_t *b) {
+
+ pa_assert(a);
+ pa_assert(b);
- oil_memcpy(b, a, sizeof(float) * n);
+ for (; n > 0; n--, a++, b++)
+ *b = (uint8_t) ((uint16_t) *a >> 8) + (uint8_t) 0x80U;
}
-static void float32ne_from_float32ne(unsigned n, const float *a, void *b) {
- assert(a);
- assert(b);
+/* float32 */
+
+static void float32ne_to_float32ne(unsigned n, const float *a, float *b) {
+ pa_assert(a);
+ pa_assert(b);
- oil_memcpy(b, a, sizeof(float) * n);
+ memcpy(b, a, (int) (sizeof(float) * n));
}
-static void float32re_to_float32ne(unsigned n, const void *a, float *b) {
- assert(a);
- assert(b);
+static void float32re_to_float32ne(unsigned n, const float *a, float *b) {
+ pa_assert(a);
+ pa_assert(b);
- while (n-- > 0)
- ((uint32_t *)b)[n] = UINT32_SWAP (((uint32_t *)a)[n]);
+ for (; n > 0; n--, a++, b++)
+ *((uint32_t *) b) = PA_UINT32_SWAP(*((uint32_t *) a));
}
-static void float32re_from_float32ne(unsigned n, const float *a, void *b) {
- assert(a);
- assert(b);
+/* s16 */
- while (n-- > 0)
- ((uint32_t *)b)[n] = UINT32_SWAP (((uint32_t *)a)[n]);
+static void s16ne_to_s16ne(unsigned n, const int16_t *a, int16_t *b) {
+ pa_assert(a);
+ pa_assert(b);
+
+ memcpy(b, a, (int) (sizeof(int16_t) * n));
+}
+
+static void s16re_to_s16ne(unsigned n, const int16_t *a, int16_t *b) {
+ pa_assert(a);
+ pa_assert(b);
+
+ for (; n > 0; n--, a++, b++)
+ *b = PA_INT16_SWAP(*a);
}
-static void ulaw_to_float32ne(unsigned n, const void *a, float *b) {
- const uint8_t *ca = a;
+/* ulaw */
+
+static void ulaw_to_float32ne(unsigned n, const uint8_t *a, float *b) {
+ pa_assert(a);
+ pa_assert(b);
- assert(a);
- assert(b);
-
for (; n > 0; n--)
- *(b++) = st_ulaw2linear16(*(ca++)) * 1.0F / 0x7FFF;
+ *(b++) = (float) st_ulaw2linear16(*(a++)) / 0x8000;
}
-static void ulaw_from_float32ne(unsigned n, const float *a, void *b) {
- uint8_t *cb = b;
+static void ulaw_from_float32ne(unsigned n, const float *a, uint8_t *b) {
+ pa_assert(a);
+ pa_assert(b);
- assert(a);
- assert(b);
-
for (; n > 0; n--) {
float v = *(a++);
+ v = PA_CLAMP_UNLIKELY(v, -1.0f, 1.0f);
+ v *= 0x1FFF;
+ *(b++) = st_14linear2ulaw((int16_t) lrintf(v));
+ }
+}
+
+static void ulaw_to_s16ne(unsigned n, const uint8_t *a, int16_t *b) {
+ pa_assert(a);
+ pa_assert(b);
+
+ for (; n > 0; n--, a++, b++)
+ *b = st_ulaw2linear16(*a);
+}
+
+static void ulaw_from_s16ne(unsigned n, const int16_t *a, uint8_t *b) {
+ pa_assert(a);
+ pa_assert(b);
- if (v > 1)
- v = 1;
+ for (; n > 0; n--, a++, b++)
+ *b = st_14linear2ulaw(*a >> 2);
+}
+
+/* alaw */
+
+static void alaw_to_float32ne(unsigned n, const uint8_t *a, float *b) {
+ pa_assert(a);
+ pa_assert(b);
- if (v < -1)
- v = -1;
+ for (; n > 0; n--, a++, b++)
+ *b = (float) st_alaw2linear16(*a) / 0x8000;
+}
+
+static void alaw_from_float32ne(unsigned n, const float *a, uint8_t *b) {
+ pa_assert(a);
+ pa_assert(b);
- *(cb++) = st_14linear2ulaw((int16_t) (v * 0x1FFF));
+ for (; n > 0; n--, a++, b++) {
+ float v = *a;
+ v = PA_CLAMP_UNLIKELY(v, -1.0f, 1.0f);
+ v *= 0xFFF;
+ *b = st_13linear2alaw((int16_t) lrintf(v));
}
}
-static void alaw_to_float32ne(unsigned n, const void *a, float *b) {
- const uint8_t *ca = a;
+static void alaw_to_s16ne(unsigned n, const int8_t *a, int16_t *b) {
+ pa_assert(a);
+ pa_assert(b);
+
+ for (; n > 0; n--, a++, b++)
+ *b = st_alaw2linear16((uint8_t) *a);
+}
- assert(a);
- assert(b);
+static void alaw_from_s16ne(unsigned n, const int16_t *a, uint8_t *b) {
+ pa_assert(a);
+ pa_assert(b);
- for (; n > 0; n--)
- *(b++) = st_alaw2linear16(*(ca++)) * 1.0F / 0x7FFF;
+ for (; n > 0; n--, a++, b++)
+ *b = st_13linear2alaw(*a >> 3);
}
-static void alaw_from_float32ne(unsigned n, const float *a, void *b) {
- uint8_t *cb = b;
+static pa_convert_func_t to_float32ne_table[] = {
+ [PA_SAMPLE_U8] = (pa_convert_func_t) u8_to_float32ne,
+ [PA_SAMPLE_ALAW] = (pa_convert_func_t) alaw_to_float32ne,
+ [PA_SAMPLE_ULAW] = (pa_convert_func_t) ulaw_to_float32ne,
+ [PA_SAMPLE_S16LE] = (pa_convert_func_t) pa_sconv_s16le_to_float32ne,
+ [PA_SAMPLE_S16BE] = (pa_convert_func_t) pa_sconv_s16be_to_float32ne,
+ [PA_SAMPLE_S32LE] = (pa_convert_func_t) pa_sconv_s32le_to_float32ne,
+ [PA_SAMPLE_S32BE] = (pa_convert_func_t) pa_sconv_s32be_to_float32ne,
+ [PA_SAMPLE_S24LE] = (pa_convert_func_t) pa_sconv_s24le_to_float32ne,
+ [PA_SAMPLE_S24BE] = (pa_convert_func_t) pa_sconv_s24be_to_float32ne,
+ [PA_SAMPLE_S24_32LE] = (pa_convert_func_t) pa_sconv_s24_32le_to_float32ne,
+ [PA_SAMPLE_S24_32BE] = (pa_convert_func_t) pa_sconv_s24_32be_to_float32ne,
+ [PA_SAMPLE_FLOAT32NE] = (pa_convert_func_t) float32ne_to_float32ne,
+ [PA_SAMPLE_FLOAT32RE] = (pa_convert_func_t) float32re_to_float32ne,
+};
+
+pa_convert_func_t pa_get_convert_to_float32ne_function(pa_sample_format_t f) {
+ pa_assert(pa_sample_format_valid(f));
+
+ return to_float32ne_table[f];
+}
- assert(a);
- assert(b);
-
- for (; n > 0; n--) {
- float v = *(a++);
+void pa_set_convert_to_float32ne_function(pa_sample_format_t f, pa_convert_func_t func) {
+ pa_assert(pa_sample_format_valid(f));
- if (v > 1)
- v = 1;
+ to_float32ne_table[f] = func;
+}
- if (v < -1)
- v = -1;
+static pa_convert_func_t from_float32ne_table[] = {
+ [PA_SAMPLE_U8] = (pa_convert_func_t) u8_from_float32ne,
+ [PA_SAMPLE_S16LE] = (pa_convert_func_t) pa_sconv_s16le_from_float32ne,
+ [PA_SAMPLE_S16BE] = (pa_convert_func_t) pa_sconv_s16be_from_float32ne,
+ [PA_SAMPLE_S32LE] = (pa_convert_func_t) pa_sconv_s32le_from_float32ne,
+ [PA_SAMPLE_S32BE] = (pa_convert_func_t) pa_sconv_s32be_from_float32ne,
+ [PA_SAMPLE_S24LE] = (pa_convert_func_t) pa_sconv_s24le_from_float32ne,
+ [PA_SAMPLE_S24BE] = (pa_convert_func_t) pa_sconv_s24be_from_float32ne,
+ [PA_SAMPLE_S24_32LE] = (pa_convert_func_t) pa_sconv_s24_32le_from_float32ne,
+ [PA_SAMPLE_S24_32BE] = (pa_convert_func_t) pa_sconv_s24_32be_from_float32ne,
+ [PA_SAMPLE_FLOAT32NE] = (pa_convert_func_t) float32ne_to_float32ne,
+ [PA_SAMPLE_FLOAT32RE] = (pa_convert_func_t) float32re_to_float32ne,
+ [PA_SAMPLE_ALAW] = (pa_convert_func_t) alaw_from_float32ne,
+ [PA_SAMPLE_ULAW] = (pa_convert_func_t) ulaw_from_float32ne
+};
+
+pa_convert_func_t pa_get_convert_from_float32ne_function(pa_sample_format_t f) {
+ pa_assert(pa_sample_format_valid(f));
+
+ return from_float32ne_table[f];
+}
- *(cb++) = st_13linear2alaw((int16_t) (v * 0xFFF));
- }
+void pa_set_convert_from_float32ne_function(pa_sample_format_t f, pa_convert_func_t func) {
+ pa_assert(pa_sample_format_valid(f));
+
+ from_float32ne_table[f] = func;
}
-pa_convert_to_float32ne_func_t pa_get_convert_to_float32ne_function(pa_sample_format_t f) {
- switch(f) {
- case PA_SAMPLE_U8:
- return u8_to_float32ne;
- case PA_SAMPLE_S16LE:
- return pa_sconv_s16le_to_float32ne;
- case PA_SAMPLE_S16BE:
- return pa_sconv_s16be_to_float32ne;
- case PA_SAMPLE_FLOAT32NE:
- return float32ne_to_float32ne;
- case PA_SAMPLE_FLOAT32RE:
- return float32re_to_float32ne;
- case PA_SAMPLE_ALAW:
- return alaw_to_float32ne;
- case PA_SAMPLE_ULAW:
- return ulaw_to_float32ne;
- default:
- return NULL;
- }
+static pa_convert_func_t to_s16ne_table[] = {
+ [PA_SAMPLE_U8] = (pa_convert_func_t) u8_to_s16ne,
+ [PA_SAMPLE_S16NE] = (pa_convert_func_t) s16ne_to_s16ne,
+ [PA_SAMPLE_S16RE] = (pa_convert_func_t) s16re_to_s16ne,
+ [PA_SAMPLE_FLOAT32BE] = (pa_convert_func_t) pa_sconv_float32be_to_s16ne,
+ [PA_SAMPLE_FLOAT32LE] = (pa_convert_func_t) pa_sconv_float32le_to_s16ne,
+ [PA_SAMPLE_S32BE] = (pa_convert_func_t) pa_sconv_s32be_to_s16ne,
+ [PA_SAMPLE_S32LE] = (pa_convert_func_t) pa_sconv_s32le_to_s16ne,
+ [PA_SAMPLE_S24BE] = (pa_convert_func_t) pa_sconv_s24be_to_s16ne,
+ [PA_SAMPLE_S24LE] = (pa_convert_func_t) pa_sconv_s24le_to_s16ne,
+ [PA_SAMPLE_S24_32BE] = (pa_convert_func_t) pa_sconv_s24_32be_to_s16ne,
+ [PA_SAMPLE_S24_32LE] = (pa_convert_func_t) pa_sconv_s24_32le_to_s16ne,
+ [PA_SAMPLE_ALAW] = (pa_convert_func_t) alaw_to_s16ne,
+ [PA_SAMPLE_ULAW] = (pa_convert_func_t) ulaw_to_s16ne
+};
+
+pa_convert_func_t pa_get_convert_to_s16ne_function(pa_sample_format_t f) {
+ pa_assert(pa_sample_format_valid(f));
+
+ return to_s16ne_table[f];
}
-pa_convert_from_float32ne_func_t pa_get_convert_from_float32ne_function(pa_sample_format_t f) {
- switch(f) {
- case PA_SAMPLE_U8:
- return u8_from_float32ne;
- case PA_SAMPLE_S16LE:
- return pa_sconv_s16le_from_float32ne;
- case PA_SAMPLE_S16BE:
- return pa_sconv_s16be_from_float32ne;
- case PA_SAMPLE_FLOAT32NE:
- return float32ne_from_float32ne;
- case PA_SAMPLE_FLOAT32RE:
- return float32re_from_float32ne;
- case PA_SAMPLE_ALAW:
- return alaw_from_float32ne;
- case PA_SAMPLE_ULAW:
- return ulaw_from_float32ne;
- default:
- return NULL;
- }
+void pa_set_convert_to_s16ne_function(pa_sample_format_t f, pa_convert_func_t func) {
+ pa_assert(pa_sample_format_valid(f));
+
+ to_s16ne_table[f] = func;
+}
+
+static pa_convert_func_t from_s16ne_table[] = {
+ [PA_SAMPLE_U8] = (pa_convert_func_t) u8_from_s16ne,
+ [PA_SAMPLE_S16NE] = (pa_convert_func_t) s16ne_to_s16ne,
+ [PA_SAMPLE_S16RE] = (pa_convert_func_t) s16re_to_s16ne,
+ [PA_SAMPLE_FLOAT32BE] = (pa_convert_func_t) pa_sconv_float32be_from_s16ne,
+ [PA_SAMPLE_FLOAT32LE] = (pa_convert_func_t) pa_sconv_float32le_from_s16ne,
+ [PA_SAMPLE_S32BE] = (pa_convert_func_t) pa_sconv_s32be_from_s16ne,
+ [PA_SAMPLE_S32LE] = (pa_convert_func_t) pa_sconv_s32le_from_s16ne,
+ [PA_SAMPLE_S24BE] = (pa_convert_func_t) pa_sconv_s24be_from_s16ne,
+ [PA_SAMPLE_S24LE] = (pa_convert_func_t) pa_sconv_s24le_from_s16ne,
+ [PA_SAMPLE_S24_32BE] = (pa_convert_func_t) pa_sconv_s24_32be_from_s16ne,
+ [PA_SAMPLE_S24_32LE] = (pa_convert_func_t) pa_sconv_s24_32le_from_s16ne,
+ [PA_SAMPLE_ALAW] = (pa_convert_func_t) alaw_from_s16ne,
+ [PA_SAMPLE_ULAW] = (pa_convert_func_t) ulaw_from_s16ne,
+};
+
+pa_convert_func_t pa_get_convert_from_s16ne_function(pa_sample_format_t f) {
+ pa_assert(pa_sample_format_valid(f));
+
+ return from_s16ne_table[f];
+}
+
+void pa_set_convert_from_s16ne_function(pa_sample_format_t f, pa_convert_func_t func) {
+ pa_assert(pa_sample_format_valid(f));
+
+ from_s16ne_table[f] = func;
}