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.
 
 
 
 
 
 

1702 lines
52 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 "dabensemble.h"
namespace modemdab
{
namespace
{
inline uint32_t readSId(const uint8_t *p, bool longForm)
{
if (longForm) {
return (static_cast<uint32_t>(p[0]) << 24) | (static_cast<uint32_t>(p[1]) << 16) | (static_cast<uint32_t>(p[2]) << 8) | p[3];
}
return (static_cast<uint32_t>(p[0]) << 8) | p[1];
}
// Split a label into characters (byte ranges) for its character set, to apply character flags.
std::vector<std::pair<int, int>> labelCharacters(const uint8_t *data, int length, int charset)
{
std::vector<std::pair<int, int>> chars;
int i = 0;
while (i < length)
{
int size = 1;
if (charset == 6)
{
size = 2;
}
else if (charset == 15)
{
const uint8_t c = data[i];
if ((c & 0xe0) == 0xc0) {
size = 2;
} else if ((c & 0xf0) == 0xe0) {
size = 3;
} else if ((c & 0xf8) == 0xf0) {
size = 4;
}
}
if (i + size > length) {
break;
}
chars.emplace_back(i, size);
i += size;
}
return chars;
}
std::string shortLabel(const uint8_t *data, int length, int charset, uint16_t flags)
{
std::vector<std::pair<int, int>> chars = labelCharacters(data, length, charset);
std::vector<uint8_t> selected;
for (std::size_t i = 0; (i < chars.size()) && (i < 16); i++)
{
if (flags & (0x8000 >> i)) {
selected.insert(selected.end(), data + chars[i].first, data + chars[i].first + chars[i].second);
}
}
return DABTables::labelToUTF8(selected.data(), selected.size(), charset);
}
} // anonymous namespace
DABFICDecoder::DABFICDecoder() :
m_profile(DABTables::ficProfile())
{
}
int DABFICDecoder::decodeBlock(
const float *soft,
std::array<std::array<uint8_t, ModeI::FIBBytes>, ModeI::FIBsPerCIF>& fibs,
std::array<bool, ModeI::FIBsPerCIF>& valid,
int& bitErrors,
int& codedBits
)
{
DABProfileScope profile(DABProfile::FIC);
bitErrors = 0;
codedBits = 0;
m_viterbi.decodePunctured(soft, ModeI::FICBlockBits, m_profile, m_bits, &bitErrors, &codedBits);
const std::vector<uint8_t>& prbs = DABTables::prbs();
int good = 0;
for (int f = 0; f < ModeI::FIBsPerCIF; f++)
{
for (int i = 0; i < ModeI::FIBBytes; i++)
{
uint8_t byte = 0;
for (int b = 0; b < 8; b++)
{
const int index = (f * ModeI::FIBBytes + i) * 8 + b;
byte = static_cast<uint8_t>((byte << 1) | ((m_bits[index] ^ prbs[index]) & 1));
}
fibs[f][i] = byte;
}
valid[f] = DABTables::crc16Check(fibs[f].data(), ModeI::FIBBytes);
if (valid[f]) {
good++;
}
}
return good;
}
ProtectionProfile DABSubchannel::profile() const
{
if (uep) {
return DABTables::uepProfile(tableIndex);
}
return DABTables::eepProfile(eepSetB, protectionLevel - 1, sizeCU);
}
std::string DABSubchannel::protection() const
{
if (uep) {
return "UEP " + std::to_string(protectionLevel);
}
return "EEP " + std::to_string(protectionLevel) + (eepSetB ? "-B" : "-A");
}
bool DABSubchannel::operator==(const DABSubchannel& other) const
{
return (id == other.id) && (startCU == other.startCU) && (sizeCU == other.sizeCU)
&& (uep == other.uep) && (tableIndex == other.tableIndex) && (eepSetB == other.eepSetB)
&& (protectionLevel == other.protectionLevel) && (bitrate == other.bitrate)
&& (fecScheme == other.fecScheme);
}
const DABServiceComponent *DABService::primaryComponent() const
{
for (const auto& component : components)
{
if (component.primary) {
return &component;
}
}
return components.empty() ? nullptr : &components[0];
}
void DABDateTime::date(int& year, int& month, int& day) const
{
// ETSI EN 300 468 annex C
const int yp = static_cast<int>((mjd - 15078.2) / 365.25);
const int mp = static_cast<int>((mjd - 14956.1 - static_cast<int>(yp * 365.25)) / 30.6001);
day = mjd - 14956 - static_cast<int>(yp * 365.25) - static_cast<int>(mp * 30.6001);
const int k = ((mp == 14) || (mp == 15)) ? 1 : 0;
year = 1900 + yp + k;
month = mp - 1 - k * 12;
}
DABEnsemble::DABEnsemble() :
m_cifs(0),
m_version(0),
m_lastCIFCount(-1),
m_cifCountUpdated(false)
{
}
void DABEnsemble::reset()
{
m_current = MCI();
m_next = MCI();
m_info = DABEnsembleInfo();
m_ensembleLabel = Label();
m_serviceLabels.clear();
m_componentLabels.clear();
m_programmeTypes.clear();
m_subchannelLanguages.clear();
m_scidLanguages.clear();
m_serviceECCs.clear();
m_extendedLabels.clear();
m_announcementSupport.clear();
m_announcements.clear();
m_announcementLastCIF.clear();
m_linkageSets.clear();
m_frequencies.clear();
m_oeServices.clear();
m_lastCIFCount = -1;
m_cifCountUpdated = false;
changed();
}
void DABEnsemble::processFIB(const uint8_t *fib)
{
int pos = 0;
while (pos < ModeI::FIBDataBytes)
{
const uint8_t header = fib[pos];
if (header == 0xff) {
break; // End marker
}
const int type = header >> 5;
const int length = header & 0x1f;
pos++;
if ((length == 0) || (pos + length > ModeI::FIBDataBytes)) {
break;
}
switch (type)
{
case 0:
fig0(&fib[pos], length);
break;
case 1:
fig1(&fib[pos], length);
break;
case 2:
fig2(&fib[pos], length);
break;
default:
break;
}
pos += length;
}
}
void DABEnsemble::cif(int cifCount)
{
// An announcement is signalled at least once a second while it lasts, and its end ten
// times a second for two seconds: one not heard of for a while has ended unseen
m_cifs++;
for (auto it = m_announcementLastCIF.begin(); it != m_announcementLastCIF.end();)
{
if (m_cifs - it->second > AnnouncementTimeoutCIFs)
{
m_announcements.erase(it->first);
it = m_announcementLastCIF.erase(it);
changed();
}
else
{
++it;
}
}
// Switch to the next configuration at the CIF given by the occurrence change
if ((m_info.changeFlags != 0) && (m_info.occurrenceChange >= 0) && !m_next.empty())
{
if ((cifCount % 250) == m_info.occurrenceChange)
{
// Information not repeated for the next configuration is carried over
MCI next = m_next;
if (next.subchannels.empty()) {
next.subchannels = m_current.subchannels;
}
if (next.services.empty()) {
next.services = m_current.services;
}
for (const auto& p : m_current.packetComponents) {
next.packetComponents.insert(p);
}
for (const auto& g : m_current.globalDefinitions) {
next.globalDefinitions.insert(g);
}
for (const auto& u : m_current.userApplications) {
next.userApplications.insert(u);
}
for (const auto& f : m_current.fecSchemes) {
next.fecSchemes.insert(f);
}
m_current = next;
m_next = MCI();
m_info.changeFlags = 0;
m_info.occurrenceChange = -1;
changed();
}
}
}
void DABEnsemble::fig0(const uint8_t *data, int length)
{
const bool next = (data[0] & 0x80) != 0;
const bool oe = (data[0] & 0x40) != 0;
const bool pd = (data[0] & 0x20) != 0;
const int extension = data[0] & 0x1f;
const uint8_t *field = data + 1;
const int fieldLength = length - 1;
if (fieldLength <= 0) {
return;
}
switch (extension)
{
case 0:
fig0_0(field, fieldLength);
break;
case 1:
fig0_1(field, fieldLength, next);
break;
case 2:
fig0_2(field, fieldLength, next, pd);
break;
case 3:
fig0_3(field, fieldLength, next);
break;
case 5:
fig0_5(field, fieldLength);
break;
case 7:
fig0_7(field, fieldLength);
break;
case 8:
fig0_8(field, fieldLength, next, pd);
break;
case 9:
fig0_9(field, fieldLength);
break;
case 10:
fig0_10(field, fieldLength);
break;
case 13:
fig0_13(field, fieldLength, next, pd);
break;
case 14:
fig0_14(field, fieldLength, next);
break;
case 17:
if (!oe) {
fig0_17(field, fieldLength);
}
break;
case 6:
fig0_6(field, fieldLength, next, pd);
break;
case 18:
fig0_18(field, fieldLength);
break;
case 19:
fig0_19(field, fieldLength);
break;
case 21:
fig0_21(field, fieldLength, next, oe);
break;
case 24:
fig0_24(field, fieldLength, next, oe, pd);
break;
default:
break;
}
}
// Ensemble information
void DABEnsemble::fig0_0(const uint8_t *data, int length)
{
if (length < 4) {
return;
}
const int eid = (data[0] << 8) | data[1];
const int changeFlags = data[2] >> 6;
const bool alarm = (data[2] & 0x20) != 0;
const int cifCount = ((data[2] & 0x1f) * 250) + data[3];
if (eid != m_info.eid)
{
// Another ensemble (a retune): nothing from the previous one applies
if (m_info.eid >= 0) {
reset();
}
m_info.eid = eid;
changed();
}
m_info.alarm = alarm;
m_info.changeFlags = changeFlags;
if ((changeFlags != 0) && (length >= 5)) {
m_info.occurrenceChange = data[4];
} else if (changeFlags == 0) {
m_info.occurrenceChange = -1;
}
if ((data[2] & 0x1f) < 20 && data[3] < 250)
{
m_lastCIFCount = cifCount;
m_cifCountUpdated = true;
}
}
// Sub-channel organization
void DABEnsemble::fig0_1(const uint8_t *data, int length, bool next)
{
MCI& m = mci(next);
int pos = 0;
while (pos + 3 <= length)
{
DABSubchannel sc;
sc.id = data[pos] >> 2;
sc.startCU = ((data[pos] & 0x03) << 8) | data[pos + 1];
const bool longForm = (data[pos + 2] & 0x80) != 0;
if (!longForm)
{
const bool tableSwitch = (data[pos + 2] & 0x40) != 0;
sc.uep = true;
sc.tableIndex = data[pos + 2] & 0x3f;
pos += 3;
UEPTableEntry entry;
if (tableSwitch || !DABTables::uepTableEntry(sc.tableIndex, entry)) {
continue;
}
sc.sizeCU = entry.sizeCU;
sc.protectionLevel = entry.protectionLevel;
sc.bitrate = entry.bitrate;
}
else
{
if (pos + 4 > length) {
break;
}
const int option = (data[pos + 2] >> 4) & 0x07;
const int level = (data[pos + 2] >> 2) & 0x03;
sc.uep = false;
sc.sizeCU = ((data[pos + 2] & 0x03) << 8) | data[pos + 3];
pos += 4;
if (option > 1) {
continue;
}
sc.eepSetB = option == 1;
sc.protectionLevel = level + 1;
sc.bitrate = DABTables::eepBitrate(sc.eepSetB, level, sc.sizeCU);
if (sc.bitrate <= 0) {
continue;
}
}
if (sc.startCU + sc.sizeCU > ModeI::CUsPerCIF) {
continue;
}
auto fec = m.fecSchemes.find(sc.id);
if (fec != m.fecSchemes.end()) {
sc.fecScheme = fec->second;
}
auto it = m.subchannels.find(sc.id);
if ((it == m.subchannels.end()) || !(it->second == sc))
{
m.subchannels[sc.id] = sc;
if (!next) {
changed();
}
}
}
}
// Basic service and service component definition
void DABEnsemble::fig0_2(const uint8_t *data, int length, bool next, bool pd)
{
MCI& m = mci(next);
const int sidLength = pd ? 4 : 2;
int pos = 0;
while (pos + sidLength + 1 <= length)
{
const uint32_t sid = readSId(&data[pos], pd);
pos += sidLength;
const int caId = (data[pos] >> 4) & 0x07;
const int count = data[pos] & 0x0f;
pos++;
if (pos + 2 * count > length) {
break;
}
ServiceDescription service;
service.dataService = pd;
service.caId = caId;
for (int i = 0; i < count; i++, pos += 2)
{
ComponentDescription c;
c.transport = data[pos] >> 6;
c.primary = (data[pos + 1] & 0x02) != 0;
c.ca = (data[pos + 1] & 0x01) != 0;
c.subchannelId = -1;
c.scid = -1;
c.type = -1;
if ((c.transport == DABServiceComponent::StreamAudio) || (c.transport == DABServiceComponent::StreamData))
{
c.type = data[pos] & 0x3f;
c.subchannelId = data[pos + 1] >> 2;
}
else if (c.transport == DABServiceComponent::PacketData)
{
c.scid = ((data[pos] & 0x3f) << 6) | (data[pos + 1] >> 2);
}
else
{
continue;
}
service.components.push_back(c);
}
auto it = m.services.find(sid);
bool same = (it != m.services.end()) && (it->second.components.size() == service.components.size())
&& (it->second.caId == service.caId);
if (same)
{
for (std::size_t i = 0; i < service.components.size(); i++)
{
const ComponentDescription& a = it->second.components[i];
const ComponentDescription& b = service.components[i];
if ((a.transport != b.transport) || (a.type != b.type) || (a.subchannelId != b.subchannelId)
|| (a.scid != b.scid) || (a.primary != b.primary) || (a.ca != b.ca))
{
same = false;
break;
}
}
}
if (!same)
{
m.services[sid] = service;
if (!next) {
changed();
}
}
}
}
// Service component in packet mode
void DABEnsemble::fig0_3(const uint8_t *data, int length, bool next)
{
MCI& m = mci(next);
int pos = 0;
while (pos + 5 <= length)
{
const int scid = (data[pos] << 4) | (data[pos + 1] >> 4);
const bool caOrg = (data[pos + 1] & 0x01) != 0;
PacketComponent pc;
pc.dataGroups = (data[pos + 2] & 0x80) == 0;
pc.dscty = data[pos + 2] & 0x3f;
pc.subchannelId = data[pos + 3] >> 2;
pc.packetAddress = ((data[pos + 3] & 0x03) << 8) | data[pos + 4];
pos += 5 + (caOrg ? 2 : 0);
auto it = m.packetComponents.find(scid);
if ((it == m.packetComponents.end()) || (it->second.subchannelId != pc.subchannelId)
|| (it->second.packetAddress != pc.packetAddress) || (it->second.dscty != pc.dscty)
|| (it->second.dataGroups != pc.dataGroups))
{
m.packetComponents[scid] = pc;
if (!next) {
changed();
}
}
}
}
// Service component language
void DABEnsemble::fig0_5(const uint8_t *data, int length)
{
int pos = 0;
while (pos + 2 <= length)
{
const bool longForm = (data[pos] & 0x80) != 0;
if (!longForm)
{
const int subchannel = data[pos] & 0x3f;
const int language = data[pos + 1];
if (m_subchannelLanguages[subchannel] != language)
{
m_subchannelLanguages[subchannel] = language;
changed();
}
pos += 2;
}
else
{
if (pos + 3 > length) {
break;
}
const int scid = ((data[pos] & 0x0f) << 8) | data[pos + 1];
const int language = data[pos + 2];
if (m_scidLanguages[scid] != language)
{
m_scidLanguages[scid] = language;
changed();
}
pos += 3;
}
}
}
// Configuration information
void DABEnsemble::fig0_7(const uint8_t *data, int length)
{
if (length < 2) {
return;
}
m_info.servicesInConfiguration = data[0] >> 2;
m_info.reconfigurationCount = ((data[0] & 0x03) << 8) | data[1];
}
// Service component global definition
void DABEnsemble::fig0_8(const uint8_t *data, int length, bool next, bool pd)
{
MCI& m = mci(next);
const int sidLength = pd ? 4 : 2;
int pos = 0;
while (pos + sidLength + 2 <= length)
{
const uint32_t sid = readSId(&data[pos], pd);
pos += sidLength;
const bool extension = (data[pos] & 0x80) != 0;
const int scids = data[pos] & 0x0f;
pos++;
GlobalDefinition gd;
gd.longForm = (data[pos] & 0x80) != 0;
gd.subchannelId = -1;
gd.scid = -1;
if (!gd.longForm)
{
gd.subchannelId = data[pos] & 0x3f;
pos++;
}
else
{
if (pos + 2 > length) {
break;
}
gd.scid = ((data[pos] & 0x0f) << 8) | data[pos + 1];
pos += 2;
}
if (extension) {
pos++;
}
const auto key = std::make_pair(sid, scids);
auto it = m.globalDefinitions.find(key);
if ((it == m.globalDefinitions.end()) || (it->second.subchannelId != gd.subchannelId) || (it->second.scid != gd.scid))
{
m.globalDefinitions[key] = gd;
if (!next) {
changed();
}
}
}
}
// Country, LTO and international table
void DABEnsemble::fig0_9(const uint8_t *data, int length)
{
if (length < 3) {
return;
}
const bool extended = (data[0] & 0x80) != 0;
const int lto = (data[0] & 0x1f) * ((data[0] & 0x20) ? -1 : 1);
const int ecc = data[1];
const int table = data[2];
if (!m_info.haveLTO || (m_info.ltoHalfHours != lto) || (m_info.ecc != ecc) || (m_info.internationalTable != table))
{
m_info.haveLTO = true;
m_info.ltoHalfHours = lto;
m_info.ecc = ecc;
m_info.internationalTable = table;
changed();
}
if (extended)
{
int pos = 3;
while (pos + 2 <= length)
{
const int count = data[pos] >> 6;
const int serviceECC = data[pos + 1];
pos += 2;
for (int i = 0; (i < count) && (pos + 2 <= length); i++, pos += 2)
{
const uint32_t sid = readSId(&data[pos], false);
m_serviceECCs[sid] = serviceECC;
}
}
}
}
// Date and time
void DABEnsemble::fig0_10(const uint8_t *data, int length)
{
if (length < 4) {
return;
}
DABDateTime t;
t.mjd = ((data[0] & 0x7f) << 10) | (data[1] << 2) | (data[2] >> 6);
const bool utcLong = (data[2] & 0x08) != 0;
t.hours = ((data[2] & 0x07) << 2) | (data[3] >> 6);
t.minutes = data[3] & 0x3f;
if (utcLong && (length >= 6))
{
t.seconds = data[4] >> 2;
t.milliseconds = ((data[4] & 0x03) << 8) | data[5];
}
t.valid = (t.hours < 24) && (t.minutes < 60) && (t.seconds < 60);
if (t.valid) {
m_info.time = t;
}
}
// User application information
void DABEnsemble::fig0_13(const uint8_t *data, int length, bool next, bool pd)
{
MCI& m = mci(next);
const int sidLength = pd ? 4 : 2;
int pos = 0;
while (pos + sidLength + 1 <= length)
{
const uint32_t sid = readSId(&data[pos], pd);
pos += sidLength;
const int scids = data[pos] >> 4;
const int count = data[pos] & 0x0f;
pos++;
std::vector<DABUserApplication> applications;
for (int i = 0; (i < count) && (pos + 2 <= length); i++)
{
DABUserApplication ua;
ua.type = (data[pos] << 3) | (data[pos + 1] >> 5);
const int dataLength = data[pos + 1] & 0x1f;
pos += 2;
if (pos + dataLength > length) {
break;
}
ua.data.assign(&data[pos], &data[pos] + dataLength);
pos += dataLength;
applications.push_back(ua);
}
const auto key = std::make_pair(sid, scids);
auto it = m.userApplications.find(key);
bool same = (it != m.userApplications.end()) && (it->second.size() == applications.size());
if (same)
{
for (std::size_t i = 0; i < applications.size(); i++)
{
if ((applications[i].type != it->second[i].type) || (applications[i].data != it->second[i].data)) {
same = false;
}
}
}
if (!same)
{
m.userApplications[key] = applications;
if (!next) {
changed();
}
}
}
}
// FEC sub-channel organization
void DABEnsemble::fig0_14(const uint8_t *data, int length, bool next)
{
MCI& m = mci(next);
for (int pos = 0; pos < length; pos++)
{
const int id = data[pos] >> 2;
const int fec = data[pos] & 0x03;
if (m.fecSchemes[id] != fec)
{
m.fecSchemes[id] = fec;
auto it = m.subchannels.find(id);
if (it != m.subchannels.end()) {
it->second.fecScheme = fec;
}
if (!next) {
changed();
}
}
}
}
// Programme type
void DABEnsemble::fig0_17(const uint8_t *data, int length)
{
int pos = 0;
while (pos + 4 <= length)
{
const uint32_t sid = readSId(&data[pos], false);
const bool dynamic = (data[pos + 2] & 0x80) != 0;
// Earlier revisions had language and complementary code flags here
const bool languageFlag = (data[pos + 2] & 0x20) != 0;
const bool complementaryFlag = (data[pos + 2] & 0x10) != 0;
int codePos = pos + 3 + (languageFlag ? 1 : 0);
if (codePos >= length) {
break;
}
const int pty = data[codePos] & 0x1f;
pos = codePos + 1 + (complementaryFlag ? 1 : 0);
auto it = m_programmeTypes.find(sid);
if ((it == m_programmeTypes.end()) || (it->second.first != pty) || (it->second.second != dynamic))
{
m_programmeTypes[sid] = std::make_pair(pty, dynamic);
changed();
}
}
}
void DABEnsemble::setLabel(int extension, const uint8_t *id, int idLength, const std::string& label, const std::string& shortLabel, bool extended)
{
Label *target = nullptr;
switch (extension)
{
case 0:
if (idLength >= 2) {
target = &m_ensembleLabel;
}
break;
case 1:
if (idLength >= 2) {
target = &m_serviceLabels[readSId(id, false)];
}
break;
case 4:
if (idLength >= 1)
{
const bool pd = (id[0] & 0x80) != 0;
const int scids = id[0] & 0x0f;
if (idLength >= 1 + (pd ? 4 : 2)) {
target = &m_componentLabels[std::make_pair(readSId(id + 1, pd), scids)];
}
}
break;
case 5:
if (idLength >= 4) {
target = &m_serviceLabels[readSId(id, true)];
}
break;
default:
break;
}
if (!target) {
return;
}
// A FIG 2 label is preferred to the FIG 1 label
if (target->extended && !extended) {
return;
}
if ((target->label != label) || (target->shortLabel != shortLabel))
{
target->label = label;
target->shortLabel = shortLabel;
target->extended = extended;
if (extension == 0)
{
m_info.label = label;
m_info.shortLabel = shortLabel;
}
changed();
}
}
static int labelIdentifierLength(int extension, const uint8_t *data, int length)
{
switch (extension)
{
case 0:
case 1:
return 2;
case 4:
return length >= 1 ? ((data[0] & 0x80) ? 5 : 3) : -1;
case 5:
return 4;
default:
return -1;
}
}
// Labels
void DABEnsemble::fig1(const uint8_t *data, int length)
{
const int charset = data[0] >> 4;
const int extension = data[0] & 0x07;
const uint8_t *id = data + 1;
const int idLength = labelIdentifierLength(extension, id, length - 1);
if ((idLength < 0) || (1 + idLength + 16 + 2 > length)) {
return;
}
const uint8_t *chars = id + idLength;
const uint16_t flags = static_cast<uint16_t>((chars[16] << 8) | chars[17]);
std::string label = DABTables::labelToUTF8(chars, 16, charset);
std::string shortText = shortLabel(chars, 16, charset, flags);
// Labels are padded with spaces to 16 characters
while (!label.empty() && (label.back() == ' ')) {
label.pop_back();
}
setLabel(extension, id, idLength, label, shortText, false);
}
// Extended labels
void DABEnsemble::fig2(const uint8_t *data, int length)
{
const int toggle = data[0] >> 7;
const int segmentIndex = (data[0] >> 4) & 0x07;
const int extension = data[0] & 0x07;
const uint8_t *id = data + 1;
const int idLength = labelIdentifierLength(extension, id, length - 1);
if ((idLength < 0) || (1 + idLength > length)) {
return;
}
uint32_t key = 0;
for (int i = 0; i < idLength; i++) {
key = (key << 8) ^ id[i];
}
ExtendedLabelSegments& label = m_extendedLabels[std::make_pair(extension, key)];
if (label.toggle != toggle)
{
label = ExtendedLabelSegments();
label.toggle = toggle;
}
const uint8_t *segment = id + idLength;
const int segmentLength = length - 1 - idLength;
label.segments[segmentIndex].assign(segment, segment + segmentLength);
label.received[segmentIndex] = true;
if (!label.received[0] || label.segments[0].size() < 3) {
return;
}
const int count = ((label.segments[0][0] >> 4) & 0x07) + 1;
for (int i = 0; i < count; i++)
{
if (!label.received[i]) {
return;
}
}
std::vector<uint8_t> field;
for (int i = 0; i < count; i++) {
field.insert(field.end(), label.segments[i].begin(), label.segments[i].end());
}
if (field.size() < 3) {
return;
}
const bool ucs2 = (field[0] & 0x80) != 0;
const uint16_t flags = static_cast<uint16_t>((field[1] << 8) | field[2]);
const int charset = ucs2 ? 6 : 15;
const uint8_t *chars = field.data() + 3;
const int charsLength = static_cast<int>(field.size()) - 3;
setLabel(extension, id, idLength, DABTables::labelToUTF8(chars, charsLength, charset),
shortLabel(chars, charsLength, charset, flags), true);
}
bool DABEnsemble::northAmericanPTy() const
{
return m_info.internationalTable == 2;
}
bool DABEnsemble::subchannel(int id, DABSubchannel& subchannel) const
{
auto it = m_current.subchannels.find(id);
if (it == m_current.subchannels.end()) {
return false;
}
subchannel = it->second;
return true;
}
std::vector<DABSubchannel> DABEnsemble::subchannels() const
{
std::vector<DABSubchannel> list;
for (const auto& s : m_current.subchannels) {
list.push_back(s.second);
}
return list;
}
bool DABEnsemble::service(uint32_t sid, DABService& service) const
{
for (const auto& s : services())
{
if (s.sid == sid)
{
service = s;
return true;
}
}
return false;
}
std::vector<DABService> DABEnsemble::services() const
{
std::vector<DABService> list;
for (const auto& entry : m_current.services)
{
const uint32_t sid = entry.first;
const ServiceDescription& description = entry.second;
DABService service;
service.sid = sid;
service.dataService = description.dataService;
service.caId = description.caId;
auto label = m_serviceLabels.find(sid);
if (label != m_serviceLabels.end())
{
service.label = label->second.label;
service.shortLabel = label->second.shortLabel;
}
auto pty = m_programmeTypes.find(sid);
if (pty != m_programmeTypes.end())
{
service.pty = pty->second.first;
service.ptyDynamic = pty->second.second;
}
if (description.dataService)
{
service.ecc = static_cast<int>(sid >> 24);
}
else
{
auto ecc = m_serviceECCs.find(sid);
service.ecc = ecc != m_serviceECCs.end() ? ecc->second : m_info.ecc;
}
for (const auto& cd : description.components)
{
DABServiceComponent c;
c.transport = cd.transport;
c.primary = cd.primary;
c.ca = cd.ca;
c.subchannelId = cd.subchannelId;
c.scid = cd.scid;
if (cd.transport == DABServiceComponent::StreamAudio) {
c.ascty = cd.type;
} else if (cd.transport == DABServiceComponent::StreamData) {
c.dscty = cd.type;
}
if (cd.transport == DABServiceComponent::PacketData)
{
auto pc = m_current.packetComponents.find(cd.scid);
if (pc != m_current.packetComponents.end())
{
c.subchannelId = pc->second.subchannelId;
c.packetAddress = pc->second.packetAddress;
c.dscty = pc->second.dscty;
c.dataGroups = pc->second.dataGroups;
}
}
// SCIdS: 0 for the primary component, otherwise from FIG 0/8
if (cd.primary) {
c.scids = 0;
}
for (const auto& gd : m_current.globalDefinitions)
{
if (gd.first.first != sid) {
continue;
}
const bool match = gd.second.longForm
? ((cd.transport == DABServiceComponent::PacketData) && (gd.second.scid == cd.scid))
: ((cd.transport != DABServiceComponent::PacketData) && (gd.second.subchannelId == cd.subchannelId));
if (match)
{
c.scids = gd.first.second;
break;
}
}
if (c.scids >= 0)
{
auto ua = m_current.userApplications.find(std::make_pair(sid, c.scids));
if (ua != m_current.userApplications.end())
{
for (DABUserApplication app : ua->second)
{
// Applications of audio components are in the X-PAD, with an X-PAD header
if (c.isAudio() && (app.data.size() >= 2))
{
app.xpad = true;
const bool caOrg = (app.data[0] & 0x40) != 0;
app.xpadAppType = app.data[0] & 0x1f;
app.dataGroups = (app.data[1] & 0x80) == 0;
app.dscty = app.data[1] & 0x3f;
const std::size_t skip = 2 + (caOrg ? 2 : 0);
app.data.erase(app.data.begin(), app.data.begin() + std::min(skip, app.data.size()));
}
else
{
app.dscty = c.dscty;
app.dataGroups = c.dataGroups;
}
c.userApplications.push_back(app);
}
}
auto cl = m_componentLabels.find(std::make_pair(sid, c.scids));
if (cl != m_componentLabels.end()) {
c.label = cl->second.label;
}
}
if (c.transport == DABServiceComponent::PacketData)
{
auto lang = m_scidLanguages.find(c.scid);
if (lang != m_scidLanguages.end()) {
c.language = lang->second;
}
}
else
{
auto lang = m_subchannelLanguages.find(c.subchannelId);
if (lang != m_subchannelLanguages.end()) {
c.language = lang->second;
}
}
service.components.push_back(c);
}
// Primary component first
std::stable_sort(service.components.begin(), service.components.end(),
[](const DABServiceComponent& a, const DABServiceComponent& b) { return a.primary && !b.primary; });
list.push_back(service);
}
return list;
}
int DABAnnouncementSwitch::type() const
{
for (int bit = 0; bit < 16; bit++)
{
if (flags & (1U << bit)) {
return bit;
}
}
return -1;
}
// Service linking (clause 8.1.15). The first Id of a set's database is the key service, a
// service of this ensemble; the Id list qualifier applies to the others.
void DABEnsemble::fig0_6(const uint8_t *data, int length, bool cn, bool pd)
{
int pos = 0;
while (pos + 2 <= length)
{
const bool idList = (data[pos] & 0x80) != 0;
const bool active = (data[pos] & 0x40) != 0;
const bool hard = (data[pos] & 0x20) != 0;
const bool international = (data[pos] & 0x10) != 0;
const int lsn = ((data[pos] & 0x0f) << 8) | data[pos + 1];
pos += 2;
const LinkageKey key{pd, hard, international, lsn};
if (!idList)
{
// Change event indication: the set is being changed
if (m_linkageSets.erase(key) > 0) {
changed();
}
continue;
}
if (pos >= length) {
return;
}
const int idlq = (data[pos] >> 5) & 0x03;
const int count = data[pos] & 0x0f;
pos++;
const int idSize = pd ? 4 : (international ? 3 : 2);
if (pos + count * idSize > length) {
return;
}
std::vector<DABLinkedId> ids;
for (int i = 0; i < count; i++, pos += idSize)
{
DABLinkedId id;
id.kind = idlq;
if (pd)
{
id.id = (static_cast<uint32_t>(data[pos]) << 24) | (data[pos + 1] << 16) | (data[pos + 2] << 8) | data[pos + 3];
if (idlq == DABLinkedId::DRMService) {
id.id &= 0xffffff;
}
}
else if (international)
{
id.id = (data[pos + 1] << 8) | data[pos + 2];
if (idlq == DABLinkedId::DRMService) {
id.id |= data[pos] << 16; // The ECC field holds the identifier's MSB
} else {
id.ecc = data[pos];
}
}
else
{
id.id = (data[pos] << 8) | data[pos + 1];
}
ids.push_back(id);
}
if ((lsn == 0) || ids.empty() || ((m_linkageSets.size() >= MaximumDatabaseEntries) && !m_linkageSets.count(key))) {
continue;
}
DABLinkageSet set = m_linkageSets.count(key) ? m_linkageSets[key] : DABLinkageSet();
set.lsn = lsn;
set.active = active;
set.hard = hard;
set.international = international;
std::size_t first = 0;
if (!cn)
{
// The start of the set's database: the key service, then the others
set.keyService = ids[0].id;
set.ids.clear();
first = 1;
}
for (std::size_t i = first; (i < ids.size()) && (set.ids.size() < MaximumDatabaseIds); i++)
{
if (std::find(set.ids.begin(), set.ids.end(), ids[i]) == set.ids.end()) {
set.ids.push_back(ids[i]);
}
}
const auto old = m_linkageSets.find(key);
if ((old == m_linkageSets.end()) || (old->second.keyService != set.keyService) || !(old->second.ids == set.ids)
|| (old->second.active != set.active))
{
m_linkageSets[key] = set;
changed();
}
}
}
// Announcement support (clause 8.1.6.1)
void DABEnsemble::fig0_18(const uint8_t *data, int length)
{
int pos = 0;
while (pos + 5 <= length)
{
const uint32_t sid = (data[pos] << 8) | data[pos + 1];
DABAnnouncementSupport support;
support.flags = static_cast<uint16_t>((data[pos + 2] << 8) | data[pos + 3]);
const int clusters = data[pos + 4] & 0x1f; // Rfa (3 bits), then the number of clusters (5 bits)
pos += 5;
if (pos + clusters > length) {
return;
}
for (int i = 0; i < clusters; i++) {
support.clusters.push_back(data[pos + i]);
}
pos += clusters;
const auto old = m_announcementSupport.find(sid);
if ((old == m_announcementSupport.end()) || (old->second.flags != support.flags) || (old->second.clusters != support.clusters))
{
if ((old == m_announcementSupport.end()) && (m_announcementSupport.size() >= MaximumDatabaseEntries)) {
continue;
}
m_announcementSupport[sid] = support;
changed();
}
}
}
// Announcement switching (clause 8.1.6.2, and TS 103 176 clause 7.3)
void DABEnsemble::fig0_19(const uint8_t *data, int length)
{
int pos = 0;
while (pos + 4 <= length)
{
DABAnnouncementSwitch announcement;
announcement.cluster = data[pos];
announcement.flags = static_cast<uint16_t>((data[pos + 1] << 8) | data[pos + 2]);
announcement.newFlag = (data[pos + 3] & 0x80) != 0;
const bool region = (data[pos + 3] & 0x40) != 0; // EN 300 401 V1: a region Id follows
announcement.subchannelId = data[pos + 3] & 0x3f;
pos += region ? 5 : 4;
const uint16_t flags = announcement.flags;
const bool singleType = (flags != 0) && ((flags & (flags - 1)) == 0);
if (announcement.cluster == 0x00) {
continue; // Not used
}
if (flags == 0)
{
// The end of the announcement
m_announcementLastCIF.erase(announcement.cluster);
if (m_announcements.erase(announcement.cluster) > 0) {
changed();
}
continue;
}
// One type only; alarms only in, and only, cluster 0xff
if (!singleType || ((announcement.cluster == 0xff) != (flags == 1))) {
continue;
}
m_announcementLastCIF[announcement.cluster] = m_cifs;
const auto old = m_announcements.find(announcement.cluster);
if ((old == m_announcements.end()) || (old->second.flags != flags) || (old->second.subchannelId != announcement.subchannelId))
{
m_announcements[announcement.cluster] = announcement;
changed();
}
}
}
// Frequency information (clause 8.1.8)
void DABEnsemble::fig0_21(const uint8_t *data, int length, bool cn, bool oe)
{
int pos = 0;
while (pos + 2 <= length)
{
const int end = std::min(length, pos + 2 + (data[pos + 1] & 0x1f));
pos += 2;
while (pos + 3 <= end)
{
DABFrequencyInformation fi;
fi.id = (data[pos] << 8) | data[pos + 1];
fi.rm = data[pos + 2] >> 4;
fi.continuity = (data[pos + 2] & 0x08) != 0;
fi.otherEnsemble = oe;
const int listLength = data[pos + 2] & 0x07;
pos += 3;
if (pos + listLength > end) {
return;
}
const uint8_t *list = data + pos;
pos += listLength;
switch (fi.rm)
{
case DABFrequencyInformation::Ensemble:
for (int i = 0; i + 3 <= listLength; i += 3)
{
const int control = list[i] >> 3;
const int freq = ((list[i] & 0x07) << 16) | (list[i + 1] << 8) | list[i + 2];
if (freq > 0) {
fi.frequencies.push_back({freq * 16000LL, (control & 0x01) == 0});
}
}
break;
case DABFrequencyInformation::FMRDS:
for (int i = 0; i < listLength; i++)
{
if ((list[i] >= 1) && (list[i] <= 204)) {
fi.frequencies.push_back({87500000LL + list[i] * 100000LL, true});
}
}
break;
case DABFrequencyInformation::DRM:
case DABFrequencyInformation::AMSS:
// The identifier's MSB, then 16-bit frequencies
if (listLength >= 1)
{
fi.id |= list[0] << 16;
for (int i = 1; i + 2 <= listLength; i += 2)
{
const int freq = ((list[i] & 0x7f) << 8) | list[i + 1];
const int64_t step = ((fi.rm == DABFrequencyInformation::DRM) && (list[i] & 0x80)) ? 10000 : 1000;
if (freq > 0) {
fi.frequencies.push_back({freq * step, true});
}
}
}
break;
default:
continue; // Other R&M values are not used now
}
const auto key = std::make_tuple(oe, fi.rm, fi.id);
if (listLength == 0)
{
// Change event indication
if (m_frequencies.erase(key) > 0) {
changed();
}
continue;
}
auto old = m_frequencies.find(key);
if (old == m_frequencies.end())
{
if (m_frequencies.size() < MaximumDatabaseEntries)
{
m_frequencies[key] = fi;
changed();
}
continue;
}
DABFrequencyInformation& entry = old->second;
if (!cn) {
entry.continuity = fi.continuity;
}
std::vector<DABFrequencyInformation::Frequency> frequencies = cn ? entry.frequencies : std::vector<DABFrequencyInformation::Frequency>();
for (const auto& f : fi.frequencies)
{
const bool known = std::any_of(frequencies.begin(), frequencies.end(),
[&f](const DABFrequencyInformation::Frequency& g) { return g.hz == f.hz; });
if (!known && (frequencies.size() < MaximumDatabaseIds)) {
frequencies.push_back(f);
}
}
const bool same = (frequencies.size() == entry.frequencies.size())
&& std::equal(frequencies.begin(), frequencies.end(), entry.frequencies.begin(),
[](const DABFrequencyInformation::Frequency& a, const DABFrequencyInformation::Frequency& b) {
return (a.hz == b.hz) && (a.adjacent == b.adjacent);
});
if (!same)
{
entry.frequencies = frequencies;
changed();
}
}
pos = end;
}
}
// OE services: the ensembles that carry a service (clause 8.1.10)
void DABEnsemble::fig0_24(const uint8_t *data, int length, bool cn, bool oe, bool pd)
{
const int sidLength = pd ? 4 : 2;
int pos = 0;
while (pos + sidLength + 1 <= length)
{
uint32_t sid = 0;
for (int i = 0; i < sidLength; i++) {
sid = (sid << 8) | data[pos + i];
}
pos += sidLength;
const int count = data[pos] & 0x0f;
pos++;
if (pos + 2 * count > length) {
return;
}
const auto key = std::make_pair(pd, sid);
if (count == 0)
{
// Change event indication
if (m_oeServices.erase(key) > 0) {
changed();
}
continue;
}
if (!m_oeServices.count(key) && (m_oeServices.size() >= MaximumDatabaseEntries))
{
pos += 2 * count;
continue;
}
OEServices& entry = m_oeServices[key];
std::vector<int> eids = cn ? entry.eids : std::vector<int>();
for (int i = 0; i < count; i++, pos += 2)
{
const int eid = (data[pos] << 8) | data[pos + 1];
if ((std::find(eids.begin(), eids.end(), eid) == eids.end()) && (eids.size() < MaximumDatabaseIds)) {
eids.push_back(eid);
}
}
if ((eids != entry.eids) || (entry.otherEnsemble != oe))
{
entry.eids = eids;
entry.otherEnsemble = oe;
changed();
}
}
}
DABAnnouncementSupport DABEnsemble::announcementSupport(uint32_t sid) const
{
const auto it = m_announcementSupport.find(sid);
return it == m_announcementSupport.end() ? DABAnnouncementSupport() : it->second;
}
std::vector<DABLinkageSet> DABEnsemble::linkageSets() const
{
std::vector<DABLinkageSet> sets;
for (const auto& set : m_linkageSets) {
sets.push_back(set.second);
}
return sets;
}
std::vector<DABFrequencyInformation> DABEnsemble::frequencyInformation() const
{
std::vector<DABFrequencyInformation> list;
for (const auto& fi : m_frequencies) {
list.push_back(fi.second);
}
return list;
}
std::vector<int> DABEnsemble::otherEnsembles(uint32_t sid) const
{
std::vector<int> eids;
for (bool pd : {false, true})
{
const auto it = m_oeServices.find(std::make_pair(pd, sid));
if (it == m_oeServices.end()) {
continue;
}
for (int eid : it->second.eids)
{
if ((eid != m_info.eid) && (std::find(eids.begin(), eids.end(), eid) == eids.end())) {
eids.push_back(eid);
}
}
}
return eids;
}
std::vector<DABServiceLink> DABEnsemble::serviceLinks(uint32_t sid) const
{
std::vector<DABServiceLink> links;
// The frequencies of an ensemble, or of a service on another system
const auto frequencies = [this](int rm, uint32_t id) {
std::vector<int64_t> hz;
for (const auto& fi : m_frequencies)
{
if ((fi.second.rm != rm) || (fi.second.id != id)) {
continue;
}
for (const auto& f : fi.second.frequencies)
{
if (std::find(hz.begin(), hz.end(), f.hz) == hz.end()) {
hz.push_back(f.hz);
}
}
}
return hz;
};
const auto ensembleFrequencies = [&frequencies](const std::vector<int>& eids) {
std::vector<int64_t> hz;
for (int eid : eids)
{
for (int64_t f : frequencies(DABFrequencyInformation::Ensemble, static_cast<uint32_t>(eid)))
{
if (std::find(hz.begin(), hz.end(), f) == hz.end()) {
hz.push_back(f);
}
}
}
return hz;
};
const std::vector<int> others = otherEnsembles(sid);
if (!others.empty())
{
DABServiceLink link;
link.kind = DABServiceLink::SameService;
link.id = sid;
link.hard = true;
link.active = true;
link.eids = others;
link.frequencies = ensembleFrequencies(others);
links.push_back(link);
}
for (const auto& entry : m_linkageSets)
{
const DABLinkageSet& set = entry.second;
if (set.keyService != sid) {
continue;
}
for (const DABLinkedId& id : set.ids)
{
DABServiceLink link;
link.id = id.id;
link.ecc = id.ecc;
link.hard = set.hard;
link.active = set.active;
if (id.kind == DABLinkedId::Service)
{
if (id.id == sid) {
continue;
}
link.kind = DABServiceLink::LinkedDAB;
const auto label = m_serviceLabels.find(id.id);
if (label != m_serviceLabels.end()) {
link.label = label->second.label;
}
link.eids = otherEnsembles(id.id);
link.frequencies = ensembleFrequencies(link.eids);
}
else if (id.kind == DABLinkedId::RDSPI)
{
link.kind = DABServiceLink::LinkedFM;
link.frequencies = frequencies(DABFrequencyInformation::FMRDS, id.id);
}
else if (id.kind == DABLinkedId::DRMService)
{
link.kind = DABServiceLink::LinkedDRM;
link.frequencies = frequencies(DABFrequencyInformation::DRM, id.id);
for (int64_t f : frequencies(DABFrequencyInformation::AMSS, id.id)) {
link.frequencies.push_back(f);
}
}
else
{
continue;
}
// A service in two sets: the stronger link
const auto same = std::find_if(links.begin(), links.end(), [&link](const DABServiceLink& l) {
return (l.kind == link.kind) && (l.id == link.id);
});
if (same == links.end())
{
links.push_back(link);
}
else
{
same->hard = same->hard || link.hard;
same->active = same->active || link.active;
}
}
}
return links;
}
int DABEnsemble::subchannelASCTy(int subchannelId) const
{
for (const auto& service : m_current.services)
{
for (const auto& component : service.second.components)
{
if ((component.transport == DABServiceComponent::StreamAudio) && (component.subchannelId == subchannelId)) {
return component.type;
}
}
}
return -1;
}
std::string DABEnsemble::subchannelServiceLabel(int subchannelId) const
{
std::string label;
for (const auto& service : m_current.services)
{
for (const auto& component : service.second.components)
{
if ((component.transport == DABServiceComponent::StreamAudio) && (component.subchannelId == subchannelId))
{
const auto it = m_serviceLabels.find(service.first);
if ((it != m_serviceLabels.end()) && (component.primary || label.empty())) {
label = it->second.label;
}
}
}
}
return label;
}
} // namespace modemdab