]> iEval git - fdkaac.git/blob - src/lpcm.c
check error of fread() and fwrite()
[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 inline int16_t pcm_f32le_to_s16(int32_t n)
168 {
169 return pcm_quantize_f64(pcm_i2f(m4af_ltoh32(n)));
170 }
171 static
172 inline int16_t pcm_f32be_to_s16(int32_t n)
173 {
174 return pcm_quantize_f64(pcm_i2f(m4af_btoh32(n)));
175 }
176 static
177 inline int16_t pcm_f64le_to_s16(int64_t n)
178 {
179 return pcm_quantize_f64(pcm_i2d(m4af_ltoh64(n)));
180 }
181 static
182 inline int16_t pcm_f64be_to_s16(int64_t n)
183 {
184 return pcm_quantize_f64(pcm_i2d(m4af_btoh64(n)));
185 }
186
187 int pcm_convert_to_native_sint16(const pcm_sample_description_t *format,
188 const void *input, uint32_t nframes,
189 int16_t **result, uint32_t *osize)
190 {
191 #define CONVERT(type, conv) \
192 do { \
193 unsigned i; \
194 type *ip = (type *)input; \
195 for (i = 0; i < count; ++i) { \
196 (*result)[i] = conv(ip[i]); \
197 } \
198 } while(0)
199
200 #define CONVERT_BYTES(conv) \
201 do { \
202 unsigned i, bytes_per_channel; \
203 uint8_t *ip = (uint8_t *)input; \
204 bytes_per_channel = PCM_BYTES_PER_CHANNEL(format); \
205 for (i = 0; i < count; ++i) { \
206 (*result)[i] = conv(ip); \
207 ip += bytes_per_channel; \
208 } \
209 } while(0)
210
211 uint32_t count = nframes * format->channels_per_frame;
212 if (!count)
213 return 0;
214 if (!*result || *osize < count) {
215 *osize = count;
216 *result = realloc(*result, count * sizeof(int16_t));
217 }
218
219 switch (PCM_BYTES_PER_CHANNEL(format) | format->sample_type<<4) {
220 case 1 | PCM_TYPE_SINT<<4:
221 CONVERT(int8_t, pcm_s8_to_s16); break;
222 case 1 | PCM_TYPE_UINT<<4:
223 CONVERT(uint8_t, pcm_u8_to_s16); break;
224 case 2 | PCM_TYPE_SINT<<4:
225 CONVERT(int16_t, pcm_s16le_to_s16); break;
226 case 2 | PCM_TYPE_UINT<<4:
227 CONVERT(uint16_t, pcm_u16le_to_s16); break;
228 case 2 | PCM_TYPE_SINT_BE<<4:
229 CONVERT(int16_t, pcm_s16be_to_s16); break;
230 case 2 | PCM_TYPE_UINT_BE<<4:
231 CONVERT(int16_t, pcm_u16be_to_s16); break;
232 case 3 | PCM_TYPE_SINT<<4:
233 CONVERT_BYTES(pcm_s24le_to_s16); break;
234 case 3 | PCM_TYPE_UINT<<4:
235 CONVERT_BYTES(pcm_u24le_to_s16); break;
236 case 3 | PCM_TYPE_SINT_BE<<4:
237 CONVERT_BYTES(pcm_s24be_to_s16); break;
238 case 3 | PCM_TYPE_UINT_BE<<4:
239 CONVERT_BYTES(pcm_u24be_to_s16); break;
240 case 4 | PCM_TYPE_SINT<<4:
241 CONVERT(int32_t, pcm_s32le_to_s16); break;
242 case 4 | PCM_TYPE_UINT<<4:
243 CONVERT(uint32_t, pcm_u32le_to_s16); break;
244 case 4 | PCM_TYPE_FLOAT<<4:
245 CONVERT(int32_t, pcm_f32le_to_s16); break;
246 case 4 | PCM_TYPE_SINT_BE<<4:
247 CONVERT(int32_t, pcm_s32be_to_s16); break;
248 case 4 | PCM_TYPE_UINT_BE<<4:
249 CONVERT(uint32_t, pcm_u32be_to_s16); break;
250 case 4 | PCM_TYPE_FLOAT_BE<<4:
251 CONVERT(int32_t, pcm_f32be_to_s16); break;
252 case 8 | PCM_TYPE_FLOAT<<4:
253 CONVERT(int64_t, pcm_f64le_to_s16); break;
254 case 8 | PCM_TYPE_FLOAT_BE<<4:
255 CONVERT(int64_t, pcm_f64be_to_s16); break;
256 default:
257 return -1;
258 }
259 return 0;
260 }
This page took 0.095621 seconds and 4 git commands to generate.