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