mirror of
https://github.com/ggerganov/ggwave.git
synced 2026-02-06 16:47:59 +08:00
251 lines
10 KiB
C++
251 lines
10 KiB
C++
#include "ggwave/ggwave.h"
|
|
|
|
#include <limits>
|
|
#include <string>
|
|
#include <typeinfo>
|
|
#include <typeindex>
|
|
#include <vector>
|
|
#include <set>
|
|
|
|
#define CHECK(cond) \
|
|
if (!(cond)) { \
|
|
fprintf(stderr, "[%s:%d] Check failed: %s\n", __FILE__, __LINE__, #cond); \
|
|
exit(1); \
|
|
}
|
|
|
|
#define CHECK_T(cond) CHECK(cond)
|
|
#define CHECK_F(cond) CHECK(!(cond))
|
|
|
|
const std::map<std::type_index, float> kSampleScale = {
|
|
{ typeid(uint8_t), std::numeric_limits<uint8_t>::max() },
|
|
{ typeid(int8_t), std::numeric_limits<int8_t>::max() },
|
|
{ typeid(uint16_t), std::numeric_limits<uint16_t>::max() },
|
|
{ typeid(int16_t), std::numeric_limits<int16_t>::max() },
|
|
{ typeid(float), 1.0f },
|
|
};
|
|
|
|
const std::map<std::type_index, float> kSampleOffset = {
|
|
{ typeid(uint8_t), 0.5f*std::numeric_limits<uint8_t>::max() },
|
|
{ typeid(int8_t), 0.0f },
|
|
{ typeid(uint16_t), 0.5f*std::numeric_limits<uint16_t>::max() },
|
|
{ typeid(int16_t), 0.0f },
|
|
{ typeid(float), 0.0f },
|
|
};
|
|
|
|
const std::set<GGWave::SampleFormat> kFormats = {
|
|
GGWAVE_SAMPLE_FORMAT_U8,
|
|
GGWAVE_SAMPLE_FORMAT_I8,
|
|
GGWAVE_SAMPLE_FORMAT_U16,
|
|
GGWAVE_SAMPLE_FORMAT_I16,
|
|
GGWAVE_SAMPLE_FORMAT_F32,
|
|
};
|
|
|
|
template <typename T>
|
|
GGWave::CBWaveformOut getCBWaveformOut(uint32_t & nSamples, std::vector<T> & buffer) {
|
|
return [&nSamples, &buffer](const void * data, uint32_t nBytes) {
|
|
nSamples = nBytes/sizeof(T);
|
|
CHECK(nSamples*sizeof(T) == nBytes);
|
|
buffer.resize(nSamples);
|
|
std::copy((char *) data, (char *) data + nBytes, (char *) buffer.data());
|
|
};
|
|
}
|
|
|
|
template <typename T>
|
|
GGWave::CBWaveformInp getCBWaveformInp(uint32_t & nSamples, std::vector<T> & buffer) {
|
|
return [&nSamples, &buffer](void * data, uint32_t nMaxBytes) {
|
|
uint32_t nCopied = std::min((uint32_t) (nSamples*sizeof(T)), nMaxBytes);
|
|
const char * p = (char *) (buffer.data() + buffer.size() - nSamples);
|
|
std::copy(p, p + nCopied, (char *) data);
|
|
nSamples -= nCopied/sizeof(T);
|
|
|
|
return nCopied;
|
|
};
|
|
}
|
|
|
|
template <typename S, typename D>
|
|
void convert(const std::vector<S> & src, std::vector<D> & dst) {
|
|
int n = src.size();
|
|
dst.resize(n);
|
|
for (int i = 0; i < n; ++i) {
|
|
dst[i] = ((float(src[i]) - kSampleOffset.at(typeid(S)))/kSampleScale.at(typeid(S)))*kSampleScale.at(typeid(D)) + kSampleOffset.at(typeid(D));
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
std::vector<uint8_t> bufferU8;
|
|
std::vector<int8_t> bufferI8;
|
|
std::vector<uint16_t> bufferU16;
|
|
std::vector<int16_t> bufferI16;
|
|
std::vector<float> bufferF32;
|
|
|
|
auto convertHelper = [&](GGWave::SampleFormat formatOut, GGWave::SampleFormat formatInp) {
|
|
switch (formatOut) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: CHECK(false); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8:
|
|
{
|
|
switch (formatInp) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: CHECK(false); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8: break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8: convert(bufferU8, bufferI8); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16: convert(bufferU8, bufferU16); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16: convert(bufferU8, bufferI16); break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32: convert(bufferU8, bufferF32); break;
|
|
};
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8:
|
|
{
|
|
switch (formatInp) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: CHECK(false); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8: convert(bufferI8, bufferU8); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8: break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16: convert(bufferI8, bufferU16); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16: convert(bufferI8, bufferI16); break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32: convert(bufferI8, bufferF32); break;
|
|
};
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16:
|
|
{
|
|
switch (formatInp) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: CHECK(false); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8: convert(bufferU16, bufferU8); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8: convert(bufferU16, bufferI8); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16: break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16: convert(bufferU16, bufferI16); break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32: convert(bufferU16, bufferF32); break;
|
|
};
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16:
|
|
{
|
|
switch (formatInp) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: CHECK(false); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8: convert(bufferI16, bufferU8); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8: convert(bufferI16, bufferI8); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16: convert(bufferI16, bufferU16); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16: break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32: convert(bufferI16, bufferF32); break;
|
|
};
|
|
} break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32:
|
|
{
|
|
switch (formatInp) {
|
|
case GGWAVE_SAMPLE_FORMAT_UNDEFINED: CHECK(false); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U8: convert(bufferF32, bufferU8); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I8: convert(bufferF32, bufferI8); break;
|
|
case GGWAVE_SAMPLE_FORMAT_U16: convert(bufferF32, bufferU16); break;
|
|
case GGWAVE_SAMPLE_FORMAT_I16: convert(bufferF32, bufferI16); break;
|
|
case GGWAVE_SAMPLE_FORMAT_F32: break;
|
|
};
|
|
} break;
|
|
};
|
|
|
|
};
|
|
|
|
uint32_t nSamples = 0;
|
|
|
|
const std::map<GGWave::SampleFormat, GGWave::CBWaveformOut> kCBWaveformOut = {
|
|
{ GGWAVE_SAMPLE_FORMAT_U8, getCBWaveformOut(nSamples, bufferU8) },
|
|
{ GGWAVE_SAMPLE_FORMAT_I8, getCBWaveformOut(nSamples, bufferI8) },
|
|
{ GGWAVE_SAMPLE_FORMAT_U16, getCBWaveformOut(nSamples, bufferU16) },
|
|
{ GGWAVE_SAMPLE_FORMAT_I16, getCBWaveformOut(nSamples, bufferI16) },
|
|
{ GGWAVE_SAMPLE_FORMAT_F32, getCBWaveformOut(nSamples, bufferF32) },
|
|
};
|
|
|
|
const std::map<GGWave::SampleFormat, GGWave::CBWaveformInp> kCBWaveformInp = {
|
|
{ GGWAVE_SAMPLE_FORMAT_U8, getCBWaveformInp(nSamples, bufferU8) },
|
|
{ GGWAVE_SAMPLE_FORMAT_I8, getCBWaveformInp(nSamples, bufferI8) },
|
|
{ GGWAVE_SAMPLE_FORMAT_U16, getCBWaveformInp(nSamples, bufferU16) },
|
|
{ GGWAVE_SAMPLE_FORMAT_I16, getCBWaveformInp(nSamples, bufferI16) },
|
|
{ GGWAVE_SAMPLE_FORMAT_F32, getCBWaveformInp(nSamples, bufferF32) },
|
|
};
|
|
|
|
{
|
|
GGWave instance(GGWave::getDefaultParameters());
|
|
|
|
std::string payload = "hello";
|
|
|
|
CHECK(instance.init(payload));
|
|
|
|
// data
|
|
CHECK_F(instance.init(-1, "asd"));
|
|
CHECK_T(instance.init(0, nullptr));
|
|
CHECK_T(instance.init(0, "asd"));
|
|
CHECK_T(instance.init(1, "asd"));
|
|
CHECK_T(instance.init(2, "asd"));
|
|
CHECK_T(instance.init(3, "asd"));
|
|
|
|
// volume
|
|
CHECK_F(instance.init(payload.size(), payload.c_str(), -1));
|
|
CHECK_T(instance.init(payload.size(), payload.c_str(), 0));
|
|
CHECK_T(instance.init(payload.size(), payload.c_str(), 50));
|
|
CHECK_T(instance.init(payload.size(), payload.c_str(), 100));
|
|
CHECK_F(instance.init(payload.size(), payload.c_str(), 101));
|
|
}
|
|
|
|
// capture / playback at different sample rates
|
|
{
|
|
auto parameters = GGWave::getDefaultParameters();
|
|
|
|
std::string payload = "hello";
|
|
|
|
// encode
|
|
{
|
|
parameters.sampleRateInp = 48000;
|
|
parameters.sampleRateOut = 12000;
|
|
GGWave instanceOut(parameters);
|
|
|
|
instanceOut.init(payload, 25);
|
|
auto expectedSize = instanceOut.encodeSize_samples();
|
|
instanceOut.encode(kCBWaveformOut.at(parameters.sampleFormatOut));
|
|
printf("Expected = %d, actual = %d\n", expectedSize, nSamples);
|
|
CHECK(expectedSize == nSamples);
|
|
convertHelper(parameters.sampleFormatOut, parameters.sampleFormatInp);
|
|
}
|
|
|
|
// decode
|
|
{
|
|
parameters.samplesPerFrame *= float(parameters.sampleRateOut)/parameters.sampleRateInp;
|
|
parameters.sampleRateInp = parameters.sampleRateOut;
|
|
GGWave instanceInp(parameters);
|
|
|
|
instanceInp.decode(kCBWaveformInp.at(parameters.sampleFormatInp));
|
|
|
|
GGWave::TxRxData result;
|
|
CHECK(instanceInp.takeRxData(result) == (int) payload.size());
|
|
for (int i = 0; i < (int) payload.size(); ++i) {
|
|
CHECK(payload[i] == result[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const auto & txProtocol : GGWave::getTxProtocols()) {
|
|
for (const auto & formatOut : kFormats) {
|
|
for (const auto & formatInp : kFormats) {
|
|
printf("Testing: protocol = %s, in = %d, out = %d\n", txProtocol.second.name, formatInp, formatOut);
|
|
|
|
auto parameters = GGWave::getDefaultParameters();
|
|
parameters.sampleFormatInp = formatInp;
|
|
parameters.sampleFormatOut = formatOut;
|
|
GGWave instance(parameters);
|
|
|
|
std::string payload = "test";
|
|
|
|
instance.init(payload, txProtocol.second, 25);
|
|
auto expectedSize = instance.encodeSize_samples();
|
|
instance.encode(kCBWaveformOut.at(formatOut));
|
|
printf("Expected = %d, actual = %d\n", expectedSize, nSamples);
|
|
CHECK(expectedSize == nSamples);
|
|
convertHelper(formatOut, formatInp);
|
|
instance.decode(kCBWaveformInp.at(formatInp));
|
|
|
|
GGWave::TxRxData result;
|
|
CHECK(instance.takeRxData(result) == (int) payload.size());
|
|
for (int i = 0; i < (int) payload.size(); ++i) {
|
|
CHECK(payload[i] == result[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|