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.
dvmhost/src/bridge/HostBridge.NXDN.cpp

757 lines
27 KiB

// SPDX-License-Identifier: GPL-2.0-only
/*
* Digital Voice Modem - Bridge
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright (C) 2026 Bryan Biedenkapp, N2PLL
*
*/
#include "Defines.h"
#include "common/analog/AnalogDefines.h"
#include "common/analog/AnalogAudio.h"
#include "common/dmr/DMRDefines.h"
#include "common/edac/AMBEFEC.h"
#include "common/nxdn/NXDNDefines.h"
#include "common/nxdn/NXDNUtils.h"
#include "common/nxdn/Audio.h"
#include "common/nxdn/Sync.h"
#include "common/nxdn/channel/FACCH1.h"
#include "common/nxdn/channel/LICH.h"
#include "common/nxdn/channel/SACCH.h"
#include "common/nxdn/lc/RTCH.h"
#include "common/Log.h"
#include "common/Utils.h"
#include "HostBridge.h"
#include "BridgeMain.h"
using namespace analog;
using namespace analog::defines;
using namespace network;
using namespace network::frame;
using namespace network::udp;
#include <cstdio>
#include <algorithm>
#include <functional>
#include <random>
// ---------------------------------------------------------------------------
// Public Class Members
// ---------------------------------------------------------------------------
/*
** NXDN
*/
/* Helper to process NXDN network traffic. */
void HostBridge::processNXDNNetwork(uint8_t* buffer, uint32_t length)
{
assert(buffer != nullptr);
using namespace nxdn;
using namespace nxdn::defines;
if (m_txMode != TX_MODE_NXDN) {
m_network->resetNXDN();
return;
}
uint8_t messageType = buffer[4U];
uint32_t srcId = GET_UINT24(buffer, 5U);
uint32_t dstId = GET_UINT24(buffer, 8U);
if (m_debug) {
LogDebug(LOG_NET, "NXDN, messageType = $%02X, srcId = %u, dstId = %u, len = %u", messageType, srcId, dstId, length);
}
if (m_audioDetect || m_trafficFromUDP)
return;
if (srcId == 0U) {
m_network->resetNXDN();
return;
}
if (dstId != m_dstId) {
m_network->resetNXDN();
return;
}
uint8_t frame[NXDN_FRAME_LENGTH_BYTES + 2U];
::memset(frame, 0x00U, NXDN_FRAME_LENGTH_BYTES + 2U);
::memcpy(frame + 2U, buffer + 24U, NXDN_FRAME_LENGTH_BYTES);
NXDNUtils::scrambler(frame + 2U);
channel::LICH lich;
if (!lich.decode(frame + 2U)) {
m_network->resetNXDN();
return;
}
FuncChannelType::E fct = lich.getFCT();
// process non-superframe control signalling (VCALL/TX_REL) from FACCH
if (fct == FuncChannelType::USC_SACCH_NS) {
channel::FACCH1 facch;
bool valid = facch.decode(frame + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
if (!valid) {
valid = facch.decode(frame + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
}
if (valid) {
uint8_t lcBuffer[10U];
::memset(lcBuffer, 0x00U, 10U);
facch.getData(lcBuffer);
lc::RTCH lc;
lc.decode(lcBuffer, NXDN_FACCH1_LENGTH_BITS);
if (lc.getMessageType() == MessageType::RTCH_VCALL) {
m_rxNXDNLC = lc;
m_callAlgoId = lc.getAlgId();
if (m_callAlgoId != CIPHER_TYPE_NONE) {
if (m_callAlgoId != m_nxdnCipherType || lc.getKId() != m_tekKeyId ||
m_nxdnCrypto->getTEKKeyLength() == 0U) {
LogWarning(LOG_HOST, "NXDN, call ignored, unsupported encryption parameters, callAlgoId = $%02X, callKID = $%02X, tekAlgoId = $%02X, tekKID = $%02X",
m_callAlgoId, lc.getKId(), m_nxdnCipherType, m_tekKeyId);
m_ignoreCall = true;
m_network->resetNXDN();
return;
}
if (m_callAlgoId == CIPHER_TYPE_EHR) {
m_nxdnCrypto->generateKeystream();
}
else {
// DES/AES headers carry VCALL in FACCH1-1 and the current
// session's VCALL_IV in FACCH1-2.
channel::FACCH1 ivFacch;
if (!ivFacch.decode(frame + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS +
NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS)) {
LogWarning(LOG_HOST, "NXDN, encrypted call ignored, missing initial VCALL_IV");
m_ignoreCall = true;
m_network->resetNXDN();
return;
}
uint8_t ivData[NXDN_RTCH_LC_LENGTH_BYTES];
::memset(ivData, 0x00U, sizeof(ivData));
ivFacch.getData(ivData);
lc::RTCH ivLC;
ivLC.decode(ivData, NXDN_FACCH1_LENGTH_BITS);
if (ivLC.getMessageType() != MessageType::RTCH_VCALL_IV) {
LogWarning(LOG_HOST, "NXDN, encrypted call ignored, invalid initial VCALL_IV");
m_ignoreCall = true;
m_network->resetNXDN();
return;
}
uint8_t mi[MI_LENGTH_BYTES];
ivLC.getMI(mi);
m_nxdnCrypto->setMI(mi);
m_nxdnCrypto->generateKeystream();
if (!m_nxdnCrypto->hasValidKeystream()) {
m_ignoreCall = true;
m_network->resetNXDN();
return;
}
}
}
m_networkWatchdog.start();
if (m_network->getNXDNStreamId() != m_rxStreamId && !m_callInProgress) {
m_callInProgress = true;
uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
m_rxStartTime = now;
LogInfoEx(LOG_HOST, "NXDN, call start, srcId = %u, dstId = %u", srcId, dstId);
if (m_preambleLeaderTone)
generatePreambleTone();
}
}
else if (lc.getMessageType() == MessageType::RTCH_TX_REL || lc.getMessageType() == MessageType::RTCH_TX_REL_EX) {
m_callInProgress = false;
m_networkWatchdog.stop();
m_ignoreCall = false;
m_callAlgoId = 0U;
if (m_rxStartTime > 0U) {
uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
uint64_t diff = now - m_rxStartTime;
LogInfoEx(LOG_HOST, "NXDN, call end, srcId = %u, dstId = %u, dur = %us", srcId, dstId, diff / 1000U);
}
m_rxNXDNLC = lc::RTCH();
m_rxStartTime = 0U;
m_rxStreamId = 0U;
m_nxdnSeqNo = 0U;
m_nxdnN = 0U;
::memset(m_nxdnAMBE, 0x00U, 36U);
m_nxdnCrypto->resetKeystream();
m_rxNXDNSACCHLC = lc::RTCH();
::memset(m_rxNXDNSACCHData, 0x00U, sizeof(m_rxNXDNSACCHData));
m_rxNXDNSACCHMask = 0U;
m_rxNXDNPendingMI = false;
if (!m_udpRTPContinuousSeq) {
m_rtpInitialFrame = false;
m_rtpSeqNo = 0U;
}
m_rtpTimestamp = INVALID_TS;
m_network->resetNXDN();
return;
}
}
}
if (m_ignoreCall)
return;
// only superframe SACCH traffic frames contain voice payloads
if (fct != FuncChannelType::USC_SACCH_SS)
return;
// reassemble the 72-bit RTCH message carried as four 18-bit SACCH
// fragments -- DES/AES alternates VCALL and VCALL_IV superframes
channel::SACCH voiceSACCH;
if (voiceSACCH.decode(frame + 2U)) {
uint8_t fragment[3U];
::memset(fragment, 0x00U, sizeof(fragment));
voiceSACCH.getData(fragment);
uint8_t quarter = 3U - (uint8_t)voiceSACCH.getStructure();
if (quarter == 0U) {
m_rxNXDNSACCHLC = lc::RTCH();
::memset(m_rxNXDNSACCHData, 0x00U, sizeof(m_rxNXDNSACCHData));
m_rxNXDNSACCHMask = 0U;
}
// RTCH::decode's offset addresses its input; assemble the fragments first.
for (uint32_t bit = 0U; bit < 18U; bit++)
WRITE_BIT(m_rxNXDNSACCHData, quarter * 18U + bit, READ_BIT(fragment, bit));
m_rxNXDNSACCHMask |= (uint8_t)(1U << quarter);
if (quarter == 3U && m_rxNXDNSACCHMask == 0x0FU) {
m_rxNXDNSACCHLC.decode(m_rxNXDNSACCHData, 72U);
uint8_t sacchType = m_rxNXDNSACCHLC.getMessageType();
if (sacchType == MessageType::RTCH_VCALL) {
m_rxNXDNLC = m_rxNXDNSACCHLC;
m_callAlgoId = m_rxNXDNLC.getAlgId();
m_nxdnSeqNo = 3U;
if (m_callAlgoId == CIPHER_TYPE_EHR &&
m_callAlgoId == m_nxdnCipherType &&
m_rxNXDNLC.getKId() == m_tekKeyId &&
m_nxdnCrypto->getTEKKeyLength() > 0U) {
m_nxdnCrypto->generateKeystream();
}
}
else if (sacchType == MessageType::RTCH_VCALL_IV &&
m_callAlgoId >= CIPHER_TYPE_DES) {
m_rxNXDNSACCHLC.getMI(m_rxNXDNNextMI);
m_rxNXDNPendingMI = true;
m_nxdnSeqNo = 7U;
}
m_rxNXDNSACCHMask = 0U;
}
}
// bridge may join an already active stream after its VCALL header, treat
// the first valid voice frame as the start of the receive call as well
if (!m_callInProgress) {
if (m_rxNXDNLC.getMessageType() != MessageType::RTCH_VCALL)
return;
if (m_callAlgoId != CIPHER_TYPE_NONE &&
(m_callAlgoId != m_nxdnCipherType || m_rxNXDNLC.getKId() != m_tekKeyId ||
m_nxdnCrypto->getTEKKeyLength() == 0U)) {
m_ignoreCall = true;
return;
}
// if late entry first observed the preceding VCALL_IV superframe, that
// announced MI is already current by the time this VCALL completes
if (m_rxNXDNPendingMI && m_callAlgoId >= CIPHER_TYPE_DES) {
m_nxdnCrypto->setMI(m_rxNXDNNextMI);
m_nxdnCrypto->generateKeystream();
m_rxNXDNPendingMI = false;
}
m_callInProgress = true;
m_networkWatchdog.start();
m_rxStartTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
LogInfoEx(LOG_HOST, "NXDN, late entry call start, srcId = %u, dstId = %u", srcId, dstId);
if (m_preambleLeaderTone)
generatePreambleTone();
}
else {
m_networkWatchdog.start();
}
LogInfoEx(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, srcId = %u, dstId = %u", srcId, dstId);
decodeNXDNAudioFrame(frame, srcId, dstId, m_nxdnSeqNo);
// a VCALL_IV completed in this frame announces the MI for the following
// eight-frame DES/AES session, so activate it only after current audio
if (m_rxNXDNPendingMI) {
m_nxdnCrypto->setMI(m_rxNXDNNextMI);
m_nxdnCrypto->generateKeystream();
m_rxNXDNPendingMI = false;
}
m_nxdnSeqNo++;
m_rxStreamId = m_network->getNXDNStreamId();
}
/* Helper to decode NXDN network traffic audio frames. */
void HostBridge::decodeNXDNAudioFrame(uint8_t* frame, uint32_t srcId, uint32_t dstId, uint8_t nxdnN)
{
assert(frame != nullptr);
using namespace nxdn;
using namespace nxdn::defines;
channel::LICH lich;
if (!lich.decode(frame + 2U))
return;
ChOption::E option = lich.getOption();
nxdn::Audio nxdnAudio;
::edac::AMBEFEC ambeFec;
// ahhh yes fantastical C++ lambda functions...
auto decodePair = [&](uint32_t pairOffset, uint8_t vcBase) {
uint8_t nxdnAMBE[18U];
::memset(nxdnAMBE, 0x00U, 18U);
::memcpy(nxdnAMBE, frame + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + pairOffset, 18U);
const uint32_t fecErrors[] = {
ambeFec.regenerateNXDN(nxdnAMBE + 0U),
ambeFec.regenerateNXDN(nxdnAMBE + 9U)
};
// match the normal NXDN voice path's lost-audio policy -- a pair is
// half of a full four-codeword frame, so use half the frame threshold
if ((fecErrors[0U] + fecErrors[1U]) > (DEFAULT_SILENCE_THRESHOLD / 2U)) {
LogWarning(LOG_HOST, "NXDN, AMBE errors exceeded threshold, substituting silence, errors = %u",
fecErrors[0U] + fecErrors[1U]);
if (m_callAlgoId != CIPHER_TYPE_NONE)
return;
::memcpy(nxdnAMBE + 0U, NULL_AMBE, 9U);
::memcpy(nxdnAMBE + 9U, NULL_AMBE, 9U);
}
uint8_t packedBits[13U];
::memset(packedBits, 0x00U, 13U);
nxdnAudio.decode(nxdnAMBE, packedBits);
for (uint8_t half = 0U; half < 2U; half++) {
uint8_t rawBits[49U];
::memset(rawBits, 0x00U, sizeof(rawBits));
for (uint32_t b = 0U; b < 49U; b++) {
rawBits[b] = READ_BIT(packedBits, (half * 49U) + b) ? 1U : 0U;
}
if (m_callAlgoId != CIPHER_TYPE_NONE) {
if (!m_nxdnCrypto->hasValidKeystream())
continue;
if (m_debug) {
uint8_t mi[MI_LENGTH_BYTES];
::memset(mi, 0x00U, MI_LENGTH_BYTES);
m_nxdnCrypto->getMI(mi);
LogInfoEx(LOG_NET, "Crypto, Enc Sync, MI = %02X %02X %02X %02X %02X %02X %02X %02X",
mi[0U], mi[1U], mi[2U], mi[3U], mi[4U], mi[5U], mi[6U], mi[7U]);
}
uint8_t framesPerSession = m_callAlgoId == CIPHER_TYPE_EHR ? 4U : 8U;
uint8_t word = (uint8_t)((nxdnN % framesPerSession) * 4U + vcBase + half);
switch (m_callAlgoId) {
case CIPHER_TYPE_EHR:
m_nxdnCrypto->cryptEHR_AMBE(rawBits, word);
break;
case CIPHER_TYPE_DES:
m_nxdnCrypto->cryptDES_AMBE(rawBits, word);
break;
case CIPHER_TYPE_AES:
m_nxdnCrypto->cryptAES_AMBE(rawBits, word);
break;
default:
continue;
}
}
short samples[AUDIO_SAMPLES_LENGTH];
int errs = 0;
#if defined(_WIN32)
if (m_useExternalVocoder) {
// reframe the NXDN 49-bit payload before handing it to the external vocoder
uint8_t ambePartial[dmr::defines::RAW_AMBE_LENGTH_BYTES];
::memset(ambePartial, 0x00U, sizeof(ambePartial));
m_encoder->encodeBits(rawBits, ambePartial);
errs = ambeDecode(ambePartial, dmr::defines::RAW_AMBE_LENGTH_BYTES, samples);
}
else {
#endif // defined(_WIN32)
errs = m_decoder->decodeBits(rawBits, samples);
#if defined(_WIN32)
}
#endif // defined(_WIN32)
errs += (int)fecErrors[half];
if (m_debug) {
LogDebug(LOG_HOST, "NXDN, Frame, VC%u.%u, srcId = %u, dstId = %u, errs = %u", nxdnN, vcBase + half, srcId, dstId, errs);
}
AnalogAudio::gain(samples, AUDIO_SAMPLES_LENGTH, m_rxAudioGain);
if (m_localAudio) {
m_outputAudio.addData(samples, AUDIO_SAMPLES_LENGTH);
assertRtsPtt();
}
if (m_udpAudio) {
int pcmIdx = 0;
uint8_t pcm[AUDIO_SAMPLES_LENGTH * 2U];
if (m_udpUseULaw) {
for (uint32_t smpIdx = 0; smpIdx < AUDIO_SAMPLES_LENGTH; smpIdx++) {
pcm[smpIdx] = AnalogAudio::encodeMuLaw(samples[smpIdx]);
}
if (m_trace)
Utils::dump(1U, "HostBridge()::decodeNXDNAudioFrame(), Encoded uLaw Audio", pcm, AUDIO_SAMPLES_LENGTH);
writeUDPAudio(srcId, dstId, pcm, AUDIO_SAMPLES_LENGTH_BYTES / 2U);
}
else {
for (uint32_t smpIdx = 0; smpIdx < AUDIO_SAMPLES_LENGTH; smpIdx++) {
pcm[pcmIdx + 0] = (uint8_t)(samples[smpIdx] & 0xFF);
pcm[pcmIdx + 1] = (uint8_t)((samples[smpIdx] >> 8) & 0xFF);
pcmIdx += 2;
}
writeUDPAudio(srcId, dstId, pcm, AUDIO_SAMPLES_LENGTH_BYTES);
}
}
}
};
switch (option) {
case ChOption::STEAL_NONE:
decodePair(0U, 0U);
decodePair(18U, 2U);
break;
case ChOption::STEAL_FACCH1_1:
decodePair(18U, 2U);
break;
case ChOption::STEAL_FACCH1_2:
decodePair(0U, 0U);
break;
case ChOption::STEAL_FACCH:
default:
break;
}
}
/* Helper to encode NXDN network traffic audio frames. */
void HostBridge::encodeNXDNAudioFrame(uint8_t* pcm, uint32_t forcedSrcId, uint32_t forcedDstId)
{
assert(pcm != nullptr);
using namespace nxdn;
using namespace nxdn::defines;
bool callStart = false;
uint32_t srcId = m_srcId;
if (m_srcIdOverride != 0 && (m_overrideSrcIdFromMDC))
srcId = m_srcIdOverride;
if (m_overrideSrcIdFromUDP)
srcId = m_udpSrcId;
if (forcedSrcId > 0 && forcedSrcId != m_srcId)
srcId = forcedSrcId;
uint32_t dstId = m_dstId;
if (forcedDstId > 0 && forcedDstId != m_dstId)
dstId = forcedDstId;
if (srcId == 0U)
srcId = m_srcId;
int smpIdx = 0;
short samples[AUDIO_SAMPLES_LENGTH];
for (uint32_t pcmIdx = 0; pcmIdx < (AUDIO_SAMPLES_LENGTH * 2U); pcmIdx += 2) {
samples[smpIdx] = (short)((pcm[pcmIdx + 1] << 8) + pcm[pcmIdx + 0]);
smpIdx++;
}
AnalogAudio::gain(samples, AUDIO_SAMPLES_LENGTH, m_txAudioGain);
uint8_t rawBits[49U];
::memset(rawBits, 0x00U, sizeof(rawBits));
#if defined(_WIN32)
if (m_useExternalVocoder) {
// reframe the NXDN 49-bit payload before handing it to the external vocoder
uint8_t ambePartial[dmr::defines::RAW_AMBE_LENGTH_BYTES];
::memset(ambePartial, 0x00U, sizeof(ambePartial));
ambeEncode(samples, AUDIO_SAMPLES_LENGTH, ambePartial);
char mbeBits[49U];
::memset(mbeBits, 0x00U, sizeof(mbeBits));
m_decoder->decodeBits(ambePartial, mbeBits);
for (uint32_t i = 0U; i < 49U; i++)
rawBits[i] = mbeBits[i] != 0;
}
else {
#endif // defined(_WIN32)
m_encoder->encodeBits(samples, rawBits);
#if defined(_WIN32)
}
#endif // defined(_WIN32)
if (m_nxdnCipherType != CIPHER_TYPE_NONE) {
if (m_nxdnCrypto->getTEKKeyLength() == 0U) {
LogWarning(LOG_HOST, "NXDN, encrypted audio dropped while TEK is unavailable");
return;
}
if (m_nxdnSeqNo == 0U && m_nxdnN == 0U && !m_nxdnCrypto->hasValidKeystream()) {
if (m_nxdnCipherType >= CIPHER_TYPE_DES)
m_nxdnCrypto->generateMI();
m_nxdnCrypto->generateKeystream();
}
// during the second superframe the existing keystream remains active,
// while the advanced MI is announced for the following session
if (m_nxdnCipherType >= CIPHER_TYPE_DES &&
(m_nxdnSeqNo % 8U) == 4U && m_nxdnN == 0U) {
m_nxdnCrypto->generateNextMI();
}
uint8_t framesPerSession = m_nxdnCipherType == CIPHER_TYPE_EHR ? 4U : 8U;
uint8_t word = (uint8_t)((m_nxdnSeqNo % framesPerSession) * 4U + m_nxdnN);
switch (m_nxdnCipherType) {
case CIPHER_TYPE_EHR:
m_nxdnCrypto->cryptEHR_AMBE(rawBits, word);
break;
case CIPHER_TYPE_DES:
m_nxdnCrypto->cryptDES_AMBE(rawBits, word);
break;
case CIPHER_TYPE_AES:
m_nxdnCrypto->cryptAES_AMBE(rawBits, word);
break;
default:
return;
}
}
if (m_nxdnN >= 4U) {
m_nxdnN = 0U;
}
uint8_t* packedAMBE = m_nxdnAMBE + (m_nxdnN * dmr::defines::RAW_AMBE_LENGTH_BYTES);
::memset(packedAMBE, 0x00U, dmr::defines::RAW_AMBE_LENGTH_BYTES);
for (uint32_t b = 0U; b < 49U; b++)
WRITE_BIT(packedAMBE, b, rawBits[b] != 0U);
m_nxdnN++;
if (m_nxdnN < 4U) {
return;
}
nxdn::Audio nxdnAudio;
uint8_t nxdnAudioPayload[36U];
::memset(nxdnAudioPayload, 0x00U, 36U);
for (uint8_t pair = 0U; pair < 2U; pair++) {
uint8_t packedBits[13U];
::memset(packedBits, 0x00U, 13U);
for (uint8_t half = 0U; half < 2U; half++) {
uint8_t* ambe = m_nxdnAMBE + ((pair * 2U + half) * dmr::defines::RAW_AMBE_LENGTH_BYTES);
for (uint32_t b = 0U; b < 49U; b++) {
WRITE_BIT(packedBits, (half * 49U) + b, READ_BIT(ambe, b));
}
}
uint8_t encodedPair[18U];
::memset(encodedPair, 0x00U, 18U);
nxdnAudio.encode(packedBits, encodedPair);
::memcpy(nxdnAudioPayload + (pair * 18U), encodedPair, 18U);
}
lc::RTCH lc = lc::RTCH();
lc.setMessageType(MessageType::RTCH_VCALL);
lc.setCallType(CallType::UNSPECIFIED);
lc.setGroup(true);
lc.setSrcId((uint16_t)srcId);
lc.setDstId((uint16_t)dstId);
lc.setTransmissionMode(TransmissionMode::MODE_4800);
lc.setAlgId(m_nxdnCipherType);
lc.setKId(m_nxdnCipherType != CIPHER_TYPE_NONE ? (uint8_t)m_tekKeyId : 0U);
lc.setEncrypted(m_nxdnCipherType != CIPHER_TYPE_NONE);
if (m_nxdnSeqNo == 0U) {
uint8_t controlFrame[NXDN_FRAME_LENGTH_BYTES + 2U];
::memset(controlFrame, 0x00U, NXDN_FRAME_LENGTH_BYTES + 2U);
Sync::addNXDNSync(controlFrame + 2U);
channel::LICH lich;
lich.setRFCT(RFChannelType::RDCH);
lich.setFCT(FuncChannelType::USC_SACCH_NS);
lich.setOption(ChOption::STEAL_FACCH);
lich.setOutbound(true);
lich.encode(controlFrame + 2U);
channel::SACCH sacch;
sacch.setData(SACCH_IDLE);
sacch.setRAN(0U);
sacch.setStructure(ChStructure::SR_SINGLE);
sacch.encode(controlFrame + 2U);
channel::FACCH1 facch;
uint8_t lcData[NXDN_RTCH_LC_LENGTH_BYTES];
::memset(lcData, 0x00U, NXDN_RTCH_LC_LENGTH_BYTES);
lc.encode(lcData, NXDN_RTCH_LC_LENGTH_BITS);
facch.setData(lcData);
facch.encode(controlFrame + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
if (m_nxdnCipherType >= CIPHER_TYPE_DES) {
lc::RTCH ivLC;
ivLC.setMessageType(MessageType::RTCH_VCALL_IV);
uint8_t mi[MI_LENGTH_BYTES];
m_nxdnCrypto->getMI(mi);
ivLC.setMI(mi);
::memset(lcData, 0x00U, sizeof(lcData));
ivLC.encode(lcData, NXDN_RTCH_LC_LENGTH_BITS);
facch.setData(lcData);
}
facch.encode(controlFrame + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS +
NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
NXDNUtils::scrambler(controlFrame + 2U);
LogInfoEx(LOG_HOST, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", srcId = %u, dstId = %u", srcId, dstId);
m_network->writeNXDN(lc, controlFrame + 2U, NXDN_FRAME_LENGTH_BYTES);
if (m_txStreamId <= 1U) {
callStart = true;
}
m_txStreamId = m_network->getNXDNStreamId();
}
uint8_t voiceFrame[NXDN_FRAME_LENGTH_BYTES + 2U];
::memset(voiceFrame, 0x00U, NXDN_FRAME_LENGTH_BYTES + 2U);
Sync::addNXDNSync(voiceFrame + 2U);
channel::LICH lich;
lich.setRFCT(RFChannelType::RDCH);
lich.setFCT(FuncChannelType::USC_SACCH_SS);
lich.setOption(ChOption::STEAL_NONE);
lich.setOutbound(true);
lich.encode(voiceFrame + 2U);
channel::SACCH sacch;
uint8_t lcData[NXDN_RTCH_LC_LENGTH_BYTES];
::memset(lcData, 0x00U, sizeof(lcData));
lc::RTCH sacchLC = lc;
if (m_nxdnCipherType >= CIPHER_TYPE_DES && (m_nxdnSeqNo % 8U) >= 4U) {
sacchLC = lc::RTCH();
sacchLC.setMessageType(MessageType::RTCH_VCALL_IV);
uint8_t mi[MI_LENGTH_BYTES];
m_nxdnCrypto->getMI(mi);
sacchLC.setMI(mi);
}
sacchLC.encode(lcData, NXDN_RTCH_LC_LENGTH_BITS);
const uint8_t superframeIndex = m_nxdnSeqNo % 4U;
const ChStructure::E structures[] = {
ChStructure::SR_1_4, ChStructure::SR_2_4,
ChStructure::SR_3_4, ChStructure::SR_4_4
};
uint8_t sacchData[3U];
::memset(sacchData, 0x00U, sizeof(sacchData));
for (uint32_t bit = 0U; bit < 18U; bit++) {
WRITE_BIT(sacchData, bit, READ_BIT(lcData, superframeIndex * 18U + bit));
}
sacch.setData(sacchData);
sacch.setRAN(0U);
sacch.setStructure(structures[superframeIndex]);
sacch.encode(voiceFrame + 2U);
::memcpy(voiceFrame + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES, nxdnAudioPayload, 36U);
NXDNUtils::scrambler(voiceFrame + 2U);
LogInfoEx(LOG_HOST, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, srcId = %u, dstId = %u", srcId, dstId);
m_network->writeNXDN(lc, voiceFrame + 2U, NXDN_FRAME_LENGTH_BYTES);
m_txStreamId = m_network->getNXDNStreamId();
m_nxdnSeqNo++;
if (m_nxdnCipherType >= CIPHER_TYPE_DES && (m_nxdnSeqNo % 8U) == 0U)
m_nxdnCrypto->generateKeystream();
m_nxdnN = 0U;
::memset(m_nxdnAMBE, 0x00U, 36U);
// is this traffic being duplicated to a raw analog TG?
if (m_duplicateToAnalog) {
analog::data::NetData analogData;
analogData.setSeqNo(m_analogN);
analogData.setSrcId(srcId);
analogData.setDstId(dstId);
analogData.setControl(0U);
analogData.setFrameType(AudioFrameType::VOICE);
if (callStart) {
analogData.setFrameType(AudioFrameType::VOICE_START);
if (m_grantDemand) {
analogData.setControl(0x80U); // analog remote grant demand flag
}
}
int pcmIdx = 0;
uint8_t outPcm[AUDIO_SAMPLES_LENGTH * 2U];
for (uint32_t smpIdx = 0; smpIdx < AUDIO_SAMPLES_LENGTH; smpIdx++) {
outPcm[smpIdx] = AnalogAudio::encodeMuLaw(samples[smpIdx]);
}
if (m_trace)
Utils::dump(1U, "HostBridge()::encodeNXDNAudioFrame(), Encoded uLaw Audio", outPcm, AUDIO_SAMPLES_LENGTH);
analogData.setAudio(outPcm);
if (analogData.getFrameType() == AudioFrameType::VOICE) {
LogInfoEx(LOG_HOST, ANO_VOICE ", audio, srcId = %u, dstId = %u, seqNo = %u", srcId, dstId, analogData.getSeqNo());
}
m_network->writeAnalog(analogData);
m_analogN++;
}
}

Powered by TurnKey Linux.