]> iEval git - fdkaac.git/blob - src/lpcm.c
add --tag-from-json
[fdkaac.git] / src / lpcm.c
1 /*
2 * Copyright (C) 2013 nu774
3 * For conditions of distribution and use, see copyright notice in COPYING
4 */
5 #if HAVE_CONFIG_H
6 # include "config.h"
7 #endif
8 #if HAVE_STDINT_H
9 # include <stdint.h>
10 #endif
11 #include <stdlib.h>
12 #include <math.h>
13 #include "lpcm.h"
14 #include "m4af_endian.h"
15
16 #ifdef _MSC_VER
17 # define inline __inline
18 # ifdef _M_IX86
19 inline int lrint(double x)
20 {
21 int n;
22 _asm {
23 fld x
24 fistp n
25 }
26 return n;
27 }
28 # else
29 # include <emmintrin.h>
30 inline int lrint(double x)
31 {
32 return _mm_cvtsd_si32(_mm_load_sd(&x));
33 }
34 # endif
35 #endif
36
37 static
38 inline double pcm_clip(double n, double min_value, double max_value)
39 {
40 if (n < min_value)
41 return min_value;
42 else if (n > max_value)
43 return max_value;
44 return n;
45 }
46 static
47 inline float pcm_i2f(int32_t n)
48 {
49 union {
50 int32_t ivalue;
51 float fvalue;
52 } u;
53 u.ivalue = n;
54 return u.fvalue;
55 }
56 static
57 inline double pcm_i2d(int64_t n)
58 {
59 union {
60 int64_t ivalue;
61 double fvalue;
62 } u;
63 u.ivalue = n;
64 return u.fvalue;
65 }
66 static
67 inline int16_t pcm_quantize_s32(int32_t n)
68 {
69 n = ((n >> 15) + 1) >> 1;
70 return (n == 0x8000) ? 0x7fff : n;
71 }
72 static
73 inline int16_t pcm_quantize_f64(double v)
74 {
75 return (int16_t)lrint(pcm_clip(v * 32768.0, -32768.0, 32767.0));
76 }
77 static
78 inline int16_t pcm_s8_to_s16(int8_t n)
79 {
80 return n << 8;
81 }
82 static
83 inline int16_t pcm_u8_to_s16(uint8_t n)
84 {
85 return (n << 8) ^ 0x8000;
86 }
87 static
88 inline int16_t pcm_s16le_to_s16(int16_t n)
89 {
90 return m4af_ltoh16(n);
91 }
92 static
93 inline int16_t pcm_s16be_to_s16(int16_t n)
94 {
95 return m4af_btoh16(n);
96 }
97 static
98 inline int16_t pcm_u16le_to_s16(uint16_t n)
99 {
100 return m4af_ltoh16(n) ^ 0x8000;
101 }
102 static
103 inline int16_t pcm_u16be_to_s16(uint16_t n)
104 {
105 return m4af_btoh16(n) ^ 0x8000;
106 }
107 static
108 inline int32_t pcm_s24le_to_s32(uint8_t *p)
109 {
110 return p[0]<<8 | p[1]<<16 | p[2]<<24;
111 }
112 static
113 inline int32_t pcm_s24be_to_s32(uint8_t *p)
114 {
115 return p[0]<<24 | p[1]<<16 | p[2]<<8;
116 }
117 static
118 inline int32_t pcm_u24le_to_s32(uint8_t *p)
119 {
120 return pcm_s24le_to_s32(p) ^ 0x80000000;
121 }
122 static
123 inline int32_t pcm_u24be_to_s32(uint8_t *p)
124 {
125 return pcm_s24be_to_s32(p) ^ 0x80000000;
126 }
127 static
128 inline int16_t pcm_s24le_to_s16(uint8_t *p)
129 {
130 return pcm_quantize_s32(pcm_s24le_to_s32(p));
131 }
132 static
133 inline int16_t pcm_s24be_to_s16(uint8_t *p)
134 {
135 return pcm_quantize_s32(pcm_s24be_to_s32(p));
136 }
137 static
138 inline int16_t pcm_u24le_to_s16(uint8_t *p)
139 {
140 return pcm_quantize_s32(pcm_u24le_to_s32(p));
141 }
142 static
143 inline int16_t pcm_u24be_to_s16(uint8_t *p)
144 {
145 return pcm_quantize_s32(pcm_u24be_to_s32(p));
146 }
147 static
148 inline int16_t pcm_s32le_to_s16(int32_t n)
149 {
150 return pcm_quantize_s32(m4af_ltoh32(n));
151 }
152 static
153 inline int16_t pcm_s32be_to_s16(int32_t n)
154 {
155 return pcm_quantize_s32(m4af_btoh32(n));
156 }
157 static
158 inline int16_t pcm_u32le_to_s16(int32_t n)
159 {
160 return pcm_quantize_s32(m4af_ltoh32(n) ^ 0x80000000);
161 }
162 static
163 inline int16_t pcm_u32be_to_s16(int32_t n)
164 {
165 return pcm_quantize_s32(m4af_btoh32(n) ^ 0x80000000);
166 }
167 static
168 inline int16_t pcm_f32le_to_s16(int32_t n)
169 {
170 return pcm_quantize_f64(pcm_i2f(m4af_ltoh32(n)));
171 }
172 static
173 inline int16_t pcm_f32be_to_s16(int32_t n)
174 {
175 return pcm_quantize_f64(pcm_i2f(m4af_btoh32(n)));
176 }
177 static
178 inline int16_t pcm_f64le_to_s16(int64_t n)
179 {
180 return pcm_quantize_f64(pcm_i2d(m4af_ltoh64(n)));
181 }
182 static
183 inline int16_t pcm_f64be_to_s16(int64_t n)
184 {
185 return pcm_quantize_f64(pcm_i2d(m4af_btoh64(n)));
186 }
187
188 int pcm_convert_to_native_sint16(const pcm_sample_description_t *format,
189 const void *input, uint32_t nframes,
190 int16_t **result, uint32_t *osize)
191 {
192 #define CONVERT(type, conv) \
193 do { \
194 unsigned i; \
195 type *ip = (type *)input; \
196 for (i = 0; i < count; ++i) { \
197 (*result)[i] = conv(ip[i]); \
198 } \
199 } while(0)
200
201 #define CONVERT_BYTES(conv) \
202 do { \
203 unsigned i, bytes_per_channel; \
204 uint8_t *ip = (uint8_t *)input; \
205 bytes_per_channel = PCM_BYTES_PER_CHANNEL(format); \
206 for (i = 0; i < count; ++i) { \
207 (*result)[i] = conv(ip); \
208 ip += bytes_per_channel; \
209 } \
210 } while(0)
211
212 uint32_t count = nframes * format->channels_per_frame;
213 if (!count)
214 return 0;
215 if (!*result || *osize < count) {
216 *osize = count;
217 *result = realloc(*result, count * sizeof(int16_t));
218 }
219
220 switch (PCM_BYTES_PER_CHANNEL(format) | format->sample_type<<4) {
221 case 1 | PCM_TYPE_SINT<<4:
222 CONVERT(int8_t, pcm_s8_to_s16); break;
223 case 1 | PCM_TYPE_UINT<<4:
224 CONVERT(uint8_t, pcm_u8_to_s16); break;
225 case 2 | PCM_TYPE_SINT<<4:
226 CONVERT(int16_t, pcm_s16le_to_s16); break;
227 case 2 | PCM_TYPE_UINT<<4:
228 CONVERT(uint16_t, pcm_u16le_to_s16); break;
229 case 2 | PCM_TYPE_SINT_BE<<4:
230 CONVERT(int16_t, pcm_s16be_to_s16); break;
231 case 2 | PCM_TYPE_UINT_BE<<4:
232 CONVERT(int16_t, pcm_u16be_to_s16); break;
233 case 3 | PCM_TYPE_SINT<<4:
234 CONVERT_BYTES(pcm_s24le_to_s16); break;
235 case 3 | PCM_TYPE_UINT<<4:
236 CONVERT_BYTES(pcm_u24le_to_s16); break;
237 case 3 | PCM_TYPE_SINT_BE<<4:
238 CONVERT_BYTES(pcm_s24be_to_s16); break;
239 case 3 | PCM_TYPE_UINT_BE<<4:
240 CONVERT_BYTES(pcm_u24be_to_s16); break;
241 case 4 | PCM_TYPE_SINT<<4:
242 CONVERT(int32_t, pcm_s32le_to_s16); break;
243 case 4 | PCM_TYPE_UINT<<4:
244 CONVERT(uint32_t, pcm_u32le_to_s16); break;
245 case 4 | PCM_TYPE_FLOAT<<4:
246 CONVERT(int32_t, pcm_f32le_to_s16); break;
247 case 4 | PCM_TYPE_SINT_BE<<4:
248 CONVERT(int32_t, pcm_s32be_to_s16); break;
249 case 4 | PCM_TYPE_UINT_BE<<4:
250 CONVERT(uint32_t, pcm_u32be_to_s16); break;
251 case 4 | PCM_TYPE_FLOAT_BE<<4:
252 CONVERT(int32_t, pcm_f32be_to_s16); break;
253 case 8 | PCM_TYPE_FLOAT<<4:
254 CONVERT(int64_t, pcm_f64le_to_s16); break;
255 case 8 | PCM_TYPE_FLOAT_BE<<4:
256 CONVERT(int64_t, pcm_f64be_to_s16); break;
257 default:
258 return -1;
259 }
260 return 0;
261 }
This page took 0.058323 seconds and 4 git commands to generate.