You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

424 lines
12 KiB

///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> //
// Some code by AI //
// //
// This program is free software; you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation as version 3 of the License, or //
// (at your option) any later version. //
// //
// This program 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 General Public License V3 for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
///////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <cstring>
#include <limits>
#include <QMutexLocker>
#include <QtEndian>
#include "audiofilereader.h"
namespace {
bool chunkIdEquals(const char *id, const char *expected)
{
return std::memcmp(id, expected, 4) == 0;
}
}
AudioFileReader::AudioFileReader() :
m_fileType(FileTypeNone),
m_wavFormat(0),
m_channelCount(0),
m_bitsPerSample(0),
m_blockAlign(0),
m_sampleRate(0),
m_dataOffset(0),
m_dataSize(0),
m_frameCount(0),
m_position(0)
{
}
AudioFileReader::~AudioFileReader()
{
close();
}
bool AudioFileReader::open(const QString& fileName)
{
QMutexLocker locker(&m_mutex);
closeUnlocked();
m_errorString.clear();
m_file.setFileName(fileName);
if (!m_file.open(QIODevice::ReadOnly | QIODevice::ExistingOnly)) {
return failUnlocked(QStringLiteral("Unable to open audio file: %1").arg(m_file.errorString()));
}
const qint64 size = m_file.size();
if (size < 0) {
return failUnlocked(QStringLiteral("Unable to determine audio file size"));
}
const quint64 fileSize = static_cast<quint64>(size);
char signature[12] = {};
const bool hasSignature = (fileSize >= sizeof(signature)) && readExact(signature, sizeof(signature));
if (!m_file.seek(0)) {
return failUnlocked(QStringLiteral("Unable to seek in audio file"));
}
if (hasSignature &&
(chunkIdEquals(signature, "RIFF") || chunkIdEquals(signature, "RF64")) &&
chunkIdEquals(signature + 8, "WAVE"))
{
return openWavUnlocked(fileSize);
}
if (fileName.endsWith(QStringLiteral(".raw"), Qt::CaseInsensitive)) {
return openRawUnlocked(fileSize);
}
return failUnlocked(QStringLiteral("Audio file is neither WAV nor F32LE raw data"));
}
void AudioFileReader::close()
{
QMutexLocker locker(&m_mutex);
closeUnlocked();
}
void AudioFileReader::closeUnlocked()
{
if (m_file.isOpen()) {
m_file.close();
}
m_fileType = FileTypeNone;
m_wavFormat = 0;
m_channelCount = 0;
m_bitsPerSample = 0;
m_blockAlign = 0;
m_sampleRate = 0;
m_dataOffset = 0;
m_dataSize = 0;
m_frameCount = 0;
m_position = 0;
m_frameBuffer.clear();
}
bool AudioFileReader::failUnlocked(const QString& error)
{
m_errorString = error;
closeUnlocked();
return false;
}
bool AudioFileReader::readExact(char *data, qint64 size)
{
return m_file.read(data, size) == size;
}
bool AudioFileReader::openRawUnlocked(quint64 fileSize)
{
m_fileType = FileTypeRawFloat32;
m_wavFormat = WavFormatIEEEFloat;
m_channelCount = 1;
m_bitsPerSample = 32;
m_blockAlign = 4;
m_sampleRate = 48000;
m_dataOffset = 0;
m_dataSize = fileSize - (fileSize % m_blockAlign);
m_frameCount = m_dataSize / m_blockAlign;
m_position = 0;
m_frameBuffer.resize(m_blockAlign);
return true;
}
bool AudioFileReader::openWavUnlocked(quint64 fileSize)
{
char riffHeader[12];
if (!readExact(riffHeader, sizeof(riffHeader))) {
return failUnlocked(QStringLiteral("WAV file has an incomplete RIFF header"));
}
const bool rf64 = chunkIdEquals(riffHeader, "RF64");
bool haveFormat = false;
bool haveData = false;
quint64 rf64DataSize = 0;
quint64 dataOffset = 0;
quint64 dataSize = 0;
while (static_cast<quint64>(m_file.pos()) + 8 <= fileSize)
{
char chunkHeader[8];
if (!readExact(chunkHeader, sizeof(chunkHeader))) {
break;
}
const quint32 chunkSize = qFromLittleEndian<quint32>(chunkHeader + 4);
const quint64 payloadOffset = static_cast<quint64>(m_file.pos());
const quint64 payloadSize = chunkSize;
if (chunkIdEquals(chunkHeader, "ds64"))
{
uchar ds64[28];
if ((chunkSize < sizeof(ds64)) || !readExact(reinterpret_cast<char *>(ds64), sizeof(ds64))) {
return failUnlocked(QStringLiteral("WAV file has an invalid RF64 ds64 chunk"));
}
rf64DataSize = qFromLittleEndian<quint64>(ds64 + 8);
}
else if (chunkIdEquals(chunkHeader, "fmt "))
{
if (chunkSize < 16) {
return failUnlocked(QStringLiteral("WAV format chunk is too short"));
}
const quint32 formatBytes = std::min<quint32>(chunkSize, 40);
QByteArray formatData(formatBytes, 0);
if (!readExact(formatData.data(), formatBytes)) {
return failUnlocked(QStringLiteral("WAV format chunk is incomplete"));
}
const uchar *format = reinterpret_cast<const uchar *>(formatData.constData());
m_wavFormat = qFromLittleEndian<quint16>(format);
m_channelCount = qFromLittleEndian<quint16>(format + 2);
m_sampleRate = qFromLittleEndian<quint32>(format + 4);
m_blockAlign = qFromLittleEndian<quint16>(format + 12);
m_bitsPerSample = qFromLittleEndian<quint16>(format + 14);
if (m_wavFormat == WavFormatExtensible)
{
if (formatBytes < 40) {
return failUnlocked(QStringLiteral("WAV extensible format chunk is incomplete"));
}
// First two bytes of the sub-format GUID are the format code
m_wavFormat = qFromLittleEndian<quint16>(format + 24);
}
haveFormat = true;
}
else if (chunkIdEquals(chunkHeader, "data"))
{
dataOffset = payloadOffset;
dataSize = (rf64 && chunkSize == std::numeric_limits<quint32>::max()) ? rf64DataSize : chunkSize;
haveData = true;
}
if (haveFormat && haveData) {
break;
}
if (payloadSize > fileSize - std::min(payloadOffset, fileSize)) {
return failUnlocked(QStringLiteral("WAV chunk extends beyond the end of the file"));
}
// Chunks are padded to an even size
const quint64 nextChunk = payloadOffset + payloadSize + (payloadSize & 1U);
if ((nextChunk > fileSize) || !m_file.seek(static_cast<qint64>(nextChunk))) {
return failUnlocked(QStringLiteral("WAV chunk padding extends beyond the end of the file"));
}
}
if (!haveFormat || !haveData) {
return failUnlocked(QStringLiteral("WAV file is missing a format or data chunk"));
}
if ((m_wavFormat != WavFormatPCM) && (m_wavFormat != WavFormatIEEEFloat)) {
return failUnlocked(QStringLiteral("WAV encoding is not PCM or IEEE float"));
}
if ((m_channelCount < 1) || (m_channelCount > 2)) {
return failUnlocked(QStringLiteral("WAV file must contain one or two channels"));
}
if (m_sampleRate == 0) {
return failUnlocked(QStringLiteral("WAV file has an invalid sample rate"));
}
const bool validPCM = (m_wavFormat == WavFormatPCM) &&
((m_bitsPerSample == 8) || (m_bitsPerSample == 16) ||
(m_bitsPerSample == 24) || (m_bitsPerSample == 32));
const bool validFloat = (m_wavFormat == WavFormatIEEEFloat) &&
((m_bitsPerSample == 32) || (m_bitsPerSample == 64));
if (!validPCM && !validFloat) {
return failUnlocked(QStringLiteral("WAV sample size is unsupported"));
}
const quint16 bytesPerSample = m_bitsPerSample / 8;
const quint16 minimumBlockAlign = m_channelCount * bytesPerSample;
if (m_blockAlign < minimumBlockAlign) {
return failUnlocked(QStringLiteral("WAV block alignment is invalid"));
}
if (dataOffset > fileSize) {
return failUnlocked(QStringLiteral("WAV data offset is outside the file"));
}
dataSize = std::min(dataSize, fileSize - dataOffset);
dataSize -= dataSize % m_blockAlign;
m_fileType = FileTypeWav;
m_dataOffset = dataOffset;
m_dataSize = dataSize;
m_frameCount = dataSize / m_blockAlign;
m_position = 0;
m_frameBuffer.resize(m_blockAlign);
if (!m_file.seek(static_cast<qint64>(m_dataOffset))) {
return failUnlocked(QStringLiteral("Unable to seek to WAV data"));
}
return true;
}
bool AudioFileReader::readFrame(float& left, float& right)
{
QMutexLocker locker(&m_mutex);
if (!m_file.isOpen() || (m_position >= m_frameCount)) {
return false;
}
if (!readExact(m_frameBuffer.data(), m_blockAlign))
{
m_position = m_frameCount;
return false;
}
const uchar *frame = reinterpret_cast<const uchar *>(m_frameBuffer.constData());
const quint16 bytesPerSample = m_bitsPerSample / 8;
left = decodeSample(frame);
right = m_channelCount == 2 ? decodeSample(frame + bytesPerSample) : left;
++m_position;
return true;
}
float AudioFileReader::decodeSample(const uchar *data) const
{
if (m_wavFormat == WavFormatIEEEFloat)
{
if (m_bitsPerSample == 32)
{
const quint32 bits = qFromLittleEndian<quint32>(data);
float sample;
std::memcpy(&sample, &bits, sizeof(sample));
return std::isfinite(sample) ? sample : 0.0f;
}
const quint64 bits = qFromLittleEndian<quint64>(data);
double sample;
std::memcpy(&sample, &bits, sizeof(sample));
return std::isfinite(sample) ? static_cast<float>(sample) : 0.0f;
}
switch (m_bitsPerSample)
{
case 8:
return (static_cast<int>(data[0]) - 128) / 128.0f;
case 16:
return qFromLittleEndian<qint16>(data) / 32768.0f;
case 24:
{
qint32 sample = static_cast<qint32>(data[0]) |
(static_cast<qint32>(data[1]) << 8) |
(static_cast<qint32>(data[2]) << 16);
if (sample & 0x00800000) {
sample |= ~0x00ffffff;
}
return sample / 8388608.0f;
}
case 32:
return qFromLittleEndian<qint32>(data) / 2147483648.0f;
default:
return 0.0f;
}
}
bool AudioFileReader::seek(quint64 frameIndex)
{
QMutexLocker locker(&m_mutex);
return seekUnlocked(frameIndex);
}
bool AudioFileReader::seekUnlocked(quint64 frameIndex)
{
if (!m_file.isOpen()) {
return false;
}
frameIndex = std::min(frameIndex, m_frameCount);
const quint64 byteOffset = m_dataOffset + frameIndex * m_blockAlign;
if (!m_file.seek(static_cast<qint64>(byteOffset))) {
return false;
}
m_position = frameIndex;
return true;
}
bool AudioFileReader::isOpen() const
{
QMutexLocker locker(&m_mutex);
return m_file.isOpen();
}
bool AudioFileReader::atEnd() const
{
QMutexLocker locker(&m_mutex);
return !m_file.isOpen() || (m_position >= m_frameCount);
}
quint32 AudioFileReader::getSampleRate() const
{
QMutexLocker locker(&m_mutex);
return m_sampleRate;
}
quint16 AudioFileReader::getChannelCount() const
{
QMutexLocker locker(&m_mutex);
return m_channelCount;
}
quint64 AudioFileReader::getFrameCount() const
{
QMutexLocker locker(&m_mutex);
return m_frameCount;
}
quint64 AudioFileReader::getPosition() const
{
QMutexLocker locker(&m_mutex);
return m_position;
}
QString AudioFileReader::getErrorString() const
{
QMutexLocker locker(&m_mutex);
return m_errorString;
}