72 if (lsb_bits == 0)
73 mask = (byte) 0x00;
74 else if (lsb_bits == 1)
75 mask = (byte) 0x80;
76 else if (lsb_bits == 2)
77 mask = (byte) 0xC0;
78 else if (lsb_bits == 3)
79 mask = (byte) 0xE0;
80 else if (lsb_bits == 4)
81 mask = (byte) 0xF0;
82 else if (lsb_bits == 5)
83 mask = (byte) 0xF8;
84 else if (lsb_bits == 6)
85 mask = (byte) 0xFC;
86 else if (lsb_bits == 7)
87 mask = (byte) 0xFE;
88 else
89 mask = (byte) 0xFF;
90 }
91
92 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
93 byte[] out_buff, int out_offset) {
94 byte[] ret = converter.toByteArray(in_buff, in_offset, in_len,
95 out_buff, out_offset);
96
97 int out_offset_end = in_len * stepsize;
98 for (int i = out_offset + offset; i < out_offset_end; i += stepsize) {
99 out_buff[i] = (byte) (out_buff[i] & mask);
100 }
101
102 return ret;
103 }
104
105 public float[] toFloatArray(byte[] in_buff, int in_offset,
106 float[] out_buff, int out_offset, int out_len) {
107 if (mask_buffer == null || mask_buffer.length < in_buff.length)
108 mask_buffer = new byte[in_buff.length];
109 System.arraycopy(in_buff, 0, mask_buffer, 0, in_buff.length);
110 int in_offset_end = out_len * stepsize;
111 for (int i = in_offset + offset; i < in_offset_end; i += stepsize) {
112 mask_buffer[i] = (byte) (mask_buffer[i] & mask);
113 }
114 float[] ret = converter.toFloatArray(mask_buffer, in_offset,
115 out_buff, out_offset, out_len);
116 return ret;
117 }
118
119 }
120
121 /***************************************************************************
122 *
123 * 64 bit float, little/big-endian
124 *
125 **************************************************************************/
126
127 // PCM 64 bit float, little-endian
128 private static class AudioFloatConversion64L extends AudioFloatConverter {
129 ByteBuffer bytebuffer = null;
130
131 DoubleBuffer floatbuffer = null;
132
133 double[] double_buff = null;
134
135 public float[] toFloatArray(byte[] in_buff, int in_offset,
136 float[] out_buff, int out_offset, int out_len) {
137 int in_len = out_len * 8;
138 if (bytebuffer == null || bytebuffer.capacity() < in_len) {
139 bytebuffer = ByteBuffer.allocate(in_len).order(
140 ByteOrder.LITTLE_ENDIAN);
141 floatbuffer = bytebuffer.asDoubleBuffer();
142 }
143 bytebuffer.position(0);
144 floatbuffer.position(0);
145 bytebuffer.put(in_buff, in_offset, in_len);
146 if (double_buff == null
147 || double_buff.length < out_len + out_offset)
148 double_buff = new double[out_len + out_offset];
149 floatbuffer.get(double_buff, out_offset, out_len);
150 int out_offset_end = out_offset + out_len;
151 for (int i = out_offset; i < out_offset_end; i++) {
152 out_buff[i] = (float) double_buff[i];
153 }
154 return out_buff;
155 }
156
157 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
158 byte[] out_buff, int out_offset) {
159 int out_len = in_len * 8;
160 if (bytebuffer == null || bytebuffer.capacity() < out_len) {
161 bytebuffer = ByteBuffer.allocate(out_len).order(
162 ByteOrder.LITTLE_ENDIAN);
163 floatbuffer = bytebuffer.asDoubleBuffer();
164 }
165 floatbuffer.position(0);
166 bytebuffer.position(0);
167 if (double_buff == null || double_buff.length < in_offset + in_len)
168 double_buff = new double[in_offset + in_len];
169 int in_offset_end = in_offset + in_len;
170 for (int i = in_offset; i < in_offset_end; i++) {
171 double_buff[i] = in_buff[i];
172 }
173 floatbuffer.put(double_buff, in_offset, in_len);
174 bytebuffer.get(out_buff, out_offset, out_len);
175 return out_buff;
176 }
177 }
178
179 // PCM 64 bit float, big-endian
180 private static class AudioFloatConversion64B extends AudioFloatConverter {
181 ByteBuffer bytebuffer = null;
182
183 DoubleBuffer floatbuffer = null;
184
185 double[] double_buff = null;
186
187 public float[] toFloatArray(byte[] in_buff, int in_offset,
188 float[] out_buff, int out_offset, int out_len) {
189 int in_len = out_len * 8;
190 if (bytebuffer == null || bytebuffer.capacity() < in_len) {
191 bytebuffer = ByteBuffer.allocate(in_len).order(
192 ByteOrder.BIG_ENDIAN);
193 floatbuffer = bytebuffer.asDoubleBuffer();
194 }
195 bytebuffer.position(0);
196 floatbuffer.position(0);
197 bytebuffer.put(in_buff, in_offset, in_len);
198 if (double_buff == null
199 || double_buff.length < out_len + out_offset)
200 double_buff = new double[out_len + out_offset];
201 floatbuffer.get(double_buff, out_offset, out_len);
202 int out_offset_end = out_offset + out_len;
203 for (int i = out_offset; i < out_offset_end; i++) {
204 out_buff[i] = (float) double_buff[i];
205 }
206 return out_buff;
207 }
208
209 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
210 byte[] out_buff, int out_offset) {
211 int out_len = in_len * 8;
212 if (bytebuffer == null || bytebuffer.capacity() < out_len) {
213 bytebuffer = ByteBuffer.allocate(out_len).order(
214 ByteOrder.BIG_ENDIAN);
215 floatbuffer = bytebuffer.asDoubleBuffer();
216 }
217 floatbuffer.position(0);
218 bytebuffer.position(0);
219 if (double_buff == null || double_buff.length < in_offset + in_len)
220 double_buff = new double[in_offset + in_len];
221 int in_offset_end = in_offset + in_len;
222 for (int i = in_offset; i < in_offset_end; i++) {
223 double_buff[i] = in_buff[i];
224 }
225 floatbuffer.put(double_buff, in_offset, in_len);
226 bytebuffer.get(out_buff, out_offset, out_len);
227 return out_buff;
228 }
229 }
230
231 /***************************************************************************
232 *
233 * 32 bit float, little/big-endian
234 *
235 **************************************************************************/
236
237 // PCM 32 bit float, little-endian
238 private static class AudioFloatConversion32L extends AudioFloatConverter {
239 ByteBuffer bytebuffer = null;
240
241 FloatBuffer floatbuffer = null;
242
243 public float[] toFloatArray(byte[] in_buff, int in_offset,
244 float[] out_buff, int out_offset, int out_len) {
245 int in_len = out_len * 4;
246 if (bytebuffer == null || bytebuffer.capacity() < in_len) {
247 bytebuffer = ByteBuffer.allocate(in_len).order(
248 ByteOrder.LITTLE_ENDIAN);
249 floatbuffer = bytebuffer.asFloatBuffer();
250 }
251 bytebuffer.position(0);
252 floatbuffer.position(0);
253 bytebuffer.put(in_buff, in_offset, in_len);
254 floatbuffer.get(out_buff, out_offset, out_len);
255 return out_buff;
256 }
257
258 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
259 byte[] out_buff, int out_offset) {
260 int out_len = in_len * 4;
261 if (bytebuffer == null || bytebuffer.capacity() < out_len) {
262 bytebuffer = ByteBuffer.allocate(out_len).order(
263 ByteOrder.LITTLE_ENDIAN);
264 floatbuffer = bytebuffer.asFloatBuffer();
265 }
266 floatbuffer.position(0);
267 bytebuffer.position(0);
268 floatbuffer.put(in_buff, in_offset, in_len);
269 bytebuffer.get(out_buff, out_offset, out_len);
270 return out_buff;
271 }
272 }
273
274 // PCM 32 bit float, big-endian
275 private static class AudioFloatConversion32B extends AudioFloatConverter {
276 ByteBuffer bytebuffer = null;
277
278 FloatBuffer floatbuffer = null;
279
280 public float[] toFloatArray(byte[] in_buff, int in_offset,
281 float[] out_buff, int out_offset, int out_len) {
282 int in_len = out_len * 4;
283 if (bytebuffer == null || bytebuffer.capacity() < in_len) {
284 bytebuffer = ByteBuffer.allocate(in_len).order(
285 ByteOrder.BIG_ENDIAN);
286 floatbuffer = bytebuffer.asFloatBuffer();
287 }
288 bytebuffer.position(0);
289 floatbuffer.position(0);
290 bytebuffer.put(in_buff, in_offset, in_len);
291 floatbuffer.get(out_buff, out_offset, out_len);
292 return out_buff;
293 }
294
295 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
296 byte[] out_buff, int out_offset) {
297 int out_len = in_len * 4;
298 if (bytebuffer == null || bytebuffer.capacity() < out_len) {
299 bytebuffer = ByteBuffer.allocate(out_len).order(
300 ByteOrder.BIG_ENDIAN);
301 floatbuffer = bytebuffer.asFloatBuffer();
302 }
303 floatbuffer.position(0);
304 bytebuffer.position(0);
305 floatbuffer.put(in_buff, in_offset, in_len);
306 bytebuffer.get(out_buff, out_offset, out_len);
307 return out_buff;
308 }
309 }
310
311 /***************************************************************************
312 *
313 * 8 bit signed/unsigned
314 *
315 **************************************************************************/
316
317 // PCM 8 bit, signed
318 private static class AudioFloatConversion8S extends AudioFloatConverter {
319 public float[] toFloatArray(byte[] in_buff, int in_offset,
320 float[] out_buff, int out_offset, int out_len) {
321 int ix = in_offset;
322 int ox = out_offset;
323 for (int i = 0; i < out_len; i++) {
324 byte x = in_buff[ix++];
325 out_buff[ox++] = x > 0 ? x / 127.0f : x / 128.0f;
326 }
327 return out_buff;
328 }
329
330 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
331 byte[] out_buff, int out_offset) {
332 int ix = in_offset;
333 int ox = out_offset;
334 for (int i = 0; i < in_len; i++) {
335 final float x = in_buff[ix++];
336 out_buff[ox++] = (byte) (x > 0 ? x * 127 : x * 128);
337 }
338 return out_buff;
339 }
340 }
341
342 // PCM 8 bit, unsigned
343 private static class AudioFloatConversion8U extends AudioFloatConverter {
344 public float[] toFloatArray(byte[] in_buff, int in_offset,
345 float[] out_buff, int out_offset, int out_len) {
346 int ix = in_offset;
347 int ox = out_offset;
348 for (int i = 0; i < out_len; i++) {
349 byte x = (byte) (in_buff[ix++] - 128);
350 out_buff[ox++] = x > 0 ? x / 127.0f : x / 128.0f;
351 }
352 return out_buff;
353 }
354
355 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
356 byte[] out_buff, int out_offset) {
357 int ix = in_offset;
358 int ox = out_offset;
359 for (int i = 0; i < in_len; i++) {
360 float x = in_buff[ix++];
361 out_buff[ox++] = (byte) (128 + (x > 0 ? x * 127 : x * 128));
362 }
363 return out_buff;
364 }
365 }
366
367 /***************************************************************************
368 *
369 * 16 bit signed/unsigned, little/big-endian
370 *
371 **************************************************************************/
372
373 // PCM 16 bit, signed, little-endian
374 private static class AudioFloatConversion16SL extends AudioFloatConverter {
375 public float[] toFloatArray(byte[] in_buff, int in_offset,
376 float[] out_buff, int out_offset, int out_len) {
377 int ix = in_offset;
378 int len = out_offset + out_len;
379 for (int ox = out_offset; ox < len; ox++) {
380 short x = (short) (in_buff[ix++] & 0xFF | (in_buff[ix++] << 8));
381 out_buff[ox] = x > 0 ? x / 32767.0f : x / 32768.0f;
382 }
383 return out_buff;
384 }
385
386 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
387 byte[] out_buff, int out_offset) {
388 int ox = out_offset;
389 int len = in_offset + in_len;
390 for (int ix = in_offset; ix < len; ix++) {
391 float f = in_buff[ix];
392 short x = (short) (f > 0 ? f * 32767 : f * 32768);
393 out_buff[ox++] = (byte) x;
394 out_buff[ox++] = (byte) (x >>> 8);
395 }
396 return out_buff;
397 }
398 }
399
400 // PCM 16 bit, signed, big-endian
401 private static class AudioFloatConversion16SB extends AudioFloatConverter {
402 public float[] toFloatArray(byte[] in_buff, int in_offset,
403 float[] out_buff, int out_offset, int out_len) {
404 int ix = in_offset;
405 int ox = out_offset;
406 for (int i = 0; i < out_len; i++) {
407 short x = (short) ((in_buff[ix++] << 8) | (in_buff[ix++] & 0xFF));
408 out_buff[ox++] = x > 0 ? x / 32767.0f : x / 32768.0f;
409 }
410 return out_buff;
411 }
412
413 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
414 byte[] out_buff, int out_offset) {
415 int ix = in_offset;
416 int ox = out_offset;
417 for (int i = 0; i < in_len; i++) {
418 float f = in_buff[ix++];
419 short x = (short) (f > 0 ? f * 32767.0f : f * 32768.0f);
420 out_buff[ox++] = (byte) (x >>> 8);
421 out_buff[ox++] = (byte) x;
422 }
423 return out_buff;
424 }
425 }
426
427 // PCM 16 bit, unsigned, little-endian
428 private static class AudioFloatConversion16UL extends AudioFloatConverter {
429 public float[] toFloatArray(byte[] in_buff, int in_offset,
430 float[] out_buff, int out_offset, int out_len) {
431 int ix = in_offset;
432 int ox = out_offset;
433 for (int i = 0; i < out_len; i++) {
434 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8);
435 x -= 32768;
436 out_buff[ox++] = x > 0 ? x / 32767.0f : x / 32768.0f;
437 }
438 return out_buff;
439 }
440
441 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
442 byte[] out_buff, int out_offset) {
443 int ix = in_offset;
444 int ox = out_offset;
445 for (int i = 0; i < in_len; i++) {
446 float f = in_buff[ix++];
447 int x = 32768 + (int) (f > 0 ? f * 32767 : f * 32768);
448 out_buff[ox++] = (byte) x;
449 out_buff[ox++] = (byte) (x >>> 8);
450 }
451 return out_buff;
452 }
453 }
454
455 // PCM 16 bit, unsigned, big-endian
456 private static class AudioFloatConversion16UB extends AudioFloatConverter {
457 public float[] toFloatArray(byte[] in_buff, int in_offset,
458 float[] out_buff, int out_offset, int out_len) {
459 int ix = in_offset;
460 int ox = out_offset;
461 for (int i = 0; i < out_len; i++) {
462 int x = ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
463 x -= 32768;
464 out_buff[ox++] = x > 0 ? x / 32767.0f : x / 32768.0f;
465 }
466 return out_buff;
467 }
468
469 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
470 byte[] out_buff, int out_offset) {
471 int ix = in_offset;
472 int ox = out_offset;
473 for (int i = 0; i < in_len; i++) {
474 float f = in_buff[ix++];
475 int x = 32768 + (int) (f > 0 ? f * 32767 : f * 32768);
476 out_buff[ox++] = (byte) (x >>> 8);
477 out_buff[ox++] = (byte) x;
478 }
479 return out_buff;
480 }
481 }
482
483 /***************************************************************************
484 *
485 * 24 bit signed/unsigned, little/big-endian
486 *
487 **************************************************************************/
488
489 // PCM 24 bit, signed, little-endian
490 private static class AudioFloatConversion24SL extends AudioFloatConverter {
491 public float[] toFloatArray(byte[] in_buff, int in_offset,
492 float[] out_buff, int out_offset, int out_len) {
493 int ix = in_offset;
494 int ox = out_offset;
495 for (int i = 0; i < out_len; i++) {
496 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8)
497 | ((in_buff[ix++] & 0xFF) << 16);
498 if (x > 0x7FFFFF)
499 x -= 0x1000000;
500 out_buff[ox++] = x > 0 ? x / 8388607.0f : x / 8388608.0f;
501 }
502 return out_buff;
503 }
504
505 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
506 byte[] out_buff, int out_offset) {
507 int ix = in_offset;
508 int ox = out_offset;
509 for (int i = 0; i < in_len; i++) {
510 float f = in_buff[ix++];
511 int x = (int) (f > 0 ? f * 8388607.0f : f * 8388608.0f);
512 if (x < 0)
513 x += 0x1000000;
514 out_buff[ox++] = (byte) x;
515 out_buff[ox++] = (byte) (x >>> 8);
516 out_buff[ox++] = (byte) (x >>> 16);
517 }
518 return out_buff;
519 }
520 }
521
522 // PCM 24 bit, signed, big-endian
523 private static class AudioFloatConversion24SB extends AudioFloatConverter {
524 public float[] toFloatArray(byte[] in_buff, int in_offset,
525 float[] out_buff, int out_offset, int out_len) {
526 int ix = in_offset;
527 int ox = out_offset;
528 for (int i = 0; i < out_len; i++) {
529 int x = ((in_buff[ix++] & 0xFF) << 16)
530 | ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
531 if (x > 0x7FFFFF)
532 x -= 0x1000000;
533 out_buff[ox++] = x > 0 ? x / 8388607.0f : x / 8388608.0f;
534 }
535 return out_buff;
536 }
537
538 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
539 byte[] out_buff, int out_offset) {
540 int ix = in_offset;
541 int ox = out_offset;
542 for (int i = 0; i < in_len; i++) {
543 float f = in_buff[ix++];
544 int x = (int) (f > 0 ? f * 8388607.0f : f * 8388608.0f);
545 if (x < 0)
546 x += 0x1000000;
547 out_buff[ox++] = (byte) (x >>> 16);
548 out_buff[ox++] = (byte) (x >>> 8);
549 out_buff[ox++] = (byte) x;
550 }
551 return out_buff;
552 }
553 }
554
555 // PCM 24 bit, unsigned, little-endian
556 private static class AudioFloatConversion24UL extends AudioFloatConverter {
557 public float[] toFloatArray(byte[] in_buff, int in_offset,
558 float[] out_buff, int out_offset, int out_len) {
559 int ix = in_offset;
560 int ox = out_offset;
561 for (int i = 0; i < out_len; i++) {
562 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8)
563 | ((in_buff[ix++] & 0xFF) << 16);
564 x -= 0x800000;
565 out_buff[ox++] = x > 0 ? x / 8388607.0f : x / 8388608.0f;
566 }
567 return out_buff;
568 }
569
570 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
571 byte[] out_buff, int out_offset) {
572 int ix = in_offset;
573 int ox = out_offset;
574 for (int i = 0; i < in_len; i++) {
575 float f = in_buff[ix++];
576 int x = (int) (f > 0 ? f * 8388607.0f : f * 8388608.0f);
577 x += 0x800000;
578 out_buff[ox++] = (byte) x;
579 out_buff[ox++] = (byte) (x >>> 8);
580 out_buff[ox++] = (byte) (x >>> 16);
581 }
582 return out_buff;
583 }
584 }
585
586 // PCM 24 bit, unsigned, big-endian
587 private static class AudioFloatConversion24UB extends AudioFloatConverter {
588 public float[] toFloatArray(byte[] in_buff, int in_offset,
589 float[] out_buff, int out_offset, int out_len) {
590 int ix = in_offset;
591 int ox = out_offset;
592 for (int i = 0; i < out_len; i++) {
593 int x = ((in_buff[ix++] & 0xFF) << 16)
594 | ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
595 x -= 0x800000;
596 out_buff[ox++] = x > 0 ? x / 8388607.0f : x / 8388608.0f;
597 }
598 return out_buff;
599 }
600
601 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
602 byte[] out_buff, int out_offset) {
603 int ix = in_offset;
604 int ox = out_offset;
605 for (int i = 0; i < in_len; i++) {
606 float f = in_buff[ix++];
607 int x = (int) (f > 0 ? f * 8388607.0f : f * 8388608.0f);
608 x += 8388608;
609 out_buff[ox++] = (byte) (x >>> 16);
610 out_buff[ox++] = (byte) (x >>> 8);
611 out_buff[ox++] = (byte) x;
612 }
613 return out_buff;
614 }
615 }
616
617 /***************************************************************************
618 *
619 * 32 bit signed/unsigned, little/big-endian
620 *
621 **************************************************************************/
622
623 // PCM 32 bit, signed, little-endian
624 private static class AudioFloatConversion32SL extends AudioFloatConverter {
625 public float[] toFloatArray(byte[] in_buff, int in_offset,
626 float[] out_buff, int out_offset, int out_len) {
627 int ix = in_offset;
628 int ox = out_offset;
629 for (int i = 0; i < out_len; i++) {
630 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8) |
631 ((in_buff[ix++] & 0xFF) << 16) |
632 ((in_buff[ix++] & 0xFF) << 24);
633 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
634 }
635 return out_buff;
636 }
637
638 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
639 byte[] out_buff, int out_offset) {
640 int ix = in_offset;
641 int ox = out_offset;
642 for (int i = 0; i < in_len; i++) {
643 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
644 out_buff[ox++] = (byte) x;
645 out_buff[ox++] = (byte) (x >>> 8);
646 out_buff[ox++] = (byte) (x >>> 16);
647 out_buff[ox++] = (byte) (x >>> 24);
648 }
649 return out_buff;
650 }
651 }
652
653 // PCM 32 bit, signed, big-endian
654 private static class AudioFloatConversion32SB extends AudioFloatConverter {
655 public float[] toFloatArray(byte[] in_buff, int in_offset,
656 float[] out_buff, int out_offset, int out_len) {
657 int ix = in_offset;
658 int ox = out_offset;
659 for (int i = 0; i < out_len; i++) {
660 int x = ((in_buff[ix++] & 0xFF) << 24) |
661 ((in_buff[ix++] & 0xFF) << 16) |
662 ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
663 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
664 }
665 return out_buff;
666 }
667
668 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
669 byte[] out_buff, int out_offset) {
670 int ix = in_offset;
671 int ox = out_offset;
672 for (int i = 0; i < in_len; i++) {
673 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
674 out_buff[ox++] = (byte) (x >>> 24);
675 out_buff[ox++] = (byte) (x >>> 16);
676 out_buff[ox++] = (byte) (x >>> 8);
677 out_buff[ox++] = (byte) x;
678 }
679 return out_buff;
680 }
681 }
682
683 // PCM 32 bit, unsigned, little-endian
684 private static class AudioFloatConversion32UL extends AudioFloatConverter {
685 public float[] toFloatArray(byte[] in_buff, int in_offset,
686 float[] out_buff, int out_offset, int out_len) {
687 int ix = in_offset;
688 int ox = out_offset;
689 for (int i = 0; i < out_len; i++) {
690 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8) |
691 ((in_buff[ix++] & 0xFF) << 16) |
692 ((in_buff[ix++] & 0xFF) << 24);
693 x -= 0x80000000;
694 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
695 }
696 return out_buff;
697 }
698
699 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
700 byte[] out_buff, int out_offset) {
701 int ix = in_offset;
702 int ox = out_offset;
703 for (int i = 0; i < in_len; i++) {
704 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
705 x += 0x80000000;
706 out_buff[ox++] = (byte) x;
707 out_buff[ox++] = (byte) (x >>> 8);
708 out_buff[ox++] = (byte) (x >>> 16);
709 out_buff[ox++] = (byte) (x >>> 24);
710 }
711 return out_buff;
712 }
713 }
714
715 // PCM 32 bit, unsigned, big-endian
716 private static class AudioFloatConversion32UB extends AudioFloatConverter {
717
718 public float[] toFloatArray(byte[] in_buff, int in_offset,
719 float[] out_buff, int out_offset, int out_len) {
720 int ix = in_offset;
721 int ox = out_offset;
722 for (int i = 0; i < out_len; i++) {
723 int x = ((in_buff[ix++] & 0xFF) << 24) |
724 ((in_buff[ix++] & 0xFF) << 16) |
725 ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
726 x -= 0x80000000;
727 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
728 }
729 return out_buff;
730 }
731
732 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
733 byte[] out_buff, int out_offset) {
734 int ix = in_offset;
735 int ox = out_offset;
736 for (int i = 0; i < in_len; i++) {
737 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
738 x += 0x80000000;
739 out_buff[ox++] = (byte) (x >>> 24);
740 out_buff[ox++] = (byte) (x >>> 16);
741 out_buff[ox++] = (byte) (x >>> 8);
742 out_buff[ox++] = (byte) x;
743 }
744 return out_buff;
745 }
746 }
747
748 /***************************************************************************
749 *
750 * 32+ bit signed/unsigned, little/big-endian
751 *
752 **************************************************************************/
753
754 // PCM 32+ bit, signed, little-endian
755 private static class AudioFloatConversion32xSL extends AudioFloatConverter {
756
757 private final int xbytes;
758
759 AudioFloatConversion32xSL(int xbytes) {
760 this.xbytes = xbytes;
761 }
762
763 public float[] toFloatArray(byte[] in_buff, int in_offset,
764 float[] out_buff, int out_offset, int out_len) {
765 int ix = in_offset;
766 int ox = out_offset;
767 for (int i = 0; i < out_len; i++) {
768 ix += xbytes;
769 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8)
770 | ((in_buff[ix++] & 0xFF) << 16)
771 | ((in_buff[ix++] & 0xFF) << 24);
772 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
773 }
774 return out_buff;
775 }
776
777 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
778 byte[] out_buff, int out_offset) {
779 int ix = in_offset;
780 int ox = out_offset;
781 for (int i = 0; i < in_len; i++) {
782 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
783 for (int j = 0; j < xbytes; j++) {
784 out_buff[ox++] = 0;
785 }
786 out_buff[ox++] = (byte) x;
787 out_buff[ox++] = (byte) (x >>> 8);
788 out_buff[ox++] = (byte) (x >>> 16);
789 out_buff[ox++] = (byte) (x >>> 24);
790 }
791 return out_buff;
792 }
793 }
794
795 // PCM 32+ bit, signed, big-endian
796 private static class AudioFloatConversion32xSB extends AudioFloatConverter {
797
798 private final int xbytes;
799
800 AudioFloatConversion32xSB(int xbytes) {
801 this.xbytes = xbytes;
802 }
803
804 public float[] toFloatArray(byte[] in_buff, int in_offset,
805 float[] out_buff, int out_offset, int out_len) {
806 int ix = in_offset;
807 int ox = out_offset;
808 for (int i = 0; i < out_len; i++) {
809 int x = ((in_buff[ix++] & 0xFF) << 24)
810 | ((in_buff[ix++] & 0xFF) << 16)
811 | ((in_buff[ix++] & 0xFF) << 8)
812 | (in_buff[ix++] & 0xFF);
813 ix += xbytes;
814 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
815 }
816 return out_buff;
817 }
818
819 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
820 byte[] out_buff, int out_offset) {
821 int ix = in_offset;
822 int ox = out_offset;
823 for (int i = 0; i < in_len; i++) {
824 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
825 out_buff[ox++] = (byte) (x >>> 24);
826 out_buff[ox++] = (byte) (x >>> 16);
827 out_buff[ox++] = (byte) (x >>> 8);
828 out_buff[ox++] = (byte) x;
829 for (int j = 0; j < xbytes; j++) {
830 out_buff[ox++] = 0;
831 }
832 }
833 return out_buff;
834 }
835 }
836
837 // PCM 32+ bit, unsigned, little-endian
838 private static class AudioFloatConversion32xUL extends AudioFloatConverter {
839
840 private final int xbytes;
841
842 AudioFloatConversion32xUL(int xbytes) {
843 this.xbytes = xbytes;
844 }
845
846 public float[] toFloatArray(byte[] in_buff, int in_offset,
847 float[] out_buff, int out_offset, int out_len) {
848 int ix = in_offset;
849 int ox = out_offset;
850 for (int i = 0; i < out_len; i++) {
851 ix += xbytes;
852 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8)
853 | ((in_buff[ix++] & 0xFF) << 16)
854 | ((in_buff[ix++] & 0xFF) << 24);
855 x -= 0x80000000;
856 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
857 }
858 return out_buff;
859 }
860
861 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
862 byte[] out_buff, int out_offset) {
863 int ix = in_offset;
864 int ox = out_offset;
865 for (int i = 0; i < in_len; i++) {
866 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
867 x += 0x80000000;
868 for (int j = 0; j < xbytes; j++) {
869 out_buff[ox++] = 0;
870 }
871 out_buff[ox++] = (byte) x;
872 out_buff[ox++] = (byte) (x >>> 8);
873 out_buff[ox++] = (byte) (x >>> 16);
874 out_buff[ox++] = (byte) (x >>> 24);
875 }
876 return out_buff;
877 }
878 }
879
880 // PCM 32+ bit, unsigned, big-endian
881 private static class AudioFloatConversion32xUB extends AudioFloatConverter {
882
883 private final int xbytes;
884
885 AudioFloatConversion32xUB(int xbytes) {
886 this.xbytes = xbytes;
887 }
888
889 public float[] toFloatArray(byte[] in_buff, int in_offset,
890 float[] out_buff, int out_offset, int out_len) {
891 int ix = in_offset;
892 int ox = out_offset;
893 for (int i = 0; i < out_len; i++) {
894 int x = ((in_buff[ix++] & 0xFF) << 24) |
895 ((in_buff[ix++] & 0xFF) << 16) |
896 ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
897 ix += xbytes;
898 x -= 0x80000000;
899 out_buff[ox++] = x * (1.0f / 2147483647.0f);
900 }
901 return out_buff;
902 }
903
904 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
905 byte[] out_buff, int out_offset) {
906 int ix = in_offset;
907 int ox = out_offset;
908 for (int i = 0; i < in_len; i++) {
909 int x = (int) (in_buff[ix++] * 2147483647.0f);
910 x += 0x80000000;
911 out_buff[ox++] = (byte) (x >>> 24);
912 out_buff[ox++] = (byte) (x >>> 16);
913 out_buff[ox++] = (byte) (x >>> 8);
914 out_buff[ox++] = (byte) x;
915 for (int j = 0; j < xbytes; j++) {
916 out_buff[ox++] = 0;
917 }
918 }
919 return out_buff;
920 }
921 }
922
923 public static AudioFloatConverter getConverter(AudioFormat format) {
|
72 if (lsb_bits == 0)
73 mask = (byte) 0x00;
74 else if (lsb_bits == 1)
75 mask = (byte) 0x80;
76 else if (lsb_bits == 2)
77 mask = (byte) 0xC0;
78 else if (lsb_bits == 3)
79 mask = (byte) 0xE0;
80 else if (lsb_bits == 4)
81 mask = (byte) 0xF0;
82 else if (lsb_bits == 5)
83 mask = (byte) 0xF8;
84 else if (lsb_bits == 6)
85 mask = (byte) 0xFC;
86 else if (lsb_bits == 7)
87 mask = (byte) 0xFE;
88 else
89 mask = (byte) 0xFF;
90 }
91
92 @Override
93 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
94 byte[] out_buff, int out_offset) {
95 byte[] ret = converter.toByteArray(in_buff, in_offset, in_len,
96 out_buff, out_offset);
97
98 int out_offset_end = in_len * stepsize;
99 for (int i = out_offset + offset; i < out_offset_end; i += stepsize) {
100 out_buff[i] = (byte) (out_buff[i] & mask);
101 }
102
103 return ret;
104 }
105
106 @Override
107 public float[] toFloatArray(byte[] in_buff, int in_offset,
108 float[] out_buff, int out_offset, int out_len) {
109 if (mask_buffer == null || mask_buffer.length < in_buff.length)
110 mask_buffer = new byte[in_buff.length];
111 System.arraycopy(in_buff, 0, mask_buffer, 0, in_buff.length);
112 int in_offset_end = out_len * stepsize;
113 for (int i = in_offset + offset; i < in_offset_end; i += stepsize) {
114 mask_buffer[i] = (byte) (mask_buffer[i] & mask);
115 }
116 float[] ret = converter.toFloatArray(mask_buffer, in_offset,
117 out_buff, out_offset, out_len);
118 return ret;
119 }
120
121 }
122
123 /***************************************************************************
124 *
125 * 64 bit float, little/big-endian
126 *
127 **************************************************************************/
128
129 // PCM 64 bit float, little-endian
130 private static class AudioFloatConversion64L extends AudioFloatConverter {
131 ByteBuffer bytebuffer = null;
132
133 DoubleBuffer floatbuffer = null;
134
135 double[] double_buff = null;
136
137 @Override
138 public float[] toFloatArray(byte[] in_buff, int in_offset,
139 float[] out_buff, int out_offset, int out_len) {
140 int in_len = out_len * 8;
141 if (bytebuffer == null || bytebuffer.capacity() < in_len) {
142 bytebuffer = ByteBuffer.allocate(in_len).order(
143 ByteOrder.LITTLE_ENDIAN);
144 floatbuffer = bytebuffer.asDoubleBuffer();
145 }
146 bytebuffer.position(0);
147 floatbuffer.position(0);
148 bytebuffer.put(in_buff, in_offset, in_len);
149 if (double_buff == null
150 || double_buff.length < out_len + out_offset)
151 double_buff = new double[out_len + out_offset];
152 floatbuffer.get(double_buff, out_offset, out_len);
153 int out_offset_end = out_offset + out_len;
154 for (int i = out_offset; i < out_offset_end; i++) {
155 out_buff[i] = (float) double_buff[i];
156 }
157 return out_buff;
158 }
159
160 @Override
161 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
162 byte[] out_buff, int out_offset) {
163 int out_len = in_len * 8;
164 if (bytebuffer == null || bytebuffer.capacity() < out_len) {
165 bytebuffer = ByteBuffer.allocate(out_len).order(
166 ByteOrder.LITTLE_ENDIAN);
167 floatbuffer = bytebuffer.asDoubleBuffer();
168 }
169 floatbuffer.position(0);
170 bytebuffer.position(0);
171 if (double_buff == null || double_buff.length < in_offset + in_len)
172 double_buff = new double[in_offset + in_len];
173 int in_offset_end = in_offset + in_len;
174 for (int i = in_offset; i < in_offset_end; i++) {
175 double_buff[i] = in_buff[i];
176 }
177 floatbuffer.put(double_buff, in_offset, in_len);
178 bytebuffer.get(out_buff, out_offset, out_len);
179 return out_buff;
180 }
181 }
182
183 // PCM 64 bit float, big-endian
184 private static class AudioFloatConversion64B extends AudioFloatConverter {
185 ByteBuffer bytebuffer = null;
186
187 DoubleBuffer floatbuffer = null;
188
189 double[] double_buff = null;
190
191 @Override
192 public float[] toFloatArray(byte[] in_buff, int in_offset,
193 float[] out_buff, int out_offset, int out_len) {
194 int in_len = out_len * 8;
195 if (bytebuffer == null || bytebuffer.capacity() < in_len) {
196 bytebuffer = ByteBuffer.allocate(in_len).order(
197 ByteOrder.BIG_ENDIAN);
198 floatbuffer = bytebuffer.asDoubleBuffer();
199 }
200 bytebuffer.position(0);
201 floatbuffer.position(0);
202 bytebuffer.put(in_buff, in_offset, in_len);
203 if (double_buff == null
204 || double_buff.length < out_len + out_offset)
205 double_buff = new double[out_len + out_offset];
206 floatbuffer.get(double_buff, out_offset, out_len);
207 int out_offset_end = out_offset + out_len;
208 for (int i = out_offset; i < out_offset_end; i++) {
209 out_buff[i] = (float) double_buff[i];
210 }
211 return out_buff;
212 }
213
214 @Override
215 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
216 byte[] out_buff, int out_offset) {
217 int out_len = in_len * 8;
218 if (bytebuffer == null || bytebuffer.capacity() < out_len) {
219 bytebuffer = ByteBuffer.allocate(out_len).order(
220 ByteOrder.BIG_ENDIAN);
221 floatbuffer = bytebuffer.asDoubleBuffer();
222 }
223 floatbuffer.position(0);
224 bytebuffer.position(0);
225 if (double_buff == null || double_buff.length < in_offset + in_len)
226 double_buff = new double[in_offset + in_len];
227 int in_offset_end = in_offset + in_len;
228 for (int i = in_offset; i < in_offset_end; i++) {
229 double_buff[i] = in_buff[i];
230 }
231 floatbuffer.put(double_buff, in_offset, in_len);
232 bytebuffer.get(out_buff, out_offset, out_len);
233 return out_buff;
234 }
235 }
236
237 /***************************************************************************
238 *
239 * 32 bit float, little/big-endian
240 *
241 **************************************************************************/
242
243 // PCM 32 bit float, little-endian
244 private static class AudioFloatConversion32L extends AudioFloatConverter {
245 ByteBuffer bytebuffer = null;
246
247 FloatBuffer floatbuffer = null;
248
249 @Override
250 public float[] toFloatArray(byte[] in_buff, int in_offset,
251 float[] out_buff, int out_offset, int out_len) {
252 int in_len = out_len * 4;
253 if (bytebuffer == null || bytebuffer.capacity() < in_len) {
254 bytebuffer = ByteBuffer.allocate(in_len).order(
255 ByteOrder.LITTLE_ENDIAN);
256 floatbuffer = bytebuffer.asFloatBuffer();
257 }
258 bytebuffer.position(0);
259 floatbuffer.position(0);
260 bytebuffer.put(in_buff, in_offset, in_len);
261 floatbuffer.get(out_buff, out_offset, out_len);
262 return out_buff;
263 }
264
265 @Override
266 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
267 byte[] out_buff, int out_offset) {
268 int out_len = in_len * 4;
269 if (bytebuffer == null || bytebuffer.capacity() < out_len) {
270 bytebuffer = ByteBuffer.allocate(out_len).order(
271 ByteOrder.LITTLE_ENDIAN);
272 floatbuffer = bytebuffer.asFloatBuffer();
273 }
274 floatbuffer.position(0);
275 bytebuffer.position(0);
276 floatbuffer.put(in_buff, in_offset, in_len);
277 bytebuffer.get(out_buff, out_offset, out_len);
278 return out_buff;
279 }
280 }
281
282 // PCM 32 bit float, big-endian
283 private static class AudioFloatConversion32B extends AudioFloatConverter {
284 ByteBuffer bytebuffer = null;
285
286 FloatBuffer floatbuffer = null;
287
288 @Override
289 public float[] toFloatArray(byte[] in_buff, int in_offset,
290 float[] out_buff, int out_offset, int out_len) {
291 int in_len = out_len * 4;
292 if (bytebuffer == null || bytebuffer.capacity() < in_len) {
293 bytebuffer = ByteBuffer.allocate(in_len).order(
294 ByteOrder.BIG_ENDIAN);
295 floatbuffer = bytebuffer.asFloatBuffer();
296 }
297 bytebuffer.position(0);
298 floatbuffer.position(0);
299 bytebuffer.put(in_buff, in_offset, in_len);
300 floatbuffer.get(out_buff, out_offset, out_len);
301 return out_buff;
302 }
303
304 @Override
305 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
306 byte[] out_buff, int out_offset) {
307 int out_len = in_len * 4;
308 if (bytebuffer == null || bytebuffer.capacity() < out_len) {
309 bytebuffer = ByteBuffer.allocate(out_len).order(
310 ByteOrder.BIG_ENDIAN);
311 floatbuffer = bytebuffer.asFloatBuffer();
312 }
313 floatbuffer.position(0);
314 bytebuffer.position(0);
315 floatbuffer.put(in_buff, in_offset, in_len);
316 bytebuffer.get(out_buff, out_offset, out_len);
317 return out_buff;
318 }
319 }
320
321 /***************************************************************************
322 *
323 * 8 bit signed/unsigned
324 *
325 **************************************************************************/
326
327 // PCM 8 bit, signed
328 private static class AudioFloatConversion8S extends AudioFloatConverter {
329 @Override
330 public float[] toFloatArray(byte[] in_buff, int in_offset,
331 float[] out_buff, int out_offset, int out_len) {
332 int ix = in_offset;
333 int ox = out_offset;
334 for (int i = 0; i < out_len; i++) {
335 byte x = in_buff[ix++];
336 out_buff[ox++] = x > 0 ? x / 127.0f : x / 128.0f;
337 }
338 return out_buff;
339 }
340
341 @Override
342 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
343 byte[] out_buff, int out_offset) {
344 int ix = in_offset;
345 int ox = out_offset;
346 for (int i = 0; i < in_len; i++) {
347 final float x = in_buff[ix++];
348 out_buff[ox++] = (byte) (x > 0 ? x * 127 : x * 128);
349 }
350 return out_buff;
351 }
352 }
353
354 // PCM 8 bit, unsigned
355 private static class AudioFloatConversion8U extends AudioFloatConverter {
356 @Override
357 public float[] toFloatArray(byte[] in_buff, int in_offset,
358 float[] out_buff, int out_offset, int out_len) {
359 int ix = in_offset;
360 int ox = out_offset;
361 for (int i = 0; i < out_len; i++) {
362 byte x = (byte) (in_buff[ix++] - 128);
363 out_buff[ox++] = x > 0 ? x / 127.0f : x / 128.0f;
364 }
365 return out_buff;
366 }
367
368 @Override
369 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
370 byte[] out_buff, int out_offset) {
371 int ix = in_offset;
372 int ox = out_offset;
373 for (int i = 0; i < in_len; i++) {
374 float x = in_buff[ix++];
375 out_buff[ox++] = (byte) (128 + (x > 0 ? x * 127 : x * 128));
376 }
377 return out_buff;
378 }
379 }
380
381 /***************************************************************************
382 *
383 * 16 bit signed/unsigned, little/big-endian
384 *
385 **************************************************************************/
386
387 // PCM 16 bit, signed, little-endian
388 private static class AudioFloatConversion16SL extends AudioFloatConverter {
389 @Override
390 public float[] toFloatArray(byte[] in_buff, int in_offset,
391 float[] out_buff, int out_offset, int out_len) {
392 int ix = in_offset;
393 int len = out_offset + out_len;
394 for (int ox = out_offset; ox < len; ox++) {
395 short x = (short) (in_buff[ix++] & 0xFF | (in_buff[ix++] << 8));
396 out_buff[ox] = x > 0 ? x / 32767.0f : x / 32768.0f;
397 }
398 return out_buff;
399 }
400
401 @Override
402 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
403 byte[] out_buff, int out_offset) {
404 int ox = out_offset;
405 int len = in_offset + in_len;
406 for (int ix = in_offset; ix < len; ix++) {
407 float f = in_buff[ix];
408 short x = (short) (f > 0 ? f * 32767 : f * 32768);
409 out_buff[ox++] = (byte) x;
410 out_buff[ox++] = (byte) (x >>> 8);
411 }
412 return out_buff;
413 }
414 }
415
416 // PCM 16 bit, signed, big-endian
417 private static class AudioFloatConversion16SB extends AudioFloatConverter {
418 @Override
419 public float[] toFloatArray(byte[] in_buff, int in_offset,
420 float[] out_buff, int out_offset, int out_len) {
421 int ix = in_offset;
422 int ox = out_offset;
423 for (int i = 0; i < out_len; i++) {
424 short x = (short) ((in_buff[ix++] << 8) | (in_buff[ix++] & 0xFF));
425 out_buff[ox++] = x > 0 ? x / 32767.0f : x / 32768.0f;
426 }
427 return out_buff;
428 }
429
430 @Override
431 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
432 byte[] out_buff, int out_offset) {
433 int ix = in_offset;
434 int ox = out_offset;
435 for (int i = 0; i < in_len; i++) {
436 float f = in_buff[ix++];
437 short x = (short) (f > 0 ? f * 32767.0f : f * 32768.0f);
438 out_buff[ox++] = (byte) (x >>> 8);
439 out_buff[ox++] = (byte) x;
440 }
441 return out_buff;
442 }
443 }
444
445 // PCM 16 bit, unsigned, little-endian
446 private static class AudioFloatConversion16UL extends AudioFloatConverter {
447 @Override
448 public float[] toFloatArray(byte[] in_buff, int in_offset,
449 float[] out_buff, int out_offset, int out_len) {
450 int ix = in_offset;
451 int ox = out_offset;
452 for (int i = 0; i < out_len; i++) {
453 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8);
454 x -= 32768;
455 out_buff[ox++] = x > 0 ? x / 32767.0f : x / 32768.0f;
456 }
457 return out_buff;
458 }
459
460 @Override
461 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
462 byte[] out_buff, int out_offset) {
463 int ix = in_offset;
464 int ox = out_offset;
465 for (int i = 0; i < in_len; i++) {
466 float f = in_buff[ix++];
467 int x = 32768 + (int) (f > 0 ? f * 32767 : f * 32768);
468 out_buff[ox++] = (byte) x;
469 out_buff[ox++] = (byte) (x >>> 8);
470 }
471 return out_buff;
472 }
473 }
474
475 // PCM 16 bit, unsigned, big-endian
476 private static class AudioFloatConversion16UB extends AudioFloatConverter {
477 @Override
478 public float[] toFloatArray(byte[] in_buff, int in_offset,
479 float[] out_buff, int out_offset, int out_len) {
480 int ix = in_offset;
481 int ox = out_offset;
482 for (int i = 0; i < out_len; i++) {
483 int x = ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
484 x -= 32768;
485 out_buff[ox++] = x > 0 ? x / 32767.0f : x / 32768.0f;
486 }
487 return out_buff;
488 }
489
490 @Override
491 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
492 byte[] out_buff, int out_offset) {
493 int ix = in_offset;
494 int ox = out_offset;
495 for (int i = 0; i < in_len; i++) {
496 float f = in_buff[ix++];
497 int x = 32768 + (int) (f > 0 ? f * 32767 : f * 32768);
498 out_buff[ox++] = (byte) (x >>> 8);
499 out_buff[ox++] = (byte) x;
500 }
501 return out_buff;
502 }
503 }
504
505 /***************************************************************************
506 *
507 * 24 bit signed/unsigned, little/big-endian
508 *
509 **************************************************************************/
510
511 // PCM 24 bit, signed, little-endian
512 private static class AudioFloatConversion24SL extends AudioFloatConverter {
513 @Override
514 public float[] toFloatArray(byte[] in_buff, int in_offset,
515 float[] out_buff, int out_offset, int out_len) {
516 int ix = in_offset;
517 int ox = out_offset;
518 for (int i = 0; i < out_len; i++) {
519 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8)
520 | ((in_buff[ix++] & 0xFF) << 16);
521 if (x > 0x7FFFFF)
522 x -= 0x1000000;
523 out_buff[ox++] = x > 0 ? x / 8388607.0f : x / 8388608.0f;
524 }
525 return out_buff;
526 }
527
528 @Override
529 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
530 byte[] out_buff, int out_offset) {
531 int ix = in_offset;
532 int ox = out_offset;
533 for (int i = 0; i < in_len; i++) {
534 float f = in_buff[ix++];
535 int x = (int) (f > 0 ? f * 8388607.0f : f * 8388608.0f);
536 if (x < 0)
537 x += 0x1000000;
538 out_buff[ox++] = (byte) x;
539 out_buff[ox++] = (byte) (x >>> 8);
540 out_buff[ox++] = (byte) (x >>> 16);
541 }
542 return out_buff;
543 }
544 }
545
546 // PCM 24 bit, signed, big-endian
547 private static class AudioFloatConversion24SB extends AudioFloatConverter {
548 @Override
549 public float[] toFloatArray(byte[] in_buff, int in_offset,
550 float[] out_buff, int out_offset, int out_len) {
551 int ix = in_offset;
552 int ox = out_offset;
553 for (int i = 0; i < out_len; i++) {
554 int x = ((in_buff[ix++] & 0xFF) << 16)
555 | ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
556 if (x > 0x7FFFFF)
557 x -= 0x1000000;
558 out_buff[ox++] = x > 0 ? x / 8388607.0f : x / 8388608.0f;
559 }
560 return out_buff;
561 }
562
563 @Override
564 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
565 byte[] out_buff, int out_offset) {
566 int ix = in_offset;
567 int ox = out_offset;
568 for (int i = 0; i < in_len; i++) {
569 float f = in_buff[ix++];
570 int x = (int) (f > 0 ? f * 8388607.0f : f * 8388608.0f);
571 if (x < 0)
572 x += 0x1000000;
573 out_buff[ox++] = (byte) (x >>> 16);
574 out_buff[ox++] = (byte) (x >>> 8);
575 out_buff[ox++] = (byte) x;
576 }
577 return out_buff;
578 }
579 }
580
581 // PCM 24 bit, unsigned, little-endian
582 private static class AudioFloatConversion24UL extends AudioFloatConverter {
583 @Override
584 public float[] toFloatArray(byte[] in_buff, int in_offset,
585 float[] out_buff, int out_offset, int out_len) {
586 int ix = in_offset;
587 int ox = out_offset;
588 for (int i = 0; i < out_len; i++) {
589 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8)
590 | ((in_buff[ix++] & 0xFF) << 16);
591 x -= 0x800000;
592 out_buff[ox++] = x > 0 ? x / 8388607.0f : x / 8388608.0f;
593 }
594 return out_buff;
595 }
596
597 @Override
598 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
599 byte[] out_buff, int out_offset) {
600 int ix = in_offset;
601 int ox = out_offset;
602 for (int i = 0; i < in_len; i++) {
603 float f = in_buff[ix++];
604 int x = (int) (f > 0 ? f * 8388607.0f : f * 8388608.0f);
605 x += 0x800000;
606 out_buff[ox++] = (byte) x;
607 out_buff[ox++] = (byte) (x >>> 8);
608 out_buff[ox++] = (byte) (x >>> 16);
609 }
610 return out_buff;
611 }
612 }
613
614 // PCM 24 bit, unsigned, big-endian
615 private static class AudioFloatConversion24UB extends AudioFloatConverter {
616 @Override
617 public float[] toFloatArray(byte[] in_buff, int in_offset,
618 float[] out_buff, int out_offset, int out_len) {
619 int ix = in_offset;
620 int ox = out_offset;
621 for (int i = 0; i < out_len; i++) {
622 int x = ((in_buff[ix++] & 0xFF) << 16)
623 | ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
624 x -= 0x800000;
625 out_buff[ox++] = x > 0 ? x / 8388607.0f : x / 8388608.0f;
626 }
627 return out_buff;
628 }
629
630 @Override
631 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
632 byte[] out_buff, int out_offset) {
633 int ix = in_offset;
634 int ox = out_offset;
635 for (int i = 0; i < in_len; i++) {
636 float f = in_buff[ix++];
637 int x = (int) (f > 0 ? f * 8388607.0f : f * 8388608.0f);
638 x += 8388608;
639 out_buff[ox++] = (byte) (x >>> 16);
640 out_buff[ox++] = (byte) (x >>> 8);
641 out_buff[ox++] = (byte) x;
642 }
643 return out_buff;
644 }
645 }
646
647 /***************************************************************************
648 *
649 * 32 bit signed/unsigned, little/big-endian
650 *
651 **************************************************************************/
652
653 // PCM 32 bit, signed, little-endian
654 private static class AudioFloatConversion32SL extends AudioFloatConverter {
655 @Override
656 public float[] toFloatArray(byte[] in_buff, int in_offset,
657 float[] out_buff, int out_offset, int out_len) {
658 int ix = in_offset;
659 int ox = out_offset;
660 for (int i = 0; i < out_len; i++) {
661 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8) |
662 ((in_buff[ix++] & 0xFF) << 16) |
663 ((in_buff[ix++] & 0xFF) << 24);
664 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
665 }
666 return out_buff;
667 }
668
669 @Override
670 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
671 byte[] out_buff, int out_offset) {
672 int ix = in_offset;
673 int ox = out_offset;
674 for (int i = 0; i < in_len; i++) {
675 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
676 out_buff[ox++] = (byte) x;
677 out_buff[ox++] = (byte) (x >>> 8);
678 out_buff[ox++] = (byte) (x >>> 16);
679 out_buff[ox++] = (byte) (x >>> 24);
680 }
681 return out_buff;
682 }
683 }
684
685 // PCM 32 bit, signed, big-endian
686 private static class AudioFloatConversion32SB extends AudioFloatConverter {
687 @Override
688 public float[] toFloatArray(byte[] in_buff, int in_offset,
689 float[] out_buff, int out_offset, int out_len) {
690 int ix = in_offset;
691 int ox = out_offset;
692 for (int i = 0; i < out_len; i++) {
693 int x = ((in_buff[ix++] & 0xFF) << 24) |
694 ((in_buff[ix++] & 0xFF) << 16) |
695 ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
696 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
697 }
698 return out_buff;
699 }
700
701 @Override
702 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
703 byte[] out_buff, int out_offset) {
704 int ix = in_offset;
705 int ox = out_offset;
706 for (int i = 0; i < in_len; i++) {
707 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
708 out_buff[ox++] = (byte) (x >>> 24);
709 out_buff[ox++] = (byte) (x >>> 16);
710 out_buff[ox++] = (byte) (x >>> 8);
711 out_buff[ox++] = (byte) x;
712 }
713 return out_buff;
714 }
715 }
716
717 // PCM 32 bit, unsigned, little-endian
718 private static class AudioFloatConversion32UL extends AudioFloatConverter {
719 @Override
720 public float[] toFloatArray(byte[] in_buff, int in_offset,
721 float[] out_buff, int out_offset, int out_len) {
722 int ix = in_offset;
723 int ox = out_offset;
724 for (int i = 0; i < out_len; i++) {
725 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8) |
726 ((in_buff[ix++] & 0xFF) << 16) |
727 ((in_buff[ix++] & 0xFF) << 24);
728 x -= 0x80000000;
729 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
730 }
731 return out_buff;
732 }
733
734 @Override
735 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
736 byte[] out_buff, int out_offset) {
737 int ix = in_offset;
738 int ox = out_offset;
739 for (int i = 0; i < in_len; i++) {
740 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
741 x += 0x80000000;
742 out_buff[ox++] = (byte) x;
743 out_buff[ox++] = (byte) (x >>> 8);
744 out_buff[ox++] = (byte) (x >>> 16);
745 out_buff[ox++] = (byte) (x >>> 24);
746 }
747 return out_buff;
748 }
749 }
750
751 // PCM 32 bit, unsigned, big-endian
752 private static class AudioFloatConversion32UB extends AudioFloatConverter {
753
754 @Override
755 public float[] toFloatArray(byte[] in_buff, int in_offset,
756 float[] out_buff, int out_offset, int out_len) {
757 int ix = in_offset;
758 int ox = out_offset;
759 for (int i = 0; i < out_len; i++) {
760 int x = ((in_buff[ix++] & 0xFF) << 24) |
761 ((in_buff[ix++] & 0xFF) << 16) |
762 ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
763 x -= 0x80000000;
764 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
765 }
766 return out_buff;
767 }
768
769 @Override
770 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
771 byte[] out_buff, int out_offset) {
772 int ix = in_offset;
773 int ox = out_offset;
774 for (int i = 0; i < in_len; i++) {
775 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
776 x += 0x80000000;
777 out_buff[ox++] = (byte) (x >>> 24);
778 out_buff[ox++] = (byte) (x >>> 16);
779 out_buff[ox++] = (byte) (x >>> 8);
780 out_buff[ox++] = (byte) x;
781 }
782 return out_buff;
783 }
784 }
785
786 /***************************************************************************
787 *
788 * 32+ bit signed/unsigned, little/big-endian
789 *
790 **************************************************************************/
791
792 // PCM 32+ bit, signed, little-endian
793 private static class AudioFloatConversion32xSL extends AudioFloatConverter {
794
795 private final int xbytes;
796
797 AudioFloatConversion32xSL(int xbytes) {
798 this.xbytes = xbytes;
799 }
800
801 @Override
802 public float[] toFloatArray(byte[] in_buff, int in_offset,
803 float[] out_buff, int out_offset, int out_len) {
804 int ix = in_offset;
805 int ox = out_offset;
806 for (int i = 0; i < out_len; i++) {
807 ix += xbytes;
808 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8)
809 | ((in_buff[ix++] & 0xFF) << 16)
810 | ((in_buff[ix++] & 0xFF) << 24);
811 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
812 }
813 return out_buff;
814 }
815
816 @Override
817 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
818 byte[] out_buff, int out_offset) {
819 int ix = in_offset;
820 int ox = out_offset;
821 for (int i = 0; i < in_len; i++) {
822 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
823 for (int j = 0; j < xbytes; j++) {
824 out_buff[ox++] = 0;
825 }
826 out_buff[ox++] = (byte) x;
827 out_buff[ox++] = (byte) (x >>> 8);
828 out_buff[ox++] = (byte) (x >>> 16);
829 out_buff[ox++] = (byte) (x >>> 24);
830 }
831 return out_buff;
832 }
833 }
834
835 // PCM 32+ bit, signed, big-endian
836 private static class AudioFloatConversion32xSB extends AudioFloatConverter {
837
838 private final int xbytes;
839
840 AudioFloatConversion32xSB(int xbytes) {
841 this.xbytes = xbytes;
842 }
843
844 @Override
845 public float[] toFloatArray(byte[] in_buff, int in_offset,
846 float[] out_buff, int out_offset, int out_len) {
847 int ix = in_offset;
848 int ox = out_offset;
849 for (int i = 0; i < out_len; i++) {
850 int x = ((in_buff[ix++] & 0xFF) << 24)
851 | ((in_buff[ix++] & 0xFF) << 16)
852 | ((in_buff[ix++] & 0xFF) << 8)
853 | (in_buff[ix++] & 0xFF);
854 ix += xbytes;
855 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
856 }
857 return out_buff;
858 }
859
860 @Override
861 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
862 byte[] out_buff, int out_offset) {
863 int ix = in_offset;
864 int ox = out_offset;
865 for (int i = 0; i < in_len; i++) {
866 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
867 out_buff[ox++] = (byte) (x >>> 24);
868 out_buff[ox++] = (byte) (x >>> 16);
869 out_buff[ox++] = (byte) (x >>> 8);
870 out_buff[ox++] = (byte) x;
871 for (int j = 0; j < xbytes; j++) {
872 out_buff[ox++] = 0;
873 }
874 }
875 return out_buff;
876 }
877 }
878
879 // PCM 32+ bit, unsigned, little-endian
880 private static class AudioFloatConversion32xUL extends AudioFloatConverter {
881
882 private final int xbytes;
883
884 AudioFloatConversion32xUL(int xbytes) {
885 this.xbytes = xbytes;
886 }
887
888 @Override
889 public float[] toFloatArray(byte[] in_buff, int in_offset,
890 float[] out_buff, int out_offset, int out_len) {
891 int ix = in_offset;
892 int ox = out_offset;
893 for (int i = 0; i < out_len; i++) {
894 ix += xbytes;
895 int x = (in_buff[ix++] & 0xFF) | ((in_buff[ix++] & 0xFF) << 8)
896 | ((in_buff[ix++] & 0xFF) << 16)
897 | ((in_buff[ix++] & 0xFF) << 24);
898 x -= 0x80000000;
899 out_buff[ox++] = x * (1.0f / (float)0x7FFFFFFF);
900 }
901 return out_buff;
902 }
903
904 @Override
905 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
906 byte[] out_buff, int out_offset) {
907 int ix = in_offset;
908 int ox = out_offset;
909 for (int i = 0; i < in_len; i++) {
910 int x = (int) (in_buff[ix++] * (float)0x7FFFFFFF);
911 x += 0x80000000;
912 for (int j = 0; j < xbytes; j++) {
913 out_buff[ox++] = 0;
914 }
915 out_buff[ox++] = (byte) x;
916 out_buff[ox++] = (byte) (x >>> 8);
917 out_buff[ox++] = (byte) (x >>> 16);
918 out_buff[ox++] = (byte) (x >>> 24);
919 }
920 return out_buff;
921 }
922 }
923
924 // PCM 32+ bit, unsigned, big-endian
925 private static class AudioFloatConversion32xUB extends AudioFloatConverter {
926
927 private final int xbytes;
928
929 AudioFloatConversion32xUB(int xbytes) {
930 this.xbytes = xbytes;
931 }
932
933 @Override
934 public float[] toFloatArray(byte[] in_buff, int in_offset,
935 float[] out_buff, int out_offset, int out_len) {
936 int ix = in_offset;
937 int ox = out_offset;
938 for (int i = 0; i < out_len; i++) {
939 int x = ((in_buff[ix++] & 0xFF) << 24) |
940 ((in_buff[ix++] & 0xFF) << 16) |
941 ((in_buff[ix++] & 0xFF) << 8) | (in_buff[ix++] & 0xFF);
942 ix += xbytes;
943 x -= 0x80000000;
944 out_buff[ox++] = x * (1.0f / 2147483647.0f);
945 }
946 return out_buff;
947 }
948
949 @Override
950 public byte[] toByteArray(float[] in_buff, int in_offset, int in_len,
951 byte[] out_buff, int out_offset) {
952 int ix = in_offset;
953 int ox = out_offset;
954 for (int i = 0; i < in_len; i++) {
955 int x = (int) (in_buff[ix++] * 2147483647.0f);
956 x += 0x80000000;
957 out_buff[ox++] = (byte) (x >>> 24);
958 out_buff[ox++] = (byte) (x >>> 16);
959 out_buff[ox++] = (byte) (x >>> 8);
960 out_buff[ox++] = (byte) x;
961 for (int j = 0; j < xbytes; j++) {
962 out_buff[ox++] = 0;
963 }
964 }
965 return out_buff;
966 }
967 }
968
969 public static AudioFloatConverter getConverter(AudioFormat format) {
|