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.
 
 
 
 
 
 

1710 lines
56 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 "drmmsc.h"
#include "drmcellmap.h"
#include "drmbitutils.h"
#include "drmconvolutional.h"
#include "drminterleaver.h"
#include <cmath>
#include <algorithm>
#include <limits>
#include <numeric>
namespace modemdrm
{
constexpr int AdditionalMLCIterations = 4;
bool MSCExtractor::extract(
Mode mode,
int occupancy,
int frameInSuperframe,
const std::vector<EqualizedSymbol>& symbols,
MSCFrameCells& output,
std::string* error
)
{
const std::vector<CellPosition>& positions = CellMap::mscCells(
mode, occupancy, frameInSuperframe
);
if (positions.empty())
{
if (error) {
*error = "Invalid DRM MSC mode, occupancy or frame index";
}
return false;
}
output = MSCFrameCells();
output.frameInSuperframe = frameInSuperframe;
output.cells.reserve(positions.size());
output.reliabilities.reserve(positions.size());
for (const CellPosition& position : positions)
{
if (position.symbol < 0 || static_cast<std::size_t>(position.symbol) >= symbols.size())
{
if (error) {
*error = "Missing equalized DRM MSC symbol";
}
output = MSCFrameCells();
return false;
}
const EqualizedSymbol& symbol = symbols[static_cast<std::size_t>(position.symbol)];
if (!symbol.contains(position.carrier))
{
if (error) {
*error = "Missing equalized DRM MSC carrier";
}
output = MSCFrameCells();
return false;
}
output.cells.push_back(symbol.cell(position.carrier));
const std::size_t channelIndex = static_cast<std::size_t>(
position.carrier - symbol.minimumCarrier
);
output.reliabilities.push_back(channelIndex < symbol.channel.size()
? std::abs(symbol.channel[channelIndex]) : 1.0f);
}
return true;
}
bool MSCSuperframeAssembler::assemble(
Mode mode,
int occupancy,
const std::vector<MSCFrameCells>& frames,
MSCSuperframeCells& output,
std::string* error
)
{
const SpectrumParameters* spectrum = Parameters::forSpectrum(mode, occupancy);
const ModeParameters& parameters = Parameters::forMode(mode);
if (!spectrum || static_cast<int>(frames.size()) != parameters.framesPerSuperframe)
{
if (error) {
*error = "Incomplete DRM MSC superframe";
}
return false;
}
output = MSCSuperframeCells();
std::size_t totalCells = 0;
for (int frame = 0; frame < parameters.framesPerSuperframe; ++frame)
{
const MSCFrameCells& input = frames[static_cast<std::size_t>(frame)];
const std::size_t expected = CellMap::mscCells(mode, occupancy, frame).size();
if (input.frameInSuperframe != frame || input.cells.size() != expected
|| input.reliabilities.size() != expected)
{
if (error) {
*error = "Invalid DRM MSC frame order or cell count";
}
output = MSCSuperframeCells();
return false;
}
totalCells += expected;
}
output.cells.reserve(totalCells);
output.reliabilities.reserve(totalCells);
for (const MSCFrameCells& frame : frames)
{
output.cells.insert(output.cells.end(), frame.cells.begin(), frame.cells.end());
output.reliabilities.insert(
output.reliabilities.end(),
frame.reliabilities.begin(),
frame.reliabilities.end()
);
}
return true;
}
bool MSCMultiplexFrameSplitter::capacity(Mode mode, int occupancy, MSCCapacity& result)
{
// NSFA, NSFU and NMUX from ETSI ES 201 980 V4.3.1, tables 41-45.
struct Entry { Mode mode; int occupancy; int available; int useful; int multiplex; };
static const Entry entries[] = {
{Mode::A, 0, 3778, 3777, 1259}, {Mode::A, 1, 4268, 4266, 1422},
{Mode::A, 2, 7897, 7896, 2632}, {Mode::A, 3, 8877, 8877, 2959},
{Mode::A, 4, 16394, 16392, 5464}, {Mode::A, 5, 18354, 18354, 6118},
{Mode::B, 0, 2900, 2898, 966}, {Mode::B, 1, 3330, 3330, 1110},
{Mode::B, 2, 6153, 6153, 2051}, {Mode::B, 3, 7013, 7011, 2337},
{Mode::B, 4, 12747, 12747, 4249}, {Mode::B, 5, 14323, 14322, 4774},
{Mode::C, 3, 5532, 5532, 1844}, {Mode::C, 5, 11603, 11601, 3867},
{Mode::D, 3, 3679, 3678, 1226}, {Mode::D, 5, 7819, 7818, 2606},
{Mode::E, 0, 29842, 29840, 7460}
};
for (const Entry& entry : entries)
{
if (entry.mode == mode && entry.occupancy == occupancy)
{
result.availableCellsPerSuperframe = entry.available;
result.usefulCellsPerSuperframe = entry.useful;
result.cellsPerMultiplexFrame = entry.multiplex;
result.dummyCellsPerSuperframe = entry.available - entry.useful;
return true;
}
}
result = MSCCapacity();
return false;
}
bool MSCMultiplexFrameSplitter::split(
Mode mode,
int occupancy,
const MSCSuperframeCells& superframe,
std::vector<MSCMultiplexFrameCells>& frames,
std::string* error
)
{
MSCCapacity values;
const ModeParameters& parameters = Parameters::forMode(mode);
if (!capacity(mode, occupancy, values)
|| superframe.cells.size() != static_cast<std::size_t>(values.availableCellsPerSuperframe)
|| superframe.reliabilities.size() != superframe.cells.size())
{
if (error) {
*error = "Invalid DRM MSC transmission superframe size";
}
frames.clear();
return false;
}
if (values.cellsPerMultiplexFrame * parameters.framesPerSuperframe
!= values.usefulCellsPerSuperframe)
{
if (error) {
*error = "Inconsistent DRM MSC capacity table";
}
frames.clear();
return false;
}
frames.assign(
static_cast<std::size_t>(parameters.framesPerSuperframe),
MSCMultiplexFrameCells()
);
for (int frame = 0; frame < parameters.framesPerSuperframe; ++frame)
{
MSCMultiplexFrameCells& output = frames[static_cast<std::size_t>(frame)];
output.frameInSuperframe = frame;
const std::size_t begin = static_cast<std::size_t>(
frame * values.cellsPerMultiplexFrame
);
const std::size_t end = begin + static_cast<std::size_t>(values.cellsPerMultiplexFrame);
output.cells.assign(
superframe.cells.begin() + static_cast<std::ptrdiff_t>(begin),
superframe.cells.begin() + static_cast<std::ptrdiff_t>(end)
);
output.reliabilities.assign(
superframe.reliabilities.begin() + static_cast<std::ptrdiff_t>(begin),
superframe.reliabilities.begin() + static_cast<std::ptrdiff_t>(end)
);
}
return true;
}
bool MSCCellInterleaver::deinterleaveBlock(
const MSCMultiplexFrameCells& input,
MSCMultiplexFrameCells& output,
std::string* error
)
{
if (input.cells.empty() || input.reliabilities.size() != input.cells.size())
{
if (error) {
*error = "Invalid DRM MSC multiplex frame";
}
output = MSCMultiplexFrameCells();
return false;
}
const std::vector<std::size_t>& permutation = BitInterleaver::cachedPermutation(
input.cells.size(), 5
);
if (permutation.size() != input.cells.size())
{
if (error) {
*error = "Unable to construct DRM MSC cell permutation";
}
output = MSCMultiplexFrameCells();
return false;
}
output = MSCMultiplexFrameCells();
output.frameInSuperframe = input.frameInSuperframe;
output.cells.resize(input.cells.size());
output.reliabilities.resize(input.reliabilities.size());
for (std::size_t i = 0; i < permutation.size(); ++i)
{
output.cells[permutation[i]] = input.cells[i];
output.reliabilities[permutation[i]] = input.reliabilities[i];
}
return true;
}
MSCCellDeinterleaver::MSCCellDeinterleaver(Mode mode, bool longInterleaving) :
m_mode(mode),
m_longInterleaving(longInterleaving)
{
}
void MSCCellDeinterleaver::reset()
{
m_inputFrameCount = 0;
m_firstFramePhase = -1;
m_cellCount = 0;
m_pending.clear();
}
int MSCCellDeinterleaver::depth() const
{
if (!m_longInterleaving) {
return 1;
}
return m_mode == Mode::E ? 6 : 5;
}
std::size_t MSCCellDeinterleaver::bufferedFrameCount() const
{
return m_pending.size();
}
bool MSCCellDeinterleaver::push(
const MSCMultiplexFrameCells& input,
MSCMultiplexFrameCells& output,
bool& outputReady,
std::string* error
)
{
outputReady = false;
const ModeParameters& parameters = Parameters::forMode(m_mode);
if (input.frameInSuperframe < 0
|| input.frameInSuperframe >= parameters.framesPerSuperframe
|| input.cells.empty()
|| input.reliabilities.size() != input.cells.size())
{
if (error) {
*error = "Invalid DRM MSC multiplex frame";
}
return false;
}
if (m_firstFramePhase < 0)
{
m_firstFramePhase = input.frameInSuperframe;
m_cellCount = input.cells.size();
}
else
{
const int expectedPhase = static_cast<int>(
(m_firstFramePhase + m_inputFrameCount)
% static_cast<std::uint64_t>(parameters.framesPerSuperframe)
);
if (input.frameInSuperframe != expectedPhase || input.cells.size() != m_cellCount)
{
if (error) {
*error = "Discontinuous DRM MSC multiplex-frame sequence";
}
return false;
}
}
if (!m_longInterleaving)
{
if (!MSCCellInterleaver::deinterleaveBlock(input, output, error)) {
return false;
}
++m_inputFrameCount;
outputReady = true;
return true;
}
const int interleavingDepth = depth();
const std::vector<std::size_t>& permutation = BitInterleaver::cachedPermutation(m_cellCount, 5);
const std::int64_t transmittedFrame = static_cast<std::int64_t>(m_inputFrameCount);
// Cell i belongs to the frame i mod D before this one: find or start
// those D frames once rather than for every cell.
std::vector<PendingFrame*> sources(static_cast<std::size_t>(interleavingDepth), nullptr);
for (int delay = 0; delay < interleavingDepth; ++delay)
{
const std::int64_t sourceFrame = transmittedFrame - delay;
if (sourceFrame < 0) {
continue;
}
auto insertion = m_pending.try_emplace(sourceFrame);
PendingFrame& pending = insertion.first->second;
if (insertion.second)
{
pending.frame.frameInSuperframe = static_cast<int>(
(m_firstFramePhase + sourceFrame) % parameters.framesPerSuperframe
);
pending.frame.cells.resize(m_cellCount);
pending.frame.reliabilities.resize(m_cellCount);
pending.received.assign(m_cellCount, false);
}
sources[static_cast<std::size_t>(delay)] = &pending;
}
for (std::size_t i = 0; i < m_cellCount; ++i)
{
PendingFrame* pending = sources[i % static_cast<std::size_t>(interleavingDepth)];
if (!pending) {
continue;
}
const std::size_t destination = permutation[i];
if (!pending->received[destination])
{
pending->frame.cells[destination] = input.cells[i];
pending->frame.reliabilities[destination] = input.reliabilities[i];
pending->received[destination] = true;
++pending->filled;
}
}
const std::int64_t completedFrame = transmittedFrame - (interleavingDepth - 1);
if (completedFrame >= 0)
{
auto pending = m_pending.find(completedFrame);
if (pending == m_pending.end() || pending->second.filled != m_cellCount)
{
if (error) {
*error = "Incomplete DRM MSC long-interleaved frame";
}
return false;
}
output = std::move(pending->second.frame);
m_pending.erase(pending);
outputReady = true;
}
++m_inputFrameCount;
return true;
}
namespace
{
bool modeE4QAMRate(int protectionLevel, CodeRate& rate, int& numerator, int& denominator)
{
switch (protectionLevel)
{
case 0:
rate = CodeRate::R1_4;
numerator = 1;
denominator = 4;
return true;
case 1:
rate = CodeRate::R1_3;
numerator = 1;
denominator = 3;
return true;
case 2:
rate = CodeRate::R2_5;
numerator = 2;
denominator = 5;
return true;
case 3:
rate = CodeRate::R1_2;
numerator = 1;
denominator = 2;
return true;
default:
return false;
}
}
struct MSCComponentProfile
{
CodeRate rate = CodeRate::R1_6;
int numerator = 0;
int denominator = 0;
int interleaverMultiplier = 0;
};
bool eepProfiles(
Mode mode,
int mscMode,
int protectionLevel,
std::vector<MSCComponentProfile>& profiles
)
{
profiles.clear();
if (mode == Mode::E && mscMode == 3)
{
CodeRate rate = CodeRate::R1_6;
int numerator = 0;
int denominator = 0;
if (!modeE4QAMRate(protectionLevel, rate, numerator, denominator)) {
return false;
}
profiles.push_back({rate, numerator, denominator, 21});
return true;
}
if (mode != Mode::E)
{
// ETSI ES 201 980 V4.3.1 tables 30 and 32. Level zero is not bit
// interleaved for 64-QAM; levels one and two use multipliers 13/21.
if (mscMode == 3)
{
switch (protectionLevel)
{
case 0:
profiles = {
{CodeRate::R1_3, 1, 3, 13},
{CodeRate::R2_3, 2, 3, 21}
};
return true;
case 1:
profiles = {
{CodeRate::R1_2, 1, 2, 13},
{CodeRate::R3_4, 3, 4, 21}
};
return true;
default:
return false;
}
}
if (mscMode != 0) {
return false;
}
switch (protectionLevel)
{
case 0:
profiles = {
{CodeRate::R1_4, 1, 4, 0},
{CodeRate::R1_2, 1, 2, 13},
{CodeRate::R3_4, 3, 4, 21}
};
return true;
case 1:
profiles = {
{CodeRate::R1_3, 1, 3, 0},
{CodeRate::R2_3, 2, 3, 13},
{CodeRate::R4_5, 4, 5, 21}
};
return true;
case 2:
profiles = {
{CodeRate::R1_2, 1, 2, 0},
{CodeRate::R3_4, 3, 4, 13},
{CodeRate::R7_8, 7, 8, 21}
};
return true;
case 3:
profiles = {
{CodeRate::R2_3, 2, 3, 0},
{CodeRate::R4_5, 4, 5, 13},
{CodeRate::R8_9, 8, 9, 21}
};
return true;
default:
return false;
}
}
if (mscMode != 0) {
return false;
}
// ETSI ES 201 980 V4.3.1 table 31.
switch (protectionLevel)
{
case 0:
profiles = {
{CodeRate::R1_6, 1, 6, 13},
{CodeRate::R1_2, 1, 2, 21}
};
return true;
case 1:
profiles = {
{CodeRate::R1_4, 1, 4, 13},
{CodeRate::R4_7, 4, 7, 21}
};
return true;
case 2:
profiles = {
{CodeRate::R1_3, 1, 3, 13},
{CodeRate::R2_3, 2, 3, 21}
};
return true;
case 3:
profiles = {
{CodeRate::R1_2, 1, 2, 13},
{CodeRate::R3_4, 3, 4, 21}
};
return true;
default:
return false;
}
}
std::vector<float> deinterleaveComponent(
const std::vector<float>& bits,
int multiplier
)
{
return multiplier == 0 ? bits : BitInterleaver::deinterleave(bits, multiplier);
}
std::vector<std::uint8_t> interleaveComponent(
const std::vector<std::uint8_t>& bits,
int multiplier
)
{
return multiplier == 0 ? bits : BitInterleaver::interleave(bits, multiplier);
}
struct MSCDecodeLayout
{
int higherProtectedCells = 0;
int lowerProtectedCells = 0;
std::vector<MSCComponentProfile> higherProfiles;
std::vector<MSCComponentProfile> lowerProfiles;
std::vector<int> higherBitCounts;
std::vector<int> lowerBitCounts;
std::vector<int> tailResiduals;
};
bool makeDecodeLayout(
Mode mode,
int mscMode,
int cellCount,
const MSCProtectionParameters& protection,
MSCDecodeLayout& layout
)
{
layout = MSCDecodeLayout();
if (cellCount <= 0
|| !eepProfiles(
mode, mscMode, protection.protectionLevelB,
layout.lowerProfiles)) {
return false;
}
layout.lowerProtectedCells = cellCount;
if (protection.partABytes > 0U)
{
if (protection.partABytes
> std::numeric_limits<std::size_t>::max() / 8U) {
return false;
}
if (!eepProfiles(
mode, mscMode, protection.protectionLevelA,
layout.higherProfiles)
|| layout.higherProfiles.size() != layout.lowerProfiles.size()) {
return false;
}
int denominatorLCM = 1;
for (const MSCComponentProfile& profile : layout.higherProfiles) {
denominatorLCM = std::lcm(denominatorLCM, profile.denominator);
}
int bitsPerLCMCells = 0;
for (const MSCComponentProfile& profile : layout.higherProfiles)
{
bitsPerLCMCells += 2 * profile.numerator
* (denominatorLCM / profile.denominator);
}
if (bitsPerLCMCells <= 0) {
return false;
}
const std::size_t requestedBits = 8U * protection.partABytes;
const std::size_t groups = (requestedBits
+ static_cast<std::size_t>(bitsPerLCMCells) - 1U)
/ static_cast<std::size_t>(bitsPerLCMCells);
if (groups > static_cast<std::size_t>(cellCount / denominatorLCM)) {
return false;
}
layout.higherProtectedCells = static_cast<int>(groups)
* denominatorLCM;
layout.lowerProtectedCells = cellCount - layout.higherProtectedCells;
if (layout.lowerProtectedCells < 20) {
return false;
}
}
else
{
layout.higherProfiles = layout.lowerProfiles;
}
const std::size_t componentCount = layout.lowerProfiles.size();
layout.higherBitCounts.resize(componentCount, 0);
layout.lowerBitCounts.resize(componentCount, 0);
layout.tailResiduals.resize(componentCount, 0);
const int lowerAvailable = 2 * layout.lowerProtectedCells - 12;
if (lowerAvailable < 0) {
return false;
}
for (std::size_t level = 0; level < componentCount; ++level)
{
const MSCComponentProfile& higher = layout.higherProfiles[level];
const MSCComponentProfile& lower = layout.lowerProfiles[level];
const int higherNumerator = 2 * layout.higherProtectedCells
* higher.numerator;
if (higherNumerator % higher.denominator != 0
|| higher.interleaverMultiplier != lower.interleaverMultiplier) {
return false;
}
layout.higherBitCounts[level] = higherNumerator / higher.denominator;
layout.lowerBitCounts[level] = lower.numerator
* (lowerAvailable / lower.denominator);
layout.tailResiduals[level] = lowerAvailable % lower.denominator;
}
return true;
}
int layoutInformationBitCount(const MSCDecodeLayout& layout)
{
return std::accumulate(
layout.higherBitCounts.begin(), layout.higherBitCounts.end(), 0
) + std::accumulate(
layout.lowerBitCounts.begin(), layout.lowerBitCounts.end(), 0
);
}
std::vector<std::uint8_t> bitsToBytes(
const std::vector<std::uint8_t>& bits,
std::size_t offset,
std::size_t byteCount
)
{
std::vector<std::uint8_t> bytes(byteCount, 0U);
for (std::size_t byte = 0; byte < byteCount; ++byte)
{
for (int bit = 0; bit < 8; ++bit)
{
bytes[byte] = static_cast<std::uint8_t>(
(bytes[byte] << 1U) | (bits[offset++] & 1U)
);
}
}
return bytes;
}
} // namespace
bool MSCChannelDecoder::supports(Mode mode, int mscMode, bool unequalProtection)
{
(void) mode;
(void) unequalProtection;
return mscMode == 0 || mscMode == 3;
}
int MSCChannelDecoder::informationBitCount(
Mode mode,
int occupancy,
int mscMode,
int protectionLevel
)
{
if (!supports(mode, mscMode, false)) {
return -1;
}
MSCCapacity capacityValues;
std::vector<MSCComponentProfile> profiles;
if (!MSCMultiplexFrameSplitter::capacity(mode, occupancy, capacityValues)
|| !eepProfiles(mode, mscMode, protectionLevel, profiles)) {
return -1;
}
const int available = 2 * capacityValues.cellsPerMultiplexFrame - 12;
int informationBits = 0;
for (const MSCComponentProfile& profile : profiles) {
informationBits += profile.numerator * (available / profile.denominator);
}
return informationBits;
}
int MSCChannelDecoder::informationBitCount(
Mode mode,
int occupancy,
int mscMode,
const MSCProtectionParameters& protection
)
{
if (protection.partABytes == 0U)
{
return informationBitCount(
mode, occupancy, mscMode, protection.protectionLevelB
);
}
if (!supports(mode, mscMode, true)) {
return -1;
}
MSCCapacity capacityValues;
MSCDecodeLayout layout;
if (!MSCMultiplexFrameSplitter::capacity(mode, occupancy, capacityValues)
|| !makeDecodeLayout(
mode, mscMode, capacityValues.cellsPerMultiplexFrame,
protection, layout)) {
return -1;
}
return layoutInformationBitCount(layout);
}
bool MSCChannelDecoder::decode(
Mode mode,
int occupancy,
int mscMode,
int protectionLevel,
const MSCMultiplexFrameCells& input,
MSCDecodedMultiplexFrame& output,
std::string* error
)
{
output = MSCDecodedMultiplexFrame();
MSCCapacity capacityValues;
std::vector<MSCComponentProfile> profiles;
if (!supports(mode, mscMode, false)
|| !MSCMultiplexFrameSplitter::capacity(mode, occupancy, capacityValues)
|| !eepProfiles(mode, mscMode, protectionLevel, profiles))
{
if (error) {
*error = "Unsupported DRM MSC constellation or protection profile";
}
return false;
}
if (input.cells.size()
!= static_cast<std::size_t>(capacityValues.cellsPerMultiplexFrame)
|| input.reliabilities.size() != input.cells.size())
{
if (error) {
*error = "Invalid DRM MSC multiplex-frame cell count";
}
return false;
}
const int available = 2 * capacityValues.cellsPerMultiplexFrame - 12;
if (mode == Mode::E && mscMode == 3)
{
const MSCComponentProfile& profile = profiles.front();
std::vector<float> interleavedSoftBits;
interleavedSoftBits.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
interleavedSoftBits.push_back(input.cells[i].real() * input.reliabilities[i]);
interleavedSoftBits.push_back(input.cells[i].imag() * input.reliabilities[i]);
}
const std::vector<float> softBits = BitInterleaver::deinterleave(
interleavedSoftBits, profile.interleaverMultiplier
);
const int informationBits = profile.numerator * (available / profile.denominator);
const int tailResidual = available % profile.denominator;
if (!ViterbiDecoder::decodePunctured(
softBits, static_cast<std::size_t>(informationBits),
profile.rate, tailResidual, output.bits))
{
if (error) {
*error = "DRM 4-QAM MSC Viterbi decoding failed";
}
output = MSCDecodedMultiplexFrame();
return false;
}
}
else if (profiles.size() == 2U)
{
constexpr float AxisScale = 0.31622776601683794f; // 1/sqrt(10)
auto axisMetric = [=](float received, int level0, int level1) {
static constexpr int amplitudes[2][2] = {{3, -1}, {1, -3}};
const float difference = received
- AxisScale * static_cast<float>(amplitudes[level0][level1]);
return std::abs(difference);
};
std::vector<float> level0Interleaved;
level0Interleaved.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
for (float axis : {input.cells[i].real(), input.cells[i].imag()})
{
const float distance0 = std::min(
axisMetric(axis, 0, 0), axisMetric(axis, 0, 1)
);
const float distance1 = std::min(
axisMetric(axis, 1, 0), axisMetric(axis, 1, 1)
);
level0Interleaved.push_back(
(distance1 - distance0) * input.reliabilities[i]
);
}
}
const MSCComponentProfile& level0Profile = profiles[0];
const int level0InformationBits = level0Profile.numerator
* (available / level0Profile.denominator);
const int level0TailResidual = available % level0Profile.denominator;
std::vector<std::uint8_t> level0Bits;
if (!ViterbiDecoder::decodePunctured(
deinterleaveComponent(
level0Interleaved, level0Profile.interleaverMultiplier
),
static_cast<std::size_t>(level0InformationBits),
level0Profile.rate, level0TailResidual, level0Bits))
{
if (error) {
*error = "DRM 16-QAM MSC level-0 decoding failed";
}
return false;
}
const std::vector<std::uint8_t> level0Mapped = interleaveComponent(
ConvolutionalCode::encodePunctured(
level0Bits, level0Profile.rate, level0TailResidual
),
level0Profile.interleaverMultiplier
);
if (level0Mapped.size() != 2U * input.cells.size())
{
if (error) {
*error = "Invalid DRM 16-QAM MSC level-0 size";
}
return false;
}
std::vector<float> level1Interleaved;
level1Interleaved.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const int level0 = level0Mapped[
2U * i + static_cast<std::size_t>(axisIndex)
];
const float distance0 = axisMetric(axes[axisIndex], level0, 0);
const float distance1 = axisMetric(axes[axisIndex], level0, 1);
level1Interleaved.push_back(
(distance1 - distance0) * input.reliabilities[i]
);
}
}
const MSCComponentProfile& level1Profile = profiles[1];
const int level1InformationBits = level1Profile.numerator
* (available / level1Profile.denominator);
const int level1TailResidual = available % level1Profile.denominator;
std::vector<std::uint8_t> level1Bits;
if (!ViterbiDecoder::decodePunctured(
deinterleaveComponent(
level1Interleaved, level1Profile.interleaverMultiplier
),
static_cast<std::size_t>(level1InformationBits),
level1Profile.rate, level1TailResidual, level1Bits))
{
if (error) {
*error = "DRM 16-QAM MSC level-1 decoding failed";
}
return false;
}
output.bits = std::move(level0Bits);
output.bits.insert(output.bits.end(), level1Bits.begin(), level1Bits.end());
}
else if (profiles.size() == 3U)
{
constexpr float AxisScale = 0.15430334996209191f; // 1/sqrt(42)
auto axisMetric = [=](float received, int level0, int level1, int level2) {
static constexpr int amplitudes[2][2][2] = {
{{7, -1}, {3, -5}},
{{5, -3}, {1, -7}}
};
const float difference = received - AxisScale * static_cast<float>(
amplitudes[level0][level1][level2]
);
return std::abs(difference);
};
auto decodeLevel = [&](
int level,
const std::vector<float>& interleaved,
std::vector<std::uint8_t>& decoded,
std::vector<std::uint8_t>& mapped
) {
const MSCComponentProfile& profile = profiles[static_cast<std::size_t>(level)];
const int informationBits = profile.numerator
* (available / profile.denominator);
const int tailResidual = available % profile.denominator;
if (!ViterbiDecoder::decodePunctured(
deinterleaveComponent(interleaved, profile.interleaverMultiplier),
static_cast<std::size_t>(informationBits), profile.rate,
tailResidual, decoded)) {
return false;
}
mapped = interleaveComponent(
ConvolutionalCode::encodePunctured(
decoded, profile.rate, tailResidual
),
profile.interleaverMultiplier
);
return mapped.size() == 2U * input.cells.size();
};
std::vector<float> level0Interleaved;
level0Interleaved.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
for (float axis : {input.cells[i].real(), input.cells[i].imag()})
{
const float distance0 = std::min({
axisMetric(axis, 0, 0, 0), axisMetric(axis, 0, 0, 1),
axisMetric(axis, 0, 1, 0), axisMetric(axis, 0, 1, 1)
});
const float distance1 = std::min({
axisMetric(axis, 1, 0, 0), axisMetric(axis, 1, 0, 1),
axisMetric(axis, 1, 1, 0), axisMetric(axis, 1, 1, 1)
});
level0Interleaved.push_back(
(distance1 - distance0) * input.reliabilities[i]
);
}
}
std::vector<std::uint8_t> level0Bits;
std::vector<std::uint8_t> level0Mapped;
if (!decodeLevel(0, level0Interleaved, level0Bits, level0Mapped))
{
if (error) {
*error = "DRM 64-QAM MSC level-0 decoding failed";
}
return false;
}
std::vector<float> level1Interleaved;
level1Interleaved.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bitIndex = 2U * i + static_cast<std::size_t>(axisIndex);
const int level0 = level0Mapped[bitIndex];
const float distance0 = std::min(
axisMetric(axes[axisIndex], level0, 0, 0),
axisMetric(axes[axisIndex], level0, 0, 1)
);
const float distance1 = std::min(
axisMetric(axes[axisIndex], level0, 1, 0),
axisMetric(axes[axisIndex], level0, 1, 1)
);
level1Interleaved.push_back(
(distance1 - distance0) * input.reliabilities[i]
);
}
}
std::vector<std::uint8_t> level1Bits;
std::vector<std::uint8_t> level1Mapped;
if (!decodeLevel(1, level1Interleaved, level1Bits, level1Mapped))
{
if (error) {
*error = "DRM 64-QAM MSC level-1 decoding failed";
}
return false;
}
std::vector<float> level2Interleaved;
level2Interleaved.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bitIndex = 2U * i + static_cast<std::size_t>(axisIndex);
const int level0 = level0Mapped[bitIndex];
const int level1 = level1Mapped[bitIndex];
const float distance0 = axisMetric(
axes[axisIndex], level0, level1, 0
);
const float distance1 = axisMetric(
axes[axisIndex], level0, level1, 1
);
level2Interleaved.push_back(
(distance1 - distance0) * input.reliabilities[i]
);
}
}
std::vector<std::uint8_t> level2Bits;
std::vector<std::uint8_t> level2Mapped;
if (!decodeLevel(2, level2Interleaved, level2Bits, level2Mapped))
{
if (error) {
*error = "DRM 64-QAM MSC level-2 decoding failed";
}
return false;
}
// Repeat the multilevel decisions using all decisions from the prior
// pass. The reference schedule re-encodes levels zero and one before
// each final level-two decision; extra passes can help a marginal
// 64-QAM signal converge.
for (int iteration = 0; iteration < AdditionalMLCIterations; ++iteration)
{
// Each pass depends only on the previous decisions, so a pass
// that changes none of them has converged.
const std::vector<std::uint8_t> previous0 = level0Bits;
const std::vector<std::uint8_t> previous1 = level1Bits;
const std::vector<std::uint8_t> previous2 = level2Bits;
level0Interleaved.clear();
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bitIndex = 2U * i
+ static_cast<std::size_t>(axisIndex);
const int level1 = level1Mapped[bitIndex];
const int level2 = level2Mapped[bitIndex];
level0Interleaved.push_back((
axisMetric(axes[axisIndex], 1, level1, level2)
- axisMetric(axes[axisIndex], 0, level1, level2)
) * input.reliabilities[i]);
}
}
if (!decodeLevel(0, level0Interleaved, level0Bits, level0Mapped))
{
if (error) {
*error = "DRM 64-QAM MSC iterative level-0 decoding failed";
}
return false;
}
level1Interleaved.clear();
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bitIndex = 2U * i
+ static_cast<std::size_t>(axisIndex);
const int level0 = level0Mapped[bitIndex];
const int level2 = level2Mapped[bitIndex];
level1Interleaved.push_back((
axisMetric(axes[axisIndex], level0, 1, level2)
- axisMetric(axes[axisIndex], level0, 0, level2)
) * input.reliabilities[i]);
}
}
if (!decodeLevel(1, level1Interleaved, level1Bits, level1Mapped))
{
if (error) {
*error = "DRM 64-QAM MSC iterative level-1 decoding failed";
}
return false;
}
level2Interleaved.clear();
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bitIndex = 2U * i
+ static_cast<std::size_t>(axisIndex);
const int level0 = level0Mapped[bitIndex];
const int level1 = level1Mapped[bitIndex];
level2Interleaved.push_back((
axisMetric(axes[axisIndex], level0, level1, 1)
- axisMetric(axes[axisIndex], level0, level1, 0)
) * input.reliabilities[i]);
}
}
if (!decodeLevel(2, level2Interleaved, level2Bits, level2Mapped))
{
if (error) {
*error = "DRM 64-QAM MSC iterative level-2 decoding failed";
}
return false;
}
if (level0Bits == previous0 && level1Bits == previous1 && level2Bits == previous2) {
break;
}
}
output.bits = std::move(level0Bits);
output.bits.insert(output.bits.end(), level1Bits.begin(), level1Bits.end());
output.bits.insert(output.bits.end(), level2Bits.begin(), level2Bits.end());
}
else
{
if (error) {
*error = "Invalid DRM MSC component profile";
}
return false;
}
EnergyDispersal::apply(output.bits);
output.trailingBitCount = static_cast<int>(output.bits.size() % 8U);
return true;
}
bool MSCChannelDecoder::decode(
Mode mode,
int occupancy,
int mscMode,
const MSCProtectionParameters& protection,
const MSCMultiplexFrameCells& input,
MSCDecodedMultiplexFrame& output,
std::string* error
)
{
if (protection.partABytes == 0U)
{
return decode(
mode, occupancy, mscMode, protection.protectionLevelB,
input, output, error
);
}
output = MSCDecodedMultiplexFrame();
MSCCapacity capacityValues;
MSCDecodeLayout layout;
if (!supports(mode, mscMode, true)
|| !MSCMultiplexFrameSplitter::capacity(mode, occupancy, capacityValues)
|| !makeDecodeLayout(
mode, mscMode, capacityValues.cellsPerMultiplexFrame,
protection, layout))
{
if (error) {
*error = "Unsupported DRM MSC unequal-protection profile";
}
return false;
}
if (input.cells.size()
!= static_cast<std::size_t>(capacityValues.cellsPerMultiplexFrame)
|| input.reliabilities.size() != input.cells.size())
{
if (error) {
*error = "Invalid DRM MSC multiplex-frame cell count";
}
return false;
}
const std::size_t componentCount = layout.lowerProfiles.size();
std::vector<std::vector<std::uint8_t>> decodedLevels(componentCount);
std::vector<std::vector<std::uint8_t>> mappedLevels(componentCount);
auto decodeLevel = [&](std::size_t level, const std::vector<float>& interleaved) {
const MSCComponentProfile& higher = layout.higherProfiles[level];
const MSCComponentProfile& lower = layout.lowerProfiles[level];
const std::size_t higherCodedCount = 2U
* static_cast<std::size_t>(layout.higherProtectedCells);
const std::size_t lowerCodedCount = 2U
* static_cast<std::size_t>(layout.lowerProtectedCells);
if (interleaved.size() != higherCodedCount + lowerCodedCount) {
return false;
}
const std::vector<float> higherInterleaved(
interleaved.begin(),
interleaved.begin() + static_cast<std::ptrdiff_t>(higherCodedCount)
);
const std::vector<float> lowerInterleaved(
interleaved.begin() + static_cast<std::ptrdiff_t>(higherCodedCount),
interleaved.end()
);
std::vector<float> softBits = deinterleaveComponent(
higherInterleaved, higher.interleaverMultiplier
);
const std::vector<float> lowerSoft = deinterleaveComponent(
lowerInterleaved, lower.interleaverMultiplier
);
softBits.insert(softBits.end(), lowerSoft.begin(), lowerSoft.end());
if (!ViterbiDecoder::decodeUEP(
softBits,
static_cast<std::size_t>(layout.higherBitCounts[level]),
higher.rate,
static_cast<std::size_t>(layout.lowerBitCounts[level]),
lower.rate, layout.tailResiduals[level], decodedLevels[level])) {
return false;
}
const auto boundary = decodedLevels[level].begin()
+ layout.higherBitCounts[level];
const std::vector<std::uint8_t> higherBits(
decodedLevels[level].begin(), boundary
);
const std::vector<std::uint8_t> lowerBits(
boundary, decodedLevels[level].end()
);
const std::vector<std::uint8_t> coded = ConvolutionalCode::encodeUEP(
higherBits, higher.rate, lowerBits, lower.rate,
layout.tailResiduals[level]
);
if (coded.size() != interleaved.size()) {
return false;
}
const std::vector<std::uint8_t> higherCoded(
coded.begin(),
coded.begin() + static_cast<std::ptrdiff_t>(higherCodedCount)
);
const std::vector<std::uint8_t> lowerCoded(
coded.begin() + static_cast<std::ptrdiff_t>(higherCodedCount), coded.end()
);
mappedLevels[level] = interleaveComponent(
higherCoded, higher.interleaverMultiplier
);
const std::vector<std::uint8_t> lowerMapped = interleaveComponent(
lowerCoded, lower.interleaverMultiplier
);
mappedLevels[level].insert(
mappedLevels[level].end(), lowerMapped.begin(), lowerMapped.end()
);
return mappedLevels[level].size() == 2U * input.cells.size();
};
if (componentCount == 1U)
{
std::vector<float> soft;
soft.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
soft.push_back(input.cells[i].real() * input.reliabilities[i]);
soft.push_back(input.cells[i].imag() * input.reliabilities[i]);
}
if (!decodeLevel(0U, soft))
{
if (error) {
*error = "DRM 4-QAM UEP MSC decoding failed";
}
return false;
}
}
else if (componentCount == 2U)
{
constexpr float AxisScale = 0.31622776601683794f;
auto metric = [=](float received, int level0, int level1) {
static constexpr int amplitudes[2][2] = {{3, -1}, {1, -3}};
const float difference = received
- AxisScale * static_cast<float>(amplitudes[level0][level1]);
return std::abs(difference);
};
std::vector<float> level0Soft;
level0Soft.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
for (float axis : {input.cells[i].real(), input.cells[i].imag()})
{
const float distance0 = std::min(
metric(axis, 0, 0), metric(axis, 0, 1)
);
const float distance1 = std::min(
metric(axis, 1, 0), metric(axis, 1, 1)
);
level0Soft.push_back(
(distance1 - distance0) * input.reliabilities[i]
);
}
}
if (!decodeLevel(0U, level0Soft))
{
if (error) {
*error = "DRM 16-QAM UEP MSC level-0 decoding failed";
}
return false;
}
std::vector<float> level1Soft;
level1Soft.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bit = 2U * i + static_cast<std::size_t>(axisIndex);
const int level0 = mappedLevels[0][bit];
level1Soft.push_back((
metric(axes[axisIndex], level0, 1)
- metric(axes[axisIndex], level0, 0)
) * input.reliabilities[i]);
}
}
if (!decodeLevel(1U, level1Soft))
{
if (error) {
*error = "DRM 16-QAM UEP MSC level-1 decoding failed";
}
return false;
}
}
else if (componentCount == 3U)
{
constexpr float AxisScale = 0.15430334996209191f;
auto metric = [=](float received, int level0, int level1, int level2) {
static constexpr int amplitudes[2][2][2] = {
{{7, -1}, {3, -5}},
{{5, -3}, {1, -7}}
};
const float difference = received - AxisScale * static_cast<float>(
amplitudes[level0][level1][level2]
);
return std::abs(difference);
};
std::vector<float> level0Soft;
level0Soft.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
for (float axis : {input.cells[i].real(), input.cells[i].imag()})
{
const float distance0 = std::min({
metric(axis, 0, 0, 0), metric(axis, 0, 0, 1),
metric(axis, 0, 1, 0), metric(axis, 0, 1, 1)
});
const float distance1 = std::min({
metric(axis, 1, 0, 0), metric(axis, 1, 0, 1),
metric(axis, 1, 1, 0), metric(axis, 1, 1, 1)
});
level0Soft.push_back(
(distance1 - distance0) * input.reliabilities[i]
);
}
}
if (!decodeLevel(0U, level0Soft))
{
if (error) {
*error = "DRM 64-QAM UEP MSC level-0 decoding failed";
}
return false;
}
std::vector<float> level1Soft;
level1Soft.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bit = 2U * i + static_cast<std::size_t>(axisIndex);
const int level0 = mappedLevels[0][bit];
const float distance0 = std::min(
metric(axes[axisIndex], level0, 0, 0),
metric(axes[axisIndex], level0, 0, 1)
);
const float distance1 = std::min(
metric(axes[axisIndex], level0, 1, 0),
metric(axes[axisIndex], level0, 1, 1)
);
level1Soft.push_back(
(distance1 - distance0) * input.reliabilities[i]
);
}
}
if (!decodeLevel(1U, level1Soft))
{
if (error) {
*error = "DRM 64-QAM UEP MSC level-1 decoding failed";
}
return false;
}
std::vector<float> level2Soft;
level2Soft.reserve(2U * input.cells.size());
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bit = 2U * i + static_cast<std::size_t>(axisIndex);
const int level0 = mappedLevels[0][bit];
const int level1 = mappedLevels[1][bit];
level2Soft.push_back((
metric(axes[axisIndex], level0, level1, 1)
- metric(axes[axisIndex], level0, level1, 0)
) * input.reliabilities[i]);
}
}
if (!decodeLevel(2U, level2Soft))
{
if (error) {
*error = "DRM 64-QAM UEP MSC level-2 decoding failed";
}
return false;
}
// Apply the same iterative multilevel-decision schedule as the EEP
// path. The UEP code changes puncturing at the part-A/part-B boundary,
// but its re-encoded constellation decisions have the same axis
// mapping.
for (int iteration = 0; iteration < AdditionalMLCIterations; ++iteration)
{
const std::vector<std::vector<std::uint8_t>> previous(
decodedLevels.begin(), decodedLevels.begin() + 3
);
level0Soft.clear();
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bit = 2U * i
+ static_cast<std::size_t>(axisIndex);
const int level1 = mappedLevels[1][bit];
const int level2 = mappedLevels[2][bit];
level0Soft.push_back((
metric(axes[axisIndex], 1, level1, level2)
- metric(axes[axisIndex], 0, level1, level2)
) * input.reliabilities[i]);
}
}
if (!decodeLevel(0U, level0Soft))
{
if (error) {
*error = "DRM 64-QAM UEP iterative level-0 decoding failed";
}
return false;
}
level1Soft.clear();
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bit = 2U * i
+ static_cast<std::size_t>(axisIndex);
const int level0 = mappedLevels[0][bit];
const int level2 = mappedLevels[2][bit];
level1Soft.push_back((
metric(axes[axisIndex], level0, 1, level2)
- metric(axes[axisIndex], level0, 0, level2)
) * input.reliabilities[i]);
}
}
if (!decodeLevel(1U, level1Soft))
{
if (error) {
*error = "DRM 64-QAM UEP iterative level-1 decoding failed";
}
return false;
}
level2Soft.clear();
for (std::size_t i = 0; i < input.cells.size(); ++i)
{
const float axes[2] = {input.cells[i].real(), input.cells[i].imag()};
for (int axisIndex = 0; axisIndex < 2; ++axisIndex)
{
const std::size_t bit = 2U * i
+ static_cast<std::size_t>(axisIndex);
const int level0 = mappedLevels[0][bit];
const int level1 = mappedLevels[1][bit];
level2Soft.push_back((
metric(axes[axisIndex], level0, level1, 1)
- metric(axes[axisIndex], level0, level1, 0)
) * input.reliabilities[i]);
}
}
if (!decodeLevel(2U, level2Soft))
{
if (error) {
*error = "DRM 64-QAM UEP iterative level-2 decoding failed";
}
return false;
}
if (std::equal(previous.begin(), previous.end(), decodedLevels.begin())) {
break;
}
}
}
else
{
if (error) {
*error = "Invalid DRM MSC UEP component profile";
}
return false;
}
output.bits.reserve(static_cast<std::size_t>(layoutInformationBitCount(layout)));
for (std::size_t level = 0; level < componentCount; ++level)
{
output.bits.insert(
output.bits.end(), decodedLevels[level].begin(),
decodedLevels[level].begin() + layout.higherBitCounts[level]
);
}
for (std::size_t level = 0; level < componentCount; ++level)
{
output.bits.insert(
output.bits.end(),
decodedLevels[level].begin() + layout.higherBitCounts[level],
decodedLevels[level].end()
);
}
EnergyDispersal::apply(output.bits);
output.trailingBitCount = static_cast<int>(output.bits.size() % 8U);
return true;
}
bool MSCMultiplexParser::extractStreams(
const MSCDecodedMultiplexFrame& multiplex,
const SDCMultiplexDescription& description,
std::vector<MSCLogicalStreamFrame>& streams,
std::string* error
)
{
streams.clear();
if (!description.present || description.streams.empty())
{
if (error) {
*error = "Missing DRM MSC multiplex description";
}
return false;
}
std::size_t partABytes = 0;
std::size_t partBBytes = 0;
for (const SDCStreamDescription& stream : description.streams)
{
if (stream.partALengthBytes < 0 || stream.partBLengthBytes < 0)
{
if (error) {
*error = "Invalid DRM MSC stream length";
}
return false;
}
partABytes += static_cast<std::size_t>(stream.partALengthBytes);
partBBytes += static_cast<std::size_t>(stream.partBLengthBytes);
}
if (8U * (partABytes + partBBytes) > multiplex.bits.size())
{
if (error) {
*error = "DRM MSC stream lengths exceed decoded capacity";
}
return false;
}
streams.resize(description.streams.size());
std::size_t partAOffset = 0;
std::size_t partBOffset = 8U * partABytes;
for (std::size_t i = 0; i < description.streams.size(); ++i)
{
const SDCStreamDescription& source = description.streams[i];
MSCLogicalStreamFrame& destination = streams[i];
destination.streamId = source.streamId;
destination.partA = bitsToBytes(
multiplex.bits, partAOffset,
static_cast<std::size_t>(source.partALengthBytes)
);
destination.partB = bitsToBytes(
multiplex.bits, partBOffset,
static_cast<std::size_t>(source.partBLengthBytes)
);
partAOffset += 8U * static_cast<std::size_t>(source.partALengthBytes);
partBOffset += 8U * static_cast<std::size_t>(source.partBLengthBytes);
}
return true;
}
} // namespace modemdrm