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.
 
 
 
 
 
 

3194 lines
116 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 <algorithm>
#include <functional>
#include <QBuffer>
#include <QDateTime>
#include <QFile>
#include <QDir>
#include <QDebug>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QSet>
#include "SWGChannelSettings.h"
#include "SWGWorkspaceInfo.h"
#include "SWGChannelReport.h"
#include "SWGChannelActions.h"
#include "SWGDVBDemodActions.h"
#include "SWGDVBDemodApp.h"
#include "SWGDVBDemodCarousel.h"
#include "SWGDVBDemodEPGEvent.h"
#include "SWGDVBDemodEPGService.h"
#include "channel/channelwebapiutils.h"
#include "dsp/dspcommands.h"
#include "device/deviceapi.h"
#include "settings/serializable.h"
#include "dvbdemod.h"
MESSAGE_CLASS_DEFINITION(DVBDemod::MsgConfigureDVBDemod, Message)
typedef DVBDemodSettings S; // For the standards
const char * const DVBDemod::m_channelIdURI = "sdrangel.channel.demoddvb";
const char * const DVBDemod::m_channelId = "DVBDemod";
DVBDemod::DVBDemod(DeviceAPI *deviceAPI) :
ChannelAPI(m_channelIdURI, ChannelAPI::StreamSingleSink),
m_deviceAPI(deviceAPI),
m_basebandSampleRate(0),
m_centerFrequency(0),
m_retuneSettled(false),
m_manualRecording(-1)
{
setObjectName(m_channelId);
m_thread.setObjectName("bbDVBDemod");
m_basebandSink = new DVBDemodBaseband();
m_basebandSink->setFifoLabel(QString("%1 [%2:%3]")
.arg(m_channelId)
.arg(m_deviceAPI->getDeviceSetIndex())
.arg(getIndexInDeviceSet())
);
m_basebandSink->moveToThread(&m_thread);
applySettings(m_settings, QStringList(), true);
m_deviceAPI->addChannelSink(this);
m_deviceAPI->addChannelSinkAPI(this);
m_networkManager = new QNetworkAccessManager();
QObject::connect(
m_networkManager,
&QNetworkAccessManager::finished,
this,
&DVBDemod::networkManagerFinished
);
QObject::connect(
this,
&ChannelAPI::indexInDeviceSetChanged,
this,
&DVBDemod::handleIndexInDeviceSetChanged
);
// The guide from earlier, as a full one takes minutes to receive
getEPG()->load(DVBDemodEPG::defaultCacheFileName());
QObject::connect(&m_epgSaveTimer, &QTimer::timeout, this, &DVBDemod::saveEPG);
m_epgSaveTimer.start(5 * 60 * 1000);
// Programmes to record are started and stopped by the transport stream's time
QObject::connect(&m_scheduleTimer, &QTimer::timeout, this, &DVBDemod::checkSchedule);
m_scheduleTimer.start(1000);
QObject::connect(&m_tuneTimer, &QTimer::timeout, this, &DVBDemod::checkTuning);
m_tuneTimer.start(250);
}
// The service selected, or if automatic, the first TV service of the transport stream by channel number
int DVBDemod::currentServiceId() const
{
if (m_settings.m_serviceId != 0) {
return m_settings.m_serviceId;
}
// What the player chose (the first program with video, in its order), so a recording's of what's on screen
if (m_playingServiceId != 0) {
return m_playingServiceId;
}
int serviceId = 0;
int lowest = 0x7FFFFFFF;
for (const auto& service : m_basebandSink->getEPG()->getServices())
{
// EN 300 468 table 87's television services: SD and HD, MPEG-2, AVC (and its NVOD and frame compatible 3D)
// and HEVC
const bool tv = (service.m_type == 0x01) || (service.m_type == 0x11) || ((service.m_type >= 0x16) && (service.m_type <= 0x20));
const int channel = service.m_channel >= 0 ? service.m_channel : 0x7FFFFFFE;
if (service.m_actual && tv && (channel < lowest))
{
lowest = channel;
serviceId = service.m_serviceId;
}
}
return serviceId;
}
// A service on another multiplex is tuned to by moving the device, so the channel, keeping its offset from the
// device's centre (as for an LO offset), is on the multiplex's frequency from the NIT, or learned when it was received.
// If neither, the UHF channels are searched for it. The player then finds the service once the new transport stream
// arrives
bool DVBDemod::playService(int networkId, int serviceId, QString& error)
{
// A recording waiting for the service played before isn't wanted now
m_pendingRecording.m_active = false;
// Played by the user: where the device's tuned is theirs, not returned from after a retune for recordings
if (!m_retuningForRecording) {
m_recordingRetune.m_active = false;
}
// Back to the multiplex searched from, so it isn't taken to be where the service is
if (m_search.m_active) {
cancelSearch();
}
if (m_scan.m_active) {
cancelScan();
}
// The transport stream received's service with the ids, if it has one (an id can be used in more than one)
DVBDemodEPG *epg = getEPG();
DVBDemodEPG::Service target;
if (!epg->getService(networkId, serviceId, target))
{
error = "Service not in the programme guide";
return false;
}
if (target.m_removed)
{
error = "The service is no longer broadcast";
return false;
}
m_search.m_text.clear();
DVBDemodSettings settings = m_settings;
QStringList settingsKeys = {"serviceId"};
settings.m_serviceId = serviceId;
if (!target.m_actual)
{
DVBDemodEPG::TransportStream ts;
if (recordingInProgress())
{
error = "The service is on another multiplex: retuning would interrupt the recording";
return false;
}
if (!epg->getTransportStream(networkId, target.m_transportStreamId, ts))
{
if (!target.m_multiplexKnown)
{
error = "The service's multiplex isn't in this area";
return false;
}
if (DVBDemodSettings::isSatellite(m_settings.m_standard))
{
error = "The service's multiplex's frequency isn't known";
return false;
}
DVBDemodSink::Status status;
getStatus(status);
if (!status.m_sampleRateOK)
{
error = "The sample rate is too low to search for the service's multiplex";
return false;
}
startSearch(target);
return true;
}
if (!retuneDevice(ts.m_frequency - m_settings.m_inputFrequencyOffset))
{
error = "The device can't be retuned";
return false;
}
qDebug("DVBDemod::playService: service %d: tuning to %.3f MHz", serviceId, ts.m_frequency / 1e6);
if (ts.m_satellite)
{
// The device's frequency is the downlink's, with its transverter delta set to the LNB's local oscillator. A
// multiplex on the other polarisation needs the LNB switched: the GUI's done that first (see
// polarisationChange()); the band isn't handled
settings.m_standard = ts.m_s2 ? S::StandardDVBS2 : S::StandardDVBS;
settingsKeys.append("standard");
// Out of range (a NIT's, or a guide cache's, in error), automatic, not the transponder before's
settings.m_symbolRate = DVBDemodSettings::isValidSymbolRate(ts.m_symbolRate) ? ts.m_symbolRate : 0;
settingsKeys.append("symbolRate");
// EN 300 468 table 35's inner code rates, as DVB-S's
settings.m_codeRate = !ts.m_s2 && (ts.m_fecInner >= 1) && (ts.m_fecInner <= 5) ? ts.m_fecInner - 1 : -1;
// The roll-off and input stream as received before (or the roll-off from the descriptor), else automatic
settings.m_rollOff = !ts.m_s2 ? 0 : DVBDemodSettings::rollOffHundredths(ts.m_rollOff);
settings.m_isi = ts.m_s2 ? ts.m_isi : -1;
settingsKeys.append({"codeRate", "rollOff", "isi"});
applyServiceSettings(settings, settingsKeys);
m_guideSettings = true;
m_guideCenterFrequency = ts.m_frequency - m_settings.m_inputFrequencyOffset;
return true;
}
if (DVBDemodSettings::isValidBandwidth(ts.m_bandwidth))
{
settings.m_bandwidth = ts.m_bandwidth;
settingsKeys.append("bandwidth");
}
// The UK describes DVB-T2 multiplexes with DVB-T's descriptor, so the standard is found, unless T2's says
settings.m_standard = ts.m_t2 ? S::StandardDVBT2 : S::StandardAutoTerrestrial;
settings.m_plpId = ts.m_t2 ? ts.m_plpId : -1;
settings.m_lowPriority = !ts.m_t2 && ts.m_lowPriority;
settingsKeys.append({"standard", "plpId", "lowPriority"});
}
applyServiceSettings(settings, settingsKeys);
return true;
}
// The multiplex received says its own polarisation in the NIT; until it's known (as just after retuning), it's the one
// switched to
bool DVBDemod::polarisationChange(int networkId, int serviceId, int& needed, int& current)
{
DVBDemodEPG *epg = getEPG();
DVBDemodEPG::Service target;
DVBDemodEPG::TransportStream ts, received;
if (!epg->getService(networkId, serviceId, target) || target.m_actual
|| !epg->getTransportStream(networkId, target.m_transportStreamId, ts) || !ts.m_satellite)
{
return false;
}
if ((epg->getTransportStreamId() >= 0) && epg->getTransportStream(epg->getNetworkId(), epg->getTransportStreamId(), received)
&& received.m_satellite)
{
m_polarisation = received.m_polarisation;
}
needed = ts.m_polarisation;
current = m_polarisation;
return (current >= 0) && (needed != current);
}
void DVBDemod::applyServiceSettings(const DVBDemodSettings& settings, const QStringList& settingsKeys)
{
applySettings(settings, settingsKeys);
if (m_guiMessageQueue) {
m_guiMessageQueue->push(MsgConfigureDVBDemod::create(settings, settingsKeys, false));
}
}
// The transport stream being received isn't known until its SI arrives from the new frequency
// A recording waiting for its service's multiplex: started once the transport stream received is its (the retune
// settled, so not the SI of the multiplex before); given up if not within 20 s (not counting a search)
void DVBDemod::checkPendingRecording()
{
PendingRecording& p = m_pendingRecording;
if (!p.m_active) {
return;
}
DVBDemodEPG *epg = getEPG();
if (m_search.m_active)
{
p.m_since.start();
}
else if (m_retuneSettled && (epg->getNetworkId() == p.m_networkId) && (epg->getTransportStreamId() == p.m_transportStreamId))
{
p.m_active = false;
QString error;
if (startRecording(error)) {
qDebug("DVBDemod::checkPendingRecording: recording service %d", p.m_serviceId);
} else {
qWarning() << "DVBDemod::checkPendingRecording: can't record service" << p.m_serviceId << ":" << error;
}
}
else if (p.m_since.elapsed() > m_pendingRecordingTimeoutMs)
{
p.m_active = false;
qWarning("DVBDemod::checkPendingRecording: not recording service %d: its multiplex (%d/%d) wasn't received",
p.m_serviceId, p.m_networkId, p.m_transportStreamId);
}
}
void DVBDemod::retuned()
{
m_playingServiceId = 0; // The player chooses again from the new multiplex's
getEPG()->retuned();
getApps()->reset();
m_sinceRetune.start();
m_retuneSettled = false;
}
bool DVBDemod::retuneDevice(qint64 frequency)
{
if (!ChannelWebAPIUtils::setCenterFrequency(m_deviceAPI->getDeviceSetIndex(), frequency)) {
return false;
}
m_retuneTarget = frequency;
m_retuneRequested.start();
retuned();
return true;
}
// After the device or the channel is moved: the receivers would otherwise keep the old signal's state, and in Auto,
// the standard of the old multiplex for 5 s
void DVBDemod::resetReceivers()
{
m_basebandSink->getInputMessageQueue()->push(DVBDemodBaseband::MsgResetReceivers::create());
}
void DVBDemod::checkTuning()
{
DVBDemodEPG *epg = getEPG();
// SI from the old frequency, still being decoded when retuned, may have set the transport stream: forget it. A
// second after the device says it's where it was asked to go (a slow device's notification can come a second or
// more after the retune: settled before, the search and scan took it to be retuned elsewhere), or once that's
// given up on (it may round the frequency more than the tolerance)
if (!m_retuneSettled && m_sinceRetune.isValid())
{
const bool there = (m_retuneTarget == 0) || (qAbs(m_centerFrequency - m_retuneTarget) <= m_retuneToleranceHz);
const bool givenUp = !there && (m_retuneRequested.elapsed() >= m_retuneConfirmTimeoutMs);
if (givenUp)
{
qWarning("DVBDemod::checkTuning: the device is at %.6f MHz, not %.6f MHz as asked", m_centerFrequency / 1e6,
m_retuneTarget / 1e6);
}
if ((there && (m_sinceRetune.elapsed() >= m_retuneSettleMs)) || givenUp)
{
epg->retuned();
m_retuneSettled = true;
m_retuneTarget = 0;
}
}
checkPendingRecording();
if (m_scan.m_active)
{
checkScan();
return;
}
if (m_search.m_active)
{
const qint64 tuned = m_centerFrequency + m_settings.m_inputFrequencyOffset;
if (m_deviceAPI->state() != DeviceAPI::StRunning)
{
endSearch(false, "The search stopped, as the device stopped");
return;
}
// Retuned elsewhere, as by the user: what's received isn't the channel being tried, and the device stays
if (m_retuneSettled && (qAbs(tuned - m_search.m_tuned) > m_retuneToleranceHz))
{
qDebug("DVBDemod::checkTuning: retuned to %.3f MHz during the search", tuned / 1e6);
m_search.m_active = false;
m_search.m_text = "The search stopped, as the device was retuned";
return;
}
if (m_retuneSettled && (epg->getTransportStreamId() >= 0))
{
// A multiplex. Whichever it is, it can be tuned to directly next time
learnFrequency(tuned);
if ((epg->getNetworkId() == m_search.m_networkId) && (epg->getTransportStreamId() == m_search.m_transportStreamId))
{
endSearch(true, QString());
}
else
{
m_search.m_index++;
searchNext();
}
return;
}
// Nothing to synchronise to, or no transport stream identified in time
DVBDemodSink::Status status;
getStatus(status);
const qint64 elapsed = m_search.m_dwell.elapsed();
if (((elapsed >= m_searchNoSignalMs) && status.isSearching()) || (elapsed >= m_searchMaxDwellMs))
{
m_search.m_index++;
searchNext();
}
return;
}
// Learn the frequency of the multiplex being received, if the NIT doesn't give it, once it's been received for a
// while, so services on it can be tuned to from other multiplexes. A frequency learned before is replaced if this
// is over 1 MHz from it (as when it was learned from another transmitter); the NIT's never are
if (m_retuneSettled && (m_sinceRetune.elapsed() >= m_learnFrequencyMs) && (epg->getTransportStreamId() >= 0) && (m_centerFrequency > 0))
{
DVBDemodSink::Status status;
getStatus(status);
if (status.isLocked()) {
learnFrequency(m_centerFrequency + m_settings.m_inputFrequencyOffset);
}
}
}
void DVBDemod::learnFrequency(qint64 frequency)
{
DVBDemodEPG *epg = getEPG();
if (DVBDemodSettings::isSatellite(m_settings.m_standard))
{
DVBDemodSink::Status status;
getStatus(status);
if ((status.m_standard == S::StandardDVBS) || (status.m_standard == S::StandardDVBS2)) {
const int symbolRate = m_settings.m_symbolRate > 0 ? m_settings.m_symbolRate : (int) std::max(0.0, status.m_autoSymbolRate);
if (symbolRate > 0)
{
const bool s2 = status.m_standard == S::StandardDVBS2;
epg->setSatelliteFrequency(frequency, symbolRate, s2, s2 ? status.m_s2.m_matypeRollOff : 0,
s2 && (status.m_s2.m_isiCount > 0) ? status.m_s2.m_isi : -1);
}
}
}
else
{
epg->setFrequency(frequency, m_settings.m_bandwidth);
}
}
// The UHF channels (8 MHz raster, 21 to 48 first, as used since the 700 MHz band was cleared, then 49 to 69), except
// those of multiplexes already known
void DVBDemod::startSearch(const DVBDemodEPG::Service& target)
{
DVBDemodEPG *epg = getEPG();
// So the multiplex being left can be returned to from the guide, if it hasn't been received for long
if (m_retuneSettled && (epg->getTransportStreamId() >= 0) && (m_centerFrequency > 0)) {
learnFrequency(m_centerFrequency + m_settings.m_inputFrequencyOffset);
}
std::vector<qint64> known;
known.push_back(m_centerFrequency + m_settings.m_inputFrequencyOffset);
for (const auto& ts : epg->getTransportStreams())
{
if (ts.m_frequency > 0) {
known.push_back(ts.m_frequency);
}
}
m_search = Search();
m_search.m_active = true;
m_search.m_networkId = target.m_networkId;
m_search.m_transportStreamId = target.m_transportStreamId;
m_search.m_serviceId = target.m_serviceId;
m_search.m_name = target.m_name.isEmpty() ? QString("service %1").arg(target.m_serviceId) : target.m_name;
m_search.m_centerFrequency = m_centerFrequency;
m_search.m_settings = m_settings;
for (int channel = 21; channel <= 69; channel++)
{
const qint64 frequency = 474000000LL + 8000000LL * (channel - 21);
bool skip = false;
for (qint64 f : known) {
skip = skip || (qAbs(f - frequency) < 1000000);
}
if (!skip) {
m_search.m_frequencies.push_back(frequency);
}
}
qDebug("DVBDemod::startSearch: %s (%d/%d): %d channels", qPrintable(m_search.m_name), target.m_networkId,
target.m_transportStreamId, (int) m_search.m_frequencies.size());
// Either standard, and any PLP, as the multiplex's aren't known
DVBDemodSettings settings = m_settings;
settings.m_standard = S::StandardAutoTerrestrial;
settings.m_plpId = -1;
settings.m_lowPriority = false;
applyServiceSettings(settings, {"standard", "plpId", "lowPriority"});
searchNext();
}
void DVBDemod::searchNext()
{
if (m_search.m_index >= (int) m_search.m_frequencies.size())
{
endSearch(false, QString("The multiplex of %1 wasn't found").arg(m_search.m_name));
return;
}
const qint64 frequency = m_search.m_frequencies[m_search.m_index];
if (!retuneDevice(frequency - m_settings.m_inputFrequencyOffset))
{
endSearch(false, "The device can't be retuned");
return;
}
m_search.m_tuned = frequency;
m_search.m_dwell.start();
m_search.m_text = QString("Searching for %1: %2 MHz (%3 of %4)").arg(m_search.m_name).arg(frequency / 1e6, 0, 'f', 0)
.arg(m_search.m_index + 1).arg(m_search.m_frequencies.size());
}
void DVBDemod::endSearch(bool found, const QString& text)
{
m_search.m_active = false;
m_search.m_text = text;
DVBDemodSettings settings = m_search.m_settings;
if (found)
{
qDebug("DVBDemod::endSearch: found %s at %.3f MHz", qPrintable(m_search.m_name),
m_search.m_frequencies[m_search.m_index] / 1e6);
settings = m_settings;
settings.m_serviceId = m_search.m_serviceId;
applyServiceSettings(settings, {"serviceId"});
m_pendingRecording.m_since.start(); // Its recording, if one's waiting, from now
}
else
{
qDebug("DVBDemod::endSearch: %s", qPrintable(text));
if (m_pendingRecording.m_active)
{
qWarning() << "DVBDemod::endSearch: not recording" << m_search.m_name << ": its multiplex wasn't found";
m_pendingRecording.m_active = false;
}
retuneDevice(m_search.m_centerFrequency);
applyServiceSettings(settings, {"serviceId", "standard", "plpId", "lowPriority"});
}
}
void DVBDemod::cancelSearch()
{
if (m_search.m_active) {
endSearch(false, QString());
}
}
// Kept by the baseband, and set again as the device starts, so the sink isn't left with a scan's band (or the sweep's
// spectrum only, with no symbol rate searched for) if the device stops meanwhile
void DVBDemod::setRateSearchBand(double frequency, double width, bool spectrumOnly)
{
m_basebandSink->setRateSearchBand(frequency, width, spectrumOnly, ++m_bandGeneration);
}
void DVBDemod::setSatelliteAutomatic(DVBDemodSettings& settings)
{
settings.m_standard = S::StandardAutoSatellite;
settings.m_symbolRate = 0;
settings.m_codeRate = -1;
settings.m_rollOff = 0;
settings.m_isi = -1;
}
bool DVBDemod::startScan(qint64 from, qint64 to, QString& error)
{
if (recordingInProgress())
{
error = "Not while recording";
return false;
}
const int rate = getChannelSampleRate();
if ((m_deviceAPI->state() != DeviceAPI::StRunning) || (rate <= 0) || (m_centerFrequency <= 0))
{
error = "The device isn't running";
return false;
}
cancelSearch();
cancelScan();
// Steps of most of the device's band (its edges are filtered), its spectrum taken at each, and the signals found in
// all of it at once
const qint64 usable = (qint64) (0.8 * rate);
m_scan = Scan();
if ((from > 0) && (to > from))
{
for (qint64 centre = from + usable / 2; centre - usable / 2 < to; centre += usable) {
m_scan.m_centres.push_back(centre);
}
m_scan.m_from = from;
m_scan.m_to = to;
}
else
{
m_scan.m_centres.push_back(m_centerFrequency);
m_scan.m_from = m_centerFrequency - usable / 2;
m_scan.m_to = m_centerFrequency + usable / 2;
}
m_scan.m_active = true;
m_scan.m_centerFrequency = m_centerFrequency;
m_scan.m_settings = m_settings;
qInfo("DVBDemod::startScan: %.3f to %.3f MHz, %d steps", m_scan.m_from / 1e6, m_scan.m_to / 1e6, (int) m_scan.m_centres.size());
// Either satellite standard, any symbol rate, MODCOD and stream
DVBDemodSettings settings = m_settings;
setSatelliteAutomatic(settings);
settings.m_inputFrequencyOffset = 0;
applyServiceSettings(settings, {"standard", "symbolRate", "codeRate", "rollOff", "isi", "inputFrequencyOffset"});
scanCentre();
return true;
}
void DVBDemod::cancelScan()
{
if (m_scan.m_active) {
endScan("The scan was stopped");
}
}
// The sweep: the device to the next step, for its spectrum. Then the signals in all of it
void DVBDemod::scanCentre()
{
if (m_scan.m_centre >= (int) m_scan.m_centres.size())
{
findScanSignals();
return;
}
const qint64 centre = m_scan.m_centres[m_scan.m_centre];
if ((centre != m_centerFrequency) && !retuneDevice(centre))
{
endScan("The device can't be retuned");
return;
}
m_scan.m_tuned = centre;
if (m_settings.m_inputFrequencyOffset != 0)
{
DVBDemodSettings settings = m_settings;
settings.m_inputFrequencyOffset = 0;
applyServiceSettings(settings, {"inputFrequencyOffset"});
}
retuned();
m_scan.m_surveying = true;
m_scan.m_bandSent = false;
m_scan.m_dwell.start();
m_search.m_text = QString("Scanning: sweeping %1 MHz (%2 of %3)")
.arg(centre / 1e6, 0, 'f', 1).arg(m_scan.m_centre + 1).arg(m_scan.m_centres.size());
}
// A step's spectrum into the sweep's, each bin at its downlink frequency
void DVBDemod::addScanSpectrum(const DVBDemodSink::Status& status)
{
const int n = (int) status.m_spectrum.size();
const double binHz = status.m_spectrumBinHz;
if ((n == 0) || (binHz <= 0.0)) {
return;
}
if (m_scan.m_power.empty())
{
const int bins = (int) ((m_scan.m_to - m_scan.m_from) / binHz) + 1;
m_scan.m_binHz = binHz;
m_scan.m_minWidth = status.m_minSignalWidth;
m_scan.m_power.assign(bins, 0.0);
m_scan.m_seen.assign(bins, 0);
}
for (int i = 0; i < n; i++)
{
const double offset = (i - n / 2) * binHz;
if (std::fabs(offset) > m_sweepHalfWidth * n * binHz) {
continue;
}
const int k = (int) std::lround((m_centerFrequency + offset - m_scan.m_from) / m_scan.m_binHz);
if ((k >= 0) && (k < (int) m_scan.m_power.size()))
{
m_scan.m_power[k] += status.m_spectrum[i];
m_scan.m_seen[k]++;
}
}
}
// The signals in the sweep's spectrum, over the noise floor near each, then tried in turn
void DVBDemod::findScanSignals()
{
const int bins = (int) m_scan.m_power.size();
std::vector<double> power(bins, 0.0);
std::vector<bool> seen(bins, false);
for (int k = 0; k < bins; k++)
{
seen[k] = m_scan.m_seen[k] > 0;
power[k] = seen[k] ? m_scan.m_power[k] / m_scan.m_seen[k] : 0.0;
}
// The floor every m_sweepFloorStep, interpolated between: the 10th percentile of the bins seen near
const int span = std::max(1, (int) (m_sweepFloorSpan / std::max(1.0, m_scan.m_binHz)));
const int step = std::max(1, (int) (m_sweepFloorStep / std::max(1.0, m_scan.m_binHz)));
std::vector<int> floorBins;
std::vector<double> floors, near;
for (int k = 0; k < bins; k += step)
{
near.clear();
for (int j = std::max(0, k - span); j <= std::min(bins - 1, k + span); j++)
{
if (seen[j]) {
near.push_back(power[j]);
}
}
if (!near.empty())
{
std::nth_element(near.begin(), near.begin() + near.size() / 10, near.end());
floorBins.push_back(k);
floors.push_back(near[near.size() / 10]);
}
}
// Over its floor (bins not seen at it), so it's 1
std::vector<double> overFloor(bins, 1.0);
size_t f = 0;
for (int k = 0; (k < bins) && !floors.empty(); k++)
{
while ((f + 1 < floorBins.size()) && (floorBins[f + 1] <= k)) {
f++;
}
double floor = floors[f];
if ((f + 1 < floorBins.size()) && (k > floorBins[f]))
{
const double t = (double) (k - floorBins[f]) / (floorBins[f + 1] - floorBins[f]);
floor = (1.0 - t) * floors[f] + t * floors[f + 1];
}
if (seen[k] && (floor > 0.0)) {
overFloor[k] = power[k] / floor;
}
}
const auto candidates = dvbs::SymbolRateSearch::findSignals(overFloor, 1.0, m_scan.m_binHz, (double) m_scan.m_from,
m_scan.m_minWidth, m_sweepThreshold);
m_scan.m_signals.clear();
m_scan.m_signal = 0;
QStringList list;
// Those overlapping as one, the strongest: on a broad weak signal, each small peak over the threshold takes the
// signal's half power points (below the threshold), so they come out at much the same frequency, out of order
std::vector<ScanSignal> sorted;
for (const auto& s : candidates) {
sorted.push_back({(qint64) std::llround(s.m_frequency), s.m_width, s.m_levelDb});
}
std::sort(sorted.begin(), sorted.end(), [](const ScanSignal& a, const ScanSignal& b) {
return a.m_frequency < b.m_frequency;
});
for (const ScanSignal& signal : sorted)
{
ScanSignal *last = m_scan.m_signals.empty() ? nullptr : &m_scan.m_signals.back();
if (last && (qAbs(signal.m_frequency - last->m_frequency) < 0.5 * std::max(signal.m_width, last->m_width)))
{
if (signal.m_levelDb > last->m_levelDb) {
*last = signal;
}
continue;
}
m_scan.m_signals.push_back(signal);
}
for (const ScanSignal& s : m_scan.m_signals)
{
list.append(QString("%1 MHz (%2 MHz wide, S/N %3 dB)").arg(s.m_frequency / 1e6, 0, 'f', 3).arg(s.m_width / 1e6, 0, 'f', 1)
.arg(s.m_levelDb, 0, 'f', 1));
}
m_scan.m_power.clear();
m_scan.m_seen.clear();
qInfo("DVBDemod::findScanSignals: %.3f to %.3f MHz swept: %d signals to try: %s", m_scan.m_from / 1e6, m_scan.m_to / 1e6,
(int) m_scan.m_signals.size(), qPrintable(list.join(", ")));
scanSignal();
}
// The device centred on the next signal found by the sweep (a wide transponder only fits in its band centred), its
// symbol rate searched for in the signal's band only, once the samples are from there
void DVBDemod::scanSignal()
{
// Not one in a transponder found (split in two, as by a dip in its spectrum), nor within one tried
while (m_scan.m_signal < (int) m_scan.m_signals.size())
{
const qint64 frequency = m_scan.m_signals[m_scan.m_signal].m_frequency;
bool found = false, tried = false;
for (const ScanFound& f : m_scan.m_found) {
found = found || (qAbs(f.m_frequency - frequency) < 0.6 * f.m_symbolRate);
}
for (const ScanSignal& t : m_scan.m_tried) {
tried = tried || (qAbs(t.m_frequency - frequency) < 0.5 * t.m_width);
}
if (!found && !tried) {
break;
}
qInfo("DVBDemod::scanSignal: %.3f MHz: in a transponder %s", frequency / 1e6, found ? "found" : "tried");
m_scan.m_signal++;
}
if (m_scan.m_signal >= (int) m_scan.m_signals.size())
{
endScan(QString());
return;
}
const ScanSignal& signal = m_scan.m_signals[m_scan.m_signal];
if ((signal.m_frequency != m_centerFrequency) && !retuneDevice(signal.m_frequency))
{
endScan("The device can't be retuned");
return;
}
m_scan.m_tuned = signal.m_frequency;
retuned();
m_scan.m_surveying = false;
m_scan.m_bandSent = false;
m_scan.m_dwell.start();
m_search.m_text = QString("Scanning: trying %1 MHz (signal %2 of %3), %4 found")
.arg(signal.m_frequency / 1e6, 0, 'f', 3).arg(m_scan.m_signal + 1).arg(m_scan.m_signals.size())
.arg(m_scan.m_found.size());
}
void DVBDemod::checkScan()
{
if (m_deviceAPI->state() != DeviceAPI::StRunning)
{
endScan("The scan stopped, as the device stopped");
return;
}
// Retuned elsewhere (by the user): the scan stops there
if (m_retuneSettled && (qAbs(m_centerFrequency - m_scan.m_tuned) > m_retuneToleranceHz))
{
m_scan.m_active = false;
setRateSearchBand(0.0, 0.0);
m_search.m_text = QString("The scan stopped, as the device was retuned: %1 found").arg(m_scan.m_found.size());
return;
}
DVBDemodSink::Status status;
const qint64 elapsed = m_scan.m_dwell.elapsed();
if (m_scan.m_surveying)
{
// The step's spectrum, from a rate search of the whole band, on samples since the retune: the band's set once
// the retune's come (the receivers' reset with it restarts the search, after the samples from before), not
// waiting the second the guide's given to settle, as nothing's decoded. The spectrum only, no rate, so the
// receivers aren't run: their searches, started again at each step, took the CPU the device needed
if (!m_scan.m_bandSent)
{
if (qAbs(m_centerFrequency - m_scan.m_tuned) > m_retuneToleranceHz)
{
if (elapsed >= m_scanRetuneTimeoutMs)
{
m_scan.m_active = false;
setRateSearchBand(0.0, 0.0);
m_search.m_text = QString("The scan stopped, as the device didn't retune to %1 MHz (or was retuned elsewhere)")
.arg(m_scan.m_tuned / 1e6, 0, 'f', 3);
}
return;
}
setRateSearchBand(0.0, 0.0, true);
m_scan.m_bandGeneration = m_bandGeneration;
m_scan.m_bandSent = true;
m_scan.m_dwell.start();
return;
}
getStatus(status);
if ((status.m_bandGeneration == m_scan.m_bandGeneration) && (status.m_rateSearches > 0))
{
addScanSpectrum(status);
m_scan.m_centre++;
scanCentre();
}
else if (elapsed >= m_scanSpectrumTimeoutMs)
{
m_scan.m_centre++; // Nothing from this step: its part of the spectrum's left out
scanCentre();
}
return;
}
if (!m_retuneSettled) {
return;
}
getStatus(status);
const ScanSignal& signal = m_scan.m_signals[m_scan.m_signal];
if (!m_scan.m_bandSent)
{
setRateSearchBand(0.0, 1.3 * signal.m_width);
m_scan.m_bandGeneration = m_bandGeneration;
m_scan.m_bandSent = true;
m_scan.m_dwell.start();
return;
}
if (status.m_bandGeneration != m_scan.m_bandGeneration)
{
// The band's not applied yet. It's set again if the device restarted meanwhile, so it's not waited for forever
if (elapsed >= m_scanBandTimeoutMs)
{
qWarning("DVBDemod::checkScan: %.3f MHz: the symbol rate search's band wasn't applied", signal.m_frequency / 1e6);
m_scan.m_tried.push_back(signal);
m_scan.m_signal++;
scanSignal();
}
return;
}
DVBDemodEPG *epg = getEPG();
const bool generic = (status.m_standard == S::StandardDVBS2) && DVBDemodSink::Status::isGeneric(status.m_s2.m_bb);
if ((status.isLocked() && (epg->getTransportStreamId() >= 0) && (m_sinceRetune.elapsed() >= m_scanSettleMs)) || (generic && (elapsed >= m_scanSettleMs)))
{
// Found: what it is, and (with its SI) into the guide, with where it is
// Where it is from the carrier offset measured: the survey's estimate is rough for a signal cut at the band's edge
ScanFound found;
const bool s2 = status.m_standard == S::StandardDVBS2;
const double offset = s2 ? status.m_s2.m_frequencyOffset : status.m_s.m_frequencyOffset;
found.m_frequency = m_centerFrequency + (qint64) std::llround(offset);
found.m_symbolRate = (int) std::max(0.0, status.m_autoSymbolRate);
found.m_text = QString("%1 MHz %2 kS/s %3").arg(found.m_frequency / 1e6, 0, 'f', 3).arg(found.m_symbolRate / 1e3, 0, 'f', 0)
.arg(!s2 ? QString("DVB-S %1").arg(status.m_s.m_fec.m_codeRateKnown ? dvbt::toString(status.m_s.m_fec.m_codeRate) : QString("?"))
: QString("DVB-S2 %1").arg(status.m_s2.m_pl.m_vlsnr >= 0 ? QString("VL-SNR %1").arg(dvbs2::vlsnrModcod(status.m_s2.m_pl.m_vlsnr).m_name)
: status.m_s2.m_pl.m_modcod >= 0 ? QString(dvbs2::modcodString(status.m_s2.m_pl.m_modcod)) : QString("?")));
if (generic) {
found.m_text += " (generic stream)";
} else {
found.m_text += QString(" network %1 TS %2").arg(epg->getNetworkId()).arg(epg->getTransportStreamId());
}
// The same as one found before, from a candidate beside it, isn't listed again
bool again = false;
for (const ScanFound& f : m_scan.m_found) {
again = again || (qAbs(f.m_frequency - found.m_frequency) < 0.5 * std::max(f.m_symbolRate, found.m_symbolRate));
}
qInfo("DVBDemod::checkScan: found %s%s", qPrintable(found.m_text), again ? " (again)" : "");
if (!generic) {
learnFrequency(found.m_frequency);
}
if (!again) {
m_scan.m_found.push_back(found);
}
m_scan.m_signal++;
scanSignal();
return;
}
// No symbol rate found by two searches (each a fraction of a second, found by the first if there's a signal), or in
// time, or no lock (or SI) after it was: DVB-S and S2 lock, and the PAT comes, within a few seconds (a scan of
// Astra 2's band, its 22 transponders all within 2.5 s of the retune)
const bool noRate = (status.m_autoSymbolRate < 0.0) && ((status.m_rateSearches >= 2) || (elapsed >= m_scanNoRateMs));
if (noRate || (elapsed >= m_scanNoLockMs))
{
// A signal wider at half power than the highest rate the sample rate allows can't be measured or received
const double maxRate = getChannelSampleRate() / 1.2;
const QString why = !noRate ? QString("no lock")
: signal.m_width > 0.95 * maxRate
? QString("no symbol rate (%1 MHz wide: more than the %2 MS/s this sample rate allows)")
.arg(signal.m_width / 1e6, 0, 'f', 1).arg(maxRate / 1e6, 0, 'f', 2)
: QString("no symbol rate");
qInfo("DVBDemod::checkScan: %.3f MHz (S/N %.1f dB): %s", signal.m_frequency / 1e6, signal.m_levelDb, qPrintable(why));
m_scan.m_tried.push_back(signal);
m_scan.m_signal++;
scanSignal();
}
}
void DVBDemod::endScan(const QString& text)
{
m_scan.m_active = false;
setRateSearchBand(0.0, 0.0);
QStringList found;
for (const ScanFound& f : m_scan.m_found) {
found.append(f.m_text);
}
m_search.m_text = (text.isEmpty() ? QString("Scan done") : text)
+ QString(": %1 transponder%2 found%3%4").arg(m_scan.m_found.size()).arg(m_scan.m_found.size() == 1 ? "" : "s")
.arg(found.isEmpty() ? "" : ": ").arg(found.join("; "));
qInfo("DVBDemod::endScan: %s", qPrintable(m_search.m_text));
// Back to where it was
retuneDevice(m_scan.m_centerFrequency);
applyServiceSettings(m_scan.m_settings, {"standard", "symbolRate", "codeRate", "rollOff", "isi", "inputFrequencyOffset"});
retuned();
}
QString DVBDemod::serviceName(int serviceId) const
{
for (const auto& service : m_basebandSink->getEPG()->getServices())
{
if (service.m_actual && (service.m_serviceId == serviceId) && !service.m_name.isEmpty()) {
return service.m_name;
}
}
return QString("Service %1").arg(serviceId);
}
// In the recording directory: the name and local start time, without characters file systems don't allow
QString DVBDemod::recordingFileName(const QString& name, qint64 utc) const
{
QString base = QString("%1 %2").arg(name).arg(QDateTime::fromSecsSinceEpoch(utc).toLocalTime().toString("yyyy-MM-dd HHmm"));
for (QChar& c : base)
{
if (QString("<>:\"/\\|?*").contains(c) || (c.unicode() < 0x20)) {
c = '_';
}
}
QDir dir(m_settings.m_recordDirectory.isEmpty() ? QDir::homePath() : m_settings.m_recordDirectory);
QString fileName = dir.filePath(base + ".ts");
for (int i = 2; QFile::exists(fileName); i++) {
fileName = dir.filePath(QString("%1 (%2).ts").arg(base).arg(i));
}
return fileName;
}
bool DVBDemod::startRecording(QString& error)
{
if (m_manualRecording >= 0) {
return true;
}
const qint64 t = getEPG()->getTime() > 0 ? getEPG()->getTime() : QDateTime::currentSecsSinceEpoch();
const bool service = m_settings.m_recordMode == 1;
const int serviceId = service ? currentServiceId() : 0;
if (service && (serviceId == 0))
{
error = "No service to record yet";
return false;
}
const QString name = service ? serviceName(serviceId)
: QString("DVB %1 MHz").arg((m_centerFrequency + m_settings.m_inputFrequencyOffset) / 1e6, 0, 'f', 3);
const int id = m_basebandSink->startRecording(recordingFileName(name, t),
service ? DTVRecorder::Service : DTVRecorder::Multiplex, serviceId, error);
if (id < 0) {
return false;
}
m_manualRecording = id;
return true;
}
void DVBDemod::stopRecording()
{
// One waiting for the service's multiplex too (the retune or search goes on, to play it)
m_pendingRecording.m_active = false;
if (m_manualRecording >= 0)
{
m_basebandSink->stopRecording(m_manualRecording);
m_manualRecording = -1;
}
}
bool DVBDemod::isScheduled(int networkId, int serviceId, int eventId) const
{
for (const auto& r : m_settings.m_scheduledRecordings)
{
if ((r.m_networkId == networkId) && (r.m_serviceId == serviceId) && (r.m_eventId == eventId)) {
return true;
}
}
return false;
}
bool DVBDemod::scheduleRecording(int networkId, int serviceId, int eventId)
{
if (isScheduled(networkId, serviceId, eventId)) {
return false;
}
for (const auto& event : getEPG()->getEvents(networkId, serviceId))
{
if (event.m_eventId == eventId)
{
DVBDemodSettings::ScheduledRecording r;
r.m_networkId = networkId;
r.m_serviceId = serviceId;
r.m_eventId = eventId;
r.m_start = event.m_start;
r.m_duration = event.m_duration;
r.m_title = event.m_title;
r.m_serviceName = serviceName(serviceId);
QList<DVBDemodSettings::ScheduledRecording> schedule = m_settings.m_scheduledRecordings;
schedule.append(r);
setSchedule(schedule);
checkSchedule(); // It may have started
return true;
}
}
return false;
}
bool DVBDemod::scheduleSeries(int networkId, int serviceId, int eventId)
{
DVBDemodEPG::Event event;
if (!getEPG()->getEvent(networkId, serviceId, eventId, event) || event.m_seriesCrid.isEmpty()
|| isSeriesScheduled(networkId, serviceId, eventId)) {
return false;
}
DVBDemodSettings::SeriesRecording s;
s.m_networkId = networkId;
s.m_serviceId = serviceId;
s.m_seriesCrid = event.m_seriesCrid;
s.m_title = event.m_title;
s.m_serviceName = serviceName(serviceId);
QList<DVBDemodSettings::SeriesRecording> series = m_settings.m_seriesRecordings;
series.append(s);
setSeries(series);
m_seriesRevision = 0; // Its programmes scheduled now
checkSchedule();
return true;
}
void DVBDemod::cancelSeries(int networkId, int serviceId, int eventId)
{
DVBDemodEPG::Event event;
if (getEPG()->getEvent(networkId, serviceId, eventId, event) && !event.m_seriesCrid.isEmpty()) {
cancelSeries(networkId, serviceId, event.m_seriesCrid);
}
}
void DVBDemod::cancelSeries(int networkId, int serviceId, const QString& seriesCrid)
{
QList<DVBDemodSettings::SeriesRecording> series = m_settings.m_seriesRecordings;
for (int i = 0; i < series.size(); i++)
{
if ((series[i].m_networkId == networkId) && (series[i].m_serviceId == serviceId) && (series[i].m_seriesCrid == seriesCrid))
{
series.removeAt(i);
setSeries(series);
return;
}
}
}
bool DVBDemod::isSeriesScheduled(int networkId, int serviceId, int eventId) const
{
DVBDemodEPG::Event event;
if (!m_basebandSink->getEPG()->getEvent(networkId, serviceId, eventId, event) || event.m_seriesCrid.isEmpty()) {
return false;
}
for (const auto& s : m_settings.m_seriesRecordings)
{
if ((s.m_networkId == networkId) && (s.m_serviceId == serviceId) && (s.m_seriesCrid == event.m_seriesCrid)) {
return true;
}
}
return false;
}
void DVBDemod::setSeries(const QList<DVBDemodSettings::SeriesRecording>& series)
{
DVBDemodSettings settings = m_settings;
settings.m_seriesRecordings = series;
applySettings(settings, {"seriesRecordings"});
if (m_guiMessageQueue) {
m_guiMessageQueue->push(MsgConfigureDVBDemod::create(settings, {"seriesRecordings"}, false));
}
}
// Each series' programmes in the guide not yet scheduled, nor scheduled before (a repeat has its first showing's
// programme CRID: not recorded again), from now on. Only when the guide's changed
bool DVBDemod::checkSeries(QList<DVBDemodSettings::ScheduledRecording>& schedule)
{
DVBDemodEPG *epg = getEPG();
if (m_settings.m_seriesRecordings.isEmpty() || (epg->getRevision() == m_seriesRevision)) {
return false;
}
m_seriesRevision = epg->getRevision();
const qint64 t = epg->getTime() > 0 ? epg->getTime() : QDateTime::currentSecsSinceEpoch();
QList<DVBDemodSettings::SeriesRecording> series = m_settings.m_seriesRecordings;
bool added = false;
static const int maxRemembered = 500; // Of a series' programmes scheduled, the latest
for (auto& s : series)
{
for (const auto& event : epg->getEvents(s.m_networkId, s.m_serviceId))
{
if ((event.m_seriesCrid != s.m_seriesCrid) || (event.end() <= t)) {
continue;
}
const QString id = event.m_programmeCrid.isEmpty() ? QString("event:%1").arg(event.m_eventId) : event.m_programmeCrid;
const bool scheduled = std::any_of(schedule.begin(), schedule.end(), [&](const DVBDemodSettings::ScheduledRecording& r) {
return (r.m_networkId == s.m_networkId) && (r.m_serviceId == s.m_serviceId) && (r.m_eventId == event.m_eventId);
});
if (scheduled || s.m_scheduled.contains(id)) {
continue;
}
DVBDemodSettings::ScheduledRecording r;
r.m_networkId = s.m_networkId;
r.m_serviceId = s.m_serviceId;
r.m_eventId = event.m_eventId;
r.m_start = event.m_start;
r.m_duration = event.m_duration;
r.m_title = event.m_title;
r.m_serviceName = s.m_serviceName;
schedule.append(r);
s.m_scheduled.append(id);
while (s.m_scheduled.size() > maxRemembered) {
s.m_scheduled.removeFirst();
}
qDebug() << "DVBDemod::checkSeries: scheduled" << r.m_title << "of" << s.m_title << "at" << QDateTime::fromSecsSinceEpoch(r.m_start);
added = true;
}
}
if (added) {
setSeries(series);
}
return added;
}
bool DVBDemod::retuneForRecording(const DVBDemodSettings::ScheduledRecording& r)
{
// Not while anything else is being recorded (its multiplex would be lost), nor in a search, scan or retune for
// another, nor to a satellite multiplex on another polarisation (the LNB isn't switched from here)
int needed, current;
if (m_recordingRetune.m_active || recordingInProgress() || !m_scheduledRecordingIds.empty() || m_search.m_active
|| m_scan.m_active || m_pendingRecording.m_active || polarisationChange(r.m_networkId, r.m_serviceId, needed, current)) {
return false;
}
const qint64 returnFrequency = m_centerFrequency;
const DVBDemodSettings returnSettings = m_settings;
QString error;
m_retuningForRecording = true;
const bool ok = playService(r.m_networkId, r.m_serviceId, error);
m_retuningForRecording = false;
if (!ok)
{
qWarning() << "DVBDemod::retuneForRecording: can't retune for" << r.m_title << ":" << error;
return false;
}
qInfo() << "DVBDemod::retuneForRecording: retuned for" << r.m_title << "on" << r.m_serviceName;
m_recordingRetune = RecordingRetune();
m_recordingRetune.m_active = true;
m_recordingRetune.m_returnFrequency = returnFrequency;
m_recordingRetune.m_returnSettings = returnSettings;
m_recordingRetune.m_since.start();
return true;
}
void DVBDemod::checkRecordingReturn(const QList<DVBDemodSettings::ScheduledRecording>& schedule, qint64 t)
{
RecordingRetune& rr = m_recordingRetune;
if (!rr.m_active || m_search.m_active) {
return;
}
// The user's retuned the device meanwhile: where it is now is theirs
if (rr.m_recorded && (m_centerFrequency != rr.m_tunedFrequency))
{
rr.m_active = false;
return;
}
// Still recording, or one due (or about to be) here: stay. Given up if no recording started within a minute
const bool due = std::any_of(schedule.begin(), schedule.end(), [&](const DVBDemodSettings::ScheduledRecording& r) {
return (t >= r.m_start - m_settings.m_recordStartPadding - m_recordRetuneLeadSeconds) && (t < r.end() + m_settings.m_recordEndPadding);
});
if (!m_scheduledRecordingIds.empty() || (rr.m_recorded && due) || (!rr.m_recorded && (rr.m_since.elapsed() < m_recordRetuneGiveUpMs))) {
return;
}
qInfo("DVBDemod::checkRecordingReturn: back to %.3f MHz", rr.m_returnFrequency / 1e6);
rr.m_active = false;
if (retuneDevice(rr.m_returnFrequency))
{
applyServiceSettings(rr.m_returnSettings, {"serviceId", "standard", "bandwidth", "plpId", "lowPriority", "symbolRate",
"codeRate", "rollOff", "isi"});
}
}
void DVBDemod::cancelScheduledRecording(int networkId, int serviceId, int eventId)
{
QList<DVBDemodSettings::ScheduledRecording> schedule = m_settings.m_scheduledRecordings;
for (int i = 0; i < schedule.size(); i++)
{
const auto& r = schedule[i];
if ((r.m_networkId == networkId) && (r.m_serviceId == serviceId) && (r.m_eventId == eventId))
{
auto it = m_scheduledRecordingIds.find(scheduleKey(networkId, serviceId, eventId));
if (it != m_scheduledRecordingIds.end())
{
m_basebandSink->stopRecording(it->second);
m_scheduledRecordingIds.erase(it);
}
schedule.removeAt(i);
setSchedule(schedule);
return;
}
}
}
// The schedule changes in the settings, here and in the GUI, which saves them
void DVBDemod::setSchedule(const QList<DVBDemodSettings::ScheduledRecording>& schedule)
{
DVBDemodSettings settings = m_settings;
settings.m_scheduledRecordings = schedule;
applySettings(settings, {"scheduledRecordings"});
if (m_guiMessageQueue) {
m_guiMessageQueue->push(MsgConfigureDVBDemod::create(settings, {"scheduledRecordings"}, false));
}
}
// Start and stop scheduled recordings, by the time in the transport stream (or the computer's, without it), and
// follow changes to the programmes' times in the guide. A recording that's missed is dropped
void DVBDemod::checkSchedule()
{
// The carousels of the service played (or that would be) are received
getApps()->setCarouselService(currentServiceId());
if (m_settings.m_scheduledRecordings.isEmpty() && m_scheduledRecordingIds.empty() && m_settings.m_seriesRecordings.isEmpty()
&& !m_recordingRetune.m_active) {
return;
}
DVBDemodEPG *epg = getEPG();
const qint64 t = epg->getTime() > 0 ? epg->getTime() : QDateTime::currentSecsSinceEpoch();
// Not by a time that's jumped, until it's believed: recordings ended and dropped from the schedule by it are lost
const bool timeOK = scheduleTimeConfirmed(t);
QList<DVBDemodSettings::ScheduledRecording> schedule = m_settings.m_scheduledRecordings;
bool changed = timeOK && checkSeries(schedule);
for (int i = 0; i < schedule.size(); )
{
DVBDemodSettings::ScheduledRecording& r = schedule[i];
DVBDemodEPG::Event event;
if (epg->getEvent(r.m_networkId, r.m_serviceId, r.m_eventId, event) && ((event.m_start != r.m_start) || (event.m_duration != r.m_duration)))
{
r.m_start = event.m_start;
r.m_duration = event.m_duration;
changed = true;
}
const qint64 key = scheduleKey(r.m_networkId, r.m_serviceId, r.m_eventId);
auto active = m_scheduledRecordingIds.find(key);
qint64 from = r.m_start - m_settings.m_recordStartPadding;
qint64 to = r.end() + m_settings.m_recordEndPadding;
// The programme's running status, where the broadcaster sends it (in its multiplex's present and following
// table): it's recorded from when it starts (or is about to), even if early, and while it's running or
// paused, even past its end (as a match that goes to extra time), for up to 3 hours more
const int running = m_settings.m_recordFollowRunning ? epg->getRunningStatus(r.m_networkId, r.m_serviceId, r.m_eventId) : -1;
static const qint64 maxOverrun = 3 * 3600;
if ((running >= 2) && (running <= 4)) {
from = std::min(from, t);
}
if (((running == 3) || (running == 4)) && (t < r.end() + maxOverrun)) {
to = std::max(to, t + 60);
}
// Recorded only from the multiplex the service is on: another may not have the service, or have another with
// its id (the recorder records by service id). Not retuned to, which would interrupt what's being watched
// (Where the guide doesn't know which multiplex it's on, it's tried on this one, as before)
DVBDemodEPG::Service service;
const bool known = epg->getService(r.m_networkId, r.m_serviceId, service) && (service.m_transportStreamId >= 0);
const bool here = !known || service.m_actual;
const bool elsewhere = !here && (epg->getTransportStreamId() >= 0); // Not while the multiplex isn't known yet
if ((active != m_scheduledRecordingIds.end()) && elsewhere && (t < to))
{
// The device was retuned to another multiplex while recording: stopped (started again if it's tuned back)
qWarning() << "DVBDemod::checkSchedule: stopped recording" << r.m_title << ": the multiplex received changed";
m_basebandSink->stopRecording(active->second);
m_scheduledRecordingIds.erase(active);
i++;
continue;
}
if (!timeOK)
{
// Carries on as it is
}
else if ((active == m_scheduledRecordingIds.end()) && (t >= from) && (t < to) && !here)
{
// Retuned to, if allowed and nothing else is being recorded (or done with the device)
if (elsewhere && !(m_settings.m_recordRetune && retuneForRecording(r)) && m_scheduledRecordingFailed.insert(key).second) {
qWarning() << "DVBDemod::checkSchedule: can't record" << r.m_title << ": its service isn't on the multiplex received";
}
}
else if ((active == m_scheduledRecordingIds.end()) && (t >= from) && (t < to))
{
QString error;
const int id = m_basebandSink->startRecording(recordingFileName(QString("%1 - %2").arg(r.m_serviceName).arg(r.m_title), r.m_start),
DTVRecorder::Service, r.m_serviceId, error);
if (id >= 0)
{
m_scheduledRecordingIds[key] = id;
m_scheduledRecordingFailed.erase(key);
if (m_recordingRetune.m_active && !m_recordingRetune.m_recorded)
{
m_recordingRetune.m_recorded = true;
m_recordingRetune.m_tunedFrequency = m_centerFrequency;
}
}
else if (m_scheduledRecordingFailed.insert(key).second)
{
qWarning() << "DVBDemod::checkSchedule: can't record" << r.m_title << ":" << error;
}
}
else if (t >= to)
{
if (active != m_scheduledRecordingIds.end())
{
m_basebandSink->stopRecording(active->second);
m_scheduledRecordingIds.erase(active);
}
m_scheduledRecordingFailed.erase(key);
schedule.removeAt(i);
changed = true;
continue;
}
i++;
}
// Recordings no longer scheduled, as when settings are loaded or the schedule is replaced
for (auto it = m_scheduledRecordingIds.begin(); it != m_scheduledRecordingIds.end(); )
{
const bool scheduled = std::any_of(schedule.begin(), schedule.end(), [&it](const DVBDemodSettings::ScheduledRecording& r) {
return scheduleKey(r.m_networkId, r.m_serviceId, r.m_eventId) == it->first;
});
if (scheduled)
{
++it;
}
else
{
m_basebandSink->stopRecording(it->second);
it = m_scheduledRecordingIds.erase(it);
}
}
if (timeOK) {
checkRecordingReturn(schedule, t);
}
if (changed) {
setSchedule(schedule);
}
}
bool DVBDemod::scheduleTimeConfirmed(qint64 t)
{
ScheduleClock& c = m_scheduleClock;
if (!c.m_clock.isValid())
{
c.m_clock.start();
c.m_time = t;
c.m_at = 0;
return true;
}
const qint64 now = c.m_clock.elapsed();
const qint64 expected = c.m_time + (now - c.m_at) / 1000;
// As expected (to within the TDT's resolution, the checks' timing, and drift): followed from here
if (qAbs(t - expected) <= m_scheduleJumpSeconds)
{
if (c.m_jumped) {
qInfo("DVBDemod::scheduleTimeConfirmed: the time's back to %s", qPrintable(QDateTime::fromSecsSinceEpoch(t).toString()));
}
c.m_time = t;
c.m_at = now;
c.m_jumped = false;
return true;
}
// Jumped: to another time than the last jump's, it starts again
const qint64 jumpExpected = c.m_jumpTime + (now - c.m_jumpAt) / 1000;
if (!c.m_jumped || (qAbs(t - jumpExpected) > m_scheduleJumpSeconds))
{
qWarning("DVBDemod::scheduleTimeConfirmed: the time's jumped %lld s, to %s: not believed yet", (long long) (t - expected),
qPrintable(QDateTime::fromSecsSinceEpoch(t).toString()));
c.m_jumped = true;
c.m_jumpTime = t;
c.m_jumpAt = now;
c.m_jumpChecks = 0;
return false;
}
// Kept to for long enough: believed
if ((++c.m_jumpChecks >= m_scheduleJumpChecks) && (now - c.m_jumpAt >= m_scheduleJumpConfirmMs))
{
qInfo("DVBDemod::scheduleTimeConfirmed: the time's now %s", qPrintable(QDateTime::fromSecsSinceEpoch(t).toString()));
c.m_time = t;
c.m_at = now;
c.m_jumped = false;
return true;
}
return false;
}
void DVBDemod::saveEPG()
{
if (getEPG()->isModified()) {
getEPG()->save(DVBDemodEPG::defaultCacheFileName());
}
}
DVBDemod::~DVBDemod()
{
qDebug("DVBDemod::~DVBDemod");
// Just stopped: not retuned back (the device set may be being deleted too), nor the GUI told (it's deleted first)
m_search.m_active = false;
m_scan.m_active = false;
m_pendingRecording.m_active = false;
m_epgSaveTimer.stop();
m_scheduleTimer.stop();
m_tuneTimer.stop();
saveEPG();
QObject::disconnect(
m_networkManager,
&QNetworkAccessManager::finished,
this,
&DVBDemod::networkManagerFinished
);
delete m_networkManager;
m_deviceAPI->removeChannelSinkAPI(this);
m_deviceAPI->removeChannelSink(this, true);
if (m_basebandSink->isRunning()) {
stop();
}
delete m_basebandSink;
}
void DVBDemod::setDeviceAPI(DeviceAPI *deviceAPI)
{
if (deviceAPI != m_deviceAPI)
{
m_deviceAPI->removeChannelSinkAPI(this);
m_deviceAPI->removeChannelSink(this, false);
m_deviceAPI = deviceAPI;
m_deviceAPI->addChannelSink(this);
m_deviceAPI->addChannelSinkAPI(this);
}
}
uint32_t DVBDemod::getNumberOfDeviceStreams() const
{
return m_deviceAPI->getNbSourceStreams();
}
int DVBDemod::getChannelSampleRate() const
{
return m_basebandSink->getChannelSampleRate();
}
void DVBDemod::feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool firstOfBurst)
{
(void) firstOfBurst;
m_basebandSink->feed(begin, end);
}
void DVBDemod::start()
{
qDebug("DVBDemod::start");
// In the device's DSP thread: what this object's thread changes is copied with the mutex
int basebandSampleRate;
qint64 centerFrequency;
DVBDemodSettings settings;
{
QMutexLocker locker(&m_settingsMutex);
basebandSampleRate = m_basebandSampleRate;
centerFrequency = m_centerFrequency;
settings = m_settings;
}
m_basebandSink->reset();
m_basebandSink->startWork();
m_thread.start();
DSPSignalNotification *dspMsg = new DSPSignalNotification(basebandSampleRate, centerFrequency);
m_basebandSink->getInputMessageQueue()->push(dspMsg);
DVBDemodBaseband::MsgConfigureDVBDemodBaseband *msg = DVBDemodBaseband::MsgConfigureDVBDemodBaseband::create(settings, QStringList(), true);
m_basebandSink->getInputMessageQueue()->push(msg);
// The symbol rate search's band, if one was set: its message may have been cleared by reset(), sent while stopped
m_basebandSink->reapplyRateSearchBand();
}
void DVBDemod::stop()
{
qDebug("DVBDemod::stop");
m_basebandSink->stopWork();
m_thread.quit();
m_thread.wait();
}
bool DVBDemod::handleMessage(const Message& cmd)
{
if (MsgConfigureDVBDemod::match(cmd))
{
MsgConfigureDVBDemod& cfg = (MsgConfigureDVBDemod&) cmd;
qDebug() << "DVBDemod::handleMessage: MsgConfigureDVBDemod";
applySettings(cfg.getSettings(), cfg.getSettingsKeys(), cfg.getForce());
return true;
}
else if (DSPSignalNotification::match(cmd))
{
DSPSignalNotification& notif = (DSPSignalNotification&) cmd;
{
QMutexLocker locker(&m_settingsMutex);
m_basebandSampleRate = notif.getSampleRate();
}
const bool retune = notif.getCenterFrequency() != m_centerFrequency;
if (retune) {
retuned();
}
// Retuned elsewhere than the guide did (by the user: further than any fine tuning of the same transponder): the
// satellite settings the guide set were for its transponder, so they're automatic again. Left, a transponder at another symbol rate, or the other standard,
// was never locked to (in Sync, until the DVB Demod was opened again)
if (retune && m_guideSettings && (qAbs(notif.getCenterFrequency() - m_guideCenterFrequency) > m_guideRetuneTolerance))
{
m_guideSettings = false;
DVBDemodSettings settings = m_settings;
setSatelliteAutomatic(settings);
qDebug("DVBDemod::handleMessage: retuned elsewhere than the guide: the satellite settings are automatic again");
applyServiceSettings(settings, {"standard", "symbolRate", "codeRate", "rollOff", "isi"});
}
{
QMutexLocker locker(&m_settingsMutex);
m_centerFrequency = notif.getCenterFrequency();
}
// Forward to the sink
DSPSignalNotification* rep = new DSPSignalNotification(notif); // make a copy
qDebug() << "DVBDemod::handleMessage: DSPSignalNotification";
m_basebandSink->getInputMessageQueue()->push(rep);
if (retune) {
resetReceivers();
}
if (getMessageQueueToGUI()) {
getMessageQueueToGUI()->push(new DSPSignalNotification(notif));
}
return true;
}
else
{
return false;
}
}
void DVBDemod::setCenterFrequency(qint64 frequency)
{
DVBDemodSettings settings = m_settings;
settings.m_inputFrequencyOffset = frequency;
applySettings(settings, {"inputFrequencyOffset"}, false);
if (m_guiMessageQueue) // forward to GUI if any
{
MsgConfigureDVBDemod *msgToGUI = MsgConfigureDVBDemod::create(settings, {"inputFrequencyOffset"}, false);
m_guiMessageQueue->push(msgToGUI);
}
}
void DVBDemod::applySettings(const DVBDemodSettings& settings, const QStringList& settingsKeys, bool force)
{
qDebug() << "DVBDemod::applySettings:"
<< settings.getDebugString(settingsKeys, force)
<< " force: " << force;
// Set by the user (or the guide again, after this): the user's to keep
if (settingsKeys.contains("standard") || settingsKeys.contains("symbolRate") || force) {
m_guideSettings = false;
}
if (settingsKeys.contains("freesatRegion") || force) {
getEPG()->setFreesatRegion(settings.m_freesatRegion);
}
if (settingsKeys.contains("streamIndex"))
{
if (m_deviceAPI->getSampleMIMO()) // change of stream is possible for MIMO devices only
{
m_deviceAPI->removeChannelSinkAPI(this);
m_deviceAPI->removeChannelSink(this, m_settings.m_streamIndex);
m_deviceAPI->addChannelSink(this, settings.m_streamIndex);
m_deviceAPI->addChannelSinkAPI(this);
{
QMutexLocker locker(&m_settingsMutex);
m_settings.m_streamIndex = settings.m_streamIndex; // make sure ChannelAPI::getStreamIndex() is consistent
}
emit streamIndexChanged(settings.m_streamIndex);
}
}
DVBDemodBaseband::MsgConfigureDVBDemodBaseband *msg = DVBDemodBaseband::MsgConfigureDVBDemodBaseband::create(settings, settingsKeys, force);
m_basebandSink->getInputMessageQueue()->push(msg);
// Another frequency, or another transport stream from the same (a PLP, or hierarchical stream)
const bool offsetChanged = settingsKeys.contains("inputFrequencyOffset") && (settings.m_inputFrequencyOffset != m_settings.m_inputFrequencyOffset);
if (offsetChanged && !force) {
resetReceivers(); // After the settings, as the channel moves with them
}
if (offsetChanged
|| (settingsKeys.contains("plpId") && (settings.m_plpId != m_settings.m_plpId))
|| (settingsKeys.contains("lowPriority") && (settings.m_lowPriority != m_settings.m_lowPriority))
|| (settingsKeys.contains("isi") && (settings.m_isi != m_settings.m_isi)) // Another input stream, another multiplex
|| force)
{
retuned();
}
if (settings.m_useReverseAPI)
{
bool fullUpdate = (settingsKeys.contains("useReverseAPI") && settings.m_useReverseAPI) ||
settingsKeys.contains("reverseAPIAddress") ||
settingsKeys.contains("reverseAPIPort") ||
settingsKeys.contains("reverseAPIDeviceIndex") ||
settingsKeys.contains("reverseAPIChannelIndex");
webapiReverseSendSettings(settingsKeys, settings, fullUpdate || force);
}
QMutexLocker locker(&m_settingsMutex);
if (force) {
m_settings = settings;
} else {
m_settings.applySettings(settingsKeys, settings);
}
}
QByteArray DVBDemod::serialize() const
{
return m_settings.serialize();
}
bool DVBDemod::deserialize(const QByteArray& data)
{
bool ok;
DVBDemodSettings settings;
{
QMutexLocker locker(&m_settingsMutex);
ok = m_settings.deserialize(data);
if (!ok) {
m_settings.resetToDefaults();
}
settings = m_settings;
}
// Not holding the mutex: from this thread, the message is handled now, and applySettings() takes it
MsgConfigureDVBDemod *msg = MsgConfigureDVBDemod::create(settings, QStringList(), true);
m_inputMessageQueue.push(msg);
return ok;
}
void DVBDemod::handleIndexInDeviceSetChanged(int index)
{
if (index < 0) {
return;
}
QString fifoLabel = QString("%1 [%2:%3]")
.arg(m_channelId)
.arg(m_deviceAPI->getDeviceSetIndex())
.arg(index);
m_basebandSink->setFifoLabel(fifoLabel);
m_basebandSink->setAudioFifoLabel(fifoLabel);
}
// Run f in object's thread, waiting for it. Only from a thread that thread never waits for (see dvbdemod.h)
int DVBDemod::inObjectThread(QObject *object, const std::function<int()>& f)
{
if (QThread::currentThread() == object->thread()) {
return f();
}
int result = 500;
QMetaObject::invokeMethod(object, [&]() {
result = f();
}, Qt::BlockingQueuedConnection);
return result;
}
int DVBDemod::webapiSettingsGet(
SWGSDRangel::SWGChannelSettings& response,
QString& errorMessage)
{
(void) errorMessage;
// The settings, which this object's thread changes
if (QThread::currentThread() != thread()) {
return inObjectThread(this, [&]() { return webapiSettingsGet(response, errorMessage); });
}
response.setDvbDemodSettings(new SWGSDRangel::SWGDVBDemodSettings());
response.getDvbDemodSettings()->init();
webapiFormatChannelSettings(response, m_settings);
return 200;
}
int DVBDemod::webapiWorkspaceGet(
SWGSDRangel::SWGWorkspaceInfo& response,
QString& errorMessage)
{
if (QThread::currentThread() != thread()) {
return inObjectThread(this, [&]() { return webapiWorkspaceGet(response, errorMessage); });
}
(void) errorMessage;
response.setIndex(m_settings.m_workspaceIndex);
return 200;
}
int DVBDemod::webapiSettingsPutPatch(
bool force,
const QStringList& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings& response,
QString& errorMessage)
{
// From the settings, which this object's thread changes
if (QThread::currentThread() != thread()) {
return inObjectThread(this, [&]() { return webapiSettingsPutPatch(force, channelSettingsKeys, response, errorMessage); });
}
DVBDemodSettings settings = m_settings;
webapiUpdateChannelSettings(settings, channelSettingsKeys, response);
// Others would divide by zero, or leave the receivers and the report disagreeing on the standard
if (channelSettingsKeys.contains("bandwidth") && !DVBDemodSettings::isValidBandwidth(settings.m_bandwidth))
{
errorMessage = QString("bandwidth %1 Hz is not 8000000, 7000000 or 6000000").arg(settings.m_bandwidth);
return 400;
}
if (channelSettingsKeys.contains("standard") && !DVBDemodSettings::isValidStandard(settings.m_standard))
{
errorMessage = QString("standard %1 is not 0 (automatic, DVB-T or T2), 1 (DVB-T), 2 (DVB-T2), 3 (DVB-T2 T2-Lite), 4 (automatic, DVB-S or S2), 5 (DVB-S) or 6 (DVB-S2)")
.arg(settings.m_standard);
return 400;
}
if (channelSettingsKeys.contains("symbolRate") && !DVBDemodSettings::isValidSymbolRate(settings.m_symbolRate))
{
errorMessage = QString("symbolRate %1 is not 0 (automatic) or from 10000 to 50000000").arg(settings.m_symbolRate);
return 400;
}
if (channelSettingsKeys.contains("rollOff") && !DVBDemodSettings::isValidRollOff(settings.m_rollOff))
{
errorMessage = QString("rollOff %1 is not 0 (automatic), 35, 25, 20, 15, 10 or 5").arg(settings.m_rollOff);
return 400;
}
if (channelSettingsKeys.contains("codeRate") && !DVBDemodSettings::isValidCodeRate(settings.m_codeRate))
{
errorMessage = QString("codeRate %1 is not -1 (automatic) or 0 to 4 (1/2 to 7/8)").arg(settings.m_codeRate);
return 400;
}
if (channelSettingsKeys.contains("freesatRegion") && !DVBDemodSettings::isValidFreesatRegion(settings.m_freesatRegion))
{
errorMessage = QString("freesatRegion %1 is not from 0 to 65535").arg(settings.m_freesatRegion);
return 400;
}
if (channelSettingsKeys.contains("isi") && !DVBDemodSettings::isValidISI(settings.m_isi))
{
errorMessage = QString("isi %1 is not -1 (automatic) or from 0 to 255").arg(settings.m_isi);
return 400;
}
if (channelSettingsKeys.contains("plScramblingCode") && !DVBDemodSettings::isValidScramblingCode(settings.m_plScramblingCode))
{
errorMessage = QString("plScramblingCode %1 is not from 0 to 262141").arg(settings.m_plScramblingCode);
return 400;
}
if (channelSettingsKeys.contains("epgReport") && !DVBDemodSettings::isValidEPGReport(settings.m_epgReport))
{
errorMessage = QString("epgReport %1 is not 0, 1 or 2").arg(settings.m_epgReport);
return 400;
}
MsgConfigureDVBDemod *msg = MsgConfigureDVBDemod::create(settings, channelSettingsKeys, force);
m_inputMessageQueue.push(msg);
if (m_guiMessageQueue) // forward to GUI if any
{
MsgConfigureDVBDemod *msgToGUI = MsgConfigureDVBDemod::create(settings, channelSettingsKeys, force);
m_guiMessageQueue->push(msgToGUI);
}
webapiFormatChannelSettings(response, settings);
return 200;
}
int DVBDemod::webapiReportGet(
SWGSDRangel::SWGChannelReport& response,
QString& errorMessage)
{
// The web API's thread: the report reads the settings and the scheduled recordings, which this object's changes
if (QThread::currentThread() != thread()) {
return inObjectThread(this, [&]() { return webapiReportGet(response, errorMessage); });
}
response.setDvbDemodReport(new SWGSDRangel::SWGDVBDemodReport());
response.getDvbDemodReport()->init();
webapiFormatChannelReport(response);
return 200;
}
void DVBDemod::webapiUpdateChannelSettings(
DVBDemodSettings& settings,
const QStringList& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings& response)
{
SWGSDRangel::SWGDVBDemodSettings *swgSettings = response.getDvbDemodSettings();
if (channelSettingsKeys.contains("inputFrequencyOffset")) {
settings.m_inputFrequencyOffset = swgSettings->getInputFrequencyOffset();
}
if (channelSettingsKeys.contains("bandwidth")) {
settings.m_bandwidth = swgSettings->getBandwidth();
}
if (channelSettingsKeys.contains("standard")) {
settings.m_standard = swgSettings->getStandard();
}
if (channelSettingsKeys.contains("plpId")) {
settings.m_plpId = swgSettings->getPlpId();
}
if (channelSettingsKeys.contains("lowPriority")) {
settings.m_lowPriority = swgSettings->getLowPriority() != 0;
}
if (channelSettingsKeys.contains("symbolRate")) {
settings.m_symbolRate = swgSettings->getSymbolRate();
}
if (channelSettingsKeys.contains("rollOff")) {
settings.m_rollOff = swgSettings->getRollOff();
}
if (channelSettingsKeys.contains("codeRate")) {
settings.m_codeRate = swgSettings->getCodeRate();
}
if (channelSettingsKeys.contains("isi")) {
settings.m_isi = swgSettings->getIsi();
}
if (channelSettingsKeys.contains("plScramblingCode")) {
settings.m_plScramblingCode = swgSettings->getPlScramblingCode();
}
if (channelSettingsKeys.contains("recordRetune")) {
settings.m_recordRetune = swgSettings->getRecordRetune() != 0;
}
if (channelSettingsKeys.contains("recordFollowRunning")) {
settings.m_recordFollowRunning = swgSettings->getRecordFollowRunning() != 0;
}
if (channelSettingsKeys.contains("equaliser")) {
settings.m_equaliser = swgSettings->getEqualiser() != 0;
}
if (channelSettingsKeys.contains("freesatRegion")) {
settings.m_freesatRegion = swgSettings->getFreesatRegion();
}
if (channelSettingsKeys.contains("udpEnabled")) {
settings.m_udpEnabled = swgSettings->getUdpEnabled() != 0;
}
if (channelSettingsKeys.contains("udpAddress")) {
settings.m_udpAddress = *swgSettings->getUdpAddress();
}
if (channelSettingsKeys.contains("udpPort") && (swgSettings->getUdpPort() > 0) && (swgSettings->getUdpPort() <= 65535)) {
settings.m_udpPort = swgSettings->getUdpPort();
}
if (channelSettingsKeys.contains("videoEnabled")) {
settings.m_videoEnabled = swgSettings->getVideoEnabled() != 0;
}
if (channelSettingsKeys.contains("serviceId")) {
settings.m_serviceId = swgSettings->getServiceId();
}
if (channelSettingsKeys.contains("deinterlace")) {
settings.m_deinterlace = swgSettings->getDeinterlace() != 0;
}
if (channelSettingsKeys.contains("hbbtv")) {
settings.m_hbbtv = swgSettings->getHbbtv() != 0;
}
if (channelSettingsKeys.contains("avOffset")) {
settings.m_avOffset = swgSettings->getAvOffset();
}
if (channelSettingsKeys.contains("recordDirectory")) {
settings.m_recordDirectory = *swgSettings->getRecordDirectory();
}
if (channelSettingsKeys.contains("recordMode")) {
settings.m_recordMode = swgSettings->getRecordMode();
}
if (channelSettingsKeys.contains("recordStartPadding")) {
settings.m_recordStartPadding = swgSettings->getRecordStartPadding();
}
if (channelSettingsKeys.contains("recordEndPadding")) {
settings.m_recordEndPadding = swgSettings->getRecordEndPadding();
}
if (channelSettingsKeys.contains("epgReport")) {
settings.m_epgReport = swgSettings->getEpgReport();
}
if (channelSettingsKeys.contains("epgReportServiceId")) {
settings.m_epgReportServiceId = swgSettings->getEpgReportServiceId();
}
if (channelSettingsKeys.contains("epgReportNetworkId")) {
settings.m_epgReportNetworkId = swgSettings->getEpgReportNetworkId();
}
if (channelSettingsKeys.contains("hardwareDecoding")) {
settings.m_hardwareDecoding = swgSettings->getHardwareDecoding() != 0;
}
if (channelSettingsKeys.contains("audioLanguage")) {
settings.m_audioLanguage = *swgSettings->getAudioLanguage();
}
if (channelSettingsKeys.contains("audioDescription")) {
settings.m_audioDescription = swgSettings->getAudioDescription() != 0;
}
if (channelSettingsKeys.contains("audioDescriptionMixed")) {
settings.m_audioDescriptionMixed = swgSettings->getAudioDescriptionMixed() != 0;
}
if (channelSettingsKeys.contains("cleanAudio")) {
settings.m_cleanAudio = swgSettings->getCleanAudio() != 0;
}
if (channelSettingsKeys.contains("subtitlesHardOfHearing")) {
settings.m_subtitlesHardOfHearing = swgSettings->getSubtitlesHardOfHearing() != 0;
}
if (channelSettingsKeys.contains("subtitles")) {
settings.m_subtitles = swgSettings->getSubtitles() != 0;
}
if (channelSettingsKeys.contains("subtitleLanguage")) {
settings.m_subtitleLanguage = *swgSettings->getSubtitleLanguage();
}
if (channelSettingsKeys.contains("audioMute")) {
settings.m_audioMute = swgSettings->getAudioMute() != 0;
}
if (channelSettingsKeys.contains("audioVolume")) {
settings.m_audioVolume = swgSettings->getAudioVolume();
}
if (channelSettingsKeys.contains("audioDeviceName")) {
settings.m_audioDeviceName = *swgSettings->getAudioDeviceName();
}
if (channelSettingsKeys.contains("rgbColor")) {
settings.m_rgbColor = swgSettings->getRgbColor();
}
if (channelSettingsKeys.contains("title")) {
settings.m_title = *swgSettings->getTitle();
}
if (channelSettingsKeys.contains("streamIndex")) {
settings.m_streamIndex = swgSettings->getStreamIndex();
}
if (channelSettingsKeys.contains("useReverseAPI")) {
settings.m_useReverseAPI = swgSettings->getUseReverseApi() != 0;
}
if (channelSettingsKeys.contains("reverseAPIAddress")) {
settings.m_reverseAPIAddress = *swgSettings->getReverseApiAddress();
}
if (channelSettingsKeys.contains("reverseAPIPort")) {
settings.m_reverseAPIPort = swgSettings->getReverseApiPort();
}
if (channelSettingsKeys.contains("reverseAPIDeviceIndex")) {
settings.m_reverseAPIDeviceIndex = swgSettings->getReverseApiDeviceIndex();
}
if (channelSettingsKeys.contains("reverseAPIChannelIndex")) {
settings.m_reverseAPIChannelIndex = swgSettings->getReverseApiChannelIndex();
}
if (settings.m_channelMarker && channelSettingsKeys.contains("channelMarker")) {
settings.m_channelMarker->updateFrom(channelSettingsKeys, swgSettings->getChannelMarker());
}
if (settings.m_rollupState && channelSettingsKeys.contains("rollupState")) {
settings.m_rollupState->updateFrom(channelSettingsKeys, swgSettings->getRollupState());
}
}
// Set a string in the SWG settings, reusing the QString if there is one
void DVBDemod::setString(QString *existing, std::function<void(QString*)> setter, const QString& value)
{
if (existing) {
*existing = value;
} else {
setter(new QString(value));
}
}
void DVBDemod::webapiFormatChannelSettings(SWGSDRangel::SWGChannelSettings& response, const DVBDemodSettings& settings)
{
SWGSDRangel::SWGDVBDemodSettings *swgSettings = response.getDvbDemodSettings();
swgSettings->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
swgSettings->setBandwidth(settings.m_bandwidth);
swgSettings->setStandard(settings.m_standard);
swgSettings->setPlpId(settings.m_plpId);
swgSettings->setLowPriority(settings.m_lowPriority ? 1 : 0);
swgSettings->setSymbolRate(settings.m_symbolRate);
swgSettings->setRollOff(settings.m_rollOff);
swgSettings->setCodeRate(settings.m_codeRate);
swgSettings->setIsi(settings.m_isi);
swgSettings->setPlScramblingCode(settings.m_plScramblingCode);
swgSettings->setEqualiser(settings.m_equaliser ? 1 : 0);
swgSettings->setRecordRetune(settings.m_recordRetune ? 1 : 0);
swgSettings->setRecordFollowRunning(settings.m_recordFollowRunning ? 1 : 0);
swgSettings->setFreesatRegion(settings.m_freesatRegion);
swgSettings->setUdpEnabled(settings.m_udpEnabled ? 1 : 0);
setString(swgSettings->getUdpAddress(), [=](QString *s) { swgSettings->setUdpAddress(s); }, settings.m_udpAddress);
swgSettings->setUdpPort(settings.m_udpPort);
swgSettings->setVideoEnabled(settings.m_videoEnabled ? 1 : 0);
swgSettings->setServiceId(settings.m_serviceId);
swgSettings->setDeinterlace(settings.m_deinterlace ? 1 : 0);
swgSettings->setHbbtv(settings.m_hbbtv ? 1 : 0);
swgSettings->setAvOffset(settings.m_avOffset);
swgSettings->setHardwareDecoding(settings.m_hardwareDecoding ? 1 : 0);
setString(swgSettings->getAudioLanguage(), [=](QString *s) { swgSettings->setAudioLanguage(s); }, settings.m_audioLanguage);
swgSettings->setAudioDescription(settings.m_audioDescription ? 1 : 0);
swgSettings->setAudioDescriptionMixed(settings.m_audioDescriptionMixed ? 1 : 0);
swgSettings->setCleanAudio(settings.m_cleanAudio ? 1 : 0);
swgSettings->setSubtitlesHardOfHearing(settings.m_subtitlesHardOfHearing ? 1 : 0);
swgSettings->setSubtitles(settings.m_subtitles ? 1 : 0);
setString(swgSettings->getSubtitleLanguage(), [=](QString *s) { swgSettings->setSubtitleLanguage(s); }, settings.m_subtitleLanguage);
setString(swgSettings->getRecordDirectory(), [=](QString *s) { swgSettings->setRecordDirectory(s); }, settings.m_recordDirectory);
swgSettings->setRecordMode(settings.m_recordMode);
swgSettings->setRecordStartPadding(settings.m_recordStartPadding);
swgSettings->setRecordEndPadding(settings.m_recordEndPadding);
swgSettings->setEpgReport(settings.m_epgReport);
swgSettings->setEpgReportServiceId(settings.m_epgReportServiceId);
swgSettings->setEpgReportNetworkId(settings.m_epgReportNetworkId);
swgSettings->setAudioMute(settings.m_audioMute ? 1 : 0);
swgSettings->setAudioVolume(settings.m_audioVolume);
setString(swgSettings->getAudioDeviceName(), [=](QString *s) { swgSettings->setAudioDeviceName(s); }, settings.m_audioDeviceName);
swgSettings->setRgbColor(settings.m_rgbColor);
setString(swgSettings->getTitle(), [=](QString *s) { swgSettings->setTitle(s); }, settings.m_title);
swgSettings->setStreamIndex(settings.m_streamIndex);
swgSettings->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
setString(swgSettings->getReverseApiAddress(), [=](QString *s) { swgSettings->setReverseApiAddress(s); }, settings.m_reverseAPIAddress);
swgSettings->setReverseApiPort(settings.m_reverseAPIPort);
swgSettings->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
swgSettings->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
if (settings.m_channelMarker)
{
if (swgSettings->getChannelMarker())
{
settings.m_channelMarker->formatTo(swgSettings->getChannelMarker());
}
else
{
SWGSDRangel::SWGChannelMarker *swgChannelMarker = new SWGSDRangel::SWGChannelMarker();
settings.m_channelMarker->formatTo(swgChannelMarker);
swgSettings->setChannelMarker(swgChannelMarker);
}
}
if (settings.m_rollupState)
{
if (swgSettings->getRollupState())
{
settings.m_rollupState->formatTo(swgSettings->getRollupState());
}
else
{
SWGSDRangel::SWGRollupState *swgRollupState = new SWGSDRangel::SWGRollupState();
settings.m_rollupState->formatTo(swgRollupState);
swgSettings->setRollupState(swgRollupState);
}
}
}
// The programme guide: its size, and what's on now and next on the service selected, or the first TV service
void DVBDemod::webapiFormatEPGReport(SWGSDRangel::SWGDVBDemodReport *report)
{
DVBDemodEPG *epg = getEPG();
const std::vector<DVBDemodEPG::Service> services = epg->getServices();
report->setEpgServices((int) services.size());
report->setEpgEvents(epg->getEventCount());
const int serviceId = currentServiceId();
const std::vector<DVBDemodSink::Recording> recordings = getRecordings();
qint64 recorded = 0;
for (const auto& recording : recordings) {
recorded += recording.m_status.m_bytes;
}
report->setRecording((int) recordings.size());
*report->getRecordingFile() = recordings.empty() ? QString() : recordings[0].m_status.m_fileName;
report->setRecordingSize(recorded);
report->setScheduledRecordings(m_settings.m_scheduledRecordings.size());
report->setEpgServiceId(serviceId);
auto iso = [](qint64 utc) { return QDateTime::fromSecsSinceEpoch(utc, Qt::UTC).toString(Qt::ISODate); };
if (m_settings.m_epgReport >= 1) {
webapiFormatEPGLists(report, services, serviceId);
}
DVBDemodEPG::Event now, next;
if ((serviceId == 0) || !epg->getNowNext(serviceId, now, next)) {
return;
}
if (now.isValid())
{
*report->getEpgNowTitle() = now.m_title;
*report->getEpgNowStart() = iso(now.m_start);
report->setEpgNowDuration(now.m_duration);
*report->getEpgNowDescription() = now.m_text;
}
if (next.isValid())
{
*report->getEpgNextTitle() = next.m_title;
*report->getEpgNextStart() = iso(next.m_start);
report->setEpgNextDuration(next.m_duration);
}
}
// The interactive applications and carousels of the service the report's of
void DVBDemod::webapiFormatAppsReport(SWGSDRangel::SWGDVBDemodReport *report)
{
const int serviceId = currentServiceId();
const DTVApps *apps = getApps();
if (serviceId == 0) {
return;
}
const int transportStreamId = apps->getTransportStreamId();
const int networkId = apps->getOriginalNetworkId();
for (const DTVApps::App& app : apps->getApps(serviceId))
{
SWGSDRangel::SWGDVBDemodApp *swgApp = new SWGSDRangel::SWGDVBDemodApp();
swgApp->setApplicationId(new QString(app.idText()));
swgApp->setType(new QString(app.typeName()));
swgApp->setControlCode(new QString(app.controlCodeName()));
swgApp->setName(new QString(app.m_name));
swgApp->setUrl(new QString(app.url(networkId, transportStreamId)));
swgApp->setCarouselPid(app.m_carouselPid);
report->getInteractiveApps()->append(swgApp);
}
for (const DTVApps::Carousel& carousel : apps->getCarousels(serviceId))
{
SWGSDRangel::SWGDVBDemodCarousel *swgCarousel = new SWGSDRangel::SWGDVBDemodCarousel();
swgCarousel->setPid(carousel.m_pid);
swgCarousel->setComponentTag(carousel.m_componentTag);
swgCarousel->setCarouselId(carousel.m_carouselId);
swgCarousel->setKind(new QString(carousel.kindName()));
swgCarousel->setReceived(carousel.m_received ? 1 : 0);
swgCarousel->setModules(carousel.m_progress.m_modules);
swgCarousel->setModulesComplete(carousel.m_progress.m_modulesComplete);
swgCarousel->setBytes(carousel.m_progress.m_bytes);
swgCarousel->setBytesComplete(carousel.m_progress.m_bytesComplete);
swgCarousel->setFiles(carousel.m_files);
report->getCarousels()->append(swgCarousel);
}
}
// What service_type is, for the web API
QString DVBDemod::serviceKind(int type)
{
switch (type)
{
case 0x01: case 0x16: case 0x17: case 0x18: return "TV";
case 0x11: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1F: return "HD TV";
case 0x02: case 0x07: case 0x0A: return "Radio";
case 0x0C: return "Data";
default: return "Other";
}
}
// An event of the guide, for the web API: just its id, title and time, unless full
SWGSDRangel::SWGDVBDemodEPGEvent *DVBDemod::webapiEPGEvent(const DVBDemodEPG::Event& event, int networkId, bool full, bool scheduled)
{
SWGSDRangel::SWGDVBDemodEPGEvent *swgEvent = new SWGSDRangel::SWGDVBDemodEPGEvent();
swgEvent->init();
swgEvent->setEventId(event.m_eventId);
*swgEvent->getTitle() = event.m_title;
*swgEvent->getStart() = QDateTime::fromSecsSinceEpoch(event.m_start, Qt::UTC).toString(Qt::ISODate);
swgEvent->setDuration(event.m_duration);
if (scheduled) {
swgEvent->setScheduled(1);
}
if (!full) {
return swgEvent;
}
*swgEvent->getDescription() = event.m_text;
if (event.m_genre >= 0) {
*swgEvent->getGenre() = DVBDemodEPG::genreText(event.m_genre, networkId);
}
if (event.m_minimumAge > 0) {
swgEvent->setMinimumAge(event.m_minimumAge);
}
*swgEvent->getGuidance() = event.m_guidance;
swgEvent->setHd(event.m_hd ? 1 : 0);
swgEvent->setSubtitles(event.m_subtitles ? 1 : 0);
swgEvent->setAudioDescription(event.m_audioDescription ? 1 : 0);
return swgEvent;
}
// Every service of the guide with what's on now and next, in channel order (those without a number last), and with
// epgReport 2, a service's schedule
void DVBDemod::webapiFormatEPGLists(SWGSDRangel::SWGDVBDemodReport *report, std::vector<DVBDemodEPG::Service> services, int serviceId)
{
DVBDemodEPG *epg = getEPG();
QSet<QString> scheduled;
for (const auto& recording : m_settings.m_scheduledRecordings) {
scheduled.insert(QString("%1/%2/%3").arg(recording.m_networkId).arg(recording.m_serviceId).arg(recording.m_eventId));
}
auto isScheduled = [&scheduled](int networkId, int serviceId, int eventId) {
return scheduled.contains(QString("%1/%2/%3").arg(networkId).arg(serviceId).arg(eventId));
};
std::stable_sort(services.begin(), services.end(), [](const DVBDemodEPG::Service& a, const DVBDemodEPG::Service& b) {
const unsigned int ca = (unsigned int) a.m_channel, cb = (unsigned int) b.m_channel; // -1 last
return ca != cb ? ca < cb : (a.m_networkId != b.m_networkId ? a.m_networkId < b.m_networkId : a.m_serviceId < b.m_serviceId);
});
QList<SWGSDRangel::SWGDVBDemodEPGService*> *list = new QList<SWGSDRangel::SWGDVBDemodEPGService*>();
for (const auto& service : services)
{
SWGSDRangel::SWGDVBDemodEPGService *swgService = new SWGSDRangel::SWGDVBDemodEPGService();
swgService->init();
swgService->setNetworkId(service.m_networkId);
swgService->setTransportStreamId(service.m_transportStreamId);
swgService->setServiceId(service.m_serviceId);
*swgService->getName() = service.m_name;
*swgService->getProvider() = service.m_provider;
swgService->setType(service.m_type);
*swgService->getKind() = serviceKind(service.m_type);
swgService->setChannel(service.m_channel);
swgService->setVisible(service.m_visible ? 1 : 0);
swgService->setOnMultiplex(service.m_actual ? 1 : 0);
swgService->setFrequency(service.m_frequency);
swgService->setEvents(service.m_events);
DVBDemodEPG::Event now, next;
if (epg->getNowNext(service.m_networkId, service.m_serviceId, now, next))
{
if (now.isValid())
{
delete swgService->getNow();
swgService->setNow(webapiEPGEvent(now, service.m_networkId, false, isScheduled(service.m_networkId, service.m_serviceId, now.m_eventId)));
}
if (next.isValid())
{
delete swgService->getNext();
swgService->setNext(webapiEPGEvent(next, service.m_networkId, false, isScheduled(service.m_networkId, service.m_serviceId, next.m_eventId)));
}
}
list->append(swgService);
}
delete report->getEpgServiceList();
report->setEpgServiceList(list);
if (m_settings.m_epgReport < 2) {
return;
}
// The service asked for, of the network given, else that received, else the first with the id
const int scheduleServiceId = m_settings.m_epgReportServiceId != 0 ? m_settings.m_epgReportServiceId : serviceId;
int networkId = m_settings.m_epgReportNetworkId;
bool actual = false;
if (networkId < 0)
{
for (const auto& service : services)
{
if ((service.m_serviceId == scheduleServiceId) && !actual && (service.m_actual || (networkId < 0)))
{
networkId = service.m_networkId;
actual = service.m_actual;
}
}
}
if ((scheduleServiceId == 0) || (networkId < 0)) {
return;
}
report->setEpgScheduleServiceId(scheduleServiceId);
report->setEpgScheduleNetworkId(networkId);
QList<SWGSDRangel::SWGDVBDemodEPGEvent*> *schedule = new QList<SWGSDRangel::SWGDVBDemodEPGEvent*>();
for (const auto& event : epg->getEvents(networkId, scheduleServiceId)) {
schedule->append(webapiEPGEvent(event, networkId, true, isScheduled(networkId, scheduleServiceId, event.m_eventId)));
}
delete report->getEpgSchedule();
report->setEpgSchedule(schedule);
}
int DVBDemod::webapiActionsPost(
const QStringList& channelActionsKeys,
SWGSDRangel::SWGChannelActions& query,
QString& errorMessage)
{
// The web API's thread: the actions use the search and the schedule, as the timers in this object's thread do
if (QThread::currentThread() != thread()) {
return inObjectThread(this, [&]() { return webapiActionsPost(channelActionsKeys, query, errorMessage); });
}
SWGSDRangel::SWGDVBDemodActions *actions = query.getDvbDemodActions();
if (!actions)
{
errorMessage = "Missing DVBDemodActions in query";
return 400;
}
if (channelActionsKeys.contains("scan"))
{
if (actions->getScan() == 0)
{
cancelScan();
}
else if (!startScan(channelActionsKeys.contains("scanFrom") ? actions->getScanFrom() : 0,
channelActionsKeys.contains("scanTo") ? actions->getScanTo() : 0, errorMessage))
{
return 400;
}
}
// Playing first, so a recording of the service selected is of the one asked for
int playedNetworkId = -1;
if (channelActionsKeys.contains("play") && (actions->getPlay() != 0))
{
if (!channelActionsKeys.contains("serviceId"))
{
errorMessage = "play needs serviceId";
return 400;
}
const int networkId = serviceNetworkId(actions->getServiceId(), channelActionsKeys.contains("networkId") ? actions->getNetworkId() : -1);
if (networkId < 0)
{
errorMessage = "Service not in the programme guide";
return 404;
}
if (!playService(networkId, actions->getServiceId(), errorMessage)) {
return 400;
}
playedNetworkId = networkId;
}
// Playing a service on another multiplex (retuning, or searching for it): it isn't received yet, and the multiplex
// before may have a service with the same id, so it's recorded once its multiplex is (or not at all, if it isn't)
DVBDemodEPG::Service played;
const bool elsewhere = channelActionsKeys.contains("play") && (actions->getPlay() != 0)
&& getEPG()->getService(playedNetworkId, actions->getServiceId(), played) && !played.m_actual;
if (channelActionsKeys.contains("record"))
{
if ((actions->getRecord() != 0) && elsewhere)
{
m_pendingRecording.m_active = true;
m_pendingRecording.m_networkId = played.m_networkId;
m_pendingRecording.m_transportStreamId = played.m_transportStreamId;
m_pendingRecording.m_serviceId = played.m_serviceId;
m_pendingRecording.m_since.start();
}
else if (actions->getRecord() != 0)
{
if (!startRecording(errorMessage)) {
return 400;
}
}
else
{
stopRecording();
}
}
if (channelActionsKeys.contains("recordEvent"))
{
if (!channelActionsKeys.contains("serviceId") || !channelActionsKeys.contains("eventId"))
{
errorMessage = "recordEvent needs serviceId and eventId";
return 400;
}
const int networkId = serviceNetworkId(actions->getServiceId(), channelActionsKeys.contains("networkId") ? actions->getNetworkId() : -1);
if (networkId < 0)
{
errorMessage = "Service not in the programme guide";
return 404;
}
if (actions->getRecordEvent() != 0)
{
if (!scheduleRecording(networkId, actions->getServiceId(), actions->getEventId()) && !isScheduled(networkId, actions->getServiceId(), actions->getEventId()))
{
errorMessage = "Programme not in the programme guide";
return 404;
}
}
else
{
cancelScheduledRecording(networkId, actions->getServiceId(), actions->getEventId());
}
}
if (channelActionsKeys.contains("recordSeries"))
{
if (!channelActionsKeys.contains("serviceId") || !channelActionsKeys.contains("eventId"))
{
errorMessage = "recordSeries needs serviceId and eventId";
return 400;
}
DVBDemodEPG::Service service;
const int networkId = channelActionsKeys.contains("networkId") ? actions->getNetworkId() : getEPG()->getNetworkId();
DVBDemodEPG::Event event;
// The network given, else the one received, else the first with the service id
int network = networkId;
if (!getEPG()->getService(network, actions->getServiceId(), service))
{
network = -1;
for (const auto& s : getEPG()->getServices())
{
if (s.m_serviceId == actions->getServiceId())
{
network = s.m_networkId;
break;
}
}
}
if ((network < 0) || !getEPG()->getEvent(network, actions->getServiceId(), actions->getEventId(), event))
{
errorMessage = "Programme not in the programme guide";
return 404;
}
if (actions->getRecordSeries() != 0)
{
if (event.m_seriesCrid.isEmpty())
{
errorMessage = "The programme isn't part of a series (it has no series CRID)";
return 400;
}
scheduleSeries(network, actions->getServiceId(), actions->getEventId());
}
else
{
cancelSeries(network, actions->getServiceId(), actions->getEventId());
}
}
return 202;
}
// Given, only it; else the first received (actual), else the first
int DVBDemod::serviceNetworkId(int serviceId, int networkId)
{
int found = -1;
bool actual = false;
for (const auto& service : getEPG()->getServices())
{
if (service.m_serviceId != serviceId) {
continue;
}
if (networkId >= 0)
{
if (service.m_networkId == networkId) {
return networkId;
}
}
else if (!actual && (service.m_actual || (found < 0)))
{
found = service.m_networkId;
actual = service.m_actual;
}
}
return found;
}
void DVBDemod::webapiFormatChannelReport(SWGSDRangel::SWGChannelReport& response)
{
DVBDemodSink::Status status;
getStatus(status);
const dvbt::OFDMDemod::Status& ofdm = status.m_receiver.m_ofdm;
SWGSDRangel::SWGDVBDemodReport *report = response.getDvbDemodReport();
report->setChannelPowerDb(status.m_power);
report->setChannelSampleRate(status.m_channelSampleRate);
*report->getState() = status.stateText(m_settings.m_bandwidth);
report->setTsBitRate(status.m_tsBitRate);
report->setUdpDatagrams(status.m_udpDatagrams);
*report->getSearchText() = getSearchText();
report->setScanTransponders(getScanTransponders());
webapiFormatEPGReport(report);
webapiFormatAppsReport(report);
if (status.m_standard == S::StandardDVBT2)
{
webapiFormatT2Report(status, report);
return;
}
if (status.isSatellite())
{
webapiFormatSatelliteReport(status, report);
return;
}
*report->getStandard() = status.m_standard == S::StandardDVBT ? "DVB-T" : "";
if (ofdm.m_state != dvbt::OFDMDemod::Acquire)
{
*report->getMode() = dvbt::toString(ofdm.m_mode);
*report->getGuardInterval() = dvbt::toString(ofdm.m_guard);
report->setFrequencyOffset(ofdm.m_frequencyOffset);
report->setClockOffset(ofdm.m_clockOffset);
}
if (ofdm.m_tpsValid)
{
*report->getConstellation() = dvbt::toString(ofdm.m_tps.m_constellation);
*report->getCodeRate() = dvbt::toString(ofdm.m_tps.m_hpCodeRate);
*report->getHierarchy() = dvbt::toString(ofdm.m_tps.m_hierarchy);
report->setMer(status.m_receiver.m_mer);
report->setSnr(ofdm.m_snr);
report->setPreViterbiBer(status.m_receiver.m_preViterbiBER);
report->setPostViterbiBer(status.m_receiver.m_postViterbiBER);
}
report->setCellId(ofdm.m_cellId);
report->setTsSync(status.m_receiver.m_tsSync ? 1 : 0);
report->setTsPackets(status.m_receiver.m_outer.m_packets);
report->setRsCorrected(status.m_receiver.m_outer.m_rsCorrected);
report->setRsFailed(status.m_receiver.m_outer.m_rsFailed);
}
void DVBDemod::webapiFormatSatelliteReport(const DVBDemodSink::Status& status, SWGSDRangel::SWGDVBDemodReport *report)
{
// Set, or found when automatic (0 while searching)
report->setSymbolRate(m_settings.m_symbolRate > 0 ? m_settings.m_symbolRate : (int) std::max(0.0, status.m_autoSymbolRate));
if (status.m_standard == S::StandardDVBS)
{
const dvbs::Receiver::Status& s = status.m_s;
*report->getStandard() = "DVB-S";
report->setMeasuredSymbolRate(s.m_frontEnd.m_measuredSymbolRate);
report->setRollOff(0.35f);
if (!s.m_frontEnd.m_estimating)
{
report->setFrequencyOffset(s.m_frequencyOffset);
report->setClockOffset(s.m_clockOffset);
}
*report->getConstellation() = "QPSK";
if (s.m_fec.m_codeRateKnown) {
*report->getCodeRate() = dvbt::toString(s.m_fec.m_codeRate);
}
if (s.m_carrierLocked)
{
report->setMer(s.m_mer);
report->setSnr(s.m_snr);
}
report->setPreViterbiBer(s.m_fec.m_preViterbiBER);
report->setPostViterbiBer(s.m_fec.m_postViterbiBER);
report->setTsSync(s.m_fec.m_tsSync ? 1 : 0);
report->setTsPackets(s.m_fec.m_outer.m_packets);
report->setReacquisitions(s.m_restarts);
report->setRsCorrected(s.m_fec.m_outer.m_rsCorrected);
report->setRsFailed(s.m_fec.m_outer.m_rsFailed);
return;
}
if (status.m_standard == S::StandardDVBS2)
{
const dvbs2::Receiver::Status& s = status.m_s2;
*report->getStandard() = "DVB-S2";
report->setMeasuredSymbolRate(s.m_frontEnd.m_measuredSymbolRate);
report->setRollOff(s.m_rollOff);
if (!s.m_frontEnd.m_estimating)
{
report->setFrequencyOffset(s.m_frequencyOffset);
report->setClockOffset(s.m_clockOffset);
}
if (s.m_pl.m_vlsnr >= 0)
{
// A VL-SNR frame's MODCOD, by its canonical name (its rate the name's, after its modulation)
const dvbs2::VLSNRModcod& vl = dvbs2::vlsnrModcod(s.m_pl.m_vlsnr);
const QString name(vl.m_name);
*report->getModcod() = QString("VL-SNR %1").arg(name);
*report->getConstellation() = dvbs2::toString(vl.m_modulation);
*report->getCodeRate() = name.section(' ', -1);
report->setPilots(1);
*report->getFrameSize() = vl.m_type == dvbt2::FECType::Short ? "short" : vl.m_type == dvbt2::FECType::Medium ? "medium" : "normal";
*report->getFecType() = vl.m_type == dvbt2::FECType::Short ? "16K" : vl.m_type == dvbt2::FECType::Medium ? "32K" : "64K";
}
else if (s.m_pl.m_modcod > 0)
{
dvbs2::Modulation modulation;
dvbt2::CodeRate rate;
if (dvbs2::modcodInfo(s.m_pl.m_modcod, modulation, rate))
{
*report->getModcod() = dvbs2::modcodString(s.m_pl.m_modcod);
*report->getConstellation() = dvbs2::toString(modulation);
*report->getCodeRate() = dvbt2::toString(rate);
}
report->setPilots((s.m_pl.m_type & 1) ? 1 : 0);
*report->getFrameSize() = (s.m_pl.m_type & 2) ? "short" : "normal";
*report->getFecType() = (s.m_pl.m_type & 2) ? "16K" : "64K";
}
if (s.m_pl.m_state == dvbs2::PLDecoder::State::Locked)
{
report->setMer(s.m_pl.m_mer);
report->setEsN0(s.m_pl.m_esn0);
report->setSnr(s.m_pl.m_esn0); // As Es/N0, from the known symbols
}
report->setIsi(s.m_isi);
report->setIsiCount(s.m_isiCount);
report->setPlFrames(s.m_pl.m_frames);
report->setDummyFrames(s.m_pl.m_dummyFrames);
report->setPlHeaderMisses(s.m_pl.m_headerMisses);
report->setReacquisitions(s.m_restarts);
report->setLdpcIterations(s.m_ldpcIterations);
report->setFecBlocks(s.m_fecFrames);
report->setBchFailures(s.m_bchFailures);
report->setTsSync(s.m_streamPackets > 0 ? 1 : 0); // Of the input stream selected
report->setTsPackets(s.m_bb.m_packets);
if (s.m_bb.m_streamType >= 0) {
*report->getStreamType() = dvbt2::BBFrameDecoder::streamTypeName(s.m_bb.m_streamType);
}
return;
}
*report->getStandard() = "";
}
void DVBDemod::webapiFormatT2Report(const DVBDemodSink::Status& status, SWGSDRangel::SWGDVBDemodReport *report)
{
const dvbt2::Receiver::Status& t2 = status.m_t2;
*report->getStandard() = t2.m_ofdm.m_p1.isT2Lite() ? "DVB-T2-Lite" : "DVB-T2";
if (t2.m_ofdm.m_state != dvbt2::OFDMDemod::SearchP1)
{
*report->getMode() = QString("%1%2").arg(dvbt2::fftSizeString(t2.m_ofdm.m_fftSize)).arg(t2.m_l1Valid && t2.m_pre.m_bwtExt ? "E" : "");
*report->getGuardInterval() = dvbt2::toString(t2.m_ofdm.m_guard);
report->setFrequencyOffset(t2.m_ofdm.m_frequencyOffset);
report->setClockOffset(t2.m_ofdm.m_clockOffset);
}
if (t2.m_l1Valid)
{
*report->getPilotPattern() = dvbt2::toString(t2.m_pre.m_pilotPattern);
report->setExtendedCarriers(t2.m_pre.m_bwtExt ? 1 : 0);
report->setCellId(t2.m_pre.m_cellId);
report->setPlpCount((int) t2.m_post.m_plps.size());
for (const dvbt2::PLP& plp : t2.m_post.m_plps)
{
if (plp.m_id == t2.m_plpId)
{
*report->getConstellation() = dvbt2::toString(plp.m_constellation);
*report->getCodeRate() = dvbt2::toString(plp.m_codeRate);
report->setRotation(plp.m_rotation ? 1 : 0);
*report->getFecType() = plp.m_fecType == dvbt2::FECType::Normal ? "64K" : "16K";
}
}
}
report->setPlpId(t2.m_plpId);
report->setMer(t2.m_mer);
report->setSnr(t2.m_ofdm.m_snr);
report->setLdpcIterations(t2.m_ldpcIterations);
report->setFecBlocks(t2.m_fecBlocks);
report->setBchFailures(t2.m_bchFailures);
report->setL1Errors(t2.m_l1Errors);
report->setTsSync(t2.m_bb.m_packets > 0 ? 1 : 0);
report->setTsPackets(t2.m_bb.m_packets);
if (t2.m_bb.m_streamType >= 0) {
*report->getStreamType() = dvbt2::BBFrameDecoder::streamTypeName(t2.m_bb.m_streamType);
}
}
void DVBDemod::webapiReverseSendSettings(const QList<QString>& channelSettingsKeys, const DVBDemodSettings& settings, bool force)
{
SWGSDRangel::SWGChannelSettings *swgChannelSettings = new SWGSDRangel::SWGChannelSettings();
webapiFormatChannelSettings(channelSettingsKeys, swgChannelSettings, settings, force);
QString channelSettingsURL = QString("http://%1:%2/sdrangel/deviceset/%3/channel/%4/settings")
.arg(settings.m_reverseAPIAddress)
.arg(settings.m_reverseAPIPort)
.arg(settings.m_reverseAPIDeviceIndex)
.arg(settings.m_reverseAPIChannelIndex);
m_networkRequest.setUrl(QUrl(channelSettingsURL));
m_networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
QBuffer *buffer = new QBuffer();
buffer->open((QBuffer::ReadWrite));
buffer->write(swgChannelSettings->asJson().toUtf8());
buffer->seek(0);
// Always use PATCH to avoid passing reverse API settings
QNetworkReply *reply = m_networkManager->sendCustomRequest(m_networkRequest, "PATCH", buffer);
buffer->setParent(reply);
delete swgChannelSettings;
}
void DVBDemod::webapiFormatChannelSettings(
const QList<QString>& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings *swgChannelSettings,
const DVBDemodSettings& settings,
bool force
)
{
swgChannelSettings->setDirection(0); // Single sink (Rx)
swgChannelSettings->setOriginatorChannelIndex(getIndexInDeviceSet());
swgChannelSettings->setOriginatorDeviceSetIndex(getDeviceSetIndex());
if (swgChannelSettings->getChannelType()) {
*swgChannelSettings->getChannelType() = m_channelId;
} else {
swgChannelSettings->setChannelType(new QString(m_channelId));
}
swgChannelSettings->setDvbDemodSettings(new SWGSDRangel::SWGDVBDemodSettings());
SWGSDRangel::SWGDVBDemodSettings *swgSettings = swgChannelSettings->getDvbDemodSettings();
// Transfer data that has been modified. When force is on transfer all data except reverse API data
if (channelSettingsKeys.contains("inputFrequencyOffset") || force) {
swgSettings->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
}
if (channelSettingsKeys.contains("bandwidth") || force) {
swgSettings->setBandwidth(settings.m_bandwidth);
}
if (channelSettingsKeys.contains("standard") || force) {
swgSettings->setStandard(settings.m_standard);
}
if (channelSettingsKeys.contains("plpId") || force) {
swgSettings->setPlpId(settings.m_plpId);
}
if (channelSettingsKeys.contains("lowPriority") || force) {
swgSettings->setLowPriority(settings.m_lowPriority ? 1 : 0);
}
if (channelSettingsKeys.contains("symbolRate") || force) {
swgSettings->setSymbolRate(settings.m_symbolRate);
}
if (channelSettingsKeys.contains("rollOff") || force) {
swgSettings->setRollOff(settings.m_rollOff);
}
if (channelSettingsKeys.contains("codeRate") || force) {
swgSettings->setCodeRate(settings.m_codeRate);
}
if (channelSettingsKeys.contains("isi") || force) {
swgSettings->setIsi(settings.m_isi);
}
if (channelSettingsKeys.contains("plScramblingCode") || force) {
swgSettings->setPlScramblingCode(settings.m_plScramblingCode);
}
if (channelSettingsKeys.contains("recordRetune") || force) {
swgSettings->setRecordRetune(settings.m_recordRetune ? 1 : 0);
}
if (channelSettingsKeys.contains("recordFollowRunning") || force) {
swgSettings->setRecordFollowRunning(settings.m_recordFollowRunning ? 1 : 0);
}
if (channelSettingsKeys.contains("equaliser") || force) {
swgSettings->setEqualiser(settings.m_equaliser ? 1 : 0);
}
if (channelSettingsKeys.contains("freesatRegion") || force) {
swgSettings->setFreesatRegion(settings.m_freesatRegion);
}
if (channelSettingsKeys.contains("udpEnabled") || force) {
swgSettings->setUdpEnabled(settings.m_udpEnabled ? 1 : 0);
}
if (channelSettingsKeys.contains("udpAddress") || force) {
swgSettings->setUdpAddress(new QString(settings.m_udpAddress));
}
if (channelSettingsKeys.contains("udpPort") || force) {
swgSettings->setUdpPort(settings.m_udpPort);
}
if (channelSettingsKeys.contains("videoEnabled") || force) {
swgSettings->setVideoEnabled(settings.m_videoEnabled ? 1 : 0);
}
if (channelSettingsKeys.contains("serviceId") || force) {
swgSettings->setServiceId(settings.m_serviceId);
}
if (channelSettingsKeys.contains("deinterlace") || force) {
swgSettings->setDeinterlace(settings.m_deinterlace ? 1 : 0);
}
if (channelSettingsKeys.contains("hbbtv") || force) {
swgSettings->setHbbtv(settings.m_hbbtv ? 1 : 0);
}
if (channelSettingsKeys.contains("avOffset") || force) {
swgSettings->setAvOffset(settings.m_avOffset);
}
if (channelSettingsKeys.contains("hardwareDecoding") || force) {
swgSettings->setHardwareDecoding(settings.m_hardwareDecoding ? 1 : 0);
}
if (channelSettingsKeys.contains("audioLanguage") || force) {
swgSettings->setAudioLanguage(new QString(settings.m_audioLanguage));
}
if (channelSettingsKeys.contains("audioDescription") || force) {
swgSettings->setAudioDescription(settings.m_audioDescription ? 1 : 0);
}
if (channelSettingsKeys.contains("audioDescriptionMixed") || force) {
swgSettings->setAudioDescriptionMixed(settings.m_audioDescriptionMixed ? 1 : 0);
}
if (channelSettingsKeys.contains("cleanAudio") || force) {
swgSettings->setCleanAudio(settings.m_cleanAudio ? 1 : 0);
}
if (channelSettingsKeys.contains("subtitlesHardOfHearing") || force) {
swgSettings->setSubtitlesHardOfHearing(settings.m_subtitlesHardOfHearing ? 1 : 0);
}
if (channelSettingsKeys.contains("subtitles") || force) {
swgSettings->setSubtitles(settings.m_subtitles ? 1 : 0);
}
if (channelSettingsKeys.contains("subtitleLanguage") || force) {
swgSettings->setSubtitleLanguage(new QString(settings.m_subtitleLanguage));
}
if (channelSettingsKeys.contains("recordDirectory") || force) {
swgSettings->setRecordDirectory(new QString(settings.m_recordDirectory));
}
if (channelSettingsKeys.contains("recordMode") || force) {
swgSettings->setRecordMode(settings.m_recordMode);
}
if (channelSettingsKeys.contains("recordStartPadding") || force) {
swgSettings->setRecordStartPadding(settings.m_recordStartPadding);
}
if (channelSettingsKeys.contains("recordEndPadding") || force) {
swgSettings->setRecordEndPadding(settings.m_recordEndPadding);
}
if (channelSettingsKeys.contains("epgReport") || force) {
swgSettings->setEpgReport(settings.m_epgReport);
}
if (channelSettingsKeys.contains("epgReportServiceId") || force) {
swgSettings->setEpgReportServiceId(settings.m_epgReportServiceId);
}
if (channelSettingsKeys.contains("epgReportNetworkId") || force) {
swgSettings->setEpgReportNetworkId(settings.m_epgReportNetworkId);
}
if (channelSettingsKeys.contains("audioMute") || force) {
swgSettings->setAudioMute(settings.m_audioMute ? 1 : 0);
}
if (channelSettingsKeys.contains("audioVolume") || force) {
swgSettings->setAudioVolume(settings.m_audioVolume);
}
if (channelSettingsKeys.contains("audioDeviceName") || force) {
swgSettings->setAudioDeviceName(new QString(settings.m_audioDeviceName));
}
if (channelSettingsKeys.contains("rgbColor") || force) {
swgSettings->setRgbColor(settings.m_rgbColor);
}
if (channelSettingsKeys.contains("title") || force) {
swgSettings->setTitle(new QString(settings.m_title));
}
if (channelSettingsKeys.contains("streamIndex") || force) {
swgSettings->setStreamIndex(settings.m_streamIndex);
}
if (settings.m_channelMarker && (channelSettingsKeys.contains("channelMarker") || force))
{
SWGSDRangel::SWGChannelMarker *swgChannelMarker = new SWGSDRangel::SWGChannelMarker();
settings.m_channelMarker->formatTo(swgChannelMarker);
swgSettings->setChannelMarker(swgChannelMarker);
}
if (settings.m_rollupState && (channelSettingsKeys.contains("rollupState") || force))
{
SWGSDRangel::SWGRollupState *swgRollupState = new SWGSDRangel::SWGRollupState();
settings.m_rollupState->formatTo(swgRollupState);
swgSettings->setRollupState(swgRollupState);
}
}
void DVBDemod::networkManagerFinished(QNetworkReply *reply)
{
QNetworkReply::NetworkError replyError = reply->error();
if (replyError)
{
qWarning() << "DVBDemod::networkManagerFinished:"
<< " error(" << (int) replyError
<< "): " << replyError
<< ": " << reply->errorString();
}
else
{
QString answer = reply->readAll();
answer.chop(1); // remove last \n
qDebug("DVBDemod::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
}
reply->deleteLater();
}