/* * Copyright (C) 2020 Linux Studio Plugins Project * (C) 2020 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 6 нояб. 2018 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include #include #define BUFFER_SIZE 0x2000 #define BUFFER_FRAMES 0x400 namespace lsp { namespace lspc { void AudioReader::decode_u8(float *vp, const void *src, size_t ns) { const uint8_t *p = reinterpret_cast(src); while (ns--) *(vp++) = float(*(p++) - 0x80) / 0x7f; } void AudioReader::decode_s8(float *vp, const void *src, size_t ns) { const int8_t *p = reinterpret_cast(src); while (ns--) *(vp++) = float(*(p++)) / 0x7f; } void AudioReader::decode_u16(float *vp, const void *src, size_t ns) { const uint16_t *p = reinterpret_cast(src); while (ns--) *(vp++) = float(*(p++) - 0x8000) / 0x7fff; } void AudioReader::decode_s16(float *vp, const void *src, size_t ns) { const int16_t *p = reinterpret_cast(src); while (ns--) *(vp++) = float(*(p++)) / 0x7fff; } void AudioReader::decode_u24le(float *vp, const void *src, size_t ns) { const uint8_t *p = reinterpret_cast(src); while (ns--) { int32_t v = __IF_LEBE( p[0] | (p[1] << 8) | (p[2] << 16), p[2] | (p[1] << 8) | (p[0] << 16) ); *(vp++) = float(v - 0x800000) / 0x7fffff; p += 3; } } void AudioReader::decode_u24be(float *vp, const void *src, size_t ns) { const uint8_t *p = reinterpret_cast(src); while (ns--) { int32_t v = __IF_LEBE( p[2] | (p[1] << 8) | (p[0] << 16), p[0] | (p[1] << 8) | (p[2] << 16) ); *(vp++) = float(v - 0x800000) / 0x7fffff; p += 3; } } void AudioReader::decode_s24le(float *vp, const void *src, size_t ns) { const uint8_t *p = reinterpret_cast(src); while (ns--) { int32_t v = __IF_LEBE( p[0] | (p[1] << 8) | (p[2] << 16), p[2] | (p[1] << 8) | (p[0] << 16) ); v = (v << 8) >> 8; // Sign-extend value *(vp++) = float(v) / 0x7fffff; p += 3; } } void AudioReader::decode_s24be(float *vp, const void *src, size_t ns) { const uint8_t *p = reinterpret_cast(src); while (ns--) { int32_t v = __IF_LEBE( p[2] | (p[1] << 8) | (p[0] << 16), p[0] | (p[1] << 8) | (p[2] << 16) ); v = (v << 8) >> 8; // Sign-extend value *(vp++) = float(v) / 0x7fffff; p += 3; } } void AudioReader::decode_u32(float *vp, const void *src, size_t ns) { const int32_t *p = reinterpret_cast(src); while (ns--) { int32_t v = *(p++) - 0x80000000; *(vp++) = double(v) / 0x7fffffff; } } void AudioReader::decode_s32(float *vp, const void *src, size_t ns) { const int32_t *p = reinterpret_cast(src); while (ns--) { int32_t v = *(p++); *(vp++) = double(v) / 0x7fffffff; } } void AudioReader::decode_f32(float *vp, const void *src, size_t ns) { const float *p = reinterpret_cast(src); while (ns--) *(vp++) = *(p++); } void AudioReader::decode_f64(float *vp, const void *src, size_t ns) { const double *p = reinterpret_cast(src); while (ns--) *(vp++) = *(p++); } AudioReader::AudioReader() { sParams.channels = 0; sParams.sample_format = 0; sParams.sample_rate = 0; sParams.codec = 0; sParams.frames = 0; pFD = NULL; pRD = NULL; nFlags = 0; nBPS = 0; nFrameSize = 0; nBytesLeft = 0; sBuf.vData = NULL; sBuf.nOff = 0; sBuf.nSize = 0; pDecode = NULL; pFBuffer = NULL; } AudioReader::~AudioReader() { close(); } status_t AudioReader::close() { // Check open status first if (!(nFlags & F_OPENED)) return STATUS_CLOSED; // Close reader (if required) status_t res = STATUS_OK; if (pRD != NULL) { if (nFlags & F_CLOSE_READER) res = update_status(res, pRD->close()); if (nFlags & F_DROP_READER) delete pRD; pRD = NULL; } // Close LSPC file (if required) if ((nFlags & F_CLOSE_FILE) && (pFD != NULL)) { res = update_status(res, pFD->close()); pFD = NULL; } // Drop buffers if (sBuf.vData != NULL) { delete [] sBuf.vData; sBuf.vData = NULL; } // Drop buffers if (pFBuffer != NULL) { delete [] pFBuffer; pFBuffer = NULL; } nFlags = 0; nBPS = 0; nFrameSize = 0; nBytesLeft = 0; sBuf.nOff = 0; sBuf.nSize = 0; pDecode = NULL; return res; } status_t AudioReader::read_audio_header(ChunkReader *rd) { chunk_audio_header_t hdr; audio_parameters_t p; // Read audio header from chunk ssize_t res = rd->read_header(&hdr, sizeof(chunk_audio_header_t)); if (res < 0) return status_t(-res); // Check version and decode header if (hdr.common.version < 1) return STATUS_CORRUPTED_FILE; if (hdr.common.size < sizeof(chunk_audio_header_t)) return STATUS_CORRUPTED_FILE; p.channels = BE_TO_CPU(hdr.channels); p.sample_format = BE_TO_CPU(hdr.sample_format); p.sample_rate = BE_TO_CPU(hdr.sample_rate); p.codec = BE_TO_CPU(hdr.codec); p.frames = BE_TO_CPU(hdr.frames); return apply_params(&p); } status_t AudioReader::apply_params(const audio_parameters_t *p) { if (p->channels <= 0) return STATUS_BAD_FORMAT; if (p->sample_rate == 0) return STATUS_BAD_FORMAT; if (p->codec != lspc::CODEC_PCM) return STATUS_UNSUPPORTED_FORMAT; // Check sample format support size_t sb = 0; decode_func_t df = NULL; bool le = false; bool arch_le = __IF_LEBE(true, false); switch (p->sample_format) { case lspc::SAMPLE_FMT_U8LE: case lspc::SAMPLE_FMT_U8BE: df = decode_u8; sb = 1; le = p->sample_format == lspc::SAMPLE_FMT_U8LE; break; case lspc::SAMPLE_FMT_S8LE: case lspc::SAMPLE_FMT_S8BE: df = decode_s8; sb = 1; le = p->sample_format == lspc::SAMPLE_FMT_S8LE; break; case lspc::SAMPLE_FMT_U16LE: case lspc::SAMPLE_FMT_U16BE: df = decode_u16; sb = 2; le = p->sample_format == lspc::SAMPLE_FMT_U16LE; break; case lspc::SAMPLE_FMT_S16LE: case lspc::SAMPLE_FMT_S16BE: df = decode_s16; sb = 2; le = p->sample_format == lspc::SAMPLE_FMT_S16LE; break; case lspc::SAMPLE_FMT_U24LE: df = decode_u24le; sb = 3; le = true; break; case lspc::SAMPLE_FMT_U24BE: df = decode_u24be; sb = 3; le = false; break; case lspc::SAMPLE_FMT_S24LE: df = decode_s24le; sb = 3; le = true; break; case lspc::SAMPLE_FMT_S24BE: df = decode_s24be; sb = 3; le = false; break; case lspc::SAMPLE_FMT_U32LE: case lspc::SAMPLE_FMT_U32BE: df = decode_u32; sb = 4; le = p->sample_format == lspc::SAMPLE_FMT_U32LE; break; case lspc::SAMPLE_FMT_S32LE: case lspc::SAMPLE_FMT_S32BE: df = decode_s32; sb = 4; le = p->sample_format == lspc::SAMPLE_FMT_S32LE; break; case lspc::SAMPLE_FMT_F32LE: case lspc::SAMPLE_FMT_F32BE: df = decode_f32; sb = 4; le = p->sample_format == lspc::SAMPLE_FMT_F32LE; break; case lspc::SAMPLE_FMT_F64LE: case lspc::SAMPLE_FMT_F64BE: df = decode_f64; sb = 8; le = p->sample_format == lspc::SAMPLE_FMT_F64LE; break; default: return STATUS_UNSUPPORTED_FORMAT; } // Estimate number of bytes to read size_t fz = sb * p->channels; size_t bytes_left = fz * p->frames; // Allocate buffers sBuf.vData = new uint8_t[BUFFER_SIZE]; if (sBuf.vData == NULL) return STATUS_NO_MEM; pFBuffer = new float[p->channels * BUFFER_FRAMES]; if (pFBuffer == NULL) { delete [] sBuf.vData; sBuf.vData = NULL; return STATUS_NO_MEM; } if (le != arch_le) nFlags |= F_REV_BYTES; // Set-up byte-reversal flag sParams = *p; nBPS = sb; nFrameSize = fz; nBytesLeft = bytes_left; sBuf.nOff = 0; sBuf.nSize = 0; pDecode = df; return STATUS_OK; } status_t AudioReader::open(File *lspc, bool auto_close) { if (nFlags & F_OPENED) return STATUS_OPENED; nFlags = 0; ChunkReader *rd = lspc->find_chunk(LSPC_CHUNK_AUDIO, NULL, 0); if (rd == NULL) return STATUS_NOT_FOUND; status_t res = read_audio_header(rd); if (res != STATUS_OK) { rd->close(); return res; } pFD = lspc; pRD = rd; nFlags |= F_OPENED | F_CLOSE_READER | F_DROP_READER; if (auto_close) nFlags |= F_CLOSE_FILE; return STATUS_OK; } status_t AudioReader::open(File *lspc, uint32_t uid, bool auto_close) { if (nFlags & F_OPENED) return STATUS_OPENED; nFlags = 0; ChunkReader *rd = lspc->read_chunk(uid); if (rd == NULL) return STATUS_NOT_FOUND; else if (rd->magic() != LSPC_CHUNK_AUDIO) { rd->close(); return STATUS_BAD_TYPE; } status_t res = read_audio_header(rd); if (res != STATUS_OK) { rd->close(); return res; } pFD = lspc; pRD = rd; nFlags |= F_OPENED | F_CLOSE_READER | F_DROP_READER; if (auto_close) nFlags |= F_CLOSE_FILE; return STATUS_OK; } status_t AudioReader::open_raw_magic(File *lspc, const audio_parameters_t *params, uint32_t magic, bool auto_close) { if (nFlags & F_OPENED) return STATUS_OPENED; else if (params == NULL) return STATUS_BAD_ARGUMENTS; nFlags = 0; ChunkReader *rd = lspc->find_chunk(magic, NULL, 0); if (rd == NULL) return STATUS_NOT_FOUND; status_t res = apply_params(params); if (res != STATUS_OK) { rd->close(); return res; } pFD = lspc; pRD = rd; nFlags |= F_OPENED | F_CLOSE_READER | F_DROP_READER; if (auto_close) nFlags |= F_CLOSE_FILE; return STATUS_OK; } status_t AudioReader::open_raw_uid(File *lspc, const audio_parameters_t *params, uint32_t uid, bool auto_close) { if (nFlags & F_OPENED) return STATUS_OPENED; else if (params == NULL) return STATUS_BAD_ARGUMENTS; nFlags = 0; ChunkReader *rd = lspc->read_chunk(uid); if (rd == NULL) return STATUS_NOT_FOUND; status_t res = apply_params(params); if (res != STATUS_OK) { rd->close(); return res; } pFD = lspc; pRD = rd; nFlags |= F_OPENED | F_CLOSE_READER | F_DROP_READER; if (auto_close) nFlags |= F_CLOSE_FILE; return STATUS_OK; } status_t AudioReader::open_raw(ChunkReader *rd, const audio_parameters_t *params, bool auto_close) { if (nFlags & F_OPENED) return STATUS_OPENED; else if (params == NULL) return STATUS_BAD_ARGUMENTS; nFlags = 0; status_t res = apply_params(params); if (res != STATUS_OK) return res; pFD = NULL; pRD = rd; nFlags |= F_OPENED; if (auto_close) nFlags |= F_CLOSE_READER; return STATUS_OK; } status_t AudioReader::get_parameters(audio_parameters_t *dst) const { if (!(nFlags & F_OPENED)) return STATUS_CLOSED; else if (dst == NULL) return STATUS_BAD_ARGUMENTS; *dst = sParams; return STATUS_OK; } status_t AudioReader::fill_buffer() { // Move buffer data from end to the beginning size_t bsize = sBuf.nSize - sBuf.nOff; if ((sBuf.nSize > 0) && (bsize > 0)) { ::memmove(sBuf.vData, &sBuf.vData[sBuf.nOff], bsize); sBuf.nSize = bsize; } else sBuf.nSize = 0; sBuf.nOff = 0; // Try to read additional data bsize = BUFFER_SIZE - bsize; ssize_t n = pRD->read(&sBuf.vData[sBuf.nSize], bsize); if (n < 0) return status_t(-n); else if (n == 0) // Number of bytes should be multiple of nFrameSize { size_t delta = sBuf.nSize - sBuf.nOff; if (delta >= nFrameSize) return STATUS_OK; else if (delta == 0) return STATUS_EOF; else return STATUS_CORRUPTED_FILE; } sBuf.nSize += n; return STATUS_OK; } ssize_t AudioReader::read_samples(float **data, size_t frames) { if (!(nFlags & F_OPENED)) return STATUS_CLOSED; size_t nc = sParams.channels; float **vp = reinterpret_cast(alloca(nc * sizeof(float *))); for (size_t i=0; i BUFFER_FRAMES) to_read = BUFFER_FRAMES; // Read frames to temporary buffer ssize_t n = read_frames(pFBuffer, to_read); if (n <= 0) return (n_read > 0) ? n_read : n; n_read += n; // Unpack frames float *p = pFBuffer; while (n--) { for (size_t j=0; j 0) ? n_read : -st; avail = sBuf.nSize - sBuf.nOff; if (avail < nFrameSize) return (n_read > 0) ? n_read : STATUS_CORRUPTED_FILE; } // Perform decode avail /= nFrameSize; if (avail > to_read) avail = to_read; size_t floats = avail * sParams.channels; if (nFlags & F_REV_BYTES) { switch (nBPS) { case 1: case 3: break; case 2: byte_swap(reinterpret_cast(&sBuf.vData[sBuf.nOff]), floats); break; case 4: byte_swap(reinterpret_cast(&sBuf.vData[sBuf.nOff]), floats); break; case 8: byte_swap(reinterpret_cast(&sBuf.vData[sBuf.nOff]), floats); break; default: return STATUS_BAD_STATE; } } // Perform decode pDecode(data, &sBuf.vData[sBuf.nOff], floats); // Update pointers n_read += avail; sBuf.nOff += avail * nFrameSize; data += floats; } return n_read; } ssize_t AudioReader::skip_frames(size_t frames) { if (!(nFlags & F_OPENED)) return STATUS_CLOSED; size_t n_skip = 0; while (n_skip < frames) { size_t to_skip = frames - n_skip; // Ensure that we have enough bytes to read at least one frame size_t avail = sBuf.nSize - sBuf.nOff; if (avail < nFrameSize) { // Try to fill buffer with new data status_t st = fill_buffer(); if (st != STATUS_OK) return (n_skip > 0) ? n_skip : -st; avail = sBuf.nSize - sBuf.nOff; if (avail < nFrameSize) return (n_skip > 0) ? n_skip : STATUS_CORRUPTED_FILE; } // Perform decode avail /= nFrameSize; if (avail > to_skip) avail = to_skip; // Update pointers n_skip += avail; sBuf.nOff += avail * nFrameSize; } return n_skip; } uint32_t AudioReader::unique_id() const { if (!(nFlags & F_OPENED)) return 0; else if (pRD == NULL) return 0; return pRD->unique_id(); } uint32_t AudioReader::magic() const { if (!(nFlags & F_OPENED)) return 0; else if (pRD == NULL) return 0; return pRD->magic(); } } } /* namespace lsp */