SDRAngel  4.11.5
Developer docs for <a href="https://github.com/f4exb/sdrangel">SDRangel<\a>, an Open Source Qt5 / OpenGL 3.0+ SDR and signal analyzer frontend to various hardware.
datvdemodgui.cpp
Go to the documentation of this file.
1 // Copyright (C) 2018 F4HKW //
3 // for F4EXB / SDRAngel //
4 // using LeanSDR Framework (C) 2016 F4DAV //
5 // //
6 // This program is free software; you can redistribute it and/or modify //
7 // it under the terms of the GNU General Public License as published by //
8 // the Free Software Foundation as version 3 of the License, or //
9 // (at your option) any later version. //
10 // //
11 // This program is distributed in the hope that it will be useful, //
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of //
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
14 // GNU General Public License V3 for more details. //
15 // //
16 // You should have received a copy of the GNU General Public License //
17 // along with this program. If not, see <http://www.gnu.org/licenses/>. //
19 
20 #include <QDockWidget>
21 #include <QMainWindow>
22 #include <QMediaMetaData>
23 
24 #include "datvdemodgui.h"
25 
26 #include "device/deviceuiset.h"
27 #include "dsp/downchannelizer.h"
28 
30 #include "ui_datvdemodgui.h"
31 #include "plugin/pluginapi.h"
32 #include "util/simpleserializer.h"
33 #include "util/db.h"
34 #include "dsp/dspengine.h"
35 #include "gui/crightclickenabler.h"
36 #include "gui/audioselectdialog.h"
37 #include "mainwindow.h"
38 
39 const QString DATVDemodGUI::m_strChannelID = "sdrangel.channel.demoddatv";
40 
42  DeviceUISet *deviceUISet,
43  BasebandSampleSink *rxChannel)
44 {
45  DATVDemodGUI* gui = new DATVDemodGUI(objPluginAPI, deviceUISet, rxChannel);
46  return gui;
47 }
48 
50 {
51  delete this;
52 }
53 
54 void DATVDemodGUI::setName(const QString& strName)
55 {
56  setObjectName(strName);
57 }
58 
59 QString DATVDemodGUI::getName() const
60 {
61  return objectName();
62 }
63 
65 {
67 }
68 
69 void DATVDemodGUI::setCenterFrequency(qint64 intCenterFrequency)
70 {
71  m_objChannelMarker.setCenterFrequency(intCenterFrequency);
72  applySettings();
73 }
74 
76 {
79  applySettings(true);
80 }
81 
82 QByteArray DATVDemodGUI::serialize() const
83 {
84  return m_settings.serialize();
85 }
86 
87 bool DATVDemodGUI::deserialize(const QByteArray& arrData)
88 {
89  if (m_settings.deserialize(arrData))
90  {
92  applySettings(true);
93  return true;
94  }
95  else
96  {
98  return false;
99  }
100 }
101 
103 {
105  {
107  m_settings.m_fec = notif.getCodeRate();
111  return true;
112  }
113  else
114  {
115  return false;
116  }
117 }
118 
120 {
121  Message* message;
122 
123  while ((message = getInputMessageQueue()->pop()) != 0)
124  {
125  if (handleMessage(*message))
126  {
127  delete message;
128  }
129  }
130 }
131 
133 {
134  ui->deltaFrequency->setValue(m_objChannelMarker.getCenterFrequency());
135 
137  {
139  applySettings();
140  }
141 }
142 
144 {
146 }
147 
148 
149 void DATVDemodGUI::onWidgetRolled(QWidget* widget, bool rollDown)
150 {
151  (void) widget;
152  (void) rollDown;
153 }
154 
156 {
157 }
158 
159 DATVDemodGUI::DATVDemodGUI(PluginAPI* objPluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* objParent) :
160  RollupWidget(objParent),
161  ui(new Ui::DATVDemodGUI),
162  m_objPluginAPI(objPluginAPI),
163  m_deviceUISet(deviceUISet),
164  m_objChannelMarker(this),
166  m_blnDoApplySettings(true),
169  m_cstlnSetByModcod(false)
170 {
171  ui->setupUi(this);
172  ui->screenTV->setColor(true);
173  setAttribute(Qt::WA_DeleteOnClose, true);
174  connect(this, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
175  connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
176 
177  m_objDATVDemod = (DATVDemod*) rxChannel;
179 
180  m_objDATVDemod->SetTVScreen(ui->screenTV);
181 
184 
187  m_intLastSpeed=0;
189  m_objTimer.setInterval(1000);
190  connect(&m_objTimer, SIGNAL(timeout()), this, SLOT(tick()));
191  m_objTimer.start();
192 
193  ui->fullScreen->setVisible(false);
194 
195  ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
196  ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
197  ui->deltaFrequency->setValueRange(false, 7, -9999999, 9999999);
198 
199  ui->rfBandwidth->setColorMapper(ColorMapper(ColorMapper::GrayYellow));
200  ui->rfBandwidth->setValueRange(true, 7, 0, 9999999);
201 
202  m_objChannelMarker.blockSignals(true);
203  m_objChannelMarker.setColor(Qt::magenta);
206  m_objChannelMarker.blockSignals(false);
208 
209  connect(&m_objChannelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
210  connect(&m_objChannelMarker, SIGNAL(highlightedByCursor()), this, SLOT(channelMarkerHighlightedByCursor()));
211 
215 
216  // QPixmap pixmapTarget = QPixmap(":/film.png");
217  // pixmapTarget = pixmapTarget.scaled(16, 16, Qt::KeepAspectRatio, Qt::SmoothTransformation);
218  // ui->videoPlay->setAlignment(Qt::AlignCenter);
219  // ui->videoPlay->setPixmap(pixmapTarget);
220 
221  CRightClickEnabler *audioMuteRightClickEnabler = new CRightClickEnabler(ui->audioMute);
222  connect(audioMuteRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(audioSelect()));
223 
224 
225  resetToDefaults(); // does applySettings()
226 }
227 
229 {
231  delete m_objDATVDemod;
232  delete ui;
233 }
234 
236 {
237  m_blnDoApplySettings = !blnBlock;
238 }
239 
241 {
242  m_objChannelMarker.blockSignals(true);
243  blockApplySettings(true);
244 
247  ui->deltaFrequency->setValue(m_settings.m_centerFrequency);
249 
250  ui->chkAllowDrift->setChecked(m_settings.m_allowDrift);
251  ui->chkHardMetric->setChecked(m_settings.m_hardMetric);
252  ui->chkFastlock->setChecked(m_settings.m_fastLock);
253  ui->chkViterbi->setChecked(m_settings.m_viterbi);
254 
255  if (m_settings.m_standard == DATVDemodSettings::dvb_version::DVB_S)
256  {
257  ui->chkAllowDrift->setEnabled(true);
258  ui->chkHardMetric->setEnabled(true);
259  ui->chkFastlock->setEnabled(true);
260  ui->chkViterbi->setEnabled(true);
261  ui->chkAllowDrift->setStyleSheet("QCheckBox { color: white }");
262  ui->chkHardMetric->setStyleSheet("QCheckBox { color: white }");
263  ui->chkFastlock->setStyleSheet("QCheckBox { color: white }");
264  ui->chkViterbi->setStyleSheet("QCheckBox { color: white }");
265  }
266  else
267  {
268  ui->chkAllowDrift->setEnabled(false);
269  ui->chkHardMetric->setEnabled(false);
270  ui->chkFastlock->setEnabled(false);
271  ui->chkViterbi->setEnabled(false);
272  ui->chkAllowDrift->setStyleSheet("QCheckBox { color: gray }");
273  ui->chkHardMetric->setStyleSheet("QCheckBox { color: gray }");
274  ui->chkFastlock->setStyleSheet("QCheckBox { color: gray }");
275  ui->chkViterbi->setStyleSheet("QCheckBox { color: gray }");
276  }
277 
278  if (m_settings.m_standard == DATVDemodSettings::dvb_version::DVB_S) {
279  ui->statusText->clear();
280  }
281 
282  ui->cmbFilter->setCurrentIndex((int) m_settings.m_filter);
284 
285  ui->spiRollOff->setValue((int) (m_settings.m_rollOff * 100.0f));
286  ui->audioMute->setChecked(m_settings.m_audioMute);
288  ui->cmbStandard->setCurrentIndex((int) m_settings.m_standard);
289  ui->spiNotchFilters->setValue(m_settings.m_notchFilters);
290  ui->rfBandwidth->setValue(m_settings.m_rfBandwidth);
291  ui->spiSymbolRate->setValue(m_settings.m_symbolRate);
292  ui->spiExcursion->setValue(m_settings.m_excursion);
293  ui->audioVolume->setValue(m_settings.m_audioVolume);
294  ui->audioVolumeText->setText(tr("%1").arg(m_settings.m_audioVolume));
295  ui->videoMute->setChecked(m_settings.m_videoMute);
296  ui->udpTS->setChecked(m_settings.m_udpTS);
297  ui->udpTSAddress->setText(m_settings.m_udpTSAddress);
298  ui->udpTSPort->setText(tr("%1").arg(m_settings.m_udpTSPort));
299 
300  blockApplySettings(false);
301  m_objChannelMarker.blockSignals(false);
302 }
303 
305 {
306  ui->cmbModulation->blockSignals(true);
307  ui->cmbFEC->blockSignals(true);
308 
309  std::vector<DATVDemodSettings::DATVModulation> modulations;
311  std::vector<DATVDemodSettings::DATVCodeRate> codeRates;
313 
314  ui->cmbModulation->clear();
315  int modulationIndex = 0;
316  int i;
317  std::vector<DATVDemodSettings::DATVModulation>::const_iterator mIt = modulations.begin();
318 
319  for (i = 0; mIt != modulations.end(); ++mIt, i++)
320  {
321  ui->cmbModulation->addItem(DATVDemodSettings::getStrFromModulation(*mIt));
322 
323  if (m_settings.m_modulation == *mIt) {
324  modulationIndex = i;
325  }
326  }
327 
328  ui->cmbFEC->clear();
329  int rateIndex = 0;
330  std::vector<DATVDemodSettings::DATVCodeRate>::const_iterator rIt = codeRates.begin();
331 
332  for (i = 0; rIt != codeRates.end(); ++rIt, i++)
333  {
334  ui->cmbFEC->addItem(DATVDemodSettings::getStrFromCodeRate(*rIt));
335 
336  if (m_settings.m_fec == *rIt) {
337  rateIndex = i;
338  }
339  }
340 
341  ui->cmbModulation->setCurrentIndex(modulationIndex);
342  ui->cmbFEC->setCurrentIndex(rateIndex);
343 
344  ui->cmbModulation->blockSignals(false);
345  ui->cmbFEC->blockSignals(false);
346 }
347 
349 {
351  {
352  qDebug("DATVDemodGUI::applySettings");
353 
356 
358 
359  QString msg = tr("DATVDemodGUI::applySettings: force: %1").arg(force ? "true" : "false");
360  m_settings.debug(msg);
361 
364  }
365 }
366 
368 {
369  blockApplySettings(true);
371  blockApplySettings(false);
372 }
373 
375 {
376  blockApplySettings(true);
378  blockApplySettings(false);
379 }
380 
382 {
383  qDebug("AMDemodGUI::audioSelect");
385  audioSelect.exec();
386 
387  if (audioSelect.m_selected)
388  {
390  applySettings();
391  }
392 }
393 
395 {
396  if (m_objDATVDemod)
397  {
400  ui->channePowerText->setText(tr("%1 dB").arg(magSqDB, 0, 'f', 1));
401 
403  {
408  QString modcodModulationStr = DATVDemodSettings::getStrFromModulation(modulation);
409  QString modcodCodeRateStr = DATVDemodSettings::getStrFromCodeRate(rate);
410  ui->statusText->setText(tr("MCOD %1 %2").arg(modcodModulationStr).arg(modcodCodeRateStr));
411  }
412 
414  {
416 
417  if (m_cstlnSetByModcod) {
418  ui->statusText->setStyleSheet("QLabel { background-color : green; }");
419  } else {
420  ui->statusText->setStyleSheet("QLabel { background:rgb(79,79,79); }");
421  }
422  }
423  }
424 
426  {
428  ui->lblRate->setText(QString("Speed: %1b/s").arg(formatBytes(m_intLastSpeed)));
429  }
430 
432  {
433  if (m_objDATVDemod->audioDecodeOK()) {
434  ui->audioMute->setStyleSheet("QToolButton { background-color : green; }");
435  } else {
436  ui->audioMute->setStyleSheet("QToolButton { background-color : red; }");
437  }
438  }
439  else
440  {
441  ui->audioMute->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
442  }
443 
445  {
446  if (m_objDATVDemod->videoDecodeOK()) {
447  ui->videoMute->setStyleSheet("QToolButton { background-color : green; }");
448  } else {
449  ui->videoMute->setStyleSheet("QToolButton { background-color : red; }");
450  }
451  }
452  else
453  {
454  ui->videoMute->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
455  }
456 
458 
459  //Try to start video rendering
460  m_objDATVDemod->PlayVideo(false);
461 
462  return;
463 }
464 
466 {
468 
469  if (m_settings.m_standard == DATVDemodSettings::dvb_version::DVB_S)
470  {
471  ui->chkAllowDrift->setEnabled(true);
472  ui->chkHardMetric->setEnabled(true);
473  ui->chkFastlock->setEnabled(true);
474  ui->chkViterbi->setEnabled(true);
475  ui->chkAllowDrift->setStyleSheet("QCheckBox { color: white }");
476  ui->chkHardMetric->setStyleSheet("QCheckBox { color: white }");
477  ui->chkFastlock->setStyleSheet("QCheckBox { color: white }");
478  ui->chkViterbi->setStyleSheet("QCheckBox { color: white }");
479  }
480  else
481  {
482  ui->chkAllowDrift->setEnabled(false);
483  ui->chkHardMetric->setEnabled(false);
484  ui->chkFastlock->setEnabled(false);
485  ui->chkViterbi->setEnabled(false);
486  ui->chkAllowDrift->setStyleSheet("QCheckBox { color: gray }");
487  ui->chkHardMetric->setStyleSheet("QCheckBox { color: gray }");
488  ui->chkFastlock->setStyleSheet("QCheckBox { color: gray }");
489  ui->chkViterbi->setStyleSheet("QCheckBox { color: gray }");
490  }
491 
492  if (m_settings.m_standard == DATVDemodSettings::dvb_version::DVB_S) {
493  ui->statusText->clear();
494  }
495 
498  applySettings();
499 }
500 
502 {
503  (void) arg1;
504  QString strModulation = ui->cmbModulation->currentText();
508 
509  //Viterbi only for BPSK and QPSK
512  {
513  ui->chkViterbi->setChecked(false);
514  }
515 
516  applySettings();
517 }
518 
520 {
521  (void) arg1;
522  QString strFEC = ui->cmbFEC->currentText();
524  applySettings();
525 }
526 
528 {
529  m_settings.m_viterbi = ui->chkViterbi->isChecked();
530  applySettings();
531 }
532 
534 {
535  m_settings.m_hardMetric = ui->chkHardMetric->isChecked();
536  applySettings();
537 }
538 
540 {
541  resetToDefaults();
542 }
543 
545 {
546  m_settings.m_symbolRate = value;
547  applySettings();
548 }
549 
551 {
552  m_settings.m_notchFilters = value;
553  applySettings();
554 }
555 
557 {
558  m_settings.m_allowDrift = ui->chkAllowDrift->isChecked();
559  applySettings();
560 }
561 
563 {
564  ui->screenTV_2->SetFullScreen(true);
565 }
566 
567 void DATVDemodGUI::on_mouseEvent(QMouseEvent* obj)
568 {
569  (void) obj;
570 }
571 
572 QString DATVDemodGUI::formatBytes(qint64 intBytes)
573 {
574  if(intBytes<1024) {
575  return QString("%1").arg(intBytes);
576  } else if(intBytes<1024*1024) {
577  return QString("%1 K").arg((float)(10*intBytes/1024)/10.0f);
578  } else if(intBytes<1024*1024*1024) {
579  return QString("%1 M").arg((float)(10*intBytes/(1024*1024))/10.0f);
580  }
581 
582  return QString("%1 G").arg((float)(10*intBytes/(1024*1024*1024))/10.0f);
583 }
584 
585 
586 void DATVDemodGUI::on_StreamDataAvailable(int *intPackets, int *intBytes, int *intPercent, qint64 *intTotalReceived)
587 {
588  (void) intPackets;
589  ui->lblStatus->setText(QString("Data: %1B").arg(formatBytes(*intTotalReceived)));
590  m_intLastDecodedData = *intTotalReceived;
591 
592  if((*intPercent)<100) {
593  ui->prgSynchro->setValue(*intPercent);
594  } else {
595  ui->prgSynchro->setValue(100);
596  }
597 
598  m_intReadyDecodedData = *intBytes;
599 }
600 
602 {
605  applySettings();
606 }
607 
609 {
612  applySettings();
613 }
614 
616 {
617  m_settings.m_fastLock = ui->chkFastlock->isChecked();
618  applySettings();
619 }
620 
622 {
623  m_settings.m_audioMute = checked;
624  applySettings();
625 }
626 
628 {
629  m_settings.m_videoMute = checked;
630  applySettings();
631 }
632 
634 {
635  ui->audioVolumeText->setText(tr("%1").arg(value));
636  m_settings.m_audioVolume = value;
637  applySettings();
638 }
639 
641 {
642  m_settings.m_udpTS = checked;
643  applySettings();
644 }
645 
647 {
648  QString strMetaData="";
649 
650  if (objMetaData != nullptr)
651  {
652  if (objMetaData->OK_TransportStream == true)
653  {
654  strMetaData.sprintf("PID: %d - Width: %d - Height: %d\r\n%s%s\r\nCodec: %s\r\n",
655  objMetaData->PID,
656  objMetaData->Width,
657  objMetaData->Height,
658  objMetaData->Program.toStdString().c_str(),
659  objMetaData->Stream.toStdString().c_str(),
660  objMetaData->CodecDescription.toStdString().c_str());
661  }
662 
663  ui->streamInfo->setText(strMetaData);
664  ui->chkData->setChecked(objMetaData->OK_Data);
665  ui->chkTS->setChecked(objMetaData->OK_TransportStream);
666  ui->chkVS->setChecked(objMetaData->OK_VideoStream);
667  ui->chkDecoding->setChecked(objMetaData->OK_Decoding);
668 
669  if (objMetaData->Height > 0) {
670  ui->screenTV_2->setFixedWidth((int)objMetaData->Width*(270.0f/(float)objMetaData->Height));
671  }
672  }
673 }
674 
676 {
677  ui->spiRollOff->setVisible(blnVisible);
678  ui->spiExcursion->setVisible(blnVisible);
679  ui->rollOffLabel->setVisible(blnVisible);
680  ui->excursionLabel->setVisible(blnVisible);
681 }
682 
684 {
685  if (index == 0) {
687  } else if (index == 1) {
689  } else {
691  }
692 
693  displayRRCParameters(index == 2);
694  applySettings();
695 }
696 
698 {
699  m_settings.m_rollOff = ((float) value) / 100.0f;
700  applySettings();
701 }
702 
704 {
705  m_settings.m_excursion = value;
706  applySettings();
707 }
708 
710 {
711  m_settings.m_udpTSAddress = ui->udpTSAddress->text();
712  applySettings();
713 }
714 
716 {
717  bool ok;
718  quint16 udpPort = ui->udpTSPort->text().toInt(&ok);
719 
720  if((!ok) || (udpPort < 1024)) {
721  udpPort = 8882;
722  }
723 
724  m_settings.m_udpTSPort = udpPort;
725  ui->udpTSPort->setText(tr("%1").arg(udpPort));
726  applySettings();
727 }
int m_modcodModulationIndex
Definition: datvdemodgui.h:123
static QString getStrFromCodeRate(const DATVCodeRate codeRate)
int getModcodModulation() const
Definition: datvdemod.h:189
bool isCstlnSetByModcod() const
Definition: datvdemod.h:191
void applySettings(bool force=false)
bool deserialize(const QByteArray &arrData)
bool videoDecodeOK()
Definition: datvdemod.cpp:153
void audioSelect()
DATVDemodSettings::DATVCodeRate getCodeRate() const
Definition: datvdemod.h:248
bool videoActive()
Definition: datvdemod.cpp:135
void on_StreamMetaDataChanged(DataTSMetaData2 *objMetaData)
static DATVModulation getModulationFromStr(const QString &str)
int getCenterFrequency() const
Definition: channelmarker.h:42
void push(Message *message, bool emitSignal=true)
Push message onto queue.
void onMetaDataChanged(DataTSMetaData2 *metaData)
static double dbPower(double magsq, double floor=1e-12)
Definition: db.cpp:22
static void getAvailableModulations(dvb_version dvbStandard, std::vector< DATVModulation > &modulations)
int m_modcodCodeRateIndex
Definition: datvdemodgui.h:124
void on_videoMute_toggled(bool checked)
MessageQueue * getInputMessageQueue()
Get the queue for asynchronous inbound communication.
void displayRRCParameters(bool blnVisible)
DATVModulation m_modulation
DATVideostream * SetVideoRender(DATVideoRender *objScreen)
Definition: datvdemod.cpp:118
void on_spiSymbolRate_valueChanged(int arg1)
qint64 m_intLastSpeed
Definition: datvdemodgui.h:117
void on_StreamDataAvailable(int *intPackets, int *intBytes, int *intPercent, qint64 *intTotalReceived)
int m_intReadyDecodedData
Definition: datvdemodgui.h:118
static const QString m_channelIdURI
Definition: datvdemod.h:197
virtual MessageQueue * getInputMessageQueue()
Definition: datvdemodgui.h:60
bool m_blnBasicSettingsShown
Definition: datvdemodgui.h:120
void on_spiRollOff_valueChanged(int arg1)
void enterEvent(QEvent *)
void displaySettings()
DATVDemod * m_objDATVDemod
Definition: datvdemodgui.h:109
QString CodecDescription
void on_spiExcursion_valueChanged(int arg1)
virtual void destroy()
QByteArray serialize() const
virtual bool handleMessage(const Message &objMessage)
void debug(const QString &msg) const
bool m_cstlnSetByModcod
Definition: datvdemodgui.h:125
virtual void setCenterFrequency(qint64 intCenterFrequency)
void addChannelMarker(ChannelMarker *channelMarker)
Add channel marker to spectrum.
Definition: deviceuiset.cpp:72
int m_intCenterFrequency
Definition: datvdemodgui.h:111
bool audioActive()
Definition: datvdemod.cpp:126
void on_cmbModulation_currentIndexChanged(const QString &arg1)
double getMagSq() const
Beware this is scaled to 2^30.
Definition: datvdemod.h:188
void on_spiNotchFilters_valueChanged(int arg1)
static DATVDemodSettings::DATVModulation getModulationFromLeanDVBCode(int leanDVBModulation)
Definition: datvdemod.cpp:1507
void on_chkHardMetric_clicked()
void channelMarkerChangedByCursor()
MovingAverageUtil< double, double, 4 > m_objMagSqAverage
Definition: datvdemodgui.h:127
static const QString m_strChannelID
Definition: datvdemodgui.h:63
Fixed< IntType, IntBits > arg(const std::complex< Fixed< IntType, IntBits > > &val)
Definition: fixed.h:2401
void displaySystemConfiguration()
void on_chkAllowDrift_clicked()
bool m_blnDoApplySettings
Definition: datvdemodgui.h:121
void channelMarkerHighlightedByCursor()
void onMenuDoubleClicked()
static DATVDemodGUI * create(PluginAPI *objPluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel)
bool audioDecodeOK()
Definition: datvdemod.cpp:144
ChannelMarker m_objChannelMarker
Definition: datvdemodgui.h:106
void on_cmbStandard_currentIndexChanged(int index)
virtual void setMessageQueueToGUI(MessageQueue *queue)
void on_cmbFilter_currentIndexChanged(int index)
static DSPEngine * instance()
Definition: dspengine.cpp:51
static MsgConfigureChannelizer * create(int centerFrequency)
Definition: datvdemod.h:207
void on_cmbFEC_currentIndexChanged(const QString &arg1)
void blockApplySettings(bool blnBlock)
void on_resetDefaults_clicked()
void setTitleColor(const QColor &c)
static MsgConfigureDATVDemod * create(const DATVDemodSettings &settings, bool force)
Definition: datvdemod.h:227
void setHighlighted(bool highlighted)
static DATVDemodSettings::DATVCodeRate getCodeRateFromLeanDVBCode(int leanDVBCodeRate)
Definition: datvdemod.cpp:1474
void registerRxChannelInstance(const QString &channelName, PluginInstanceGUI *pluginGUI)
Definition: deviceuiset.cpp:82
void on_audioMute_toggled(bool checked)
int32_t i
Definition: decimators.h:244
void addRollupWidget(QWidget *widget)
Add rollup widget to channel window.
Definition: deviceuiset.cpp:77
void on_chkFastlock_clicked()
void removeRxChannelInstance(PluginInstanceGUI *pluginGUI)
Definition: deviceuiset.cpp:94
static bool match(const Message *message)
Definition: message.cpp:45
bool getHighlighted() const
Definition: channelmarker.h:61
void on_mouseEvent(QMouseEvent *obj)
PluginAPI * m_objPluginAPI
Definition: datvdemodgui.h:103
void on_udpTS_clicked(bool checked)
qint64 m_intPreviousDecodedData
Definition: datvdemodgui.h:115
DATVDemodSettings m_settings
Definition: datvdemodgui.h:112
void on_fullScreen_clicked()
QTimer m_objTimer
Definition: datvdemodgui.h:114
DeviceUISet * m_deviceUISet
Definition: datvdemodgui.h:104
void setHighlighted(bool highlighted)
bool SetTVScreen(TVScreen *objScreen)
Definition: datvdemod.cpp:112
QString getName() const
void on_chkViterbi_clicked()
void setColor(const QColor &color)
void resetToDefaults()
void on_rfBandwidth_changed(qint64 value)
bool PlayVideo(bool blnStartStop)
Definition: datvdemod.cpp:162
void onWidgetRolled(QWidget *widget, bool rollDown)
Ui::DATVDemodGUI * ui
Definition: datvdemodgui.h:102
virtual qint64 getCenterFrequency() const
void setVisible(bool visible)
int getBandwidth() const
Definition: channelmarker.h:45
DATVDemodGUI(PluginAPI *objPluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget *objParent=0)
void on_deltaFrequency_changed(qint64 value)
void on_udpTSPort_editingFinished()
void setBandwidth(int bandwidth)
const QColor & getColor() const
Definition: channelmarker.h:64
static DATVCodeRate getCodeRateFromStr(const QString &str)
virtual ~DATVDemodGUI()
void leaveEvent(QEvent *)
void setCenterFrequency(int centerFrequency)
bool deserialize(const QByteArray &data)
DATVDemodSettings::DATVModulation getModulation() const
Definition: datvdemod.h:247
static void getAvailableCodeRates(dvb_version dvbStandard, DATVModulation modulation, std::vector< DATVCodeRate > &codeRates)
void handleInputMessages()
#define SDR_RX_SCALED
Definition: dsptypes.h:34
void widgetRolled(QWidget *widget, bool rollDown)
dvb_version m_standard
qint64 m_intLastDecodedData
Definition: datvdemodgui.h:116
int getModcodCodeRate() const
Definition: datvdemod.h:190
QByteArray serialize() const
QString formatBytes(qint64 intBytes)
void on_audioVolume_valueChanged(int value)
static QString getStrFromModulation(const DATVModulation modulation)
void on_udpTSAddress_editingFinished()
void onDataPackets(int *intDataPackets, int *intDataBytes, int *intPercentBuffer, qint64 *intTotalReceived)
void setName(const QString &strName)