4 This file is part of PulseAudio.
6 Copyright 2004-2006 Lennart Poettering
7 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
9 PulseAudio is free software; you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License as published
11 by the Free Software Foundation; either version 2 of the License,
12 or (at your option) any later version.
14 PulseAudio is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU Lesser General Public License
20 along with PulseAudio; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
32 #include <liboil/liboilfuncs.h>
33 #include <liboil/liboil.h>
35 #include <pulsecore/g711.h>
36 #include <pulsecore/macro.h>
38 #include "endianmacros.h"
39 #include "sconv-s16le.h"
40 #include "sconv-s16be.h"
45 static void u8_to_float32ne(unsigned n
, const uint8_t *a
, float *b
) {
46 static const double add
= -1, factor
= 1.0/128.0;
51 oil_scaleconv_f32_u8(b
, a
, n
, &add
, &factor
);
54 static void u8_from_float32ne(unsigned n
, const float *a
, uint8_t *b
) {
55 static const double add
= 128, factor
= 127.0;
60 oil_scaleconv_u8_f32(b
, a
, n
, &add
, &factor
);
63 static void u8_to_s16ne(unsigned n
, const uint8_t *a
, int16_t *b
) {
64 static const int16_t add
= -0x80, factor
= 0x100;
69 oil_conv_s16_u8(b
, 2, a
, 1, n
);
70 oil_scalaradd_s16(b
, 2, b
, 2, &add
, n
);
71 oil_scalarmult_s16(b
, 2, b
, 2, &factor
, n
);
74 static void u8_from_s16ne(unsigned n
, const int16_t *a
, uint8_t *b
) {
79 for (; n
> 0; n
--, a
++, b
++)
80 *b
= (uint8_t) (*a
/ 0x100 + 0x80);
85 static void float32ne_to_float32ne(unsigned n
, const float *a
, float *b
) {
89 oil_memcpy(b
, a
, sizeof(float) * n
);
92 static void float32re_to_float32ne(unsigned n
, const float *a
, float *b
) {
96 for (; n
> 0; n
--, a
++, b
++)
97 *((uint32_t *) b
) = UINT32_SWAP(*((uint32_t *) a
));
102 static void s16ne_to_s16ne(unsigned n
, const int16_t *a
, int16_t *b
) {
106 oil_memcpy(b
, a
, sizeof(int16_t) * n
);
109 static void s16re_to_s16ne(unsigned n
, const int16_t *a
, int16_t *b
) {
113 for (; n
> 0; n
--, a
++, b
++)
114 *b
= UINT16_SWAP(*a
);
119 static void ulaw_to_float32ne(unsigned n
, const uint8_t *a
, float *b
) {
124 *(b
++) = (float) st_ulaw2linear16(*(a
++)) / 0x8000;
127 static void ulaw_from_float32ne(unsigned n
, const float *a
, uint8_t *b
) {
135 *(b
++) = st_14linear2ulaw((int16_t) v
);
139 static void ulaw_to_s16ne(unsigned n
, const uint8_t *a
, int16_t *b
) {
143 for (; n
> 0; n
--, a
++, b
++)
144 *b
= st_ulaw2linear16(*a
);
147 static void ulaw_from_s16ne(unsigned n
, const int16_t *a
, uint8_t *b
) {
151 for (; n
> 0; n
--, a
++, b
++)
152 *b
= st_14linear2ulaw(*a
>> 2);
157 static void alaw_to_float32ne(unsigned n
, const uint8_t *a
, float *b
) {
161 for (; n
> 0; n
--, a
++, b
++)
162 *b
= (float) st_alaw2linear16(*a
) / 0x8000;
165 static void alaw_from_float32ne(unsigned n
, const float *a
, uint8_t *b
) {
169 for (; n
> 0; n
--, a
++, b
++) {
173 *b
= st_13linear2alaw((int16_t) v
);
177 static void alaw_to_s16ne(unsigned n
, const int8_t *a
, int16_t *b
) {
181 for (; n
> 0; n
--, a
++, b
++)
182 *b
= st_alaw2linear16(*a
);
185 static void alaw_from_s16ne(unsigned n
, const int16_t *a
, uint8_t *b
) {
189 for (; n
> 0; n
--, a
++, b
++)
190 *b
= st_13linear2alaw(*a
>> 3);
193 pa_convert_func_t
pa_get_convert_to_float32ne_function(pa_sample_format_t f
) {
195 static const pa_convert_func_t table
[] = {
196 [PA_SAMPLE_U8
] = (pa_convert_func_t
) u8_to_float32ne
,
197 [PA_SAMPLE_ALAW
] = (pa_convert_func_t
) alaw_to_float32ne
,
198 [PA_SAMPLE_ULAW
] = (pa_convert_func_t
) ulaw_to_float32ne
,
199 [PA_SAMPLE_S16LE
] = (pa_convert_func_t
) pa_sconv_s16le_to_float32ne
,
200 [PA_SAMPLE_S16BE
] = (pa_convert_func_t
) pa_sconv_s16be_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_FLOAT32NE
] = (pa_convert_func_t
) float32ne_to_float32ne
,
218 [PA_SAMPLE_FLOAT32RE
] = (pa_convert_func_t
) float32re_to_float32ne
,
219 [PA_SAMPLE_ALAW
] = (pa_convert_func_t
) alaw_from_float32ne
,
220 [PA_SAMPLE_ULAW
] = (pa_convert_func_t
) ulaw_from_float32ne
224 pa_assert(f
< PA_SAMPLE_MAX
);
229 pa_convert_func_t
pa_get_convert_to_s16ne_function(pa_sample_format_t f
) {
231 static const pa_convert_func_t table
[] = {
232 [PA_SAMPLE_U8
] = (pa_convert_func_t
) u8_to_s16ne
,
233 [PA_SAMPLE_S16NE
] = (pa_convert_func_t
) s16ne_to_s16ne
,
234 [PA_SAMPLE_S16RE
] = (pa_convert_func_t
) s16re_to_s16ne
,
235 [PA_SAMPLE_FLOAT32BE
] = (pa_convert_func_t
) pa_sconv_float32be_to_s16ne
,
236 [PA_SAMPLE_FLOAT32LE
] = (pa_convert_func_t
) pa_sconv_float32le_to_s16ne
,
237 [PA_SAMPLE_ALAW
] = (pa_convert_func_t
) alaw_to_s16ne
,
238 [PA_SAMPLE_ULAW
] = (pa_convert_func_t
) ulaw_to_s16ne
242 pa_assert(f
< PA_SAMPLE_MAX
);
247 pa_convert_func_t
pa_get_convert_from_s16ne_function(pa_sample_format_t f
) {
249 static const pa_convert_func_t table
[] = {
250 [PA_SAMPLE_U8
] = (pa_convert_func_t
) u8_from_s16ne
,
251 [PA_SAMPLE_S16NE
] = (pa_convert_func_t
) s16ne_to_s16ne
,
252 [PA_SAMPLE_S16RE
] = (pa_convert_func_t
) s16re_to_s16ne
,
253 [PA_SAMPLE_FLOAT32BE
] = (pa_convert_func_t
) pa_sconv_float32be_from_s16ne
,
254 [PA_SAMPLE_FLOAT32LE
] = (pa_convert_func_t
) pa_sconv_float32le_from_s16ne
,
255 [PA_SAMPLE_ALAW
] = (pa_convert_func_t
) alaw_from_s16ne
,
256 [PA_SAMPLE_ULAW
] = (pa_convert_func_t
) ulaw_from_s16ne
,
260 pa_assert(f
< PA_SAMPLE_MAX
);