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.
 
 
 
 
 
 

280 lines
9.2 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 "drmdata.h"
#include <algorithm>
#include "drmbitutils.h"
namespace modemdrm
{
void DRMPacketDemultiplexer::reset()
{
m_continuity.fill(-1);
for (auto& unit : m_units) {
unit.clear();
}
m_unitValid.fill(false);
m_lostPackets.fill(0);
m_validPackets = 0;
m_invalidPackets = 0;
}
void DRMPacketDemultiplexer::frameLost()
{
// The next packet's continuity index cannot show how many were lost
m_continuity.fill(-1);
for (auto& unit : m_units) {
unit.clear();
}
m_unitValid.fill(false);
m_lostPackets.fill(0);
}
void DRMPacketDemultiplexer::push(
const std::vector<std::uint8_t>& stream,
int packetLengthBytes,
int packetId,
bool dataUnits,
std::vector<std::vector<std::uint8_t>>& completed
)
{
if (packetLengthBytes <= 0 || packetId < 0 || packetId > 3) {
return;
}
// A header byte, the data field and a CRC over both.
const std::size_t packetBytes = static_cast<std::size_t>(packetLengthBytes) + 3U;
for (std::size_t offset = 0; offset + packetBytes <= stream.size(); offset += packetBytes)
{
const std::uint8_t* packet = stream.data() + offset;
const std::uint16_t crc = static_cast<std::uint16_t>((packet[packetBytes - 2U] << 8) | packet[packetBytes - 1U]);
if (CRC::crc16Bytes(packet, packetBytes - 2U) != crc)
{
// Its packet Id is unknown; the continuity index of the next
// good packet shows which data unit lost it (while fewer than 8
// are lost).
++m_invalidPackets;
for (int& lost : m_lostPackets) {
lost = std::min(lost + 1, 8);
}
continue;
}
++m_validPackets;
const bool first = (packet[0] & 0x80U) != 0U;
const bool last = (packet[0] & 0x40U) != 0U;
const int id = (packet[0] >> 4) & 0x03;
const bool padded = (packet[0] & 0x08U) != 0U;
const int continuity = packet[0] & 0x07;
if (m_continuity[static_cast<std::size_t>(id)] >= 0
&& (((m_continuity[static_cast<std::size_t>(id)] + 1) % 8 != continuity)
|| (m_lostPackets[static_cast<std::size_t>(id)] >= 8))) {
m_unitValid[static_cast<std::size_t>(id)] = false;
}
m_continuity[static_cast<std::size_t>(id)] = continuity;
m_lostPackets[static_cast<std::size_t>(id)] = 0;
// A padded packet's first data byte is its count of useful bytes.
const std::uint8_t* data = packet + 1;
std::size_t useful = static_cast<std::size_t>(packetLengthBytes);
if (padded)
{
useful = data[0];
++data;
if (useful > static_cast<std::size_t>(packetLengthBytes) - 1U)
{
m_unitValid[static_cast<std::size_t>(id)] = false;
continue;
}
}
if (id != packetId) {
continue;
}
if (!dataUnits)
{
if (useful > 0U) {
completed.emplace_back(data, data + useful);
}
continue;
}
std::vector<std::uint8_t>& unit = m_units[static_cast<std::size_t>(id)];
if (first)
{
unit.clear();
m_unitValid[static_cast<std::size_t>(id)] = true;
}
// An empty packet (first, last, no useful data) only fills the frame.
if (!m_unitValid[static_cast<std::size_t>(id)] || (first && last && useful == 0U)) {
continue;
}
unit.insert(unit.end(), data, data + useful);
if (unit.size() > MaximumDataUnitBytes)
{
m_unitValid[static_cast<std::size_t>(id)] = false;
unit.clear();
continue;
}
if (last)
{
completed.push_back(std::move(unit));
unit.clear();
m_unitValid[static_cast<std::size_t>(id)] = false;
}
}
}
const SDCDataApplication* DRMSlideshowDecoder::find(const SDCData& sdc, int shortId)
{
const auto found = std::find_if(sdc.dataApplications.begin(), sdc.dataApplications.end(),
[shortId](const SDCDataApplication& application) {
return application.shortId == shortId && application.packetMode && application.dataUnits
&& application.applicationDomain == 1
&& application.userApplicationType == SDCDataApplication::MOTSlideshow;
});
return found == sdc.dataApplications.end() ? nullptr : &*found;
}
void DRMSlideshowDecoder::reset()
{
m_packets.reset();
m_mot.reset();
m_configuredStream = -1;
m_configuredPacketId = -1;
m_configuredPacketLength = -1;
}
bool DRMSlideshowDecoder::setService(std::int64_t serviceIdentifier)
{
const bool changed = (m_service >= 0) && (serviceIdentifier != m_service);
if (changed) {
reset();
}
m_service = serviceIdentifier;
return changed;
}
void DRMSlideshowDecoder::push(
const SDCDataApplication& application,
const std::vector<std::uint8_t>& stream,
std::vector<MOTObject>& completed
)
{
if (application.streamId != m_configuredStream || application.packetId != m_configuredPacketId
|| application.packetLengthBytes != m_configuredPacketLength)
{
reset();
m_configuredStream = application.streamId;
m_configuredPacketId = application.packetId;
m_configuredPacketLength = application.packetLengthBytes;
}
std::vector<std::vector<std::uint8_t>> dataGroups;
m_packets.push(stream, application.packetLengthBytes, application.packetId, application.dataUnits, dataGroups);
for (const auto& dataGroup : dataGroups) {
m_mot.push(dataGroup, completed);
}
}
const SDCDataApplication* DRMWebsiteDecoder::find(const SDCData& sdc, int shortId)
{
const auto found = std::find_if(sdc.dataApplications.begin(), sdc.dataApplications.end(),
[shortId](const SDCDataApplication& application) {
return (application.shortId == shortId) && application.packetMode && application.dataUnits
&& (application.applicationDomain == 1)
&& (application.userApplicationType == SDCDataApplication::BroadcastWebsite);
});
return found == sdc.dataApplications.end() ? nullptr : &*found;
}
void DRMWebsiteDecoder::reset()
{
m_packets.reset();
m_mot.reset();
m_configuredStream = -1;
m_configuredPacketId = -1;
m_configuredPacketLength = -1;
}
bool DRMWebsiteDecoder::setService(std::int64_t serviceIdentifier)
{
const bool changed = (m_service >= 0) && (serviceIdentifier != m_service);
if (changed) {
reset();
}
m_service = serviceIdentifier;
return changed;
}
bool DRMWebsiteDecoder::push(const SDCDataApplication& application, const std::vector<std::uint8_t>& stream)
{
// A changed component starts again: the website shown goes too
bool changed = false;
if ((application.streamId != m_configuredStream) || (application.packetId != m_configuredPacketId)
|| (application.packetLengthBytes != m_configuredPacketLength))
{
changed = !website().files.empty();
reset();
m_configuredStream = application.streamId;
m_configuredPacketId = application.packetId;
m_configuredPacketLength = application.packetLengthBytes;
}
// The user application data lists the service's profiles, up to a 0x00
const auto end = std::find(application.applicationData.begin(), application.applicationData.end(), 0U);
m_mot.setProfiles(std::vector<std::uint8_t>(application.applicationData.begin(), end));
std::vector<std::vector<std::uint8_t>> dataGroups;
m_packets.push(stream, application.packetLengthBytes, application.packetId, application.dataUnits, dataGroups);
for (const auto& dataGroup : dataGroups) {
changed = m_mot.push(dataGroup) || changed;
}
return changed;
}
} // namespace modemdrm