Huge new year audio commit!
[blender.git] / intern / audaspace / intern / AUD_ConverterFunctions.cpp
1 /*
2  * $Id$
3  *
4  * ***** BEGIN LGPL LICENSE BLOCK *****
5  *
6  * Copyright 2009 Jörg Hermann Müller
7  *
8  * This file is part of AudaSpace.
9  *
10  * AudaSpace is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * AudaSpace is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with AudaSpace.  If not, see <http://www.gnu.org/licenses/>.
22  *
23  * ***** END LGPL LICENSE BLOCK *****
24  */
25
26 #include "AUD_ConverterFunctions.h"
27 #include "AUD_Buffer.h"
28
29 #define AUD_U8_0                0x80
30 #define AUD_S16_MAX             0x7FFF
31 #define AUD_S16_MIN             0x8000
32 #define AUD_S16_FLT             32768.0
33 #define AUD_S32_MAX             0x7FFFFFFF
34 #define AUD_S32_MIN             0x80000000
35 #define AUD_S32_FLT             2147483648.0
36 #define AUD_FLT_MAX             1.0
37 #define AUD_FLT_MIN             -1.0
38
39 void AUD_convert_u8_s16(data_t* target, data_t* source, int length)
40 {
41         int16_t* t = (int16_t*) target;
42         for(int i = 0; i < length; i++)
43                 t[i] = (((int16_t)source[i]) - AUD_U8_0) << 8;
44 }
45
46 void AUD_convert_u8_s24_be(data_t* target, data_t* source, int length)
47 {
48         for(int i = 0; i < length; i++)
49         {
50                 target[i*3] = source[i] - AUD_U8_0;
51                 target[i*3+1] = 0;
52                 target[i*3+2] = 0;
53         }
54 }
55
56 void AUD_convert_u8_s24_le(data_t* target, data_t* source, int length)
57 {
58         for(int i = 0; i < length; i++)
59         {
60                 target[i*3+2] = source[i] - AUD_U8_0;
61                 target[i*3+1] = 0;
62                 target[i*3] = 0;
63         }
64 }
65
66 void AUD_convert_u8_s32(data_t* target, data_t* source, int length)
67 {
68         int32_t* t = (int32_t*) target;
69         for(int i = 0; i < length; i++)
70                 t[i] = (((int32_t)source[i]) - AUD_U8_0) << 24;
71 }
72
73 void AUD_convert_u8_float(data_t* target, data_t* source, int length)
74 {
75         float* t = (float*) target;
76         for(int i = 0; i < length; i++)
77                 t[i] = (((int32_t)source[i]) - AUD_U8_0) / ((float)AUD_U8_0);
78 }
79
80 void AUD_convert_u8_double(data_t* target, data_t* source, int length)
81 {
82         double* t = (double*) target;
83         for(int i = 0; i < length; i++)
84                 t[i] = (((int32_t)source[i]) - AUD_U8_0) / ((double)AUD_U8_0);
85 }
86
87 void AUD_convert_s16_u8(data_t* target, data_t* source, int length)
88 {
89         int16_t* s = (int16_t*) source;
90         for(int i = 0; i < length; i++)
91                 target[i] = (unsigned char)((s[i] >> 8) + AUD_U8_0);
92 }
93
94 void AUD_convert_s16_s24_be(data_t* target, data_t* source, int length)
95 {
96         int16_t* s = (int16_t*) source;
97         for(int i = 0; i < length; i++)
98         {
99                 target[i*3] = s[i] >> 8 & 0xFF;
100                 target[i*3+1] = s[i] & 0xFF;
101                 target[i*3+2] = 0;
102         }
103 }
104
105 void AUD_convert_s16_s24_le(data_t* target, data_t* source, int length)
106 {
107         int16_t* s = (int16_t*) source;
108         for(int i = 0; i < length; i++)
109         {
110                 target[i*3+2] = s[i] >> 8 & 0xFF;
111                 target[i*3+1] = s[i] & 0xFF;
112                 target[i*3] = 0;
113         }
114 }
115
116 void AUD_convert_s16_s32(data_t* target, data_t* source, int length)
117 {
118         int16_t* s = (int16_t*) source;
119         int32_t* t = (int32_t*) target;
120         for(int i = 0; i < length; i++)
121                 t[i] = ((int32_t)s[i]) << 16;
122 }
123
124 void AUD_convert_s16_float(data_t* target, data_t* source, int length)
125 {
126         int16_t* s = (int16_t*) source;
127         float* t = (float*) target;
128         for(int i = 0; i < length; i++)
129                 t[i] = s[i] / AUD_S16_FLT;
130 }
131
132 void AUD_convert_s16_double(data_t* target, data_t* source, int length)
133 {
134         int16_t* s = (int16_t*) source;
135         double* t = (double*) target;
136         for(int i = 0; i < length; i++)
137                 t[i] = s[i] / AUD_S16_FLT;
138 }
139
140 void AUD_convert_s24_u8_be(data_t* target, data_t* source, int length)
141 {
142         for(int i = 0; i < length; i++)
143                 target[i] = source[i*3] ^ AUD_U8_0;
144 }
145
146 void AUD_convert_s24_u8_le(data_t* target, data_t* source, int length)
147 {
148         for(int i = 0; i < length; i++)
149                 target[i] = source[i*3+2] ^ AUD_U8_0;
150 }
151
152 void AUD_convert_s24_s16_be(data_t* target, data_t* source, int length)
153 {
154         int16_t* t = (int16_t*) target;
155         for(int i = 0; i < length; i++)
156                 t[i] = source[i*3] << 8 | source[i*3+1];
157 }
158
159 void AUD_convert_s24_s16_le(data_t* target, data_t* source, int length)
160 {
161         int16_t* t = (int16_t*) target;
162         for(int i = 0; i < length; i++)
163                 t[i] = source[i*3+2] << 8 | source[i*3+1];
164 }
165
166 void AUD_convert_s24_s24(data_t* target, data_t* source, int length)
167 {
168         memcpy(target, source, length * 3);
169 }
170
171 void AUD_convert_s24_s32_be(data_t* target, data_t* source, int length)
172 {
173         int32_t* t = (int32_t*) target;
174         for(int i = 0; i < length; i++)
175                 t[i] = source[i*3] << 24 | source[i*3+1] << 16 | source[i*3+2] << 8;
176 }
177
178 void AUD_convert_s24_s32_le(data_t* target, data_t* source, int length)
179 {
180         int32_t* t = (int32_t*) target;
181         for(int i = 0; i < length; i++)
182                 t[i] = source[i*3+2] << 24 | source[i*3+1] << 16 | source[i*3] << 8;
183 }
184
185 void AUD_convert_s24_float_be(data_t* target, data_t* source, int length)
186 {
187         float* t = (float*) target;
188         int32_t s;
189         for(int i = 0; i < length; i++)
190         {
191                 s = source[i*3] << 24 | source[i*3+1] << 16 | source[i*3+2] << 8;
192                 t[i] = s / AUD_S32_FLT;
193         }
194 }
195
196 void AUD_convert_s24_float_le(data_t* target, data_t* source, int length)
197 {
198         float* t = (float*) target;
199         int32_t s;
200         for(int i = 0; i < length; i++)
201         {
202                 s = source[i*3+2] << 24 | source[i*3+1] << 16 | source[i*3] << 8;
203                 t[i] = s / AUD_S32_FLT;
204         }
205 }
206
207 void AUD_convert_s24_double_be(data_t* target, data_t* source, int length)
208 {
209         double* t = (double*) target;
210         int32_t s;
211         for(int i = 0; i < length; i++)
212         {
213                 s = source[i*3] << 24 | source[i*3+1] << 16 | source[i*3+2] << 8;
214                 t[i] = s / AUD_S32_FLT;
215         }
216 }
217
218 void AUD_convert_s24_double_le(data_t* target, data_t* source, int length)
219 {
220         double* t = (double*) target;
221         int32_t s;
222         for(int i = 0; i < length; i++)
223         {
224                 s = source[i*3+2] << 24 | source[i*3+1] << 16 | source[i*3] << 8;
225                 t[i] = s / AUD_S32_FLT;
226         }
227 }
228
229 void AUD_convert_s32_u8(data_t* target, data_t* source, int length)
230 {
231         int16_t* s = (int16_t*) source;
232         for(int i = 0; i < length; i++)
233                 target[i] = (unsigned char)((s[i] >> 24) + AUD_U8_0);
234 }
235
236 void AUD_convert_s32_s16(data_t* target, data_t* source, int length)
237 {
238         int16_t* t = (int16_t*) target;
239         int32_t* s = (int32_t*) source;
240         for(int i = 0; i < length; i++)
241                 t[i] = s[i] >> 16;
242 }
243
244 void AUD_convert_s32_s24_be(data_t* target, data_t* source, int length)
245 {
246         int32_t* s = (int32_t*) source;
247         for(int i = 0; i < length; i++)
248         {
249                 target[i*3] = s[i] >> 24 & 0xFF;
250                 target[i*3+1] = s[i] >> 16 & 0xFF;
251                 target[i*3+2] = s[i] >> 8 & 0xFF;
252         }
253 }
254
255 void AUD_convert_s32_s24_le(data_t* target, data_t* source, int length)
256 {
257         int16_t* s = (int16_t*) source;
258         for(int i = 0; i < length; i++)
259         {
260                 target[i*3+2] = s[i] >> 24 & 0xFF;
261                 target[i*3+1] = s[i] >> 16 & 0xFF;
262                 target[i*3] = s[i] >> 8 & 0xFF;
263         }
264 }
265
266 void AUD_convert_s32_float(data_t* target, data_t* source, int length)
267 {
268         int32_t* s = (int32_t*) source;
269         float* t = (float*) target;
270         for(int i = 0; i < length; i++)
271                 t[i] = s[i] / AUD_S32_FLT;
272 }
273
274 void AUD_convert_s32_double(data_t* target, data_t* source, int length)
275 {
276         int32_t* s = (int32_t*) source;
277         double* t = (double*) target;
278         for(int i = 0; i < length; i++)
279                 t[i] = s[i] / AUD_S32_FLT;
280 }
281
282 void AUD_convert_float_u8(data_t* target, data_t* source, int length)
283 {
284         float* s = (float*) source;
285         float t;
286         for(int i = 0; i < length; i++)
287         {
288                 t = s[i] + AUD_FLT_MAX;
289                 if(t <= 0.0f)
290                         target[i] = 0;
291                 else if(t >= 2.0f)
292                         target[i] = 255;
293                 else
294                         target[i] = (unsigned char)(t*127);
295         }
296 }
297
298 void AUD_convert_float_s16(data_t* target, data_t* source, int length)
299 {
300         int16_t* t = (int16_t*) target;
301         float* s = (float*) source;
302         for(int i = 0; i < length; i++)
303         {
304                 if(s[i] <= AUD_FLT_MIN)
305                         t[i] = AUD_S16_MIN;
306                 else if(s[i] >= AUD_FLT_MAX)
307                         t[i] = AUD_S16_MAX;
308                 else
309                         t[i] = (int16_t)(s[i] * AUD_S16_MAX);
310         }
311 }
312
313 void AUD_convert_float_s24_be(data_t* target, data_t* source, int length)
314 {
315         int32_t t;
316         float* s = (float*) source;
317         for(int i = 0; i < length; i++)
318         {
319                 if(s[i] <= AUD_FLT_MIN)
320                         t = AUD_S32_MIN;
321                 else if(s[i] >= AUD_FLT_MAX)
322                         t = AUD_S32_MAX;
323                 else
324                         t = (int32_t)(s[i]*AUD_S32_MAX);
325                 target[i*3] = t >> 24 & 0xFF;
326                 target[i*3+1] = t >> 16 & 0xFF;
327                 target[i*3+2] = t >> 8 & 0xFF;
328         }
329 }
330
331 void AUD_convert_float_s24_le(data_t* target, data_t* source, int length)
332 {
333         int32_t t;
334         float* s = (float*) source;
335         for(int i = 0; i < length; i++)
336         {
337                 if(s[i] <= AUD_FLT_MIN)
338                         t = AUD_S32_MIN;
339                 else if(s[i] >= AUD_FLT_MAX)
340                         t = AUD_S32_MAX;
341                 else
342                         t = (int32_t)(s[i]*AUD_S32_MAX);
343                 target[i*3+2] = t >> 24 & 0xFF;
344                 target[i*3+1] = t >> 16 & 0xFF;
345                 target[i*3] = t >> 8 & 0xFF;
346         }
347 }
348
349 void AUD_convert_float_s32(data_t* target, data_t* source, int length)
350 {
351         int32_t* t = (int32_t*) target;
352         float* s = (float*) source;
353         for(int i = 0; i < length; i++)
354         {
355                 if(s[i] <= AUD_FLT_MIN)
356                         t[i] = AUD_S32_MIN;
357                 else if(s[i] >= AUD_FLT_MAX)
358                         t[i] = AUD_S32_MAX;
359                 else
360                         t[i] = (int32_t)(s[i]*AUD_S32_MAX);
361         }
362 }
363
364 void AUD_convert_float_double(data_t* target, data_t* source, int length)
365 {
366         float* s = (float*) source;
367         double* t = (double*) target;
368         for(int i = 0; i < length; i++)
369                 t[i] = s[i];
370 }
371
372 void AUD_convert_double_u8(data_t* target, data_t* source, int length)
373 {
374         double* s = (double*) source;
375         double t;
376         for(int i = 0; i < length; i++)
377         {
378                 t = s[i] + AUD_FLT_MAX;
379                 if(t <= 0.0)
380                         target[i] = 0;
381                 else if(t >= 2.0)
382                         target[i] = 255;
383                 else
384                         target[i] = (unsigned char)(t*127);
385         }
386 }
387
388 void AUD_convert_double_s16(data_t* target, data_t* source, int length)
389 {
390         int16_t* t = (int16_t*) target;
391         double* s = (double*) source;
392         for(int i = 0; i < length; i++)
393         {
394                 if(s[i] <= AUD_FLT_MIN)
395                         t[i] = AUD_S16_MIN;
396                 else if(s[i] >= AUD_FLT_MAX)
397                         t[i] = AUD_S16_MAX;
398                 else
399                         t[i] = (int16_t)(s[i]*AUD_S16_MAX);
400         }
401 }
402
403 void AUD_convert_double_s24_be(data_t* target, data_t* source, int length)
404 {
405         int32_t t;
406         double* s = (double*) source;
407         for(int i = 0; i < length; i++)
408         {
409                 if(s[i] <= AUD_FLT_MIN)
410                         t = AUD_S32_MIN;
411                 else if(s[i] >= AUD_FLT_MAX)
412                         t = AUD_S32_MAX;
413                 else
414                         t = (int32_t)(s[i]*AUD_S32_MAX);
415                 target[i*3] = t >> 24 & 0xFF;
416                 target[i*3+1] = t >> 16 & 0xFF;
417                 target[i*3+2] = t >> 8 & 0xFF;
418         }
419 }
420
421 void AUD_convert_double_s24_le(data_t* target, data_t* source, int length)
422 {
423         int32_t t;
424         double* s = (double*) source;
425         for(int i = 0; i < length; i++)
426         {
427                 if(s[i] <= AUD_FLT_MIN)
428                         t = AUD_S32_MIN;
429                 else if(s[i] >= AUD_FLT_MAX)
430                         t = AUD_S32_MAX;
431                 else
432                         t = (int32_t)(s[i]*AUD_S32_MAX);
433                 target[i*3+2] = t >> 24 & 0xFF;
434                 target[i*3+1] = t >> 16 & 0xFF;
435                 target[i*3] = t >> 8 & 0xFF;
436         }
437 }
438
439 void AUD_convert_double_s32(data_t* target, data_t* source, int length)
440 {
441         int32_t* t = (int32_t*) target;
442         double* s = (double*) source;
443         for(int i = 0; i < length; i++)
444         {
445                 if(s[i] <= AUD_FLT_MIN)
446                         t[i] = AUD_S32_MIN;
447                 else if(s[i] >= AUD_FLT_MAX)
448                         t[i] = AUD_S32_MAX;
449                 else
450                         t[i] = (int32_t)(s[i]*AUD_S32_MAX);
451         }
452 }
453
454 void AUD_convert_double_float(data_t* target, data_t* source, int length)
455 {
456         double* s = (double*) source;
457         float* t = (float*) target;
458         for(int i = 0; i < length; i++)
459                 t[i] = s[i];
460 }