/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 28 авг. 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
#include
#include
#define EXTRA_SIZE 0x10
#define BUFFER_SIZE 0x100000
namespace lsp
{
typedef struct lspc_chunk_audio_header_v2_t: public lspc::chunk_audio_header_t
{
uint8_t extra[EXTRA_SIZE];
} lspc_chunk_audio_header_v2_t;
typedef struct lspc_chunk_audio_profile_v2_t: public lspc::chunk_audio_profile_t
{
uint8_t extra[EXTRA_SIZE];
} lspc_chunk_audio_profile_v2_t;
}
UTEST_BEGIN("runtime.fmt.lspc", lspc)
void create_lspc_file(const ByteBuffer &content, bool v2)
{
lspc::File fd;
io::Path path;
UTEST_ASSERT(path.fmt("%s/utest-%s.lspc", tempdir(), full_name()));
printf("Writing file %s ...\n", path.as_native());
status_t res = fd.create(&path);
UTEST_ASSERT(res == STATUS_OK);
// Write audio chunk
lspc::ChunkWriter *wr = fd.write_chunk(LSPC_CHUNK_AUDIO);
UTEST_ASSERT(wr != NULL);
if (v2)
{
lspc_chunk_audio_header_v2_t ahdr2;
bzero(&ahdr2, sizeof(ahdr2));
ahdr2.common.version = 2;
ahdr2.common.size = sizeof(lspc_chunk_audio_header_v2_t);
ahdr2.channels = 1;
ahdr2.sample_format = lspc::SAMPLE_FMT_F32LE;
ahdr2.sample_rate = 48000;
ahdr2.codec = lspc::CODEC_PCM;
ahdr2.frames = (content.size() / sizeof(float));
ahdr2.channels = BE_TO_CPU(ahdr2.channels);
ahdr2.sample_format = BE_TO_CPU(ahdr2.sample_format);
ahdr2.sample_rate = BE_TO_CPU(ahdr2.sample_rate);
ahdr2.codec = BE_TO_CPU(ahdr2.codec);
ahdr2.frames = BE_TO_CPU(ahdr2.frames);
for (size_t i=0; i < EXTRA_SIZE; ++i)
ahdr2.extra[i] = uint8_t(i + 1);
res = wr->write_header(&ahdr2);
UTEST_ASSERT(res == STATUS_OK);
}
else
{
lspc::chunk_audio_header_t ahdr1;
bzero(&ahdr1, sizeof(ahdr1));
ahdr1.common.version = 1;
ahdr1.common.size = sizeof(lspc::chunk_audio_header_t);
ahdr1.channels = 1;
ahdr1.sample_format = lspc::SAMPLE_FMT_F32LE;
ahdr1.sample_rate = 48000;
ahdr1.codec = lspc::CODEC_PCM;
ahdr1.frames = (content.size() / sizeof(float));
ahdr1.channels = BE_TO_CPU(ahdr1.channels);
ahdr1.sample_format = BE_TO_CPU(ahdr1.sample_format);
ahdr1.sample_rate = BE_TO_CPU(ahdr1.sample_rate);
ahdr1.codec = BE_TO_CPU(ahdr1.codec);
ahdr1.frames = BE_TO_CPU(ahdr1.frames);
res = wr->write_header(&ahdr1);
UTEST_ASSERT(res == STATUS_OK);
}
// Flush data
res = wr->flush();
UTEST_ASSERT(res == STATUS_OK);
// Write contents of audio chunk
size_t chunk_id = wr->unique_id();
res = wr->write(content, content.size());
UTEST_ASSERT(res == STATUS_OK);
// Flush data
res = wr->flush();
UTEST_ASSERT(res == STATUS_OK);
// Close chunk
res = wr->close();
UTEST_ASSERT(res == STATUS_OK);
delete wr;
// Write profile chunk
wr = fd.write_chunk(LSPC_CHUNK_PROFILE);
UTEST_ASSERT(wr != NULL);
if (v2)
{
lspc_chunk_audio_profile_v2_t prof2;
bzero(&prof2, sizeof(prof2));
prof2.common.version = 2;
prof2.common.size = sizeof(lspc_chunk_audio_profile_v2_t);
prof2.chunk_id = lspc::chunk_id_t(chunk_id);
prof2.chirp_order = 1;
prof2.alpha = 1.0;
prof2.beta = 2.0;
prof2.gamma = 3.0;
prof2.delta = 4.0;
prof2.initial_freq = 10.0;
prof2.final_freq = 48000.0;
prof2.chunk_id = CPU_TO_BE(prof2.chunk_id);
prof2.chirp_order = CPU_TO_BE(prof2.chirp_order);
prof2.alpha = CPU_TO_BE(prof2.alpha);
prof2.beta = CPU_TO_BE(prof2.beta);
prof2.gamma = CPU_TO_BE(prof2.gamma);
prof2.delta = CPU_TO_BE(prof2.delta);
prof2.initial_freq = CPU_TO_BE(prof2.initial_freq);
prof2.final_freq = CPU_TO_BE(prof2.final_freq);
for (size_t i=0; i < EXTRA_SIZE; ++i)
prof2.extra[i] = uint8_t(i + 1);
res = wr->write_header(&prof2);
UTEST_ASSERT(res == STATUS_OK);
}
else
{
lspc::chunk_audio_profile_t prof1;
bzero(&prof1, sizeof(prof1));
prof1.common.version = 1;
prof1.common.size = sizeof(lspc::chunk_audio_profile_t);
prof1.chunk_id = lspc::chunk_id_t(chunk_id);
prof1.chirp_order = 1;
prof1.alpha = 1.0;
prof1.beta = 2.0;
prof1.gamma = 3.0;
prof1.delta = 4.0;
prof1.initial_freq = 10.0;
prof1.final_freq = 48000.0;
prof1.chunk_id = CPU_TO_BE(prof1.chunk_id);
prof1.chirp_order = CPU_TO_BE(prof1.chirp_order);
prof1.alpha = CPU_TO_BE(prof1.alpha);
prof1.beta = CPU_TO_BE(prof1.beta);
prof1.gamma = CPU_TO_BE(prof1.gamma);
prof1.delta = CPU_TO_BE(prof1.delta);
prof1.initial_freq = CPU_TO_BE(prof1.initial_freq);
prof1.final_freq = CPU_TO_BE(prof1.final_freq);
res = wr->write_header(&prof1);
UTEST_ASSERT(res == STATUS_OK);
}
// Flush data
res = wr->flush();
UTEST_ASSERT(res == STATUS_OK);
// Close header
res = wr->close();
UTEST_ASSERT(res == STATUS_OK);
delete wr;
// Close file
res = fd.close();
UTEST_ASSERT(res == STATUS_OK);
}
void read_lspc_file(ByteBuffer &content, bool v2)
{
lspc::File fd;
io::Path path;
UTEST_ASSERT(path.fmt("%s/utest-%s.lspc", tempdir(), full_name()));
printf("Reading file %s ...\n", path.as_native());
status_t res = fd.open(&path);
UTEST_ASSERT(res == STATUS_OK);
// Find profile chunk
uint32_t chunk_id = 0;
lspc::ChunkReader *rd = fd.find_chunk(LSPC_CHUNK_PROFILE, &chunk_id);
UTEST_ASSERT_MSG(rd != NULL, "Error while searching for profile chunk");
if (v2)
{
// Read as 'upgraded' version
lspc_chunk_audio_profile_v2_t prof2;
ssize_t n = rd->read_header(&prof2, sizeof(lspc_chunk_audio_profile_v2_t));
UTEST_ASSERT( n >= 0 );
res = status_t(rd->last_error());
UTEST_ASSERT_MSG((res == STATUS_OK) || (res == STATUS_EOF), "Invalid last_error status: %d", int(res));
prof2.chunk_id = CPU_TO_BE(prof2.chunk_id);
prof2.chirp_order = CPU_TO_BE(prof2.chirp_order);
prof2.alpha = CPU_TO_BE(prof2.alpha);
prof2.beta = CPU_TO_BE(prof2.beta);
prof2.gamma = CPU_TO_BE(prof2.gamma);
prof2.delta = CPU_TO_BE(prof2.delta);
prof2.initial_freq = CPU_TO_BE(prof2.initial_freq);
prof2.final_freq = CPU_TO_BE(prof2.final_freq);
UTEST_ASSERT(prof2.chirp_order == 1);
UTEST_ASSERT(prof2.alpha == 1.0);
UTEST_ASSERT(prof2.beta == 2.0);
UTEST_ASSERT(prof2.gamma == 3.0);
UTEST_ASSERT(prof2.delta == 4.0);
UTEST_ASSERT(prof2.initial_freq == 10.0);
UTEST_ASSERT(prof2.final_freq == 48000.0);
if (prof2.common.version == 1)
{
UTEST_ASSERT(prof2.common.size == sizeof(lspc::chunk_audio_profile_t));
for (size_t i=0; i < EXTRA_SIZE; ++i)
UTEST_ASSERT(prof2.extra[i] == 0);
}
else if (prof2.common.version == 2)
{
UTEST_ASSERT(prof2.common.size == sizeof(lspc_chunk_audio_profile_v2_t));
for (size_t i=0; i < EXTRA_SIZE; ++i)
UTEST_ASSERT(prof2.extra[i] == uint8_t(i + 1));
}
else
{
UTEST_FAIL_MSG("Invalid profile header version: %d", int(prof2.common.version));
}
chunk_id = prof2.chunk_id;
}
else
{
// Read as 'legacy' version
lspc::chunk_audio_profile_t prof1;
ssize_t n = rd->read_header(&prof1, sizeof(lspc::chunk_audio_profile_t));
UTEST_ASSERT( n >= 0 );
res = status_t(rd->last_error());
UTEST_ASSERT_MSG((res == STATUS_OK) || (res == STATUS_EOF), "Invalid last_error status: %d", int(res));
prof1.chunk_id = CPU_TO_BE(prof1.chunk_id);
prof1.chirp_order = CPU_TO_BE(prof1.chirp_order);
prof1.alpha = CPU_TO_BE(prof1.alpha);
prof1.beta = CPU_TO_BE(prof1.beta);
prof1.gamma = CPU_TO_BE(prof1.gamma);
prof1.delta = CPU_TO_BE(prof1.delta);
prof1.initial_freq = CPU_TO_BE(prof1.initial_freq);
prof1.final_freq = CPU_TO_BE(prof1.final_freq);
UTEST_ASSERT(prof1.chirp_order == 1);
UTEST_ASSERT(prof1.alpha == 1.0);
UTEST_ASSERT(prof1.beta == 2.0);
UTEST_ASSERT(prof1.gamma == 3.0);
UTEST_ASSERT(prof1.delta == 4.0);
UTEST_ASSERT(prof1.initial_freq == 10.0);
UTEST_ASSERT(prof1.final_freq == 48000.0);
UTEST_ASSERT(prof1.common.size == sizeof(lspc::chunk_audio_profile_t));
UTEST_ASSERT_MSG((prof1.common.version == 1) || (prof1.common.version == 2),
"Invalid profile header version: %d", int(prof1.common.version));
chunk_id = prof1.chunk_id;
}
// Try to read data after profile header
ssize_t count = rd->read(content.data(), content.size());
UTEST_ASSERT_MSG(count <= 0, "Extra data found after profile header");
res = status_t(rd->last_error());
UTEST_ASSERT_MSG((res == STATUS_OK) || (res == STATUS_EOF), "Invalid last_error status: %d", int(res));
// Close chunk reader
res = rd->close();
UTEST_ASSERT(res == STATUS_OK);
delete rd;
// Read audio chunk
rd = fd.read_chunk(chunk_id);
UTEST_ASSERT_MSG(rd != NULL, "Error while reading audio chunk id=%d", int(chunk_id));
UTEST_ASSERT(rd->unique_id() == chunk_id);
UTEST_ASSERT(rd->magic() == LSPC_CHUNK_AUDIO);
if (v2)
{
// Read as 'upgraded' version
lspc_chunk_audio_header_v2_t ahdr2;
bzero(&ahdr2, sizeof(ahdr2));
ssize_t n = rd->read_header(&ahdr2, sizeof(lspc_chunk_audio_header_v2_t));
UTEST_ASSERT(n >= 0);
res = status_t(rd->last_error());
UTEST_ASSERT_MSG((res == STATUS_OK), "Invalid last_error status: %d", int(res));
ahdr2.channels = BE_TO_CPU(ahdr2.channels);
ahdr2.sample_format = BE_TO_CPU(ahdr2.sample_format);
ahdr2.sample_rate = BE_TO_CPU(ahdr2.sample_rate);
ahdr2.codec = BE_TO_CPU(ahdr2.codec);
ahdr2.frames = BE_TO_CPU(ahdr2.frames);
UTEST_ASSERT(ahdr2.channels == 1);
UTEST_ASSERT(ahdr2.sample_format == lspc::SAMPLE_FMT_F32LE);
UTEST_ASSERT(ahdr2.sample_rate == 48000);
UTEST_ASSERT(ahdr2.codec == lspc::CODEC_PCM);
UTEST_ASSERT(ahdr2.frames == (content.size() / sizeof(float)));
if (ahdr2.common.version == 1)
{
UTEST_ASSERT(ahdr2.common.size == sizeof(lspc::chunk_audio_header_t));
for (size_t i=0; i < EXTRA_SIZE; ++i)
UTEST_ASSERT(ahdr2.extra[i] == 0);
}
else if (ahdr2.common.version == 2)
{
UTEST_ASSERT(ahdr2.common.size == sizeof(lspc_chunk_audio_header_v2_t));
for (size_t i=0; i < EXTRA_SIZE; ++i)
UTEST_ASSERT(ahdr2.extra[i] == uint8_t(i + 1));
}
else
{
UTEST_FAIL_MSG("Invalid profile header version: %d", int(ahdr2.common.version));
}
}
else
{
// Read as 'legacy' version
lspc::chunk_audio_header_t ahdr1;
bzero(&ahdr1, sizeof(ahdr1));
ssize_t n = rd->read_header(&ahdr1, sizeof(lspc::chunk_audio_header_t));
UTEST_ASSERT(n >= 0);
res = status_t(rd->last_error());
UTEST_ASSERT_MSG((res == STATUS_OK), "Invalid last_error status: %d", int(res));
ahdr1.channels = BE_TO_CPU(ahdr1.channels);
ahdr1.sample_format = BE_TO_CPU(ahdr1.sample_format);
ahdr1.sample_rate = BE_TO_CPU(ahdr1.sample_rate);
ahdr1.codec = BE_TO_CPU(ahdr1.codec);
ahdr1.frames = BE_TO_CPU(ahdr1.frames);
UTEST_ASSERT(ahdr1.channels == 1);
UTEST_ASSERT(ahdr1.sample_format == lspc::SAMPLE_FMT_F32LE);
UTEST_ASSERT(ahdr1.sample_rate == 48000);
UTEST_ASSERT(ahdr1.codec == lspc::CODEC_PCM);
UTEST_ASSERT(ahdr1.frames == (content.size() / sizeof(float)));
UTEST_ASSERT(ahdr1.common.size == sizeof(lspc::chunk_audio_header_t));
UTEST_ASSERT_MSG((ahdr1.common.version == 1) || (ahdr1.common.version == 2),
"Invalid profile header version: %d", int(ahdr1.common.version));
}
// Read buffer data
count = rd->read(content.data(), content.size());
UTEST_ASSERT_MSG((count == ssize_t(content.size())),
"Invalid read size: %d, expected: %d", int(count), int(content.size()));
// Try to read data after profile header
count = rd->read(content.data(), content.size());
UTEST_ASSERT_MSG(count <= 0, "Invalid read size: %d, expected: %d", int(count), int(0));
res = status_t(rd->last_error());
UTEST_ASSERT_MSG((res == STATUS_OK) || (res == STATUS_EOF), "Invalid last_error status: %d", int(res));
// Close chunk reader
res = rd->close();
UTEST_ASSERT(res == STATUS_OK);
delete rd;
// Close file
res = fd.close();
UTEST_ASSERT(res == STATUS_OK);
}
UTEST_MAIN
{
ByteBuffer src(BUFFER_SIZE);
for (size_t i=0; i<=0x03; ++i)
{
printf("Writing %s data, reading %s data\n",
((i & 0x01) ? "v2" : "v1"),
((i & 0x02) ? "v2" : "v1")
);
ByteBuffer dst(BUFFER_SIZE);
create_lspc_file(src, i & 0x01);
read_lspc_file(dst, i & 0x02);
UTEST_ASSERT_MSG(src.valid(), "Source buffer corrupted");
UTEST_ASSERT_MSG(dst.valid(), "Destination buffer corrupted");
if (!src.equals(dst))
{
src.dump("src");
dst.dump("dst");
UTEST_FAIL_MSG("Source and destination buffers differ");
}
}
}
UTEST_END