Debian Codegraph @

modules/lsp-runtime-lib/src/main/fmt/lspc/AudioReader.cpp

raw
1 /*
2 * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2020 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 6 нояб. 2018 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib 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 Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/common/endian.h>
23 #include <lsp-plug.in/fmt/lspc/AudioReader.h>
24 #include <lsp-plug.in/stdlib/string.h>
25 #include <stdlib.h>
26
27 #define BUFFER_SIZE 0x2000
28 #define BUFFER_FRAMES 0x400
29
30 namespace lsp
31 {
32 namespace lspc
33 {
34 void AudioReader::decode_u8(float *vp, const void *src, size_t ns)
35 {
36 const uint8_t *p = reinterpret_cast<const uint8_t *>(src);
37 while (ns--)
38 *(vp++) = float(*(p++) - 0x80) / 0x7f;
39 }
40
41 void AudioReader::decode_s8(float *vp, const void *src, size_t ns)
42 {
43 const int8_t *p = reinterpret_cast<const int8_t *>(src);
44 while (ns--)
45 *(vp++) = float(*(p++)) / 0x7f;
46 }
47
48 void AudioReader::decode_u16(float *vp, const void *src, size_t ns)
49 {
50 const uint16_t *p = reinterpret_cast<const uint16_t *>(src);
51 while (ns--)
52 *(vp++) = float(*(p++) - 0x8000) / 0x7fff;
53 }
54
55 void AudioReader::decode_s16(float *vp, const void *src, size_t ns)
56 {
57 const int16_t *p = reinterpret_cast<const int16_t *>(src);
58 while (ns--)
59 *(vp++) = float(*(p++)) / 0x7fff;
60 }
61
62 void AudioReader::decode_u24le(float *vp, const void *src, size_t ns)
63 {
64 const uint8_t *p = reinterpret_cast<const uint8_t *>(src);
65 while (ns--)
66 {
67 int32_t v =
68 __IF_LEBE(
69 p[0] | (p[1] << 8) | (p[2] << 16),
70 p[2] | (p[1] << 8) | (p[0] << 16)
71 );
72
73 *(vp++) = float(v - 0x800000) / 0x7fffff;
74 p += 3;
75 }
76 }
77
78 void AudioReader::decode_u24be(float *vp, const void *src, size_t ns)
79 {
80 const uint8_t *p = reinterpret_cast<const uint8_t *>(src);
81 while (ns--)
82 {
83 int32_t v =
84 __IF_LEBE(
85 p[2] | (p[1] << 8) | (p[0] << 16),
86 p[0] | (p[1] << 8) | (p[2] << 16)
87 );
88
89 *(vp++) = float(v - 0x800000) / 0x7fffff;
90 p += 3;
91 }
92 }
93
94 void AudioReader::decode_s24le(float *vp, const void *src, size_t ns)
95 {
96 const uint8_t *p = reinterpret_cast<const uint8_t *>(src);
97 while (ns--)
98 {
99 int32_t v =
100 __IF_LEBE(
101 p[0] | (p[1] << 8) | (p[2] << 16),
102 p[2] | (p[1] << 8) | (p[0] << 16)
103 );
104 v = (v << 8) >> 8; // Sign-extend value
105 *(vp++) = float(v) / 0x7fffff;
106 p += 3;
107 }
108 }
109
110 void AudioReader::decode_s24be(float *vp, const void *src, size_t ns)
111 {
112 const uint8_t *p = reinterpret_cast<const uint8_t *>(src);
113 while (ns--)
114 {
115 int32_t v =
116 __IF_LEBE(
117 p[2] | (p[1] << 8) | (p[0] << 16),
118 p[0] | (p[1] << 8) | (p[2] << 16)
119 );
120 v = (v << 8) >> 8; // Sign-extend value
121 *(vp++) = float(v) / 0x7fffff;
122 p += 3;
123 }
124 }
125
126 void AudioReader::decode_u32(float *vp, const void *src, size_t ns)
127 {
128 const int32_t *p = reinterpret_cast<const int32_t *>(src);
129 while (ns--)
130 {
131 int32_t v = *(p++) - 0x80000000;
132 *(vp++) = double(v) / 0x7fffffff;
133 }
134 }
135
136 void AudioReader::decode_s32(float *vp, const void *src, size_t ns)
137 {
138 const int32_t *p = reinterpret_cast<const int32_t *>(src);
139 while (ns--)
140 {
141 int32_t v = *(p++);
142 *(vp++) = double(v) / 0x7fffffff;
143 }
144 }
145
146 void AudioReader::decode_f32(float *vp, const void *src, size_t ns)
147 {
148 const float *p = reinterpret_cast<const float *>(src);
149 while (ns--)
150 *(vp++) = *(p++);
151 }
152
153 void AudioReader::decode_f64(float *vp, const void *src, size_t ns)
154 {
155 const double *p = reinterpret_cast<const double *>(src);
156 while (ns--)
157 *(vp++) = *(p++);
158 }
159
160 AudioReader::AudioReader()
161 {
162 sParams.channels = 0;
163 sParams.sample_format = 0;
164 sParams.sample_rate = 0;
165 sParams.codec = 0;
166 sParams.frames = 0;
167
168 pFD = NULL;
169 pRD = NULL;
170 nFlags = 0;
171 nBPS = 0;
172 nFrameSize = 0;
173 nBytesLeft = 0;
174 sBuf.vData = NULL;
175 sBuf.nOff = 0;
176 sBuf.nSize = 0;
177 pDecode = NULL;
178 pFBuffer = NULL;
179 }
180
181 AudioReader::~AudioReader()
182 {
183 close();
184 }
185
186 status_t AudioReader::close()
187 {
188 // Check open status first
189 if (!(nFlags & F_OPENED))
190 return STATUS_CLOSED;
191
192 // Close reader (if required)
193 status_t res = STATUS_OK;
194 if (pRD != NULL)
195 {
196 if (nFlags & F_CLOSE_READER)
197 res = update_status(res, pRD->close());
198 if (nFlags & F_DROP_READER)
199 delete pRD;
200 pRD = NULL;
201 }
202
203 // Close LSPC file (if required)
204 if ((nFlags & F_CLOSE_FILE) && (pFD != NULL))
205 {
206 res = update_status(res, pFD->close());
207 pFD = NULL;
208 }
209
210 // Drop buffers
211 if (sBuf.vData != NULL)
212 {
213 delete [] sBuf.vData;
214 sBuf.vData = NULL;
215 }
216
217 // Drop buffers
218 if (pFBuffer != NULL)
219 {
220 delete [] pFBuffer;
221 pFBuffer = NULL;
222 }
223
224 nFlags = 0;
225 nBPS = 0;
226 nFrameSize = 0;
227 nBytesLeft = 0;
228 sBuf.nOff = 0;
229 sBuf.nSize = 0;
230 pDecode = NULL;
231
232 return res;
233 }
234
235 status_t AudioReader::read_audio_header(ChunkReader *rd)
236 {
237 chunk_audio_header_t hdr;
238 audio_parameters_t p;
239
240 // Read audio header from chunk
241 ssize_t res = rd->read_header(&hdr, sizeof(chunk_audio_header_t));
242 if (res < 0)
243 return status_t(-res);
244
245 // Check version and decode header
246 if (hdr.common.version < 1)
247 return STATUS_CORRUPTED_FILE;
248 if (hdr.common.size < sizeof(chunk_audio_header_t))
249 return STATUS_CORRUPTED_FILE;
250
251 p.channels = BE_TO_CPU(hdr.channels);
252 p.sample_format = BE_TO_CPU(hdr.sample_format);
253 p.sample_rate = BE_TO_CPU(hdr.sample_rate);
254 p.codec = BE_TO_CPU(hdr.codec);
255 p.frames = BE_TO_CPU(hdr.frames);
256
257 return apply_params(&p);
258 }
259
260 status_t AudioReader::apply_params(const audio_parameters_t *p)
261 {
262 if (p->channels <= 0)
263 return STATUS_BAD_FORMAT;
264 if (p->sample_rate == 0)
265 return STATUS_BAD_FORMAT;
266 if (p->codec != lspc::CODEC_PCM)
267 return STATUS_UNSUPPORTED_FORMAT;
268
269 // Check sample format support
270 size_t sb = 0;
271 decode_func_t df = NULL;
272 bool le = false;
273 bool arch_le = __IF_LEBE(true, false);
274
275 switch (p->sample_format)
276 {
277 case lspc::SAMPLE_FMT_U8LE:
278 case lspc::SAMPLE_FMT_U8BE:
279 df = decode_u8;
280 sb = 1;
281 le = p->sample_format == lspc::SAMPLE_FMT_U8LE;
282 break;
283
284 case lspc::SAMPLE_FMT_S8LE:
285 case lspc::SAMPLE_FMT_S8BE:
286 df = decode_s8;
287 sb = 1;
288 le = p->sample_format == lspc::SAMPLE_FMT_S8LE;
289 break;
290
291 case lspc::SAMPLE_FMT_U16LE:
292 case lspc::SAMPLE_FMT_U16BE:
293 df = decode_u16;
294 sb = 2;
295 le = p->sample_format == lspc::SAMPLE_FMT_U16LE;
296 break;
297
298 case lspc::SAMPLE_FMT_S16LE:
299 case lspc::SAMPLE_FMT_S16BE:
300 df = decode_s16;
301 sb = 2;
302 le = p->sample_format == lspc::SAMPLE_FMT_S16LE;
303 break;
304
305 case lspc::SAMPLE_FMT_U24LE:
306 df = decode_u24le;
307 sb = 3;
308 le = true;
309 break;
310 case lspc::SAMPLE_FMT_U24BE:
311 df = decode_u24be;
312 sb = 3;
313 le = false;
314 break;
315 case lspc::SAMPLE_FMT_S24LE:
316 df = decode_s24le;
317 sb = 3;
318 le = true;
319 break;
320 case lspc::SAMPLE_FMT_S24BE:
321 df = decode_s24be;
322 sb = 3;
323 le = false;
324 break;
325
326 case lspc::SAMPLE_FMT_U32LE:
327 case lspc::SAMPLE_FMT_U32BE:
328 df = decode_u32;
329 sb = 4;
330 le = p->sample_format == lspc::SAMPLE_FMT_U32LE;
331 break;
332
333 case lspc::SAMPLE_FMT_S32LE:
334 case lspc::SAMPLE_FMT_S32BE:
335 df = decode_s32;
336 sb = 4;
337 le = p->sample_format == lspc::SAMPLE_FMT_S32LE;
338 break;
339
340 case lspc::SAMPLE_FMT_F32LE:
341 case lspc::SAMPLE_FMT_F32BE:
342 df = decode_f32;
343 sb = 4;
344 le = p->sample_format == lspc::SAMPLE_FMT_F32LE;
345 break;
346
347 case lspc::SAMPLE_FMT_F64LE:
348 case lspc::SAMPLE_FMT_F64BE:
349 df = decode_f64;
350 sb = 8;
351 le = p->sample_format == lspc::SAMPLE_FMT_F64LE;
352 break;
353
354 default:
355 return STATUS_UNSUPPORTED_FORMAT;
356 }
357
358 // Estimate number of bytes to read
359 size_t fz = sb * p->channels;
360 size_t bytes_left = fz * p->frames;
361
362 // Allocate buffers
363 sBuf.vData = new uint8_t[BUFFER_SIZE];
364 if (sBuf.vData == NULL)
365 return STATUS_NO_MEM;
366
367 pFBuffer = new float[p->channels * BUFFER_FRAMES];
368 if (pFBuffer == NULL)
369 {
370 delete [] sBuf.vData;
371 sBuf.vData = NULL;
372 return STATUS_NO_MEM;
373 }
374
375 if (le != arch_le)
376 nFlags |= F_REV_BYTES; // Set-up byte-reversal flag
377
378 sParams = *p;
379 nBPS = sb;
380 nFrameSize = fz;
381 nBytesLeft = bytes_left;
382 sBuf.nOff = 0;
383 sBuf.nSize = 0;
384 pDecode = df;
385
386 return STATUS_OK;
387 }
388
389 status_t AudioReader::open(File *lspc, bool auto_close)
390 {
391 if (nFlags & F_OPENED)
392 return STATUS_OPENED;
393 nFlags = 0;
394
395 ChunkReader *rd = lspc->find_chunk(LSPC_CHUNK_AUDIO, NULL, 0);
396 if (rd == NULL)
397 return STATUS_NOT_FOUND;
398
399 status_t res = read_audio_header(rd);
400 if (res != STATUS_OK)
401 {
402 rd->close();
403 return res;
404 }
405
406 pFD = lspc;
407 pRD = rd;
408 nFlags |= F_OPENED | F_CLOSE_READER | F_DROP_READER;
409 if (auto_close)
410 nFlags |= F_CLOSE_FILE;
411 return STATUS_OK;
412 }
413
414 status_t AudioReader::open(File *lspc, uint32_t uid, bool auto_close)
415 {
416 if (nFlags & F_OPENED)
417 return STATUS_OPENED;
418 nFlags = 0;
419
420 ChunkReader *rd = lspc->read_chunk(uid);
421 if (rd == NULL)
422 return STATUS_NOT_FOUND;
423 else if (rd->magic() != LSPC_CHUNK_AUDIO)
424 {
425 rd->close();
426 return STATUS_BAD_TYPE;
427 }
428
429 status_t res = read_audio_header(rd);
430 if (res != STATUS_OK)
431 {
432 rd->close();
433 return res;
434 }
435
436 pFD = lspc;
437 pRD = rd;
438 nFlags |= F_OPENED | F_CLOSE_READER | F_DROP_READER;
439 if (auto_close)
440 nFlags |= F_CLOSE_FILE;
441 return STATUS_OK;
442 }
443
444 status_t AudioReader::open_raw_magic(File *lspc, const audio_parameters_t *params, uint32_t magic, bool auto_close)
445 {
446 if (nFlags & F_OPENED)
447 return STATUS_OPENED;
448 else if (params == NULL)
449 return STATUS_BAD_ARGUMENTS;
450 nFlags = 0;
451
452 ChunkReader *rd = lspc->find_chunk(magic, NULL, 0);
453 if (rd == NULL)
454 return STATUS_NOT_FOUND;
455
456 status_t res = apply_params(params);
457 if (res != STATUS_OK)
458 {
459 rd->close();
460 return res;
461 }
462
463 pFD = lspc;
464 pRD = rd;
465 nFlags |= F_OPENED | F_CLOSE_READER | F_DROP_READER;
466 if (auto_close)
467 nFlags |= F_CLOSE_FILE;
468 return STATUS_OK;
469 }
470
471 status_t AudioReader::open_raw_uid(File *lspc, const audio_parameters_t *params, uint32_t uid, bool auto_close)
472 {
473 if (nFlags & F_OPENED)
474 return STATUS_OPENED;
475 else if (params == NULL)
476 return STATUS_BAD_ARGUMENTS;
477 nFlags = 0;
478
479 ChunkReader *rd = lspc->read_chunk(uid);
480 if (rd == NULL)
481 return STATUS_NOT_FOUND;
482
483 status_t res = apply_params(params);
484 if (res != STATUS_OK)
485 {
486 rd->close();
487 return res;
488 }
489
490 pFD = lspc;
491 pRD = rd;
492 nFlags |= F_OPENED | F_CLOSE_READER | F_DROP_READER;
493 if (auto_close)
494 nFlags |= F_CLOSE_FILE;
495 return STATUS_OK;
496 }
497
498 status_t AudioReader::open_raw(ChunkReader *rd, const audio_parameters_t *params, bool auto_close)
499 {
500 if (nFlags & F_OPENED)
501 return STATUS_OPENED;
502 else if (params == NULL)
503 return STATUS_BAD_ARGUMENTS;
504 nFlags = 0;
505
506 status_t res = apply_params(params);
507 if (res != STATUS_OK)
508 return res;
509
510 pFD = NULL;
511 pRD = rd;
512 nFlags |= F_OPENED;
513 if (auto_close)
514 nFlags |= F_CLOSE_READER;
515 return STATUS_OK;
516 }
517
518 status_t AudioReader::get_parameters(audio_parameters_t *dst) const
519 {
520 if (!(nFlags & F_OPENED))
521 return STATUS_CLOSED;
522 else if (dst == NULL)
523 return STATUS_BAD_ARGUMENTS;
524 *dst = sParams;
525
526 return STATUS_OK;
527 }
528
529 status_t AudioReader::fill_buffer()
530 {
531 // Move buffer data from end to the beginning
532 size_t bsize = sBuf.nSize - sBuf.nOff;
533 if ((sBuf.nSize > 0) && (bsize > 0))
534 {
535 ::memmove(sBuf.vData, &sBuf.vData[sBuf.nOff], bsize);
536 sBuf.nSize = bsize;
537 }
538 else
539 sBuf.nSize = 0;
540 sBuf.nOff = 0;
541
542 // Try to read additional data
543 bsize = BUFFER_SIZE - bsize;
544 ssize_t n = pRD->read(&sBuf.vData[sBuf.nSize], bsize);
545 if (n < 0)
546 return status_t(-n);
547 else if (n == 0) // Number of bytes should be multiple of nFrameSize
548 {
549 size_t delta = sBuf.nSize - sBuf.nOff;
550 if (delta >= nFrameSize)
551 return STATUS_OK;
552 else if (delta == 0)
553 return STATUS_EOF;
554 else
555 return STATUS_CORRUPTED_FILE;
556 }
557
558 sBuf.nSize += n;
559 return STATUS_OK;
560 }
561
562 ssize_t AudioReader::read_samples(float **data, size_t frames)
563 {
564 if (!(nFlags & F_OPENED))
565 return STATUS_CLOSED;
566
567 size_t nc = sParams.channels;
568 float **vp = reinterpret_cast<float **>(alloca(nc * sizeof(float *)));
569 for (size_t i=0; i<nc; ++i)
570 vp[i] = data[i];
571
572 size_t n_read = 0;
573
574 while (n_read < frames)
575 {
576 // Estimate number of frames to read
577 size_t to_read = frames - n_read;
578 if (to_read > BUFFER_FRAMES)
579 to_read = BUFFER_FRAMES;
580
581 // Read frames to temporary buffer
582 ssize_t n = read_frames(pFBuffer, to_read);
583 if (n <= 0)
584 return (n_read > 0) ? n_read : n;
585
586 n_read += n;
587
588 // Unpack frames
589 float *p = pFBuffer;
590 while (n--)
591 {
592 for (size_t j=0; j<nc; ++j, ++p)
593 {
594 if (!vp[j])
595 continue;
596 *(vp[j]++) = *p;
597 }
598 }
599 }
600
601 return n_read;
602 }
603
604 ssize_t AudioReader::read_frames(float *data, size_t frames)
605 {
606 if (!(nFlags & F_OPENED))
607 return STATUS_CLOSED;
608
609 size_t n_read = 0;
610 while (n_read < frames)
611 {
612 size_t to_read = frames - n_read;
613
614 // Ensure that we have enough bytes to read at least one frame
615 size_t avail = sBuf.nSize - sBuf.nOff;
616 if (avail < nFrameSize)
617 {
618 // Try to fill buffer with new data
619 status_t st = fill_buffer();
620 if (st != STATUS_OK)
621 return (n_read > 0) ? n_read : -st;
622 avail = sBuf.nSize - sBuf.nOff;
623 if (avail < nFrameSize)
624 return (n_read > 0) ? n_read : STATUS_CORRUPTED_FILE;
625 }
626
627 // Perform decode
628 avail /= nFrameSize;
629 if (avail > to_read)
630 avail = to_read;
631 size_t floats = avail * sParams.channels;
632 if (nFlags & F_REV_BYTES)
633 {
634 switch (nBPS)
635 {
636 case 1:
637 case 3:
638 break;
639 case 2:
640 byte_swap(reinterpret_cast<uint16_t *>(&sBuf.vData[sBuf.nOff]), floats);
641 break;
642 case 4:
643 byte_swap(reinterpret_cast<uint32_t *>(&sBuf.vData[sBuf.nOff]), floats);
644 break;
645 case 8:
646 byte_swap(reinterpret_cast<uint64_t *>(&sBuf.vData[sBuf.nOff]), floats);
647 break;
648 default:
649 return STATUS_BAD_STATE;
650 }
651 }
652
653 // Perform decode
654 pDecode(data, &sBuf.vData[sBuf.nOff], floats);
655
656 // Update pointers
657 n_read += avail;
658 sBuf.nOff += avail * nFrameSize;
659 data += floats;
660 }
661
662 return n_read;
663 }
664
665 ssize_t AudioReader::skip_frames(size_t frames)
666 {
667 if (!(nFlags & F_OPENED))
668 return STATUS_CLOSED;
669
670 size_t n_skip = 0;
671 while (n_skip < frames)
672 {
673 size_t to_skip = frames - n_skip;
674
675 // Ensure that we have enough bytes to read at least one frame
676 size_t avail = sBuf.nSize - sBuf.nOff;
677 if (avail < nFrameSize)
678 {
679 // Try to fill buffer with new data
680 status_t st = fill_buffer();
681 if (st != STATUS_OK)
682 return (n_skip > 0) ? n_skip : -st;
683 avail = sBuf.nSize - sBuf.nOff;
684 if (avail < nFrameSize)
685 return (n_skip > 0) ? n_skip : STATUS_CORRUPTED_FILE;
686 }
687
688 // Perform decode
689 avail /= nFrameSize;
690 if (avail > to_skip)
691 avail = to_skip;
692
693 // Update pointers
694 n_skip += avail;
695 sBuf.nOff += avail * nFrameSize;
696 }
697
698 return n_skip;
699 }
700
701 uint32_t AudioReader::unique_id() const
702 {
703 if (!(nFlags & F_OPENED))
704 return 0;
705 else if (pRD == NULL)
706 return 0;
707
708 return pRD->unique_id();
709 }
710
711 uint32_t AudioReader::magic() const
712 {
713 if (!(nFlags & F_OPENED))
714 return 0;
715 else if (pRD == NULL)
716 return 0;
717
718 return pRD->magic();
719 }
720 }
721
722 } /* namespace lsp */