/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 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
#define BUFFER_FRAMES 0x400
namespace lsp
{
namespace lspc
{
void AudioWriter::encode_u8(void *vp, const float *src, size_t ns)
{
uint8_t *p = reinterpret_cast(vp);
while (ns--)
*(p++) = int8_t((*src++) * 0x7f) + 0x80;
}
void AudioWriter::encode_s8(void *vp, const float *src, size_t ns)
{
int8_t *p = reinterpret_cast(vp);
while (ns--)
*(p++) = int8_t((*src++) * 0x7f);
}
void AudioWriter::encode_u16(void *vp, const float *src, size_t ns)
{
uint16_t *p = reinterpret_cast(vp);
while (ns--)
*(p++) = int16_t((*src++) * 0x7fff) + 0x8000;
}
void AudioWriter::encode_s16(void *vp, const float *src, size_t ns)
{
int16_t *p = reinterpret_cast(vp);
while (ns--)
*(p++) = int16_t((*src++) * 0x7fff);
}
void AudioWriter::encode_u24le(void *vp, const float *src, size_t ns)
{
uint8_t *p = reinterpret_cast(vp);
while (ns--)
{
uint32_t s = int32_t(*(src++) * 0x7fffff) + 0x800000;
__IF_LE(p[0] = uint8_t(s); p[1] = uint8_t(s >> 8); p[2] = uint8_t(s >> 16));
__IF_BE(p[0] = uint8_t(s >> 16); p[1] = uint8_t(s >> 8); p[2] = uint8_t(s));
p += 3;
}
}
void AudioWriter::encode_u24be(void *vp, const float *src, size_t ns)
{
uint8_t *p = reinterpret_cast(vp);
while (ns--)
{
uint32_t s = int32_t(*(src++) * 0x7fffff) + 0x800000;
__IF_BE(p[0] = uint8_t(s); p[1] = uint8_t(s >> 8); p[2] = uint8_t(s >> 16));
__IF_LE(p[0] = uint8_t(s >> 16); p[1] = uint8_t(s >> 8); p[2] = uint8_t(s));
p += 3;
}
}
void AudioWriter::encode_s24le(void *vp, const float *src, size_t ns)
{
uint8_t *p = reinterpret_cast(vp);
while (ns--)
{
int32_t s = int32_t(*(src++) * 0x7fffff);
__IF_LE(p[0] = uint8_t(s); p[1] = uint8_t(s >> 8); p[2] = uint8_t(s >> 16));
__IF_BE(p[0] = uint8_t(s >> 16); p[1] = uint8_t(s >> 8); p[2] = uint8_t(s));
p += 3;
}
}
void AudioWriter::encode_s24be(void *vp, const float *src, size_t ns)
{
uint8_t *p = reinterpret_cast(vp);
while (ns--)
{
int32_t s = int32_t(*(src++) * 0x7fffff);
__IF_BE(p[0] = uint8_t(s); p[1] = uint8_t(s >> 8); p[2] = uint8_t(s >> 16));
__IF_LE(p[0] = uint8_t(s >> 16); p[1] = uint8_t(s >> 8); p[2] = uint8_t(s));
p += 3;
}
}
void AudioWriter::encode_u32(void *vp, const float *src, size_t ns)
{
uint32_t *p = reinterpret_cast(vp);
while (ns--)
{
int32_t v = double(*(src++)) * 0x7fffffff;
*(p++) = v + 0x80000000;
}
}
void AudioWriter::encode_s32(void *vp, const float *src, size_t ns)
{
int32_t *p = reinterpret_cast(vp);
while (ns--)
*(p++) = double(*(src++)) * 0x7fffffff;
}
void AudioWriter::encode_f32(void *vp, const float *src, size_t ns)
{
float *p = reinterpret_cast(vp);
::memcpy(p, src, ns * sizeof(float));
}
void AudioWriter::encode_f64(void *vp, const float *src, size_t ns)
{
double *p = reinterpret_cast(vp);
while (ns--)
*(p++) = *(src++);
}
AudioWriter::AudioWriter()
{
sParams.channels = 0;
sParams.sample_format = 0;
sParams.sample_rate = 0;
sParams.codec = 0;
sParams.frames = 0;
pFD = NULL;
pWD = NULL;
nFlags = 0;
nBPS = 0;
nFrameChannels = 0;
pEncode = NULL;
pBuffer = NULL;
pFBuffer = NULL;
}
AudioWriter::~AudioWriter()
{
free_resources();
}
status_t AudioWriter::free_resources()
{
status_t res = STATUS_OK;
if (pWD != NULL)
{
if (nFlags & F_CLOSE_WRITER)
res = update_status(res, pWD->close());
if (nFlags & F_DROP_WRITER)
delete pWD;
pWD = NULL;
}
if (pFD != NULL)
{
if (nFlags & F_CLOSE_FILE)
res = update_status(res, pFD->close());
if (nFlags & F_DROP_FILE)
delete pFD;
pFD = NULL;
}
if (pFBuffer != NULL)
{
delete [] pFBuffer;
pFBuffer = NULL;
}
if (pBuffer != NULL)
{
delete [] pBuffer;
pBuffer = NULL;
}
nFlags = 0;
nBPS = 0;
nFrameChannels = 0;
pEncode = NULL;
return res;
}
status_t AudioWriter::close()
{
// Check open status first
if (!(nFlags & F_OPENED))
return STATUS_CLOSED;
return free_resources();
}
status_t AudioWriter::parse_parameters(const audio_parameters_t *p)
{
if (p == NULL)
return STATUS_BAD_ARGUMENTS;
else if (p->channels > 0xff)
return STATUS_BAD_FORMAT;
else if (p->sample_rate == 0)
return STATUS_BAD_FORMAT;
else if (p->codec != lspc::CODEC_PCM)
return STATUS_BAD_FORMAT;
size_t sb = 0;
encode_func_t ef = NULL;
bool le = false;
bool int_sample = true;
bool arch_le = __IF_LEBE(true, false);
switch (p->sample_format)
{
case lspc::SAMPLE_FMT_U8LE:
case lspc::SAMPLE_FMT_U8BE:
ef = encode_u8;
sb = 1;
le = p->sample_format == lspc::SAMPLE_FMT_U8LE;
break;
case lspc::SAMPLE_FMT_S8LE:
case lspc::SAMPLE_FMT_S8BE:
ef = encode_s8;
sb = 1;
le = p->sample_format == lspc::SAMPLE_FMT_S8LE;
break;
case lspc::SAMPLE_FMT_U16LE:
case lspc::SAMPLE_FMT_U16BE:
ef = encode_u16;
sb = 2;
le = p->sample_format == lspc::SAMPLE_FMT_U16LE;
break;
case lspc::SAMPLE_FMT_S16LE:
case lspc::SAMPLE_FMT_S16BE:
ef = encode_s16;
sb = 2;
le = p->sample_format == lspc::SAMPLE_FMT_S16LE;
break;
case lspc::SAMPLE_FMT_U24LE:
ef = encode_u24le;
sb = 3;
le = true;
break;
case lspc::SAMPLE_FMT_U24BE:
ef = encode_u24be;
sb = 3;
le = false;
break;
case lspc::SAMPLE_FMT_S24LE:
ef = encode_s24le;
sb = 3;
le = true;
break;
case lspc::SAMPLE_FMT_S24BE:
ef = encode_s24be;
sb = 3;
le = false;
break;
case lspc::SAMPLE_FMT_U32LE:
case lspc::SAMPLE_FMT_U32BE:
ef = encode_u32;
sb = 4;
le = p->sample_format == lspc::SAMPLE_FMT_U32LE;
break;
case lspc::SAMPLE_FMT_S32LE:
case lspc::SAMPLE_FMT_S32BE:
ef = encode_s32;
sb = 4;
le = p->sample_format == lspc::SAMPLE_FMT_S32LE;
break;
case lspc::SAMPLE_FMT_F32LE:
case lspc::SAMPLE_FMT_F32BE:
ef = encode_f32;
int_sample = false;
sb = 4;
le = p->sample_format == lspc::SAMPLE_FMT_F32LE;
break;
case lspc::SAMPLE_FMT_F64LE:
case lspc::SAMPLE_FMT_F64BE:
ef = encode_f64;
int_sample = false;
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;
// Allocate buffers
pFBuffer = new uint8_t[fz * BUFFER_FRAMES];
if (pFBuffer == NULL)
return STATUS_NO_MEM;
pBuffer = new float[p->channels * BUFFER_FRAMES];
if (pBuffer == NULL)
{
delete [] pFBuffer;
pFBuffer = NULL;
return STATUS_NO_MEM;
}
if (le != arch_le)
nFlags |= F_REV_BYTES; // Set-up byte-reversal flag
if (int_sample)
nFlags |= F_INTEGER_SAMPLE;
sParams = *p;
nBPS = sb;
nFrameChannels = p->channels;
pEncode = ef;
return STATUS_OK;
}
status_t AudioWriter::write_header(ChunkWriter *wr)
{
chunk_audio_header_t hdr;
::memset(&hdr, 0, sizeof(hdr));
hdr.common.size = sizeof(chunk_audio_header_t);
hdr.common.version = 1;
hdr.channels = sParams.channels;
hdr.sample_format = sParams.sample_format;
hdr.sample_rate = uint32_t(sParams.sample_rate);
hdr.codec = uint32_t(sParams.codec);
hdr.frames = sParams.frames;
hdr.offset = 0;
hdr.channels = CPU_TO_BE(hdr.channels);
hdr.sample_format = CPU_TO_BE(hdr.sample_format);
hdr.sample_rate = CPU_TO_BE(hdr.sample_rate);
hdr.codec = CPU_TO_BE(hdr.codec);
hdr.frames = CPU_TO_BE(hdr.frames);
hdr.offset = CPU_TO_BE(hdr.offset);
return wr->write_header(&hdr);
}
status_t AudioWriter::create(const char *path, const audio_parameters_t *params)
{
LSPString tmp;
if (!tmp.set_utf8(path))
return STATUS_NO_MEM;
return create(&tmp, params);
}
status_t AudioWriter::create(const LSPString *path, const audio_parameters_t *params)
{
File *fd = new File();
if (fd == NULL)
return STATUS_NO_MEM;
status_t res = fd->create(path);
if (res == STATUS_OK)
{
res = open(fd, params, true);
if (res == STATUS_OK)
nFlags |= F_CLOSE_FILE | F_DROP_FILE;
}
if (res != STATUS_OK)
{
fd->close();
delete fd;
return res;
}
return STATUS_OK;
}
status_t AudioWriter::create(const io::Path *path, const audio_parameters_t *params)
{
return create(path->as_string(), params);
}
status_t AudioWriter::open(File *lspc, uint32_t magic, const audio_parameters_t *params, bool auto_close)
{
if (nFlags & F_OPENED)
return STATUS_OPENED;
nFlags = 0;
status_t res = parse_parameters(params);
if (res != STATUS_OK)
return res;
ChunkWriter *wr = lspc->write_chunk(magic);
if (wr == NULL)
return STATUS_NO_MEM;
res = write_header(wr);
if (res != STATUS_OK)
{
free_resources();
wr->close();
delete wr;
return res;
}
pFD = lspc;
pWD = wr;
nFlags |= F_OPENED | F_CLOSE_WRITER | F_DROP_WRITER;
if (auto_close)
nFlags |= F_CLOSE_FILE;
return STATUS_OK;
}
status_t AudioWriter::open(File *lspc, const audio_parameters_t *params, bool auto_close)
{
return open(lspc, LSPC_CHUNK_AUDIO, params, auto_close);
}
status_t AudioWriter::open(ChunkWriter *wr, const audio_parameters_t *params, bool auto_close)
{
if (nFlags & F_OPENED)
return STATUS_OPENED;
nFlags = 0;
status_t res = parse_parameters(params);
if (res != STATUS_OK)
return res;
res = write_header(wr);
if (res != STATUS_OK)
{
free_resources();
return res;
}
nFlags |= F_OPENED;
if (auto_close)
nFlags |= F_CLOSE_WRITER;
return STATUS_OK;
}
status_t AudioWriter::open_raw(File *lspc, const audio_parameters_t *params, bool auto_close)
{
if (nFlags & F_OPENED)
return STATUS_OPENED;
nFlags = 0;
status_t res = parse_parameters(params);
if (res != STATUS_OK)
return res;
ChunkWriter *wr = lspc->write_chunk(LSPC_CHUNK_AUDIO);
if (wr == NULL)
return STATUS_NO_MEM;
pFD = lspc;
pWD = wr;
nFlags |= F_OPENED | F_CLOSE_WRITER | F_DROP_WRITER;
if (auto_close)
nFlags |= F_CLOSE_FILE;
return STATUS_OK;
}
status_t AudioWriter::open_raw(File *lspc, uint32_t magic, const audio_parameters_t *params, bool auto_close)
{
if (nFlags & F_OPENED)
return STATUS_OPENED;
nFlags = 0;
status_t res = parse_parameters(params);
if (res != STATUS_OK)
return res;
ChunkWriter *wr = lspc->write_chunk(magic);
if (wr == NULL)
return STATUS_NO_MEM;
pFD = lspc;
pWD = wr;
nFlags |= F_OPENED | F_CLOSE_WRITER | F_DROP_WRITER;
if (auto_close)
nFlags |= F_CLOSE_FILE;
return STATUS_OK;
}
status_t AudioWriter::open_raw(ChunkWriter *wr, const audio_parameters_t *params, bool auto_close)
{
if (nFlags & F_OPENED)
return STATUS_OPENED;
nFlags = 0;
status_t res = parse_parameters(params);
if (res != STATUS_OK)
return res;
nFlags |= F_OPENED;
if (auto_close)
nFlags |= F_CLOSE_WRITER;
return STATUS_OK;
}
status_t AudioWriter::write_samples(const float **data, size_t frames)
{
if (!(nFlags & F_OPENED))
return STATUS_CLOSED;
size_t nc = sParams.channels;
const float **vp = reinterpret_cast(alloca(nc * sizeof(float *)));
for (size_t i=0; i BUFFER_FRAMES)
to_write = BUFFER_FRAMES;
// Pack frames
float *p = pBuffer;
for (size_t i=0; i BUFFER_FRAMES)
to_write = BUFFER_FRAMES;
// Copy frames to buffer
size_t floats = to_write * nFrameChannels;
pEncode(pFBuffer, data, floats);
// Reverse bytes (if required)
if (nFlags & F_REV_BYTES)
{
switch (nBPS)
{
case 1:
case 3:
break;
case 2:
byte_swap(reinterpret_cast(pFBuffer), floats);
break;
case 4:
byte_swap(reinterpret_cast(pFBuffer), floats);
break;
case 8:
byte_swap(reinterpret_cast(pFBuffer), floats);
break;
default:
return STATUS_BAD_STATE;
}
}
// Write data to LSPC
status_t res = pWD->write(pFBuffer, floats * nBPS);
if (res != STATUS_OK)
return res;
data += floats;
n_written += to_write;
}
return STATUS_OK;
}
status_t AudioWriter::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;
}
uint32_t AudioWriter::unique_id() const
{
if (!(nFlags & F_OPENED))
return 0;
else if (pWD == NULL)
return 0;
return pWD->unique_id();
}
uint32_t AudioWriter::magic() const
{
if (!(nFlags & F_OPENED))
return 0;
else if (pWD == NULL)
return 0;
return pWD->magic();
}
} /* namespace lspc */
} /* namespace lsp */