Digital_Voice_Modem_Project
/
dvmhost
mirror of https://github.com/DVMProject/dvmhost.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove various verbosities for NXDN channel classes; correct incorrect handling of dump RCCH data option; refactor NXDN code;

Browse Source
2.0-maint
Bryan Biedenkapp 3 years ago
parent a78199c6a2
commit 01ffa07c69
14 changed files with 52 additions and 114 deletions
Show Stats Download Patch File Download Diff File

10
nxdn/Control.cpp
Unescape View File

@ -130,6 +130,7 @@ Control::Control(uint32_t ran, uint32_t callHang, uint32_t queueSize, uint32_t t
m_minRSSI(0U), m_minRSSI(0U),
m_aveRSSI(0U), m_aveRSSI(0U),
m_rssiCount(0U), m_rssiCount(0U),
m_dumpRCCH(dumpRCCHData),
m_verbose(verbose), m_verbose(verbose),
m_debug(debug) m_debug(debug)
{ {
@ -140,9 +141,12 @@ Control::Control(uint32_t ran, uint32_t callHang, uint32_t queueSize, uint32_t t
acl::AccessControl::init(m_ridLookup, m_tidLookup); acl::AccessControl::init(m_ridLookup, m_tidLookup);
m_voice = new Voice(this, network, debug, verbose); m_voice = new Voice(this, network, dumpRCCHData, debug, verbose);
m_trunk = new Trunk(this, network, debug, verbose, dumpRCCHData); m_trunk = new Trunk(this, network, dumpRCCHData, debug, verbose);
m_data = new Data(this, network, debug, verbose); m_data = new Data(this, network, debug, verbose);
m_rfLC.setVerbose(m_dumpRCCH);
m_netLC.setVerbose(m_dumpRCCH);
} }
/// <summary> /// <summary>
@ -182,11 +186,13 @@ void Control::reset()
m_queue.clear(); m_queue.clear();
m_rfMask = 0x00U; m_rfMask = 0x00U;
m_rfLC.setVerbose(m_dumpRCCH);
m_rfLC.reset(); m_rfLC.reset();
m_netState = RS_NET_IDLE; m_netState = RS_NET_IDLE;
m_netMask = 0x00U; m_netMask = 0x00U;
m_netLC.setVerbose(m_dumpRCCH);
m_netLC.reset(); m_netLC.reset();
} }

2
nxdn/Control.h
Unescape View File

@ -172,6 +172,8 @@ namespace nxdn
uint32_t m_aveRSSI; uint32_t m_aveRSSI;
uint32_t m_rssiCount; uint32_t m_rssiCount;
bool m_dumpRCCH;
bool m_verbose; bool m_verbose;
bool m_debug; bool m_debug;

29
nxdn/channel/CAC.cpp
Unescape View File

