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.
469 lines
13 KiB
469 lines
13 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 "dabprofile.h" |
|
#include "util/reedsolomon.h" |
|
|
|
#include "dabaudioframing.h" |
|
#include "dabtables.h" |
|
|
|
namespace modemdab |
|
{ |
|
|
|
namespace |
|
{ |
|
|
|
// RS(120, 110, t = 5), shortened from RS(255, 245): generator roots alpha^0..alpha^9, |
|
// field polynomial x^8 + x^4 + x^3 + x^2 + 1 |
|
const ReedSolomon::RS<255, 245>& reedSolomon() |
|
{ |
|
static const ReedSolomon::RS<255, 245> rs; |
|
return rs; |
|
} |
|
|
|
// Bits read MSB first |
|
class BitReader |
|
{ |
|
public: |
|
BitReader(const uint8_t *data, int size, int bit) : m_data(data), m_bits(size * 8), m_bit(bit) {} |
|
|
|
bool read(int count, int& value) |
|
{ |
|
if (m_bit + count > m_bits) { |
|
return false; |
|
} |
|
value = 0; |
|
for (int i = 0; i < count; i++, m_bit++) { |
|
value = (value << 1) | ((m_data[m_bit >> 3] >> (7 - (m_bit & 7))) & 1); |
|
} |
|
return true; |
|
} |
|
int position() const { return m_bit; } |
|
|
|
private: |
|
const uint8_t *m_data; |
|
int m_bits; |
|
int m_bit; |
|
}; |
|
|
|
} // anonymous namespace |
|
|
|
bool DABPlusParameters::operator==(const DABPlusParameters& o) const |
|
{ |
|
return (dac48 == o.dac48) && (sbr == o.sbr) && (stereo == o.stereo) && (ps == o.ps) |
|
&& (mpegSurround == o.mpegSurround) && (numAUs == o.numAUs); |
|
} |
|
|
|
DABPlusFramer::DABPlusFramer() |
|
{ |
|
reset(); |
|
} |
|
|
|
void DABPlusFramer::reset() |
|
{ |
|
m_frames.clear(); |
|
m_framesLost.clear(); |
|
m_synchronized = false; |
|
m_phase = 0; |
|
m_failures = 0; |
|
m_parameters = DABPlusParameters(); |
|
m_superframes = 0; |
|
m_fireCodeErrors = 0; |
|
m_rsCorrected = 0; |
|
m_rsUncorrectable = 0; |
|
m_auCount = 0; |
|
m_auErrors = 0; |
|
} |
|
|
|
bool DABPlusFramer::decode(std::vector<uint8_t>& superframe, int& corrected, int& uncorrectable) const |
|
{ |
|
// The virtual interleaver: row i is bytes i, i + s, i + 2s... of the superframe |
|
const int s = static_cast<int>(superframe.size()) / 120; |
|
uint8_t codeword[120]; |
|
|
|
corrected = 0; |
|
uncorrectable = 0; |
|
for (int i = 0; i < s; i++) |
|
{ |
|
for (int j = 0; j < 120; j++) { |
|
codeword[j] = superframe[i + j * s]; |
|
} |
|
const int result = reedSolomon().decode(codeword, 110, codeword + 110); |
|
if (result < 0) |
|
{ |
|
uncorrectable++; |
|
} |
|
else if (result > 0) |
|
{ |
|
corrected += result; |
|
for (int j = 0; j < 110; j++) { |
|
superframe[i + j * s] = codeword[j]; |
|
} |
|
} |
|
} |
|
return uncorrectable == 0; |
|
} |
|
|
|
bool DABPlusFramer::parse(const std::vector<uint8_t>& superframe, DABPlusSuperframe& out) |
|
{ |
|
const int dataSize = static_cast<int>(superframe.size()) / 120 * 110; |
|
DABPlusParameters p; |
|
|
|
p.dac48 = (superframe[2] & 0x40) != 0; |
|
p.sbr = (superframe[2] & 0x20) != 0; |
|
p.stereo = (superframe[2] & 0x10) != 0; |
|
p.ps = (superframe[2] & 0x08) != 0; |
|
p.mpegSurround = superframe[2] & 0x07; |
|
|
|
int auStart[7]; |
|
if (p.sbr) { |
|
p.numAUs = p.dac48 ? 3 : 2; |
|
} else { |
|
p.numAUs = p.dac48 ? 6 : 4; |
|
} |
|
switch (p.numAUs) |
|
{ |
|
case 2: auStart[0] = 5; break; |
|
case 3: auStart[0] = 6; break; |
|
case 4: auStart[0] = 8; break; |
|
default: auStart[0] = 11; break; |
|
} |
|
for (int n = 1; n < p.numAUs; n++) |
|
{ |
|
const int byte = 3 + ((n - 1) * 3) / 2; |
|
if ((n & 1) == 1) { |
|
auStart[n] = (superframe[byte] << 4) | (superframe[byte + 1] >> 4); |
|
} else { |
|
auStart[n] = ((superframe[byte] & 0x0f) << 8) | superframe[byte + 1]; |
|
} |
|
} |
|
auStart[p.numAUs] = dataSize; |
|
|
|
out.parameters = p; |
|
out.accessUnits.clear(); |
|
for (int n = 0; n < p.numAUs; n++) |
|
{ |
|
DABAccessUnit au; |
|
const int start = auStart[n]; |
|
const int end = auStart[n + 1]; |
|
|
|
if ((start >= 0) && (end <= dataSize) && (end - start > 2)) |
|
{ |
|
au.valid = DABTables::crc16Check(&superframe[start], end - start); |
|
au.data.assign(superframe.begin() + start, superframe.begin() + end - 2); |
|
} |
|
m_auCount++; |
|
if (!au.valid) { |
|
m_auErrors++; |
|
} |
|
out.accessUnits.push_back(std::move(au)); |
|
} |
|
m_parameters = p; |
|
return true; |
|
} |
|
|
|
bool DABPlusFramer::push(const uint8_t *data, int size, DABPlusSuperframe& superframe) |
|
{ |
|
DABProfileScope profile(DABProfile::AudioFraming); |
|
if ((size <= 0) || (size % 3)) { |
|
return false; |
|
} |
|
if (data) { |
|
m_frames.emplace_back(data, data + size); |
|
} else { |
|
m_frames.emplace_back(size, 0); |
|
} |
|
m_framesLost.push_back(data == nullptr); |
|
|
|
if (m_frames.size() < 5) { |
|
return false; |
|
} |
|
while (m_frames.size() > 5) |
|
{ |
|
m_frames.pop_front(); |
|
m_framesLost.pop_front(); |
|
} |
|
|
|
// Superframe of 5 logical frames: 120 bytes for each 8 kbit/s |
|
std::vector<uint8_t> sf; |
|
bool lost = false; |
|
for (std::size_t i = 0; i < 5; i++) |
|
{ |
|
sf.insert(sf.end(), m_frames[i].begin(), m_frames[i].end()); |
|
lost = lost || m_framesLost[i]; |
|
} |
|
if (sf.size() % 120) { |
|
return false; |
|
} |
|
|
|
int corrected = 0; |
|
int uncorrectable = 0; |
|
|
|
if (!m_synchronized) |
|
{ |
|
// Find the superframe boundary: a valid Fire code, before or after correction |
|
bool found = !lost && DABTables::fireCodeCheck(sf.data()); |
|
if (!found && !lost) |
|
{ |
|
std::vector<uint8_t> copy = sf; |
|
decode(copy, corrected, uncorrectable); |
|
found = DABTables::fireCodeCheck(copy.data()); |
|
} |
|
if (!found) |
|
{ |
|
m_frames.pop_front(); |
|
m_framesLost.pop_front(); |
|
return false; |
|
} |
|
m_synchronized = true; |
|
m_failures = 0; |
|
} |
|
|
|
m_frames.clear(); |
|
m_framesLost.clear(); |
|
|
|
decode(sf, corrected, uncorrectable); |
|
m_rsCorrected += corrected; |
|
m_rsUncorrectable += uncorrectable; |
|
m_superframes++; |
|
|
|
superframe.rsCorrectedBytes = corrected; |
|
superframe.rsUncorrectableRows = uncorrectable; |
|
|
|
if (!DABTables::fireCodeCheck(sf.data())) |
|
{ |
|
// The header cannot be trusted: every AU of the superframe is lost |
|
m_fireCodeErrors++; |
|
if (!lost) { |
|
m_failures++; |
|
} |
|
if (m_failures >= 3) { |
|
m_synchronized = false; |
|
} |
|
superframe.parameters = m_parameters; |
|
superframe.accessUnits.assign(std::max(m_parameters.numAUs, 0), DABAccessUnit()); |
|
m_auCount += m_parameters.numAUs; |
|
m_auErrors += m_parameters.numAUs; |
|
return true; |
|
} |
|
|
|
m_failures = 0; |
|
return parse(sf, superframe); |
|
} |
|
|
|
bool DABPlusFramer::extractPAD(const std::vector<uint8_t>& au, const uint8_t *&pad, int& padLength) |
|
{ |
|
// data_stream_element(): id_syn_ele (3 bits, 4), element_instance_tag (4), |
|
// data_byte_align_flag (1), count (8), [esc_count (8)] |
|
if ((au.size() < 2) || ((au[0] >> 5) != 4)) { |
|
return false; |
|
} |
|
int count = au[1]; |
|
std::size_t position = 2; |
|
if (count == 255) |
|
{ |
|
if (au.size() < 3) { |
|
return false; |
|
} |
|
count += au[2]; |
|
position = 3; |
|
} |
|
if ((count < 2) || (position + count > au.size())) { |
|
return false; |
|
} |
|
pad = &au[position]; |
|
padLength = count; |
|
return true; |
|
} |
|
|
|
DABMP2Framer::DABMP2Framer() |
|
{ |
|
reset(); |
|
} |
|
|
|
void DABMP2Framer::reset() |
|
{ |
|
m_pending.clear(); |
|
m_pendingLost = false; |
|
m_frames = 0; |
|
m_crcErrors = 0; |
|
} |
|
|
|
bool DABMP2Framer::check(const uint8_t *data, int size, DABMP2Frame& frame) |
|
{ |
|
static const int bitratesMPEG1[16] = {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0}; |
|
static const int bitratesMPEG2[16] = {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0}; |
|
static const int ratesMPEG1[4] = {44100, 48000, 32000, 0}; |
|
static const int ratesMPEG2[4] = {22050, 24000, 16000, 0}; |
|
// Bits of the bit allocation of each sub-band (ISO/IEC 11172-3 tables B.2a and B.2c, |
|
// ISO/IEC 13818-3 table B.1) |
|
static const int tableA[27] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2}; |
|
static const int tableC[8] = {4, 4, 3, 3, 3, 3, 3, 3}; |
|
static const int tableLSF[30] = {4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; |
|
|
|
frame.valid = false; |
|
if (size < 8) { |
|
return false; |
|
} |
|
if ((data[0] != 0xff) || ((data[1] & 0xf0) != 0xf0)) { |
|
return false; |
|
} |
|
const bool mpeg1 = (data[1] & 0x08) != 0; |
|
const int layer = (data[1] >> 1) & 0x03; |
|
const bool protection = (data[1] & 0x01) == 0; |
|
const int bitrateIndex = data[2] >> 4; |
|
const int rateIndex = (data[2] >> 2) & 0x03; |
|
const int mode = data[3] >> 6; |
|
const int modeExtension = (data[3] >> 4) & 0x03; |
|
|
|
if ((layer != 2) || !protection) { |
|
return false; |
|
} |
|
|
|
frame.sampleRate = mpeg1 ? ratesMPEG1[rateIndex] : ratesMPEG2[rateIndex]; |
|
frame.bitrate = mpeg1 ? bitratesMPEG1[bitrateIndex] : bitratesMPEG2[bitrateIndex]; |
|
frame.channels = mode == 3 ? 1 : 2; |
|
if ((frame.sampleRate == 0) || (frame.bitrate == 0)) { |
|
return false; |
|
} |
|
|
|
const int *nbal; |
|
int sblimit; |
|
const int perChannel = frame.bitrate / frame.channels; |
|
|
|
if (!mpeg1) |
|
{ |
|
nbal = tableLSF; |
|
sblimit = 30; |
|
frame.scfCRCLength = 4; |
|
} |
|
else if (perChannel <= 48) |
|
{ |
|
nbal = tableC; |
|
sblimit = 8; |
|
frame.scfCRCLength = 2; |
|
} |
|
else |
|
{ |
|
nbal = tableA; |
|
sblimit = 27; |
|
frame.scfCRCLength = 4; |
|
} |
|
|
|
int bound = sblimit; |
|
if (mode == 1) { |
|
bound = std::min(sblimit, 4 * (modeExtension + 1)); |
|
} |
|
|
|
// The CRC covers the header from the bit rate index and the bit allocation and ScFSI |
|
BitReader reader(data, size, 48); |
|
int allocation[2][32] = {}; |
|
int value; |
|
|
|
for (int sb = 0; sb < sblimit; sb++) |
|
{ |
|
if (sb < bound) |
|
{ |
|
for (int ch = 0; ch < frame.channels; ch++) |
|
{ |
|
if (!reader.read(nbal[sb], allocation[ch][sb])) { |
|
return false; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if (!reader.read(nbal[sb], value)) { |
|
return false; |
|
} |
|
allocation[0][sb] = value; |
|
allocation[1][sb] = value; |
|
} |
|
} |
|
for (int sb = 0; sb < sblimit; sb++) |
|
{ |
|
for (int ch = 0; ch < frame.channels; ch++) |
|
{ |
|
if (allocation[ch][sb] && !reader.read(2, value)) { |
|
return false; |
|
} |
|
} |
|
} |
|
|
|
uint16_t crc = DABTables::crc16MPEG(data, 16, 16); |
|
crc = DABTables::crc16MPEG(data, 48, reader.position() - 48, crc); |
|
frame.valid = crc == static_cast<uint16_t>((data[4] << 8) | data[5]); |
|
return frame.valid; |
|
} |
|
|
|
bool DABMP2Framer::push(const uint8_t *data, int size, int bitrate, DABMP2Frame& frame) |
|
{ |
|
DABProfileScope profile(DABProfile::AudioFraming); |
|
(void) bitrate; |
|
|
|
if (!data) |
|
{ |
|
// The frame this was part of is lost |
|
if (!m_pending.empty()) { |
|
m_pending.clear(); |
|
} |
|
m_pendingLost = true; |
|
return false; |
|
} |
|
|
|
if (!m_pending.empty()) |
|
{ |
|
// Second half of a 24 kHz (MPEG-2 LSF) frame |
|
frame.data = m_pending; |
|
frame.data.insert(frame.data.end(), data, data + size); |
|
m_pending.clear(); |
|
check(frame.data.data(), static_cast<int>(frame.data.size()), frame); |
|
m_frames++; |
|
if (!frame.valid) { |
|
m_crcErrors++; |
|
} |
|
return true; |
|
} |
|
|
|
const bool sync = (size >= 4) && (data[0] == 0xff) && ((data[1] & 0xf0) == 0xf0); |
|
if (sync && ((data[1] & 0x08) == 0)) |
|
{ |
|
// 24 kHz: the frame continues in the next logical frame |
|
m_pending.assign(data, data + size); |
|
m_pendingLost = false; |
|
return false; |
|
} |
|
if (!sync && m_pendingLost) |
|
{ |
|
// The second half of a frame whose first half was lost |
|
m_pendingLost = false; |
|
return false; |
|
} |
|
|
|
frame.data.assign(data, data + size); |
|
check(frame.data.data(), size, frame); |
|
m_frames++; |
|
if (!frame.valid) { |
|
m_crcErrors++; |
|
} |
|
return true; |
|
} |
|
|
|
} // namespace modemdab
|
|
|