]> iEval git - fdkaac.git/blob - src/lpcm.c
tweak configure.ac and Makefile.am
[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 inline double pcm_clip(double n, double min_value, double max_value)
38 {
39 if (n < min_value)
40 return min_value;
41 else if (n > max_value)
42 return max_value;
43 return n;
44 }
45 inline float pcm_i2f(int32_t n)
46 {
47 union {
48 int32_t ivalue;
49 float fvalue;
50 } u;
51 u.ivalue = n;
52 return u.fvalue;
53 }
54 inline double pcm_i2d(int64_t n)
55 {
56 union {
57 int64_t ivalue;
58 double fvalue;
59 } u;
60 u.ivalue = n;
61 return u.fvalue;
62 }
63 inline int16_t pcm_quantize_s32(int32_t n)
64 {
65 n = ((n >> 15) + 1) >> 1;
66 return (n == 0x8000) ? 0x7fff : n;
67 }
68 inline int16_t pcm_quantize_f64(double v)
69 {
70 return (int16_t)lrint(pcm_clip(v * 32768.0, -32768.0, 32767.0));
71 }
72 inline int16_t pcm_s8_to_s16(int8_t n)
73 {
74 return n << 8;
75 }
76 inline int16_t pcm_u8_to_s16(uint8_t n)
77 {
78 return (n << 8) ^ 0x8000;
79 }
80 inline int16_t pcm_s16le_to_s16(int16_t n)
81 {
82 return m4af_ltoh16(n);
83 }
84 inline int16_t pcm_s16be_to_s16(int16_t n)
85 {
86 return m4af_btoh16(n);
87 }
88 inline int16_t pcm_u16le_to_s16(uint16_t n)
89 {
90 return m4af_ltoh16(n) ^ 0x8000;
91 }
92 inline int16_t pcm_u16be_to_s16(uint16_t n)
93 {
94 return m4af_btoh16(n) ^ 0x8000;
95 }
96 inline int32_t pcm_s24le_to_s32(uint8_t *p)
97 {
98 return p[0]<<8 | p[1]<<16 | p[2]<<24;
99 }
100 inline int32_t pcm_s24be_to_s32(uint8_t *p)
101 {
102 return p[0]<<24 | p[1]<<16 | p[2]<<8;
103 }
104 inline int32_t pcm_u24le_to_s32(uint8_t *p)
105 {
106 return pcm_s24le_to_s32(p) ^ 0x80000000;
107 }
108 inline int32_t pcm_u24be_to_s32(uint8_t *p)
109 {
110 return pcm_s24be_to_s32(p) ^ 0x80000000;
111 }
112 inline int16_t pcm_s24le_to_s16(uint8_t *p)
113 {
114 return pcm_quantize_s32(pcm_s24le_to_s32(p));
115 }
116 inline int16_t pcm_s24be_to_s16(uint8_t *p)
117 {
118 return pcm_quantize_s32(pcm_s24be_to_s32(p));
119 }
120 inline int16_t pcm_u24le_to_s16(uint8_t *p)
121 {
122 return pcm_quantize_s32(pcm_u24le_to_s32(p));
123 }
124 inline int16_t pcm_u24be_to_s16(uint8_t *p)
125 {
126 return pcm_quantize_s32(pcm_u24be_to_s32(p));
127 }
128 inline int16_t pcm_s32le_to_s16(int32_t n)
129 {
130 return pcm_quantize_s32(m4af_ltoh32(n));
131 }
132 inline int16_t pcm_s32be_to_s16(int32_t n)
133 {
134 return pcm_quantize_s32(m4af_btoh32(n));
135 }
136 inline int16_t pcm_u32le_to_s16(int32_t n)
137 {
138 return pcm_quantize_s32(m4af_ltoh32(n) ^ 0x80000000);
139 }
140 inline int16_t pcm_u32be_to_s16(int32_t n)
141 {
142 return pcm_quantize_s32(m4af_btoh32(n) ^ 0x80000000);
143 }
144 inline int16_t pcm_f32le_to_s16(int32_t n)
145 {
146 return pcm_quantize_f64(pcm_i2f(m4af_ltoh32(n)));
147 }
148 inline int16_t pcm_f32be_to_s16(int32_t n)
149 {
150 return pcm_quantize_f64(pcm_i2f(m4af_btoh32(n)));
151 }
152 inline int16_t pcm_f64le_to_s16(int64_t n)
153 {
154 return pcm_quantize_f64(pcm_i2d(m4af_ltoh64(n)));
155 }
156 inline int16_t pcm_f64be_to_s16(int64_t n)
157 {
158 return pcm_quantize_f64(pcm_i2d(m4af_btoh64(n)));
159 }
160
161 int pcm_convert_to_native_sint16(const pcm_sample_description_t *format,
162 const void *input, uint32_t nframes,
163 int16_t **result, uint32_t *osize)
164 {
165 #define CONVERT(type, conv) \
166 do { \
167 unsigned i; \
168 type *ip = (type *)input; \
169 for (i = 0; i < count; ++i) { \
170 (*result)[i] = conv(ip[i]); \
171 } \
172 } while(0)
173
174 #define CONVERT_BYTES(conv) \
175 do { \
176 unsigned i, bytes_per_channel; \
177 uint8_t *ip = (uint8_t *)input; \
178 bytes_per_channel = PCM_BYTES_PER_CHANNEL(format); \
179 for (i = 0; i < count; ++i) { \
180 (*result)[i] = conv(ip); \
181 ip += bytes_per_channel; \
182 } \
183 } while(0)
184
185 uint32_t count = nframes * format->channels_per_frame;
186 if (!count)
187 return 0;
188 if (!*result || *osize < count) {
189 *osize = count;
190 *result = realloc(*result, count * sizeof(int16_t));
191 }
192
193 switch (PCM_BYTES_PER_CHANNEL(format) | format->sample_type<<4) {
194 case 1 | PCM_TYPE_SINT<<4:
195 CONVERT(int8_t, pcm_s8_to_s16); break;
196 case 1 | PCM_TYPE_UINT<<4:
197 CONVERT(uint8_t, pcm_u8_to_s16); break;
198 case 2 | PCM_TYPE_SINT<<4:
199 CONVERT(int16_t, pcm_s16le_to_s16); break;
200 case 2 | PCM_TYPE_UINT<<4:
201 CONVERT(uint16_t, pcm_u16le_to_s16); break;
202 case 2 | PCM_TYPE_SINT_BE<<4:
203 CONVERT(int16_t, pcm_s16be_to_s16); break;
204 case 2 | PCM_TYPE_UINT_BE<<4:
205 CONVERT(int16_t, pcm_u16be_to_s16); break;
206 case 3 | PCM_TYPE_SINT<<4:
207 CONVERT_BYTES(pcm_s24le_to_s16); break;
208 case 3 | PCM_TYPE_UINT<<4:
209 CONVERT_BYTES(pcm_u24le_to_s16); break;
210 case 3 | PCM_TYPE_SINT_BE<<4:
211 CONVERT_BYTES(pcm_s24be_to_s16); break;
212 case 3 | PCM_TYPE_UINT_BE<<4:
213 CONVERT_BYTES(pcm_u24be_to_s16); break;
214 case 4 | PCM_TYPE_SINT<<4:
215 CONVERT(int32_t, pcm_s32le_to_s16); break;
216 case 4 | PCM_TYPE_UINT<<4:
217 CONVERT(uint32_t, pcm_u32le_to_s16); break;
218 case 4 | PCM_TYPE_FLOAT<<4:
219 CONVERT(int32_t, pcm_f32le_to_s16); break;
220 case 4 | PCM_TYPE_SINT_BE<<4:
221 CONVERT(int32_t, pcm_s32be_to_s16); break;
222 case 4 | PCM_TYPE_UINT_BE<<4:
223 CONVERT(uint32_t, pcm_u32be_to_s16); break;
224 case 4 | PCM_TYPE_FLOAT_BE<<4:
225 CONVERT(int32_t, pcm_f32be_to_s16); break;
226 case 8 | PCM_TYPE_FLOAT<<4:
227 CONVERT(int64_t, pcm_f64le_to_s16); break;
228 case 8 | PCM_TYPE_FLOAT_BE<<4:
229 CONVERT(int64_t, pcm_f64be_to_s16); break;
230 default:
231 return -1;
232 }
233 return 0;
234 }
This page took 0.062173 seconds and 4 git commands to generate.