@ -119,8 +119,7 @@ const uint32_t PUNCTURE_LIST_OUT[] = {
/// Initializes a new instance of the CAC class. /// Initializes a new instance of the CAC class.
/// </summary> /// </summary>
CAC::CAC() : CAC::CAC() :
m_verbose(false), m_ran(0U),
m_ran(1U),
m_structure(NXDN_SR_RCCH_SINGLE), m_structure(NXDN_SR_RCCH_SINGLE),
m_idleBusy(true), m_idleBusy(true),
m_txContinuous(false), m_txContinuous(false),
@ -137,8 +136,7 @@ CAC::CAC() :
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="data"></param>
CAC::CAC(const CAC& data) : CAC::CAC(const CAC& data) :
m_verbose(false), m_ran(0U),
m_ran(1U),
m_structure(NXDN_SR_RCCH_SINGLE), m_structure(NXDN_SR_RCCH_SINGLE),
m_idleBusy(true), m_idleBusy(true),
m_txContinuous(false), m_txContinuous(false),
@ -167,8 +165,6 @@ CAC& CAC::operator=(const CAC& data)
if (&data != this) { if (&data != this) {
::memcpy(m_data, data.m_data, NXDN_CAC_CRC_LENGTH_BYTES); ::memcpy(m_data, data.m_data, NXDN_CAC_CRC_LENGTH_BYTES);
m_verbose = data.m_verbose;
m_ran = m_data[0U] & 0x3FU; m_ran = m_data[0U] & 0x3FU;
m_structure = (m_data[0U] >> 6) & 0x03U; m_structure = (m_data[0U] >> 6) & 0x03U;
@ -224,9 +220,9 @@ bool CAC::decode(const uint8_t* data)
conv.chainback(m_data, NXDN_CAC_SHORT_CRC_LENGTH_BITS); conv.chainback(m_data, NXDN_CAC_SHORT_CRC_LENGTH_BITS);
if (m_verbose) { #if DEBUG_NXDN_CAC
Utils::dump(2U, "Decoded CAC", m_data, (NXDN_CAC_SHORT_CRC_LENGTH_BITS / 8U) + 1U); Utils::dump(2U, "Decoded CAC", m_data, (NXDN_CAC_SHORT_CRC_LENGTH_BITS / 8U) + 1U);
} #endif
// check CRC-16 // check CRC-16
bool ret = CRC::checkCRC16(m_data, NXDN_CAC_SHORT_LENGTH_BITS); bool ret = CRC::checkCRC16(m_data, NXDN_CAC_SHORT_LENGTH_BITS);
@ -251,10 +247,9 @@ bool CAC::decode(const uint8_t* data)
m_rxCRC = (crc[0U] << 8) | (crc[1U] << 0); m_rxCRC = (crc[0U] << 8) | (crc[1U] << 0);
#if DEBUG_NXDN_CAC #if DEBUG_NXDN_CAC
if (m_verbose) { Utils::dump(2U, "Raw CAC Buffer", m_data, NXDN_CAC_FEC_LENGTH_BYTES);
Utils::dump(2U, "Raw CAC Buffer", m_data, NXDN_CAC_FEC_LENGTH_BYTES);
}
#endif #endif
return true; return true;
} }
@ -282,9 +277,9 @@ void CAC::encode(uint8_t* data) const
CRC::addCRC16(buffer, NXDN_CAC_LENGTH_BITS); CRC::addCRC16(buffer, NXDN_CAC_LENGTH_BITS);
if (m_verbose) { #if DEBUG_NXDN_CAC
Utils::dump(2U, "Encoded CAC", buffer, NXDN_CAC_FEC_LENGTH_BYTES); Utils::dump(2U, "Encoded CAC", buffer, NXDN_CAC_FEC_LENGTH_BYTES);
} #endif
// encode convolution // encode convolution
uint8_t convolution[NXDN_CAC_FEC_CONV_LENGTH_BYTES]; uint8_t convolution[NXDN_CAC_FEC_CONV_LENGTH_BYTES];
@ -293,10 +288,6 @@ void CAC::encode(uint8_t* data) const
Convolution conv; Convolution conv;
conv.encode(buffer, convolution, NXDN_CAC_CRC_LENGTH_BITS); conv.encode(buffer, convolution, NXDN_CAC_CRC_LENGTH_BITS);
#if DEBUG_NXDN_CAC
Utils::dump(2U, "CAC::encode(), CAC Convolution", convolution, NXDN_CAC_FEC_CONV_LENGTH_BYTES);
#endif
// puncture // puncture
uint8_t puncture[NXDN_CAC_FEC_LENGTH_BYTES]; uint8_t puncture[NXDN_CAC_FEC_LENGTH_BYTES];
::memset(puncture, 0x00U, NXDN_CAC_FEC_LENGTH_BYTES); ::memset(puncture, 0x00U, NXDN_CAC_FEC_LENGTH_BYTES);

3
nxdn/channel/CAC.h
Unescape View File

@ -64,9 +64,6 @@ namespace nxdn
void setData(const uint8_t* data); void setData(const uint8_t* data);
public: public:
/// <summary>Flag indicating verbose log output.</summary>
__PROPERTY(bool, verbose, Verbose);
/** Common Data */ /** Common Data */
/// <summary>Radio Access Number</summary> /// <summary>Radio Access Number</summary>
__PROPERTY(uint8_t, ran, RAN); __PROPERTY(uint8_t, ran, RAN);

22
nxdn/channel/FACCH1.cpp
Unescape View File

@ -72,7 +72,6 @@ const uint32_t PUNCTURE_LIST[] = {
/// Initializes a new instance of the FACCH1 class. /// Initializes a new instance of the FACCH1 class.
/// </summary> /// </summary>
FACCH1::FACCH1() : FACCH1::FACCH1() :
m_verbose(false),
m_data(NULL) m_data(NULL)
{ {
m_data = new uint8_t[NXDN_FACCH1_CRC_LENGTH_BYTES]; m_data = new uint8_t[NXDN_FACCH1_CRC_LENGTH_BYTES];
@ -84,7 +83,6 @@ FACCH1::FACCH1() :
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="data"></param>
FACCH1::FACCH1(const FACCH1& data) : FACCH1::FACCH1(const FACCH1& data) :
m_verbose(false),
m_data(NULL) m_data(NULL)
{ {
copy(data); copy(data);
@ -107,8 +105,6 @@ FACCH1& FACCH1::operator=(const FACCH1& data)
{ {
if (&data != this) { if (&data != this) {
::memcpy(m_data, data.m_data, NXDN_FACCH1_CRC_LENGTH_BYTES); ::memcpy(m_data, data.m_data, NXDN_FACCH1_CRC_LENGTH_BYTES);
m_verbose = data.m_verbose;
} }
return *this; return *this;
@ -171,9 +167,9 @@ bool FACCH1::decode(const uint8_t* data, uint32_t offset)
conv.chainback(m_data, NXDN_FACCH1_CRC_LENGTH_BITS); conv.chainback(m_data, NXDN_FACCH1_CRC_LENGTH_BITS);
if (m_verbose) { #if DEBUG_NXDN_FACCH1
Utils::dump(2U, "Decoded FACCH1", m_data, NXDN_FACCH1_CRC_LENGTH_BYTES); Utils::dump(2U, "Decoded FACCH1", m_data, NXDN_FACCH1_CRC_LENGTH_BYTES);
} #endif
// check CRC-12 // check CRC-12
bool ret = CRC::checkCRC12(m_data, NXDN_FACCH1_LENGTH_BITS); bool ret = CRC::checkCRC12(m_data, NXDN_FACCH1_LENGTH_BITS);
@ -200,9 +196,9 @@ void FACCH1::encode(uint8_t* data, uint32_t offset) const
CRC::addCRC12(buffer, NXDN_FACCH1_LENGTH_BITS); CRC::addCRC12(buffer, NXDN_FACCH1_LENGTH_BITS);
if (m_verbose) { #if DEBUG_NXDN_FACCH1
Utils::dump(2U, "Encoded FACCH1", buffer, NXDN_FACCH1_CRC_LENGTH_BYTES); Utils::dump(2U, "Encoded FACCH1", buffer, NXDN_FACCH1_CRC_LENGTH_BYTES);
} #endif
// encode convolution // encode convolution
uint8_t convolution[NXDN_FACCH1_FEC_CONV_LENGTH_BYTES]; uint8_t convolution[NXDN_FACCH1_FEC_CONV_LENGTH_BYTES];
@ -211,10 +207,6 @@ void FACCH1::encode(uint8_t* data, uint32_t offset) const
Convolution conv; Convolution conv;
conv.encode(buffer, convolution, NXDN_FACCH1_CRC_LENGTH_BITS); conv.encode(buffer, convolution, NXDN_FACCH1_CRC_LENGTH_BITS);
#if DEBUG_NXDN_FACCH1
Utils::dump(2U, "FACCH1::encode(), FACCH1 Convolution", convolution, NXDN_FACCH1_FEC_CONV_LENGTH_BYTES);
#endif
// puncture // puncture
uint8_t puncture[NXDN_FACCH1_FEC_LENGTH_BYTES]; uint8_t puncture[NXDN_FACCH1_FEC_LENGTH_BYTES];
::memset(puncture, 0x00U, NXDN_FACCH1_FEC_LENGTH_BYTES); ::memset(puncture, 0x00U, NXDN_FACCH1_FEC_LENGTH_BYTES);
@ -276,6 +268,4 @@ void FACCH1::copy(const FACCH1& data)
{ {
m_data = new uint8_t[NXDN_FACCH1_CRC_LENGTH_BYTES]; m_data = new uint8_t[NXDN_FACCH1_CRC_LENGTH_BYTES];
::memcpy(m_data, data.m_data, NXDN_FACCH1_CRC_LENGTH_BYTES); ::memcpy(m_data, data.m_data, NXDN_FACCH1_CRC_LENGTH_BYTES);
m_verbose = data.m_verbose;
} }

4
nxdn/channel/FACCH1.h
Unescape View File

@ -63,10 +63,6 @@ namespace nxdn
/// <summary>Sets the raw FACCH1 data.</summary> /// <summary>Sets the raw FACCH1 data.</summary>
void setData(const uint8_t* data); void setData(const uint8_t* data);
public:
/// <summary>Flag indicating verbose log output.</summary>
__PROPERTY(bool, verbose, Verbose);
private: private:
uint8_t* m_data; uint8_t* m_data;

26
nxdn/channel/SACCH.cpp
Unescape View File

@ -65,8 +65,7 @@ const uint32_t PUNCTURE_LIST[] = { 5U, 11U, 17U, 23U, 29U, 35U, 41U, 47U, 53U, 5
/// Initializes a new instance of the SACCH class. /// Initializes a new instance of the SACCH class.
/// </summary> /// </summary>
SACCH::SACCH() : SACCH::SACCH() :
m_verbose(false), m_ran(0U),
m_ran(1U),
m_structure(NXDN_SR_SINGLE), m_structure(NXDN_SR_SINGLE),
m_data(NULL) m_data(NULL)
{ {
@ -79,8 +78,7 @@ SACCH::SACCH() :
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="data"></param>
SACCH::SACCH(const SACCH& data) : SACCH::SACCH(const SACCH& data) :
m_verbose(false), m_ran(0U),
m_ran(1U),
m_structure(NXDN_SR_SINGLE), m_structure(NXDN_SR_SINGLE),
m_data(NULL) m_data(NULL)
{ {
@ -105,8 +103,6 @@ SACCH& SACCH::operator=(const SACCH& data)
if (&data != this) { if (&data != this) {
::memcpy(m_data, data.m_data, NXDN_SACCH_CRC_LENGTH_BYTES); ::memcpy(m_data, data.m_data, NXDN_SACCH_CRC_LENGTH_BYTES);
m_verbose = data.m_verbose;
m_ran = m_data[0U] & 0x3FU; m_ran = m_data[0U] & 0x3FU;
m_structure = (m_data[0U] >> 6) & 0x03U; m_structure = (m_data[0U] >> 6) & 0x03U;
} }
@ -156,10 +152,6 @@ bool SACCH::decode(const uint8_t* data)
puncture[n++] = 0U; puncture[n++] = 0U;
} }
#if DEBUG_NXDN_SACCH
Utils::dump(2U, "SACCH::decode(), SACCH Puncture List", puncture, 90U);
#endif
// decode convolution // decode convolution
Convolution conv; Convolution conv;
conv.start(); conv.start();
@ -177,9 +169,9 @@ bool SACCH::decode(const uint8_t* data)
conv.chainback(m_data, NXDN_SACCH_CRC_LENGTH_BITS); conv.chainback(m_data, NXDN_SACCH_CRC_LENGTH_BITS);
if (m_verbose) { #if DEBUG_NXDN_SACCH
Utils::dump(2U, "Decoded SACCH", m_data, NXDN_SACCH_CRC_LENGTH_BYTES); Utils::dump(2U, "Decoded SACCH", m_data, NXDN_SACCH_CRC_LENGTH_BYTES);
} #endif
// check CRC-6 // check CRC-6
bool ret = CRC::checkCRC6(m_data, NXDN_SACCH_LENGTH_BITS); bool ret = CRC::checkCRC6(m_data, NXDN_SACCH_LENGTH_BITS);
@ -218,9 +210,9 @@ void SACCH::encode(uint8_t* data) const
CRC::addCRC6(buffer, NXDN_SACCH_LENGTH_BITS); CRC::addCRC6(buffer, NXDN_SACCH_LENGTH_BITS);
if (m_verbose) { #if DEBUG_NXDN_SACCH
Utils::dump(2U, "Encoded SACCH", buffer, NXDN_SACCH_CRC_LENGTH_BYTES); Utils::dump(2U, "Encoded SACCH", buffer, NXDN_SACCH_CRC_LENGTH_BYTES);
} #endif
// encode convolution // encode convolution
uint8_t convolution[NXDN_SACCH_FEC_CONV_LENGTH_BYTES]; uint8_t convolution[NXDN_SACCH_FEC_CONV_LENGTH_BYTES];
@ -229,10 +221,6 @@ void SACCH::encode(uint8_t* data) const
Convolution conv; Convolution conv;
conv.encode(buffer, convolution, NXDN_SACCH_CRC_LENGTH_BITS); conv.encode(buffer, convolution, NXDN_SACCH_CRC_LENGTH_BITS);
#if DEBUG_NXDN_SACCH
Utils::dump(2U, "SACCH::encode(), SACCH Convolution", convolution, NXDN_SACCH_FEC_CONV_LENGTH_BYTES);
#endif
// puncture // puncture
uint8_t puncture[NXDN_SACCH_FEC_LENGTH_BYTES]; uint8_t puncture[NXDN_SACCH_FEC_LENGTH_BYTES];
::memset(puncture, 0x00U, NXDN_SACCH_FEC_LENGTH_BYTES); ::memset(puncture, 0x00U, NXDN_SACCH_FEC_LENGTH_BYTES);

3
nxdn/channel/SACCH.h
Unescape View File

@ -65,9 +65,6 @@ namespace nxdn
void setData(const uint8_t* data); void setData(const uint8_t* data);
public: public:
/// <summary>Flag indicating verbose log output.</summary>
__PROPERTY(bool, verbose, Verbose);
/** Common Data */ /** Common Data */
/// <summary>Radio Access Number</summary> /// <summary>Radio Access Number</summary>
__PROPERTY(uint8_t, ran, RAN); __PROPERTY(uint8_t, ran, RAN);

20
nxdn/channel/UDCH.cpp
Unescape View File

@ -94,7 +94,6 @@ const uint32_t PUNCTURE_LIST[] = {
/// Initializes a new instance of the UDCH class. /// Initializes a new instance of the UDCH class.
/// </summary> /// </summary>
UDCH::UDCH() : UDCH::UDCH() :
m_verbose(false),
m_ran(0U), m_ran(0U),
m_data(NULL) m_data(NULL)
{ {
@ -107,7 +106,6 @@ UDCH::UDCH() :
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="data"></param>
UDCH::UDCH(const UDCH& data) : UDCH::UDCH(const UDCH& data) :
m_verbose(false),
m_ran(0U), m_ran(0U),
m_data(NULL) m_data(NULL)
{ {
@ -132,8 +130,6 @@ UDCH& UDCH::operator=(const UDCH& data)
if (&data != this) { if (&data != this) {
::memcpy(m_data, data.m_data, NXDN_UDCH_CRC_LENGTH_BYTES); ::memcpy(m_data, data.m_data, NXDN_UDCH_CRC_LENGTH_BYTES);
m_verbose = data.m_verbose;
m_ran = m_data[0U] & 0x3FU; m_ran = m_data[0U] & 0x3FU;
} }
@ -197,9 +193,9 @@ bool UDCH::decode(const uint8_t* data)
conv.chainback(m_data, NXDN_UDCH_CRC_LENGTH_BITS); conv.chainback(m_data, NXDN_UDCH_CRC_LENGTH_BITS);
if (m_verbose) { #if DEBUG_NXDN_UDCH
Utils::dump(2U, "Decoded UDCH", m_data, NXDN_UDCH_CRC_LENGTH_BYTES); Utils::dump(2U, "Decoded UDCH", m_data, NXDN_UDCH_CRC_LENGTH_BYTES);
} #endif
// check CRC-15 // check CRC-15
bool ret = CRC::checkCRC15(m_data, NXDN_UDCH_LENGTH_BITS); bool ret = CRC::checkCRC15(m_data, NXDN_UDCH_LENGTH_BITS);
@ -229,9 +225,9 @@ void UDCH::encode(uint8_t* data) const
CRC::addCRC15(buffer, NXDN_UDCH_LENGTH_BITS); CRC::addCRC15(buffer, NXDN_UDCH_LENGTH_BITS);
if (m_verbose) { #if DEBUG_NXDN_UDCH
Utils::dump(2U, "Encoded UDCH", m_data, NXDN_UDCH_CRC_LENGTH_BYTES); Utils::dump(2U, "Encoded UDCH", m_data, NXDN_UDCH_CRC_LENGTH_BYTES);
} #endif
// encode convolution // encode convolution
uint8_t convolution[NXDN_UDCH_FEC_CONV_LENGTH_BYTES]; uint8_t convolution[NXDN_UDCH_FEC_CONV_LENGTH_BYTES];
@ -240,10 +236,6 @@ void UDCH::encode(uint8_t* data) const
Convolution conv; Convolution conv;
conv.encode(buffer, convolution, NXDN_UDCH_CRC_LENGTH_BITS); conv.encode(buffer, convolution, NXDN_UDCH_CRC_LENGTH_BITS);
#if DEBUG_NXDN_UDCH
Utils::dump(2U, "UDCH::encode(), UDCH Convolution", convolution, NXDN_UDCH_FEC_CONV_LENGTH_BYTES);
#endif
// puncture // puncture
uint8_t puncture[NXDN_UDCH_FEC_LENGTH_BYTES]; uint8_t puncture[NXDN_UDCH_FEC_LENGTH_BYTES];
::memset(puncture, 0x00U, NXDN_UDCH_FEC_LENGTH_BYTES); ::memset(puncture, 0x00U, NXDN_UDCH_FEC_LENGTH_BYTES);

3
nxdn/channel/UDCH.h
Unescape View File

@ -65,9 +65,6 @@ namespace nxdn
void setData(const uint8_t* data); void setData(const uint8_t* data);
public: public:
/// <summary>Flag indicating verbose log output.</summary>
__PROPERTY(bool, verbose, Verbose);
/** Common Data */ /** Common Data */
/// <summary>Radio Access Number</summary> /// <summary>Radio Access Number</summary>
__PROPERTY(uint8_t, ran, RAN); __PROPERTY(uint8_t, ran, RAN);

2
nxdn/packet/Data.cpp
Unescape View File

@ -182,7 +182,6 @@ bool Data::process(uint8_t option, uint8_t* data, uint32_t len)
assert(data != NULL); assert(data != NULL);
channel::UDCH udch; channel::UDCH udch;
udch.setVerbose(m_verbose);
bool validUDCH = udch.decode(data + 2U); bool validUDCH = udch.decode(data + 2U);
if (m_nxdn->m_rfState == RS_RF_LISTENING && !validUDCH) if (m_nxdn->m_rfState == RS_RF_LISTENING && !validUDCH)
return false; return false;
@ -298,7 +297,6 @@ bool Data::processNetwork(uint8_t option, lc::RTCH& netLC, uint8_t* data, uint32
} }
channel::UDCH udch; channel::UDCH udch;
udch.setVerbose(m_verbose);
bool validUDCH = udch.decode(data + 2U); bool validUDCH = udch.decode(data + 2U);
if (m_nxdn->m_netState == RS_NET_IDLE && !validUDCH) if (m_nxdn->m_netState == RS_NET_IDLE && !validUDCH)
return false; return false;

6
nxdn/packet/Trunk.cpp
Unescape View File

@ -394,11 +394,11 @@ void Trunk::writeRF_Message(bool noNetwork, bool clearBeforeWrite)
uint8_t buffer[NXDN_RCCH_LC_LENGTH_BYTES]; uint8_t buffer[NXDN_RCCH_LC_LENGTH_BYTES];
::memset(buffer, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES); ::memset(buffer, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES);
m_rfLC.setVerbose(m_dumpRCCH);
m_rfLC.encode(buffer, NXDN_RCCH_LC_LENGTH_BITS); m_rfLC.encode(buffer, NXDN_RCCH_LC_LENGTH_BITS);
// generate the CAC // generate the CAC
channel::CAC cac; channel::CAC cac;
cac.setVerbose(m_dumpRCCH);
cac.setRAN(m_nxdn->m_ran); cac.setRAN(m_nxdn->m_ran);
cac.setStructure(NXDN_SR_RCCH_SINGLE); cac.setStructure(NXDN_SR_RCCH_SINGLE);
cac.setData(buffer); cac.setData(buffer);
@ -700,12 +700,12 @@ void Trunk::writeRF_CC_Message_Site_Info()
uint8_t buffer[NXDN_RCCH_LC_LENGTH_BYTES]; uint8_t buffer[NXDN_RCCH_LC_LENGTH_BYTES];
::memset(buffer, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES); ::memset(buffer, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES);
m_rfLC.setVerbose(m_dumpRCCH);
m_rfLC.setMessageType(RCCH_MESSAGE_TYPE_SITE_INFO); m_rfLC.setMessageType(RCCH_MESSAGE_TYPE_SITE_INFO);
m_rfLC.encode(buffer, NXDN_RCCH_LC_LENGTH_BITS); m_rfLC.encode(buffer, NXDN_RCCH_LC_LENGTH_BITS);
// generate the CAC // generate the CAC
channel::CAC cac; channel::CAC cac;
cac.setVerbose(m_dumpRCCH);
cac.setRAN(m_nxdn->m_ran); cac.setRAN(m_nxdn->m_ran);
cac.setStructure(NXDN_SR_RCCH_HEAD_SINGLE); cac.setStructure(NXDN_SR_RCCH_HEAD_SINGLE);
cac.setData(buffer); cac.setData(buffer);
@ -748,13 +748,13 @@ void Trunk::writeRF_CC_Message_Service_Info()
uint8_t buffer[NXDN_RCCH_LC_LENGTH_BYTES]; uint8_t buffer[NXDN_RCCH_LC_LENGTH_BYTES];
::memset(buffer, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES); ::memset(buffer, 0x00U, NXDN_RCCH_LC_LENGTH_BYTES);
m_rfLC.setVerbose(m_dumpRCCH);
m_rfLC.setMessageType(MESSAGE_TYPE_SRV_INFO); m_rfLC.setMessageType(MESSAGE_TYPE_SRV_INFO);
m_rfLC.encode(buffer, NXDN_RCCH_LC_LENGTH_BITS / 2U); m_rfLC.encode(buffer, NXDN_RCCH_LC_LENGTH_BITS / 2U);
m_rfLC.encode(buffer, NXDN_RCCH_LC_LENGTH_BITS / 2U, NXDN_RCCH_LC_LENGTH_BITS / 2U); m_rfLC.encode(buffer, NXDN_RCCH_LC_LENGTH_BITS / 2U, NXDN_RCCH_LC_LENGTH_BITS / 2U);
// generate the CAC // generate the CAC
channel::CAC cac; channel::CAC cac;
cac.setVerbose(m_dumpRCCH);
cac.setRAN(m_nxdn->m_ran); cac.setRAN(m_nxdn->m_ran);
cac.setStructure(NXDN_SR_RCCH_DUAL); cac.setStructure(NXDN_SR_RCCH_DUAL);
cac.setData(buffer); cac.setData(buffer);

32
nxdn/packet/Voice.cpp
Unescape View File

@ -189,7 +189,6 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
assert(data != NULL); assert(data != NULL);
channel::SACCH sacch; channel::SACCH sacch;
sacch.setVerbose(m_verbose);
bool valid = sacch.decode(data + 2U); bool valid = sacch.decode(data + 2U);
if (valid) { if (valid) {
uint8_t ran = sacch.getRAN(); uint8_t ran = sacch.getRAN();
@ -202,7 +201,6 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
if (fct == NXDN_LICH_USC_SACCH_NS) { if (fct == NXDN_LICH_USC_SACCH_NS) {
// the SACCH on a non-superblock frame is usually an idle and not interesting apart from the RAN. // the SACCH on a non-superblock frame is usually an idle and not interesting apart from the RAN.
channel::FACCH1 facch; channel::FACCH1 facch;
facch.setVerbose(m_verbose);
bool valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); bool valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
if (!valid) if (!valid)
valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
@ -213,7 +211,7 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
facch.getData(buffer); facch.getData(buffer);
lc::RTCH lc; lc::RTCH lc;
lc.setVerbose(m_verbose); lc.setVerbose(m_dumpRTCH);
lc.decode(buffer, NXDN_FACCH1_FEC_LENGTH_BITS); lc.decode(buffer, NXDN_FACCH1_FEC_LENGTH_BITS);
uint16_t dstId = lc.getDstId(); uint16_t dstId = lc.getDstId();
uint16_t srcId = lc.getSrcId(); uint16_t srcId = lc.getSrcId();
@ -255,7 +253,6 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
// generate the SACCH // generate the SACCH
channel::SACCH sacch; channel::SACCH sacch;
sacch.setVerbose(m_verbose);
sacch.setData(SACCH_IDLE); sacch.setData(SACCH_IDLE);
sacch.setRAN(m_nxdn->m_ran); sacch.setRAN(m_nxdn->m_ran);
sacch.setStructure(NXDN_SR_SINGLE); sacch.setStructure(NXDN_SR_SINGLE);
@ -315,7 +312,6 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
} else { } else {
if (m_nxdn->m_rfState == RS_RF_LISTENING) { if (m_nxdn->m_rfState == RS_RF_LISTENING) {
channel::FACCH1 facch; channel::FACCH1 facch;
facch.setVerbose(m_verbose);
bool valid = false; bool valid = false;
switch (option) { switch (option) {
case NXDN_LICH_STEAL_FACCH: case NXDN_LICH_STEAL_FACCH:
@ -339,7 +335,7 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
facch.getData(buffer); facch.getData(buffer);
lc::RTCH lc; lc::RTCH lc;
lc.setVerbose(m_verbose); lc.setVerbose(m_dumpRTCH);
lc.decode(buffer, NXDN_FACCH1_FEC_LENGTH_BITS); lc.decode(buffer, NXDN_FACCH1_FEC_LENGTH_BITS);
hasInfo = lc.getMessageType() == RTCH_MESSAGE_TYPE_VCALL; hasInfo = lc.getMessageType() == RTCH_MESSAGE_TYPE_VCALL;
@ -437,7 +433,6 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
// generate the SACCH // generate the SACCH
channel::SACCH sacch; channel::SACCH sacch;
sacch.setVerbose(m_verbose);
sacch.setData(SACCH_IDLE); sacch.setData(SACCH_IDLE);
sacch.setRAN(m_nxdn->m_ran); sacch.setRAN(m_nxdn->m_ran);
sacch.setStructure(NXDN_SR_SINGLE); sacch.setStructure(NXDN_SR_SINGLE);
@ -479,7 +474,6 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
// regenerate SACCH if it's valid // regenerate SACCH if it's valid
channel::SACCH sacch; channel::SACCH sacch;
sacch.setVerbose(m_verbose);
bool validSACCH = sacch.decode(data + 2U); bool validSACCH = sacch.decode(data + 2U);
if (validSACCH) { if (validSACCH) {
sacch.setRAN(m_nxdn->m_ran); sacch.setRAN(m_nxdn->m_ran);
@ -518,7 +512,6 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
} }
} else if (option == NXDN_LICH_STEAL_FACCH1_1) { } else if (option == NXDN_LICH_STEAL_FACCH1_1) {
channel::FACCH1 facch1; channel::FACCH1 facch1;
facch1.setVerbose(m_verbose);
bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
if (valid) if (valid)
facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
@ -574,19 +567,16 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
} }
channel::FACCH1 facch1; channel::FACCH1 facch1;
facch1.setVerbose(m_verbose);
bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
if (valid) if (valid)
facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
} else { } else {
channel::FACCH1 facch11; channel::FACCH1 facch11;
facch11.setVerbose(m_verbose);
bool valid1 = facch11.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); bool valid1 = facch11.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
if (valid1) if (valid1)
facch11.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); facch11.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
channel::FACCH1 facch12; channel::FACCH1 facch12;
facch12.setVerbose(m_verbose);
bool valid2 = facch12.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); bool valid2 = facch12.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
if (valid2) if (valid2)
facch12.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); facch12.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
@ -633,13 +623,11 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
} }
channel::SACCH sacch; channel::SACCH sacch;
sacch.setVerbose(m_verbose);
sacch.decode(data + 2U); sacch.decode(data + 2U);
if (fct == NXDN_LICH_USC_SACCH_NS) { if (fct == NXDN_LICH_USC_SACCH_NS) {
// the SACCH on a non-superblock frame is usually an idle and not interesting apart from the RAN. // the SACCH on a non-superblock frame is usually an idle and not interesting apart from the RAN.
channel::FACCH1 facch; channel::FACCH1 facch;
facch.setVerbose(m_verbose);
bool valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); bool valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
if (!valid) if (!valid)
valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
@ -650,7 +638,7 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
facch.getData(buffer); facch.getData(buffer);
lc::RTCH lc; lc::RTCH lc;
lc.setVerbose(m_verbose); lc.setVerbose(m_dumpRTCH);
lc.decode(buffer, NXDN_FACCH1_FEC_LENGTH_BITS); lc.decode(buffer, NXDN_FACCH1_FEC_LENGTH_BITS);
uint16_t dstId = lc.getDstId(); uint16_t dstId = lc.getDstId();
uint16_t srcId = lc.getSrcId(); uint16_t srcId = lc.getSrcId();
@ -692,7 +680,6 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
// generate the SACCH // generate the SACCH
channel::SACCH sacch; channel::SACCH sacch;
sacch.setVerbose(m_verbose);
sacch.setData(SACCH_IDLE); sacch.setData(SACCH_IDLE);
sacch.setRAN(m_nxdn->m_ran); sacch.setRAN(m_nxdn->m_ran);
sacch.setStructure(NXDN_SR_SINGLE); sacch.setStructure(NXDN_SR_SINGLE);
@ -735,7 +722,6 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
} else { } else {
if (m_nxdn->m_netState == RS_NET_IDLE) { if (m_nxdn->m_netState == RS_NET_IDLE) {
channel::FACCH1 facch; channel::FACCH1 facch;
facch.setVerbose(m_verbose);
bool valid = false; bool valid = false;
switch (option) { switch (option) {
case NXDN_LICH_STEAL_FACCH: case NXDN_LICH_STEAL_FACCH:
@ -759,7 +745,7 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
facch.getData(buffer); facch.getData(buffer);
lc::RTCH lc; lc::RTCH lc;
lc.setVerbose(m_verbose); lc.setVerbose(m_dumpRTCH);
lc.decode(buffer, NXDN_FACCH1_FEC_LENGTH_BITS); lc.decode(buffer, NXDN_FACCH1_FEC_LENGTH_BITS);
hasInfo = lc.getMessageType() == RTCH_MESSAGE_TYPE_VCALL; hasInfo = lc.getMessageType() == RTCH_MESSAGE_TYPE_VCALL;
@ -850,7 +836,6 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
// generate the SACCH // generate the SACCH
channel::SACCH sacch; channel::SACCH sacch;
sacch.setVerbose(m_verbose);
sacch.setData(SACCH_IDLE); sacch.setData(SACCH_IDLE);
sacch.setRAN(m_nxdn->m_ran); sacch.setRAN(m_nxdn->m_ran);
sacch.setStructure(NXDN_SR_SINGLE); sacch.setStructure(NXDN_SR_SINGLE);
@ -888,7 +873,6 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
// regenerate SACCH if it's valid // regenerate SACCH if it's valid
channel::SACCH sacch; channel::SACCH sacch;
sacch.setVerbose(m_verbose);
bool validSACCH = sacch.decode(data + 2U); bool validSACCH = sacch.decode(data + 2U);
if (validSACCH) { if (validSACCH) {
sacch.setRAN(m_nxdn->m_ran); sacch.setRAN(m_nxdn->m_ran);
@ -914,7 +898,6 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
} }
} else if (option == NXDN_LICH_STEAL_FACCH1_1) { } else if (option == NXDN_LICH_STEAL_FACCH1_1) {
channel::FACCH1 facch1; channel::FACCH1 facch1;
facch1.setVerbose(m_verbose);
bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
if (valid) if (valid)
facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
@ -947,19 +930,16 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, errs = %u/94 (%.1f%%)", errors, float(errors) / 0.94F); LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, errs = %u/94 (%.1f%%)", errors, float(errors) / 0.94F);
} }
channel::FACCH1 facch1; channel::FACCH1 facch1;
facch1.setVerbose(m_verbose);
bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
if (valid) if (valid)
facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
} else { } else {
channel::FACCH1 facch11; channel::FACCH1 facch11;
facch11.setVerbose(m_verbose);
bool valid1 = facch11.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); bool valid1 = facch11.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
if (valid1) if (valid1)
facch11.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS); facch11.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS);
channel::FACCH1 facch12; channel::FACCH1 facch12;
facch12.setVerbose(m_verbose);
bool valid2 = facch12.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); bool valid2 = facch12.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
if (valid2) if (valid2)
facch12.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS); facch12.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_FEC_LENGTH_BITS + NXDN_FACCH1_FEC_LENGTH_BITS);
@ -992,9 +972,10 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
/// </summary> /// </summary>
/// <param name="nxdn">Instance of the Control class.</param> /// <param name="nxdn">Instance of the Control class.</param>
/// <param name="network">Instance of the BaseNetwork class.</param> /// <param name="network">Instance of the BaseNetwork class.</param>
/// <param name="dumpRTCHData">Flag indicating whether RTCH data is dumped to the log.</param>
/// <param name="debug">Flag indicating whether NXDN debug is enabled.</param> /// <param name="debug">Flag indicating whether NXDN debug is enabled.</param>
/// <param name="verbose">Flag indicating whether NXDN verbose logging is enabled.</param> /// <param name="verbose">Flag indicating whether NXDN verbose logging is enabled.</param>
Voice::Voice(Control* nxdn, network::BaseNetwork* network, bool debug, bool verbose) : Voice::Voice(Control* nxdn, network::BaseNetwork* network, bool dumpRTCHData, bool debug, bool verbose) :
m_nxdn(nxdn), m_nxdn(nxdn),
m_network(network), m_network(network),
m_rfFrames(0U), m_rfFrames(0U),
@ -1005,6 +986,7 @@ Voice::Voice(Control* nxdn, network::BaseNetwork* network, bool debug, bool verb
m_netLost(0U), m_netLost(0U),
m_lastRejectId(0U), m_lastRejectId(0U),
m_silenceThreshold(DEFAULT_SILENCE_THRESHOLD), m_silenceThreshold(DEFAULT_SILENCE_THRESHOLD),
m_dumpRTCH(dumpRTCHData),
m_verbose(verbose), m_verbose(verbose),
m_debug(debug) m_debug(debug)
{ {

4
nxdn/packet/Voice.h
Unescape View File

@ -84,11 +84,13 @@ namespace nxdn
uint32_t m_silenceThreshold; uint32_t m_silenceThreshold;
bool m_dumpRTCH;
bool m_verbose; bool m_verbose;
bool m_debug; bool m_debug;
/// <summary>Initializes a new instance of the Voice class.</summary> /// <summary>Initializes a new instance of the Voice class.</summary>
Voice(Control* nxdn, network::BaseNetwork* network, bool debug, bool verbose); Voice(Control* nxdn, network::BaseNetwork* network, bool dumpRTCHData, bool debug, bool verbose);
/// <summary>Finalizes a instance of the Voice class.</summary> /// <summary>Finalizes a instance of the Voice class.</summary>
virtual ~Voice(); virtual ~Voice();

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.