mirror of
https://github.com/JS8Call-improved/JS8Call-improved
synced 2026-08-13 17:47:36 -04:00
356bdc0f50
Rename all header files with .h extension Fix function declaration in HamlibTransceiver.h that overrode member function but was not marked override Remove unused variable in Modulator.cpp Remove unused files from source tree Remove duplicate LazyFillComboBox files Reformat codebase to LLVM C++ standard
263 lines
8.7 KiB
C++
263 lines
8.7 KiB
C++
#include "decodedtext.h"
|
|
#include "JS8_Include/commons.h"
|
|
#include <JS8_Main/varicode.h>
|
|
#include <QStringBuilder>
|
|
|
|
/******************************************************************************/
|
|
// Constants
|
|
/******************************************************************************/
|
|
|
|
namespace {
|
|
// Quality level below which we'll consider a decode to be suspect;
|
|
// the UI will generally enclose the decode within [] characters to
|
|
// denote it as being sketchy.
|
|
|
|
constexpr auto QUALITY_THRESHOLD = 0.17f;
|
|
} // namespace
|
|
|
|
/******************************************************************************/
|
|
// Local Routines
|
|
/******************************************************************************/
|
|
|
|
namespace {
|
|
// Translation of standard submode IDs to their character equivalents.
|
|
// this is only used when writing out to ALL.TXT, so we've defined it
|
|
// here, but arguably it should be part of JS8::Submode or Varicode.
|
|
|
|
QChar submodeChar(int const submode) {
|
|
switch (submode) {
|
|
case Varicode::SubmodeType::JS8CallNormal:
|
|
return 'A';
|
|
case Varicode::SubmodeType::JS8CallFast:
|
|
return 'B';
|
|
case Varicode::SubmodeType::JS8CallTurbo:
|
|
return 'C';
|
|
case Varicode::SubmodeType::JS8CallSlow:
|
|
return 'E';
|
|
case Varicode::SubmodeType::JS8CallUltra:
|
|
return 'I';
|
|
default:
|
|
return '~';
|
|
}
|
|
}
|
|
|
|
// Create and return a potentially compound call from the provided
|
|
// parts; the parts are at this point guaranteed to be at least of
|
|
// size 2, but any part might be empty.
|
|
|
|
QString buildCompound(QStringList const &parts) {
|
|
auto subset = parts.mid(0, 2);
|
|
subset.removeAll("");
|
|
return subset.join('/');
|
|
}
|
|
} // namespace
|
|
|
|
/******************************************************************************/
|
|
// Private Implementation
|
|
/******************************************************************************/
|
|
|
|
// Core constructor, called by the two public constructors.
|
|
// Attempts to unpack, using the unpack strategies defined
|
|
// in the order of the unpack strategies array, until one
|
|
// of them works or all of them have failed.
|
|
|
|
DecodedText::DecodedText(QString const &frame, int bits, int submode,
|
|
bool isLowConfidence, int time, int frequencyOffset,
|
|
float snr, float dt)
|
|
: frameType_(Varicode::FrameUnknown), frame_(frame), isAlt_(false),
|
|
isHeartbeat_(false), isLowConfidence_(isLowConfidence), message_(frame_),
|
|
bits_(bits), submode_(submode), time_(time),
|
|
frequencyOffset_(frequencyOffset), snr_(snr), dt_(dt) {
|
|
auto const m = message().trimmed();
|
|
|
|
if (m.length() < 12 || m.contains(' '))
|
|
return;
|
|
|
|
for (auto unpack : unpackStrategies) {
|
|
if ((this->*unpack)(m))
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool DecodedText::tryUnpackFastData(QString const &m) {
|
|
if ((bits_ & Varicode::JS8CallData) != Varicode::JS8CallData)
|
|
return false;
|
|
|
|
if (auto const data = Varicode::unpackFastDataMessage(m); data.isEmpty()) {
|
|
return false;
|
|
} else {
|
|
message_ = data;
|
|
frameType_ = Varicode::FrameData;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool DecodedText::tryUnpackData(QString const &m) {
|
|
if ((bits_ & Varicode::JS8CallData) == Varicode::JS8CallData)
|
|
return false;
|
|
|
|
if (auto const data = Varicode::unpackDataMessage(m); data.isEmpty()) {
|
|
return false;
|
|
} else {
|
|
message_ = data;
|
|
frameType_ = Varicode::FrameData;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool DecodedText::tryUnpackHeartbeat(QString const &m) {
|
|
if ((bits_ & Varicode::JS8CallData) == Varicode::JS8CallData)
|
|
return false;
|
|
|
|
bool isAlt = false;
|
|
quint8 type = Varicode::FrameUnknown;
|
|
quint8 bits3 = 0;
|
|
auto const parts =
|
|
Varicode::unpackHeartbeatMessage(m, &type, &isAlt, &bits3);
|
|
|
|
if (parts.length() < 2)
|
|
return false;
|
|
|
|
// Heartbeat Alt Type
|
|
// ------------------
|
|
// 1 0 HB
|
|
// 1 1 CQ
|
|
|
|
frameType_ = type;
|
|
isHeartbeat_ = true;
|
|
isAlt_ = isAlt;
|
|
extra_ = parts.value(2, QString());
|
|
compound_ = buildCompound(parts);
|
|
message_ = compound_ % ": ";
|
|
|
|
if (isAlt) {
|
|
message_ += "@ALLCALL " % Varicode::cqString(bits3);
|
|
} else {
|
|
auto const sbits3 = Varicode::hbString(bits3);
|
|
message_ += "@HB " % (sbits3 == "HB" ? "HEARTBEAT" : sbits3);
|
|
}
|
|
|
|
message_ += ' ' % extra_ % ' ';
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DecodedText::tryUnpackCompound(QString const &m) {
|
|
quint8 type = Varicode::FrameUnknown;
|
|
quint8 bits3 = 0;
|
|
auto const parts = Varicode::unpackCompoundMessage(m, &type, &bits3);
|
|
|
|
if (parts.length() < 2 ||
|
|
(bits_ & Varicode::JS8CallData) == Varicode::JS8CallData)
|
|
return false;
|
|
|
|
frameType_ = type;
|
|
extra_ = parts.mid(2).join(' ');
|
|
compound_ = buildCompound(parts);
|
|
|
|
if (type == Varicode::FrameCompound) {
|
|
message_ = compound_ % ": ";
|
|
} else if (type == Varicode::FrameCompoundDirected) {
|
|
message_ = compound_ % extra_ % ' ';
|
|
|
|
directed_.reserve(parts.size() - 2 + 2);
|
|
directed_ = {"<....>", compound_};
|
|
directed_ += parts.mid(2);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DecodedText::tryUnpackDirected(QString const &m) {
|
|
if ((bits_ & Varicode::JS8CallData) == Varicode::JS8CallData)
|
|
return false;
|
|
|
|
quint8 type = Varicode::FrameUnknown;
|
|
QStringList const parts = Varicode::unpackDirectedMessage(m, &type);
|
|
|
|
if (parts.isEmpty())
|
|
return false;
|
|
|
|
switch (parts.length()) {
|
|
case 3: // Directed message => "0: 12 "
|
|
case 4: // Directed numeric message => "0: 12 3 "
|
|
message_ =
|
|
parts.at(0) % ": " % parts.at(1) % parts.mid(2).join(' ') % ' ';
|
|
break;
|
|
default: // Free text message
|
|
message_ = parts.join("");
|
|
break;
|
|
}
|
|
|
|
directed_ = parts;
|
|
frameType_ = type;
|
|
|
|
return true;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
// Public Implementation
|
|
/******************************************************************************/
|
|
|
|
// Main constructor, used to interpret Decoded events emitted by the JS8
|
|
// decoder. This function used to be handled via parsing strings issued by
|
|
// the Fortran decoder.
|
|
//
|
|
// Of note here is the quality check; that was present in the previous code,
|
|
// but did not seem to be looking in the right place for the annotation that
|
|
// the Fortran decoded emitted.
|
|
|
|
DecodedText::DecodedText(JS8::Event::Decoded const &decoded)
|
|
: DecodedText(QString::fromStdString(decoded.data), decoded.type,
|
|
decoded.mode, decoded.quality < QUALITY_THRESHOLD,
|
|
decoded.utc, decoded.frequency, decoded.snr, decoded.xdt) {}
|
|
|
|
// Constructor used internally; we're basically taking advantage of the ability
|
|
// of this class to unpack, and as such this probably doesn't belong here, but
|
|
// keeping it aligned with the previous code for now.
|
|
|
|
DecodedText::DecodedText(QString const &frame, int const bits,
|
|
int const submode)
|
|
: DecodedText(frame, bits, submode, false, 0, 0, 0.0f, 0.0f) {}
|
|
|
|
// Simple word split for free text messages; preallocate memory for
|
|
// efficiency; add whole message as item 0 to mimic regular expression
|
|
// capture list.
|
|
|
|
QStringList DecodedText::messageWords() const {
|
|
QStringList words;
|
|
|
|
words.reserve(message_.count(' ') + 2);
|
|
words.append(message_);
|
|
words.append(message_.split(' ', Qt::SkipEmptyParts));
|
|
|
|
return words;
|
|
}
|
|
|
|
// Format as a string suitable for appending to ALL.TXT. Original
|
|
// code has no space between time and SNR; matching that here.
|
|
|
|
QString DecodedText::string() const {
|
|
struct hour_minute_second hms = decode_time(time_);
|
|
|
|
return QStringLiteral("%1:%2:%3%4 %5 %6 %7 %8 %9 ")
|
|
.arg(hms.hour, 2, 10, QChar('0')) // Right-aligned integer with 2
|
|
// characters, padded with zeroes.
|
|
.arg(hms.minute, 2, 10, QChar('0')) // Right-aligned integer with 2
|
|
// characters, padded with zeroes.
|
|
.arg(hms.second, 2, 10, QChar('0')) // Right-aligned integer with 2
|
|
// characters, padded with zeroes.
|
|
.arg(snr_, 3, 10, QChar(' ')) // Right-aligned integer with 3
|
|
// characters, padded with spaces
|
|
.arg(dt_, 4, 'f', 1) // Right-aligned float with 1 decimal point
|
|
.arg(frequencyOffset_, 4, 10,
|
|
QChar(' ')) // Right-aligned integer with 4 characters, passed with
|
|
// spaces
|
|
.arg(submodeChar(submode_)) // Single character
|
|
.arg(frame_) // Fixed string, 12 characters
|
|
.arg(bits_); // Single 3-bit integer
|
|
}
|
|
|
|
/******************************************************************************/
|