source: roaraudio/libroardsp/convert.c @ 3811:49db840fb4f4

Last change on this file since 3811:49db840fb4f4 was 3811:49db840fb4f4, checked in by phi, 14 years ago

fixed some copyright statements

File size: 28.6 KB
Line 
1//convert.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2010
5 *
6 *  This file is part of libroar a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroar is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 *  NOTE for everyone want's to change something and send patches:
25 *  read README and HACKING! There a addition information on
26 *  the license of this document you need to read before you send
27 *  any patches.
28 *
29 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
30 *  or libpulse*:
31 *  The libs libroaresd, libroararts and libroarpulse link this lib
32 *  and are therefore GPL. Because of this it may be illigal to use
33 *  them with any software that uses libesd, libartsc or libpulse*.
34 */
35
36#include "libroardsp.h"
37//#define free(p) {ROAR_WARN("free(%p) = ?", (p)); free((p)); ROAR_WARN("free(%p): OK", (p));}
38
39int roar_conv_bits (void * out, void * in, int samples, int from, int to) {
40 int format;
41
42 if ( from == to ) {
43  if ( in == out )
44   return 0;
45
46  memcpy(out, in, samples * from / 8);
47  return 0;
48 }
49
50 format = ((from / 8) << 4) + (to / 8);
51
52 switch (format) {
53  case 0x12: return roar_conv_bits_8to16( out, in, samples);
54  case 0x14: return roar_conv_bits_8to32( out, in, samples);
55  case 0x21: return roar_conv_bits_16to8( out, in, samples);
56  case 0x24: return roar_conv_bits_16to32(out, in, samples);
57  case 0x34: return roar_conv_bits_24to32(out, in, samples);
58  case 0x41: return roar_conv_bits_32to8( out, in, samples);
59  case 0x42: return roar_conv_bits_32to16(out, in, samples);
60  default:
61   errno = ENOSYS;
62   return -1;
63 }
64
65 return -1;
66}
67
68int roar_conv_bits_8to16 (void * out, void * in, int samples) {
69 char    * ip = (char   *)in;
70 int16_t * op = (int16_t*)out;
71 int i;
72
73 for (i = samples - 1; i >= 0; i--)
74  op[i] = ip[i] << 8;
75
76 return 0;
77}
78
79int roar_conv_bits_8to32  (void * out, void * in, int samples) {
80 char    * ip = (char   *)in;
81 int32_t * op = (int32_t*)out;
82 int i;
83
84 for (i = samples - 1; i >= 0; i--)
85  op[i] = (int32_t) ip[i] << 24;
86
87 return 0;
88}
89
90int roar_conv_bits_16to8 (void * out, void * in, int samples) {
91 int16_t * ip = (int16_t*)in;
92 char    * op = (char   *)out;
93 int i;
94
95 ROAR_DBG("roar_conv_bits_16to8(out=%p, in=%p, samples=%i) = ?", out, in, samples);
96
97 for (i = 0; i < samples; i++)
98  op[i] = ip[i] >> 8;
99
100 return 0;
101}
102
103int roar_conv_bits_16to32 (void * out, void * in, int samples) {
104 int16_t * ip = (int16_t*)in;
105 int32_t * op = (int32_t*)out;
106 int i;
107
108 for (i = samples - 1; i >= 0; i--)
109  op[i] = (int32_t) ip[i] << 16;
110
111 return 0;
112}
113
114int roar_conv_bits_24to32 (void * out, void * in, int samples) {
115 uint8_t * ip = (uint8_t*)in;
116 int32_t * op = (int32_t*)out;
117 int i;
118 union {
119  int32_t i;
120  uint8_t c[4];
121 } t;
122
123 ROAR_DBG("roar_conv_bits_24to32(out=%p, in=%p, samples=%i) = ?", out, in, samples);
124
125#if (BYTE_ORDER == BIG_ENDIAN) || (BYTE_ORDER == LITTLE_ENDIAN)
126 t.i = 0;
127#else
128  ROAR_DBG("roar_conv_bits_24to32(out=%p, in=%p, samples=%i) = -1", out, in, samples);
129  return -1;
130#endif
131
132 samples--;
133 ip += 3 * samples;
134
135 for (i = samples; i >= 0; i--) {
136#if BYTE_ORDER == BIG_ENDIAN
137  t.c[0] = *(ip--);
138  t.c[1] = *(ip--);
139  t.c[2] = *(ip--);
140#elif BYTE_ORDER == LITTLE_ENDIAN
141  t.c[2] = *(ip--);
142  t.c[3] = *(ip--);
143  t.c[1] = *(ip--);
144#endif
145  ROAR_DBG("roar_conv_bits_24to32(*): i=%i, t.i=0x%.8X", i, t.i);
146  op[i] = t.i;
147 }
148
149 ROAR_DBG("roar_conv_bits_24to32(out=%p, in=%p, samples=%i) = 0", out, in, samples);
150 return 0;
151}
152
153int roar_conv_bits_32to8 (void * out, void * in, int samples) {
154 int32_t * ip = (int32_t*)in;
155 char    * op = (char   *)out;
156 int i;
157
158 for (i = 0; i < samples; i++)
159  op[i] = ip[i] >> 24;
160
161 return 0;
162}
163
164int roar_conv_bits_32to16 (void * out, void * in, int samples) {
165 int32_t * ip = (int32_t*)in;
166 int16_t * op = (int16_t*)out;
167 int i;
168
169 for (i = 0; i < samples; i++)
170  op[i] = ip[i] >> 16;
171
172 return 0;
173}
174
175int roar_conv_chans (void * out, void * in, int samples, int from, int to, int bits) {
176 if ( from == to ) {
177  if ( in == out )
178   return 0;
179
180  memcpy(out, in, samples * from * bits / 8);
181  return 0;
182 }
183
184 switch (bits) {
185  case 8:
186   switch (from) {
187    case 1:
188     switch (to) {
189      case  2: return roar_conv_chans_1to28(out, in, samples);
190      default: return roar_conv_chans_1ton8(out, in, samples, to);
191     }
192     break;
193    case 2:
194     switch (to) {
195      case  1: return roar_conv_chans_2to18(out, in, samples);
196      default: return -1;
197     }
198     break;
199    default:
200     switch (to) {
201      case  1: return roar_conv_chans_nto18(out, in, samples, from);
202      default: return -1;
203     }
204   }
205  break;
206  case 16:
207   switch (from) {
208    case 1:
209     switch (to) {
210      case  2: return roar_conv_chans_1to216(out, in, samples);
211      default: return roar_conv_chans_1ton16(out, in, samples, to);
212     }
213     break;
214    case 2:
215     switch (to) {
216      case  1: return roar_conv_chans_2to116(out, in, samples);
217      case  3: return roar_conv_chans_2to316(out, in, samples);
218      case  4: return roar_conv_chans_2to416(out, in, samples);
219      case  5: return roar_conv_chans_2to516(out, in, samples);
220      case  6: return roar_conv_chans_2to616(out, in, samples);
221      default: return -1;
222     }
223     break;
224    case 4:
225     switch (to) {
226      case  1: return roar_conv_chans_nto116(out, in, samples, 4);
227      case  2: return roar_conv_chans_4to216(out, in, samples);
228      default: return -1;
229     }
230     break;
231    default:
232     switch (to) {
233      case  1: return roar_conv_chans_nto116(out, in, samples, from);
234      default: return -1;
235     }
236   }
237  break;
238  default: return -1;
239 }
240
241 return -1;
242}
243
244int roar_conv_chans_1ton8  (void * out, void * in, int samples, int to) {
245 char * ip = (char*) in, * op = (char*) out;
246 int i;
247 int c;
248
249 for (i = samples - 1; i >= 0; i--)
250  for (c = to - 1; c >= 0; c--)
251   op[i*to + c] = ip[i];
252
253 return 0;
254}
255
256int roar_conv_chans_1to28  (void * out, void * in, int samples) {
257 char * ip = (char*) in, * op = (char*) out;
258 int i, h;
259
260 samples--;
261
262 for (i = (h = samples) * 2; i >= 0; i -= 2, h--) {
263  op[i + 0] = ip[h];
264  op[i + 1] = ip[h];
265 }
266
267 return 0;
268}
269
270int roar_conv_chans_1ton16 (void * out, void * in, int samples, int to) {
271 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
272 int i;
273 int c;
274
275 for (i = samples - 1; i >= 0; i--)
276  for (c = to - 1; c >= 0; c--)
277   op[i*to + c] = ip[i];
278
279 return 0;
280}
281
282int roar_conv_chans_1to216 (void * out, void * in, int samples) {
283 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
284 int i, h;
285
286 samples--;
287
288 for (i = (h = samples) * 2; i >= 0; i -= 2, h--) {
289  op[i + 0] = ip[h];
290  op[i + 1] = ip[h];
291 }
292
293 return 0;
294}
295
296int roar_conv_chans_nto18  (void * out, void * in, int samples, int from) {
297 int8_t * ip = (int8_t*) in, * op = (int8_t*) out;
298 int i;
299 int c;
300 register int s;
301
302 samples /= from;
303
304 for (i = samples - 1; i >= 0; i--) {
305  s  = 0;
306
307  for (c = 0; c < from; c++)
308   s += ip[i*from + c];
309
310  s /= from;
311  op[i] = s;
312 }
313
314 return 0;
315}
316
317int roar_conv_chans_2to18  (void * out, void * in, int samples) {
318 int8_t * ip = (int8_t*) in, * op = (int8_t*) out;
319 int i, h;
320
321 samples -= 2;
322
323 for (h = (i = samples) / 2; i >= 0; i -= 2, h--)
324  op[h] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
325
326 return 0;
327}
328
329int roar_conv_chans_nto116 (void * out, void * in, int samples, int from) {
330 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
331 int i;
332 int c;
333 register int s;
334
335 samples /= from;
336
337 for (i = samples - 1; i >= 0; i--) {
338  s  = 0;
339
340  for (c = 0; c < from; c++)
341   s += ip[i*from + c];
342
343  s /= from;
344  op[i] = s;
345 }
346
347 return 0;
348}
349
350int roar_conv_chans_2to116  (void * out, void * in, int samples) {
351 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
352 int i, h;
353
354 ROAR_DBG("roar_conv_chans_2to116(out=%p, in=%p, samples=%i) = ?", out, in, samples);
355
356 samples -= 2;
357
358 for (h = (i = samples) / 2; i >= 0; i -= 2, h--) {
359  ROAR_DBG("roar_conv_chans_2to116(out=%p, in=%p, samples=%i): op[%i] = (ip[%i] + ip[%i])/2", out, in, samples, h, i, i+1);
360  op[h] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
361 }
362
363 return 0;
364}
365
366int roar_conv_chans_2to38  (void * out, void * in, int samples);
367int roar_conv_chans_2to316 (void * out, void * in, int samples) {
368 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
369 int i, h;
370
371 samples -= 2;
372
373 i  = samples;
374 h  = (samples / 2) * 3;
375
376 for (; i >= 0; i -= 2, h -= 3) {
377  op[h+0] = ip[i+0];
378  op[h+1] = ip[i+1];
379  op[h+2] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
380 }
381
382 return 0;
383}
384
385int roar_conv_chans_2to48  (void * out, void * in, int samples);
386int roar_conv_chans_2to416 (void * out, void * in, int samples) {
387 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
388 int i, h;
389
390 samples -= 2;
391
392 i  = samples;
393 h  = (samples / 2) * 4;
394
395 for (; i >= 0; i -= 2, h -= 4) {
396  op[h+0] = ip[i+0];
397  op[h+1] = ip[i+1];
398  op[h+2] = ip[i+0];
399  op[h+3] = ip[i+1];
400 }
401
402 return 0;
403}
404
405int roar_conv_chans_2to58  (void * out, void * in, int samples);
406int roar_conv_chans_2to516 (void * out, void * in, int samples) {
407 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
408 int i, h;
409
410 samples -= 2;
411
412 i  = samples;
413 h  = (samples / 2) * 5;
414
415 for (; i >= 0; i -= 2, h -= 5) {
416  op[h+0] = ip[i+0];
417  op[h+1] = ip[i+1];
418  op[h+2] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
419  op[h+3] = ip[i+0];
420  op[h+4] = ip[i+1];
421 }
422
423 return 0;
424}
425int roar_conv_chans_2to68  (void * out, void * in, int samples);
426int roar_conv_chans_2to616 (void * out, void * in, int samples) {
427 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
428 int i, h;
429
430 samples -= 2;
431
432 i  = samples;
433 h  = (samples / 2) * 6;
434
435 for (; i >= 0; i -= 2, h -= 6) {
436  op[h+0] = ip[i+0];
437  op[h+1] = ip[i+1];
438  op[h+2] = ((int)ip[i + 0] + (int)ip[i + 1]) / 2;
439  op[h+3] = op[h+2];
440  op[h+4] = ip[i+0];
441  op[h+5] = ip[i+1];
442 }
443
444 return 0;
445}
446
447int roar_conv_chans_3to28  (void * out, void * in, int samples);
448int roar_conv_chans_3to216 (void * out, void * in, int samples);
449int roar_conv_chans_4to28  (void * out, void * in, int samples);
450int roar_conv_chans_4to216 (void * out, void * in, int samples) {
451 int16_t * ip = (int16_t*) in, * op = (int16_t*) out;
452 int i, h;
453
454 samples -= 4;
455
456 for (i = h = 0; i < samples; i += 4, h += 2) {
457  op[h+0] = ((int)ip[i + 0] + (int)ip[i + 2]) / 2;
458  op[h+1] = ((int)ip[i + 1] + (int)ip[i + 3]) / 2;
459 }
460
461 return 0;
462}
463
464int roar_conv_chans_5to28  (void * out, void * in, int samples);
465int roar_conv_chans_5to216 (void * out, void * in, int samples);
466int roar_conv_chans_6to28  (void * out, void * in, int samples);
467int roar_conv_chans_6to216 (void * out, void * in, int samples);
468
469
470
471int roar_conv_rate (void * out, void * in, int samples, int from, int to, int bits, int channels) {
472#ifdef ROAR_HAVE_LIBSAMPLERATE
473 return roar_conv_rate_SRC(out, in, samples, from, to, bits, channels);
474#else
475 if ( bits == 8  )
476  return roar_conv_rate_8(out, in, samples, from, to, channels);
477
478 if ( bits == 16 )
479  return roar_conv_rate_16(out, in, samples, from, to, channels);
480
481 return -1;
482#endif
483}
484
485int roar_conv_rate_8  (void * out, void * in, int samples, int from, int to, int channels) {
486 return -1;
487}
488
489int roar_conv_rate_16 (void * out, void * in, int samples, int from, int to, int channels) {
490 if ( from > to ) {
491  switch (channels) {
492   case 1:
493     return roar_conv_rate_161zoh(out, in, samples, from, to);
494   case 2:
495     return roar_conv_rate_162zoh(out, in, samples, from, to);
496   default:
497     return -1;
498  }
499 } else {
500  if ( channels == 1 ) {
501   printf("roar_conv_rate_16(): samples=%i -> %i, rate=%i -> %i\n", samples*from/to, samples, from, to);
502   return roar_conv_poly4_16s((int16_t*) out, (int16_t*) in, samples, samples*from/to, (float)from/to);
503 //  return roar_conv_poly4_16((int16_t*) out, (int16_t*) in, samples*to/from, samples);
504  }
505 }
506
507 return -1;
508}
509
510int roar_conv_rate_161zoh(void * out, void * in, int samples, int from, int to) {
511 int16_t * ip = in;
512 int16_t * op = out;
513 float t = 0;
514 float step = (float)to/from;
515 int i;
516
517 for (i= 0; i < samples; i++) {
518  op[(int)t] = ip[i];
519  t += step;
520 }
521
522 return 0;
523}
524
525int roar_conv_rate_162zoh(void * out, void * in, int samples, int from, int to) {
526 int16_t * ip = in;
527 int16_t * op = out;
528 float t = 0;
529 float step = (float)to/from;
530 int i;
531
532 ROAR_DBG("roar_conv_rate_162zoh(*): samples=%i", samples);
533 samples /= 2;
534// samples -= 1;
535 ROAR_DBG("roar_conv_rate_162zoh(*): samples=%i", samples);
536
537 for (i= 0; i < samples; i++) {
538  ROAR_DBG("roar_conv_rate_162zoh(*): t=%f, i=%i // op[%i] = ip[%i]", t, i, 2*(int)t, 2*i);
539  op[2*(int)t    ] = ip[2*i    ];
540  op[2*(int)t + 1] = ip[2*i + 1];
541  t += step;
542 }
543
544 return 0;
545}
546
547int roar_conv_rate_SRC   (void * out, void * in, int samples, int from, int to, int bits, int channels) {
548#ifdef ROAR_HAVE_LIBSAMPLERATE
549 double radio = (double) to / (double) from;
550 int outsamples = radio * samples;
551 float * inf  = roar_mm_malloc(samples*sizeof(float));
552 float * outf = roar_mm_malloc(outsamples*sizeof(float));
553 int i;
554 SRC_DATA srcdata;
555
556 ROAR_DBG("roar_conv_rate_SRC(*): radio=%lf, samples=%i, outsamples=%i", radio, samples, outsamples);
557
558 if ( inf == NULL ) {
559  if ( outf != NULL )
560   roar_mm_free(outf);
561
562  return -1;
563 }
564
565 if ( outf == NULL ) {
566  if ( inf != NULL )
567   roar_mm_free(inf);
568
569  return -1;
570 }
571
572 switch (bits) {
573  case  8:
574    for (i = 0; i < samples; i++)
575     inf[i] = *(((int8_t *)in)+i) / 128.0;
576   break;
577  case 16:
578    for (i = 0; i < samples; i++)
579     inf[i] = *(((int16_t*)in)+i) / 32768.0;
580   break;
581  case 32:
582    for (i = 0; i < samples; i++)
583     inf[i] = *(((int32_t*)in)+i) / 2147483648.0;
584   break;
585  default:
586    roar_mm_free(outf);
587    roar_mm_free(inf);
588    return -1;
589 }
590
591 srcdata.data_in       = inf;
592 srcdata.data_out      = outf;
593 srcdata.input_frames  = samples/channels;
594 srcdata.output_frames = outsamples/channels;
595 srcdata.src_ratio     = radio;
596
597 if ( src_simple(&srcdata, SRC_ZERO_ORDER_HOLD, channels) != 0 ) {
598  roar_mm_free(outf);
599  roar_mm_free(inf);
600  return -1;
601 }
602
603 switch (bits) {
604  case  8:
605    for (i = 0; i < outsamples; i++)
606     *(((int8_t *)out)+i) = outf[i] * 128.0;
607   break;
608  case 16:
609    for (i = 0; i < outsamples; i++)
610     *(((int16_t*)out)+i) = outf[i] * 32768.0;
611   break;
612  case 32:
613    for (i = 0; i < outsamples; i++)
614     *(((int32_t*)out)+i) = outf[i] * 2147483648.0;
615   break;
616   // no errors here, they are handled above
617 }
618
619 roar_mm_free(outf);
620 roar_mm_free(inf);
621
622 return 0;
623#else
624 return -1;
625#endif
626}
627
628int roar_conv_signedness  (void * out, void * in, int samples, int from, int to, int bits) {
629
630 if ( from != to ) {
631  if ( from && !to ) {
632   switch (bits) {
633    case  8: roar_conv_codec_s2u8( out, in, samples); break;
634    case 16: roar_conv_codec_s2u16(out, in, samples); break;
635    case 32: roar_conv_codec_s2u32(out, in, samples); break;
636    default:
637     errno = ENOSYS;
638     return -1;
639   }
640  } else if ( !from && to ) {
641   switch (bits) {
642    case  8: roar_conv_codec_u2s8( out, in, samples); break;
643    case 16: roar_conv_codec_u2s16(out, in, samples); break;
644    case 32: roar_conv_codec_u2s32(out, in, samples); break;
645    default:
646     errno = ENOSYS;
647     return -1;
648   }
649  } else {
650   return -1;
651  }
652 } else {
653  if ( out == in )
654   return 0;
655
656  memcpy(out, in, samples * bits / 8);
657  return 0;
658 }
659
660 return 0;
661}
662
663int roar_conv_codec (void * out, void * in, int samples, int from, int to, int bits) {
664 int inbo = ROAR_CODEC_BYTE_ORDER(from), outbo = ROAR_CODEC_BYTE_ORDER(to);
665 int ins  = ROAR_CODEC_IS_SIGNED(from),  outs  = ROAR_CODEC_IS_SIGNED(to);
666 void * nin = in;
667
668
669 ROAR_DBG("roar_conv_codec(out=%p, in=%p, samples=%i, from=%i(%s), to=%i(%s), bits=%i) = ?",
670              out, in, samples, from, roar_codec2str(from), to, roar_codec2str(to), bits);
671
672 roar_conv_endian(out, in, samples, inbo, outbo, bits);
673 nin = out;
674
675 return roar_conv_signedness(out, in, samples, ins, outs, bits);
676}
677
678int roar_conv_codec_s2u8 (void * out, void * in, int samples) {
679 char * ip = in;
680 unsigned char * op = out;
681 int i;
682
683 for(i = 0; i < samples; i++)
684  op[i] = ip[i] + 128;
685
686 return 0;
687}
688
689int roar_conv_codec_s2u16 (void * out, void * in, int samples) {
690 int16_t  * ip = in;
691 uint16_t * op = out;
692 int i;
693
694 for(i = 0; i < samples; i++)
695  op[i] = ip[i] + 32768;
696
697 return 0;
698}
699
700int roar_conv_codec_s2u32 (void * out, void * in, int samples) {
701 int32_t  * ip = in;
702 uint32_t * op = out;
703 int i;
704
705 for(i = 0; i < samples; i++)
706  op[i] = ip[i] + 2147483648U;
707
708 return 0;
709}
710
711int roar_conv_codec_u2s8 (void * out, void * in, int samples) {
712 unsigned char * ip = in;
713          char * op = out;
714 int i;
715
716 for(i = 0; i < samples; i++)
717  op[i] = ip[i] - 128;
718
719 return 0;
720}
721
722int roar_conv_codec_u2s16 (void * out, void * in, int samples) {
723 uint16_t  * ip = in;
724 int16_t   * op = out;
725 int i;
726
727 for(i = 0; i < samples; i++)
728  op[i] = ip[i] - 32768;
729
730 return 0;
731}
732
733int roar_conv_codec_u2s32 (void * out, void * in, int samples) {
734 uint32_t  * ip = in;
735 int32_t   * op = out;
736 int i;
737
738 for(i = 0; i < samples; i++)
739  op[i] = ip[i] - 2147483648U;
740
741 return 0;
742}
743
744
745int roar_conv_endian      (void * out, void * in, int samples, int from, int to, int bits) {
746
747 if ( bits == 8 ) {
748  from = to = ROAR_CODEC_NATIVE_ENDIAN;
749
750 } else if ( bits == 16 ) {
751  if ( from  == ROAR_CODEC_PDP )
752   from = ROAR_CODEC_LE;
753  if ( to    == ROAR_CODEC_PDP )
754   to   = ROAR_CODEC_LE;
755 }
756
757 ROAR_DBG("roar_conv_endian(out=%p, in=%p, samples=%i, from=%i, to=%i, bits=%i) = ?", out, in, samples, from, to, bits);
758
759 if ( from == to ) {
760  if ( in != out ) {
761   memcpy(out, in, samples * bits / 8);
762  }
763  return 0;
764 } else {
765  switch (bits) {
766   case 16:
767     // in this case we can only have LE vs. BE, so, only need to swap:
768     ROAR_DBG("roar_conv_endian(*): Doing 16 bit byteswap");
769     return roar_conv_endian_16(out, in, samples);
770    break;
771   case 24:
772     if ( (from == ROAR_CODEC_LE || from == ROAR_CODEC_BE) && (to == ROAR_CODEC_LE || to == ROAR_CODEC_BE) ) {
773      return roar_conv_endian_24(out, in, samples);
774     } else { // what the hell is PDP eddines in 24 bit mode?
775      return -1;
776     }
777    break;
778   case 32:
779    if ( (from == ROAR_CODEC_LE || from == ROAR_CODEC_BE) && (to == ROAR_CODEC_LE || to == ROAR_CODEC_BE) ) {
780     return roar_conv_endian_32(out, in, samples);
781    } else { // need to handle 32 PDP eddines here?
782     if ( from == ROAR_CODEC_BE )
783      if ( roar_conv_endian_32(out, in, samples) == -1 )
784       return -1;
785
786     if ( roar_conv_endian_16(out, in, samples*2) == -1 )
787      return -1;
788
789     if ( to == ROAR_CODEC_BE )
790      if ( roar_conv_endian_32(out, in, samples) == -1 )
791       return -1;
792
793     return 0;
794    }
795    break;
796   default:
797     return -1;
798    break;
799  }
800 }
801
802 return -1;
803}
804
805
806int roar_conv_endian_16   (void * out, void * in, int samples) {
807 char          * ip = in;
808 char          * op = out;
809 register char   c;
810 int             i;
811
812 samples *= 2;
813
814 if ( out != in ) {
815//  printf("out != in\n");
816  for(i = 0; i < samples; i += 2) {
817//   printf("op[%i] = ip[%i]\nop[%i] = ip[%i]\n", i, i+1, i+1, i);
818   op[i  ] = ip[i+1];
819   op[i+1] = ip[i  ];
820  }
821 } else {
822//  printf("out == in\n");
823  for(i = 0; i < samples; i += 2) {
824   c       = ip[i+1];
825   op[i+1] = ip[i  ];
826   op[i  ] = c;
827  }
828 }
829
830 return 0;
831}
832
833int roar_conv_endian_24   (void * out, void * in, int samples) {
834 char          * ip = in;
835 char          * op = out;
836 register char   c;
837 int             i;
838
839 samples *= 3;
840
841 if ( out != in ) {
842//  printf("out != in\n");
843  for(i = 0; i < samples; i += 3) {
844//   printf("op[%i] = ip[%i]\nop[%i] = ip[%i]\n", i, i+1, i+1, i);
845   op[i  ] = ip[i+2];
846   op[i+2] = ip[i  ];
847  }
848 } else {
849//  printf("out == in\n");
850  for(i = 0; i < samples; i += 3) {
851   c       = ip[i+2];
852   op[i+2] = ip[i  ];
853   op[i  ] = c;
854  }
855 }
856
857 return 0;
858}
859
860int roar_conv_endian_32   (void * out, void * in, int samples) {
861 int32_t       * ip = in;
862 int32_t       * op = out;
863 union {
864  int32_t val;
865  char    data[4];
866 }               c, h;
867 int             i;
868
869 // may the holly optimizer save our souls!
870
871 ROAR_DBG("roar_conv_endian_32(out=%p, in=%p, samples=%i) = ?", out, in, samples);
872
873 for (i = 0; i < samples; i++) {
874  c.val     = ip[i];
875  h.data[0] = c.data[3];
876  h.data[1] = c.data[2];
877  h.data[2] = c.data[1];
878  h.data[3] = c.data[0];
879  op[i]     = h.val;
880 }
881
882 return 0;
883}
884
885int roar_conv       (void * out, void * in, int samples, struct roar_audio_info * from, struct roar_audio_info * to) {
886 void * ip = in;
887 void * real_out = NULL;
888 size_t from_size, to_size;
889
890 // TODO: decide how to work around both in and out beeing to small to hold all
891 //       data between the steps.
892 //       for the moment: guess out >= in
893
894 from_size = (from->bits * samples) / 8;
895 to_size   = (  to->bits * samples * to->rate * to->channels) / (8 * from->rate * from->channels);
896
897 ROAR_DBG("roar_conv(*): size: %i->%i", from_size, to_size);
898
899 if ( to_size < from_size ) {
900  real_out = out;
901
902  if ( (out = roar_mm_malloc(from_size)) == NULL )
903   return -1;
904
905  ROAR_DBG("roar_conv(*): roar_mm_malloc(%i)=%p", (int)from_size, out);
906 }
907
908 ROAR_DBG("roar_conv(*): bo conv: %i->%i(native)", ROAR_CODEC_BYTE_ORDER(from->codec), ROAR_CODEC_NATIVE_ENDIAN);
909
910 if ( ROAR_CODEC_BYTE_ORDER(from->codec) != ROAR_CODEC_NATIVE_ENDIAN ) {
911  ROAR_DBG("roar_conv(*): doing bo input conv");
912  if ( roar_conv_endian(out, ip, samples, ROAR_CODEC_BYTE_ORDER(from->codec), ROAR_CODEC_NATIVE_ENDIAN, from->bits) == -1 ) {
913   if ( to_size < from_size )
914    roar_mm_free(out);
915   return -1;
916  } else {
917   ip = out;
918  }
919 }
920
921 if ( from->bits != to->bits ) {
922  if ( roar_conv_bits(out, ip, samples, from->bits, to->bits) == -1 ) {
923   if ( to_size < from_size )
924    roar_mm_free(out);
925   return -1;
926  } else {
927   ip = out;
928  }
929 }
930
931 if ( ROAR_CODEC_IS_SIGNED(from->codec) != ROAR_CODEC_IS_SIGNED(to->codec) ) {
932  if ( roar_conv_signedness(out, ip, samples, ROAR_CODEC_IS_SIGNED(from->codec), ROAR_CODEC_IS_SIGNED(to->codec), to->bits) == -1 ) {
933   if ( to_size < from_size )
934    roar_mm_free(out);
935   return -1;
936  } else {
937   ip = out;
938  }
939 }
940
941/*
942 if ( from->codec != to->codec ) {
943  if ( roar_conv_codec (out, ip, samples, from->codec, to->codec, to->bits) == -1 )
944   return -1;
945  else
946   ip = out;
947 }
948*/
949
950 if ( from->rate != to->rate ) {
951  if ( roar_conv_rate(out, ip, samples, from->rate, to->rate, to->bits, from->channels) == -1 ) {
952   ROAR_DBG("roar_conv(*): failed to convert rate %i->%i (%ich%ibits)", from->rate, to->rate, to->bits, from->channels);
953   if ( to_size < from_size )
954    roar_mm_free(out);
955   return -1;
956  } else {
957   ip = out;
958   samples = (samples * to->rate) / from->rate;
959  }
960 }
961
962 if ( from->channels != to->channels ) {
963  if ( roar_conv_chans(out, ip, samples, from->channels, to->channels, to->bits) == -1 ) {
964   if ( to_size < from_size )
965    roar_mm_free(out);
966   return -1;
967  } else {
968   ip = out;
969  }
970 }
971
972 if ( ROAR_CODEC_BYTE_ORDER(to->codec) != ROAR_CODEC_NATIVE_ENDIAN ) {
973  if ( roar_conv_endian(out, ip, samples, ROAR_CODEC_NATIVE_ENDIAN, ROAR_CODEC_BYTE_ORDER(to->codec), to->bits) == -1 ) {
974   if ( to_size < from_size )
975    roar_mm_free(out);
976   return -1;
977  } else {
978   ip = out;
979  }
980 }
981
982 if ( to_size < from_size ) {
983  ROAR_DBG("roar_conv(*): memcpy(%p, %p, %i) = ?", real_out, out, (int)to_size);
984  memcpy(real_out, out, to_size);
985  roar_mm_free(out);
986  ROAR_DBG("roar_conv(*): free(%p): OK!", out);
987 }
988
989 return 0;
990}
991
992int roar_conv2(void * out, void * in,
993               size_t inlen,
994               struct roar_audio_info * from, struct roar_audio_info * to,
995               size_t bufsize) {
996 size_t samples;
997 size_t needed_buffer;
998 void   * cin = in;
999 struct roar_audio_info cinfo;
1000 int    need_signed = 0;
1001
1002 memcpy(&cinfo, from, sizeof(cinfo));
1003
1004 ROAR_DBG("roar_conv2(out=%p, in=%p, inlen=%lu, from=%p{...}, to=%p{...}, bufsize=%lu", out, in, inlen, from, to, bufsize);
1005
1006/*
1007 if ( in != out ) {
1008  memset(out, 0xA0, bufsize);
1009 } else {
1010  ROAR_WARN("roar_conv2(*): in==out!");
1011  memset(out+inlen, 0xA0, bufsize-inlen);
1012 }
1013*/
1014
1015 // calcumate number of input samples:
1016 samples = (inlen * 8) / (from->bits);
1017
1018 ROAR_DBG("roar_conv2(*): input samples: %i", samples);
1019
1020 // calculate size per frame
1021 needed_buffer  = ROAR_MAX(from->channels, to->channels) * ROAR_MAX(from->bits, to->bits) / 8;
1022
1023 needed_buffer *= samples;
1024 needed_buffer /= from->channels;
1025
1026 if ( from->rate < to->rate )
1027  needed_buffer *= (float)to->rate/(float)from->rate;
1028
1029 ROAR_DBG("roar_conv2(*): needed_buffer=%u, bufsize=%u", needed_buffer, bufsize);
1030
1031 // chjeck if we have enogth RAM to convert
1032 if ( needed_buffer > bufsize )
1033  return -1;
1034
1035 if ( from->rate != to->rate || from->channels != to->channels )
1036  need_signed = 1;
1037
1038  ROAR_DBG("roar_conv2(*): need_signed=%i", need_signed);
1039
1040 if ( ROAR_CODEC_BYTE_ORDER(from->codec) != ROAR_CODEC_NATIVE_ENDIAN ) {
1041  ROAR_DBG("roar_conv2(*): doing bo input conv");
1042  if ( roar_conv_endian(out, cin, samples,
1043       ROAR_CODEC_BYTE_ORDER(from->codec), ROAR_CODEC_NATIVE_ENDIAN, from->bits) == -1 ) {
1044   return -1;
1045  }
1046  cin = out;
1047 }
1048
1049 if ( to->bits > from->bits ) {
1050  ROAR_DBG("roar_conv2(*): bits: %i->%i", from->bits, to->bits);
1051  if ( roar_conv_bits(out, cin, samples, from->bits, to->bits) == -1 )
1052   return -1;
1053
1054  cin        = out;
1055  cinfo.bits = to->bits;
1056 }
1057
1058 if ( need_signed && ! ROAR_CODEC_IS_SIGNED(from->codec) ) {
1059  ROAR_DBG("roar_conv2(*): sign: unsigned->signed");
1060  if ( roar_conv_signedness(out, cin, samples,
1061                            ROAR_CODEC_IS_SIGNED(from->codec), ROAR_CODEC_IS_SIGNED(to->codec),
1062                            cinfo.bits) == -1 )
1063   return -1;
1064
1065  cin            = out;
1066  cinfo.codec    = ROAR_CODEC_PCM_S_LE; // just a signed PCM, which is of no intrest
1067 }
1068
1069 if ( to->channels > from->channels ) {
1070  ROAR_DBG("roar_conv2(*): channels: %i->%i", from->channels, to->channels);
1071  if ( roar_conv_chans(out, cin, samples, from->channels, to->channels, cinfo.bits) == -1 )
1072   return -1;
1073
1074  cin            = out;
1075  cinfo.channels = to->channels;
1076 }
1077
1078//--//
1079 if ( from->rate != to->rate ) {
1080  if ( roar_conv_rate(out, cin, samples, from->rate, to->rate, cinfo.bits, cinfo.channels) == -1 )
1081   return -1;
1082
1083  cin            = out;
1084  samples        = (float)samples * (float)to->rate / (float)from->rate;
1085  cinfo.rate     = to->rate;
1086 }
1087
1088 if ( cinfo.channels != to->channels ) {
1089  ROAR_DBG("roar_conv2(*): channels: %i->%i", cinfo.channels, to->channels);
1090  if ( roar_conv_chans(out, cin, samples, cinfo.channels, to->channels, cinfo.bits) == -1 )
1091   return -1;
1092
1093  cin            = out;
1094  cinfo.channels = to->channels;
1095 }
1096
1097 if ( ROAR_CODEC_IS_SIGNED(cinfo.codec) != ROAR_CODEC_IS_SIGNED(to->codec) ) {
1098  ROAR_DBG("roar_conv2(*): sign: ?(%i)->?(%i)", ROAR_CODEC_IS_SIGNED(cinfo.codec), ROAR_CODEC_IS_SIGNED(to->codec));
1099  if ( roar_conv_signedness(out, cin, samples,
1100                            ROAR_CODEC_IS_SIGNED(cinfo.codec), ROAR_CODEC_IS_SIGNED(to->codec),
1101                            cinfo.bits) == -1 )
1102   return -1;
1103
1104  cin            = out;
1105  cinfo.codec    = to->codec;
1106 }
1107
1108 if ( cinfo.bits != to->bits ) {
1109  ROAR_DBG("roar_conv2(*): bits: %i->%i", cinfo.bits, to->bits);
1110  if ( roar_conv_bits(out, cin, samples, cinfo.bits, to->bits) == -1 )
1111   return -1;
1112
1113  cin        = out;
1114  cinfo.bits = to->bits;
1115 }
1116
1117 if ( ROAR_CODEC_BYTE_ORDER(to->codec) != ROAR_CODEC_NATIVE_ENDIAN ) {
1118  ROAR_DBG("roar_conv2(*): doing bo output conv");
1119  if ( roar_conv_endian(out, cin, samples,
1120       ROAR_CODEC_NATIVE_ENDIAN, ROAR_CODEC_BYTE_ORDER(to->codec), to->bits) == -1 ) {
1121   return -1;
1122  }
1123  cin = out;
1124 }
1125
1126 ROAR_DBG("roar_conv2(*) = 0");
1127 return 0;
1128}
1129
1130int roar_conv_poly4_16 (int16_t * out, int16_t * in, size_t olen, size_t ilen) {
1131 return roar_conv_poly4_16s(out, in, olen, ilen, (float)ilen/olen);
1132}
1133
1134int roar_conv_poly4_16s (int16_t * out, int16_t * in, size_t olen, size_t ilen, float step) {
1135 float poly[4];
1136 float data[4];
1137 float t    = 0;
1138 int16_t * ci = in;
1139 int io, ii = 0;
1140 int i;
1141
1142 printf("step=%f\n", step);
1143
1144 // we can not make a poly4 with less than 4 points ;)
1145 if ( ilen < 4 )
1146  return -1;
1147
1148 for (i = 0; i < 4; i++)
1149  data[i] = ci[i];
1150 roar_math_mkpoly_4x4(poly, data);
1151/*
1152 printf("new poly: data[4] = {%f, %f, %f, %f}, poly[4] = {%f, %f, %f, %f}\n",
1153         data[0], data[1], data[2], data[3],
1154         poly[0], poly[1], poly[2], poly[3]
1155       );
1156*/
1157
1158 //0 1 2 3
1159
1160 for (io = 0; io < olen; io++) {
1161//  printf("t=%f\n", t);
1162  out[io] = roar_math_cvpoly_4x4(poly, t);
1163  t += step;
1164  if ( t > 2 ) { // we need a new ploynome
1165 //  printf("t > 2, need new data\n");
1166   if ( (ii + 4) < ilen ) { // else: end of block.
1167    t -= 1;
1168//    printf("new data: ii=%i\n", ii);
1169    ii++;
1170    ci++;
1171    for (i = 0; i < 4; i++)
1172     data[i] = ci[i];
1173    roar_math_mkpoly_4x4(poly, data);
1174/*
1175   printf("new poly: data[4] = {%f, %f, %f, %f}, poly[4] = {%f, %f, %f, %f}\n",
1176           data[0], data[1], data[2], data[3],
1177           poly[0], poly[1], poly[2], poly[3]
1178          );
1179*/
1180   }
1181  }
1182 }
1183
1184 printf("io=%i\n", io);
1185
1186 return 0;
1187}
1188
1189//ll
Note: See TracBrowser for help on using the repository browser.