2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
30 #include <liboil/liboilfuncs.h>
31 #include <liboil/liboil.h>
33 #include <pulsecore/g711.h>
34 #include <pulsecore/macro.h>
36 #include "endianmacros.h"
37 #include "sconv-s16le.h"
38 #include "sconv-s16be.h"
43 static void u8_to_float32ne(unsigned n
, const uint8_t *a
, float *b
) {
44 static const double add
= -1, factor
= 1.0/128.0;
49 oil_scaleconv_f32_u8(b
, a
, (int) n
, &add
, &factor
);
52 static void u8_from_float32ne(unsigned n
, const float *a
, uint8_t *b
) {
53 static const double add
= 128, factor
= 127.0;
58 oil_scaleconv_u8_f32(b
, a
, (int) n
, &add
, &factor
);
61 static void u8_to_s16ne(unsigned n
, const uint8_t *a
, int16_t *b
) {
62 static const int16_t add
= -0x80, factor
= 0x100;
67 oil_conv_s16_u8(b
, 2, a
, 1, (int) n
);
68 oil_scalaradd_s16(b
, 2, b
, 2, &add
, (int) n
);
69 oil_scalarmult_s16(b
, 2, b
, 2, &factor
, (int) n
);
72 static void u8_from_s16ne(unsigned n
, const int16_t *a
, uint8_t *b
) {
77 for (; n
> 0; n
--, a
++, b
++)
78 *b
= (uint8_t) (*a
/ 0x100 + 0x80);
83 static void float32ne_to_float32ne(unsigned n
, const float *a
, float *b
) {
87 oil_memcpy(b
, a
, (int) (sizeof(float) * n
));
90 static void float32re_to_float32ne(unsigned n
, const float *a
, float *b
) {
94 for (; n
> 0; n
--, a
++, b
++)
95 *((uint32_t *) b
) = PA_UINT32_SWAP(*((uint32_t *) a
));
100 static void s16ne_to_s16ne(unsigned n
, const int16_t *a
, int16_t *b
) {
104 oil_memcpy(b
, a
, (int) (sizeof(int16_t) * n
));
107 static void s16re_to_s16ne(unsigned n
, const int16_t *a
, int16_t *b
) {
111 for (; n
> 0; n
--, a
++, b
++)
112 *b
= PA_INT16_SWAP(*a
);
117 static void ulaw_to_float32ne(unsigned n
, const uint8_t *a
, float *b
) {
122 *(b
++) = (float) st_ulaw2linear16(*(a
++)) / 0x8000;
125 static void ulaw_from_float32ne(unsigned n
, const float *a
, uint8_t *b
) {
131 v
= PA_CLAMP_UNLIKELY(v
, -1.0f
, 1.0f
);
133 *(b
++) = st_14linear2ulaw((int16_t) v
);
137 static void ulaw_to_s16ne(unsigned n
, const uint8_t *a
, int16_t *b
) {
141 for (; n
> 0; n
--, a
++, b
++)
142 *b
= st_ulaw2linear16(*a
);
145 static void ulaw_from_s16ne(unsigned n
, const int16_t *a
, uint8_t *b
) {
149 for (; n
> 0; n
--, a
++, b
++)
150 *b
= st_14linear2ulaw(*a
>> 2);
155 static void alaw_to_float32ne(unsigned n
, const uint8_t *a
, float *b
) {
159 for (; n
> 0; n
--, a
++, b
++)
160 *b
= (float) st_alaw2linear16(*a
) / 0x8000;
163 static void alaw_from_float32ne(unsigned n
, const float *a
, uint8_t *b
) {
167 for (; n
> 0; n
--, a
++, b
++) {
169 v
= PA_CLAMP_UNLIKELY(v
, -1.0f
, 1.0f
);
171 *b
= st_13linear2alaw((int16_t) v
);
175 static void alaw_to_s16ne(unsigned n
, const int8_t *a
, int16_t *b
) {
179 for (; n
> 0; n
--, a
++, b
++)
180 *b
= st_alaw2linear16((uint8_t) *a
);
183 static void alaw_from_s16ne(unsigned n
, const int16_t *a
, uint8_t *b
) {
187 for (; n
> 0; n
--, a
++, b
++)
188 *b
= st_13linear2alaw(*a
>> 3);
191 pa_convert_func_t
pa_get_convert_to_float32ne_function(pa_sample_format_t f
) {
193 static const pa_convert_func_t table
[] = {
194 [PA_SAMPLE_U8
] = (pa_convert_func_t
) u8_to_float32ne
,
195 [PA_SAMPLE_ALAW
] = (pa_convert_func_t
) alaw_to_float32ne
,
196 [PA_SAMPLE_ULAW
] = (pa_convert_func_t
) ulaw_to_float32ne
,
197 [PA_SAMPLE_S16LE
] = (pa_convert_func_t
) pa_sconv_s16le_to_float32ne
,
198 [PA_SAMPLE_S16BE
] = (pa_convert_func_t
) pa_sconv_s16be_to_float32ne
,
199 [PA_SAMPLE_S32LE
] = (pa_convert_func_t
) pa_sconv_s32le_to_float32ne
,
200 [PA_SAMPLE_S32BE
] = (pa_convert_func_t
) pa_sconv_s32be_to_float32ne
,
201 [PA_SAMPLE_FLOAT32NE
] = (pa_convert_func_t
) float32ne_to_float32ne
,
202 [PA_SAMPLE_FLOAT32RE
] = (pa_convert_func_t
) float32re_to_float32ne
,
206 pa_assert(f
< PA_SAMPLE_MAX
);
211 pa_convert_func_t
pa_get_convert_from_float32ne_function(pa_sample_format_t f
) {
213 static const pa_convert_func_t table
[] = {
214 [PA_SAMPLE_U8
] = (pa_convert_func_t
) u8_from_float32ne
,
215 [PA_SAMPLE_S16LE
] = (pa_convert_func_t
) pa_sconv_s16le_from_float32ne
,
216 [PA_SAMPLE_S16BE
] = (pa_convert_func_t
) pa_sconv_s16be_from_float32ne
,
217 [PA_SAMPLE_S32LE
] = (pa_convert_func_t
) pa_sconv_s32le_from_float32ne
,
218 [PA_SAMPLE_S32BE
] = (pa_convert_func_t
) pa_sconv_s32be_from_float32ne
,
219 [PA_SAMPLE_FLOAT32NE
] = (pa_convert_func_t
) float32ne_to_float32ne
,
220 [PA_SAMPLE_FLOAT32RE
] = (pa_convert_func_t
) float32re_to_float32ne
,
221 [PA_SAMPLE_ALAW
] = (pa_convert_func_t
) alaw_from_float32ne
,
222 [PA_SAMPLE_ULAW
] = (pa_convert_func_t
) ulaw_from_float32ne
226 pa_assert(f
< PA_SAMPLE_MAX
);
231 pa_convert_func_t
pa_get_convert_to_s16ne_function(pa_sample_format_t f
) {
233 static const pa_convert_func_t table
[] = {
234 [PA_SAMPLE_U8
] = (pa_convert_func_t
) u8_to_s16ne
,
235 [PA_SAMPLE_S16NE
] = (pa_convert_func_t
) s16ne_to_s16ne
,
236 [PA_SAMPLE_S16RE
] = (pa_convert_func_t
) s16re_to_s16ne
,
237 [PA_SAMPLE_FLOAT32BE
] = (pa_convert_func_t
) pa_sconv_float32be_to_s16ne
,
238 [PA_SAMPLE_FLOAT32LE
] = (pa_convert_func_t
) pa_sconv_float32le_to_s16ne
,
239 [PA_SAMPLE_S32BE
] = (pa_convert_func_t
) pa_sconv_s32be_to_s16ne
,
240 [PA_SAMPLE_S32LE
] = (pa_convert_func_t
) pa_sconv_s32le_to_s16ne
,
241 [PA_SAMPLE_ALAW
] = (pa_convert_func_t
) alaw_to_s16ne
,
242 [PA_SAMPLE_ULAW
] = (pa_convert_func_t
) ulaw_to_s16ne
246 pa_assert(f
< PA_SAMPLE_MAX
);
251 pa_convert_func_t
pa_get_convert_from_s16ne_function(pa_sample_format_t f
) {
253 static const pa_convert_func_t table
[] = {
254 [PA_SAMPLE_U8
] = (pa_convert_func_t
) u8_from_s16ne
,
255 [PA_SAMPLE_S16NE
] = (pa_convert_func_t
) s16ne_to_s16ne
,
256 [PA_SAMPLE_S16RE
] = (pa_convert_func_t
) s16re_to_s16ne
,
257 [PA_SAMPLE_FLOAT32BE
] = (pa_convert_func_t
) pa_sconv_float32be_from_s16ne
,
258 [PA_SAMPLE_FLOAT32LE
] = (pa_convert_func_t
) pa_sconv_float32le_from_s16ne
,
259 [PA_SAMPLE_S32BE
] = (pa_convert_func_t
) pa_sconv_s32be_from_s16ne
,
260 [PA_SAMPLE_S32LE
] = (pa_convert_func_t
) pa_sconv_s32le_from_s16ne
,
261 [PA_SAMPLE_ALAW
] = (pa_convert_func_t
) alaw_from_s16ne
,
262 [PA_SAMPLE_ULAW
] = (pa_convert_func_t
) ulaw_from_s16ne
,
266 pa_assert(f
< PA_SAMPLE_MAX
);