MythTV  master
videosource.cpp
Go to the documentation of this file.
1 // -*- Mode: c++ -*-
2 
3 // Standard UNIX C headers
4 #include <unistd.h>
5 #include <fcntl.h>
6 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(_WIN32)
7 #include <sys/types.h>
8 #else
9 #include <sys/sysmacros.h>
10 #endif
11 #include <sys/stat.h>
12 
13 // C++ headers
14 #include <algorithm>
15 
16 // Qt headers
17 #include <QCoreApplication>
18 #include <QCursor>
19 #include <QDateTime>
20 #include <QDir>
21 #include <QFile>
22 #include <QLayout>
23 #include <QMap>
24 #include <QStringList>
25 #include <QTextStream>
26 #include <utility>
27 
28 // MythTV headers
29 #include "libmyth/mythterminal.h"
30 #include "libmythbase/compat.h"
31 #include "libmythbase/exitcodes.h"
32 #include "libmythbase/mythconfig.h"
34 #include "libmythbase/mythdb.h"
35 #include "libmythbase/mythdirs.h"
39 #include "libmythupnp/httprequest.h" // for TestMimeType()
40 
41 #include "cardutil.h"
42 #include "channelinfo.h"
43 #include "channelutil.h"
44 #include "diseqcsettings.h"
45 #include "frequencies.h"
47 #include "scanwizard.h"
48 #include "sourceutil.h"
49 #include "v4l2util.h"
50 #include "videosource.h"
51 
52 #ifdef USING_DVB
53 #include "recorders/dvbtypes.h"
54 #endif
55 
56 #ifdef USING_VBOX
57 #include "recorders/vboxutils.h"
58 #endif
59 
60 #ifdef USING_HDHOMERUN
61 #include HDHOMERUN_HEADERFILE
62 #endif
63 
65  QString _card_types,
66  bool _must_have_mplexid) :
67  m_initialSourceId(_initial_sourceid),
68  m_cardTypes(std::move(_card_types)),
69  m_mustHaveMplexId(_must_have_mplexid)
70 {
71  setLabel(tr("Video Source"));
73  QObject::tr(
74  "Select a video source that is connected to one "
75  "or more capture cards. Default is the video source "
76  "selected in the Channel Editor page."
77  ));
78 }
79 
81 {
83 
84  QString querystr =
85  "SELECT DISTINCT videosource.name, videosource.sourceid "
86  "FROM capturecard, videosource";
87 
88  querystr += (m_mustHaveMplexId) ? ", channel " : " ";
89 
90  querystr +=
91  "WHERE capturecard.sourceid = videosource.sourceid AND "
92  " capturecard.hostname = :HOSTNAME ";
93 
94  if (!m_cardTypes.isEmpty())
95  {
96  querystr += QString(" AND capturecard.cardtype in %1 ")
97  .arg(m_cardTypes);
98  }
99 
100  if (m_mustHaveMplexId)
101  {
102  querystr +=
103  " AND channel.sourceid = videosource.sourceid "
104  " AND channel.mplexid != 32767 "
105  " AND channel.mplexid != 0 ";
106  }
107 
108  query.prepare(querystr);
109  query.bindValue(":HOSTNAME", gCoreContext->GetHostName());
110 
111  if (!query.exec() || !query.isActive() || query.size() <= 0)
112  return;
113 
114  uint sel = 0;
115  uint cnt = 0;
116  for (; query.next(); cnt++)
117  {
118  addSelection(query.value(0).toString(),
119  query.value(1).toString());
120 
121  sel = (query.value(1).toUInt() == m_initialSourceId) ? cnt : sel;
122  }
123 
124  if (m_initialSourceId)
125  {
126  if (cnt)
127  setValue(sel);
128  }
129 
131 }
132 
134  m_initialSourceId(_initial_sourceid)
135 {
136  setLabel(tr("Video Source"));
137  setHelpText(
138  QObject::tr(
139  "The video source that is "
140  "selected in the Channel Editor page."
141  ));
142 }
143 
145 {
146  MSqlQuery query(MSqlQuery::InitCon());
147 
148  QString querystr =
149  "SELECT DISTINCT videosource.name, videosource.sourceid "
150  "FROM capturecard, videosource "
151  "WHERE capturecard.sourceid = videosource.sourceid AND "
152  " capturecard.hostname = :HOSTNAME AND "
153  " videosource.sourceid = :SOURCEID ";
154 
155  query.prepare(querystr);
156  query.bindValue(":HOSTNAME", gCoreContext->GetHostName());
157  query.bindValue(":SOURCEID", m_initialSourceId);
158 
159  if (!query.exec() || !query.isActive())
160  {
161  MythDB::DBError("VideoSourceShow::Load", query);
162  return;
163  }
164 
165  if (query.next())
166  {
167  setValue(query.value(0).toString());
168  }
169 }
170 
172 {
173  public:
174  explicit InstanceCount(const CardInput &parent) :
175  MythUISpinBoxSetting(new CardInputDBStorage(this, parent, "reclimit"),
176  1, 10, 1)
177  {
178  setLabel(QObject::tr("Max recordings"));
179  setValue(1);
180  setHelpText(
181  QObject::tr(
182  "Maximum number of simultaneous recordings MythTV will "
183  "attempt using this device. If set to a value other than "
184  "1, MythTV can sometimes record multiple programs on "
185  "the same multiplex or overlapping copies of the same "
186  "program on a single channel."
187  ));
188  };
189 };
190 
192 {
193  public:
194  explicit SchedGroup(const CardInput &parent) :
195  MythUICheckBoxSetting(new CardInputDBStorage(this, parent, "schedgroup"))
196  {
197  setLabel(QObject::tr("Schedule as group"));
198  setValue(true);
199  setHelpText(
200  QObject::tr(
201  "Schedule all virtual inputs on this device as a group. "
202  "This is more efficient than scheduling each input "
203  "individually. Additional, virtual inputs will be "
204  "automatically added as needed to fulfill the recording "
205  "load."
206  ));
207  };
208 };
209 
211 {
212  QString sourceidTag(":WHERESOURCEID");
213 
214  QString query("sourceid = " + sourceidTag);
215 
216  bindings.insert(sourceidTag, m_parent.getSourceID());
217 
218  return query;
219 }
220 
222 {
223  QString sourceidTag(":SETSOURCEID");
224  QString colTag(":SET" + GetColumnName().toUpper());
225 
226  QString query("sourceid = " + sourceidTag + ", " +
227  GetColumnName() + " = " + colTag);
228 
229  bindings.insert(sourceidTag, m_parent.getSourceID());
230  bindings.insert(colTag, m_user->GetDBValue());
231 
232  return query;
233 }
234 
236 {
237  QString cardidTag(":WHERECARDID");
238 
239  QString query("cardid = " + cardidTag);
240 
241  bindings.insert(cardidTag, m_parent.getCardID());
242 
243  return query;
244 }
245 
247 {
248  QString cardidTag(":SETCARDID");
249  QString colTag(":SET" + GetColumnName().toUpper());
250 
251  QString query("cardid = " + cardidTag + ", " +
252  GetColumnName() + " = " + colTag);
253 
254  bindings.insert(cardidTag, m_parent.getCardID());
255  bindings.insert(colTag, m_user->GetDBValue());
256 
257  return query;
258 }
259 
261 {
262  public:
263  explicit XMLTVGrabber(const VideoSource &parent) :
265  "xmltvgrabber")),
266  m_parent(parent)
267  {
268  setLabel(QObject::tr("Listings grabber"));
269  };
270 
271  void Load(void) override // StandardSetting
272  {
273  addTargetedChild("eitonly", new EITOnly_config(m_parent, this));
274  addTargetedChild("/bin/true", new NoGrabber_config(m_parent));
275 
276  addSelection(
277  QObject::tr("Transmitted guide only (EIT)"), "eitonly");
278 
279  addSelection(QObject::tr("No grabber"), "/bin/true");
280 
281  QString gname;
282  QString d1;
283  QString d2;
284  QString d3;
286 
287 #ifdef _MSC_VER
288 #pragma message( "tv_find_grabbers is not supported yet on windows." )
289  //-=>TODO:Screen doesn't show up if the call to MythSysemLegacy is executed
290 #else
291 
292  QString loc = QString("XMLTVGrabber::Load(%1): ").arg(m_parent.getSourceName());
293 
294  QMutexLocker lock(&m_lock);
295  if (m_nameList.isEmpty())
296  {
297  QStringList args;
298  args += "baseline";
299 
300  MythSystemLegacy find_grabber_proc("tv_find_grabbers", args,
302  find_grabber_proc.Run(25s);
303  LOG(VB_GENERAL, LOG_INFO,
304  loc + "Running 'tv_find_grabbers " + args.join(" ") + "'.");
305  uint status = find_grabber_proc.Wait();
306 
307  if (status == GENERIC_EXIT_OK)
308  {
309  QTextStream ostream(find_grabber_proc.ReadAll());
310  while (!ostream.atEnd())
311  {
312  QString grabber_list(ostream.readLine());
313  #if QT_VERSION < QT_VERSION_CHECK(5,14,0)
314  QStringList grabber_split =
315  grabber_list.split("|", QString::SkipEmptyParts);
316  #else
317  QStringList grabber_split =
318  grabber_list.split("|", Qt::SkipEmptyParts);
319  #endif
320  QString grabber_name = grabber_split[1] + " (xmltv)";
321  QFileInfo grabber_file(grabber_split[0]);
322 
323  m_nameList.push_back(grabber_name);
324  m_progList.push_back(grabber_file.fileName());
325  LOG(VB_GENERAL, LOG_DEBUG, "Found " + grabber_split[0]);
326  }
327  LOG(VB_GENERAL, LOG_INFO, loc + "Finished running tv_find_grabbers");
328  }
329  else
330  {
331  LOG(VB_GENERAL, LOG_ERR, loc + "Failed to run tv_find_grabbers");
332  }
333  }
334  else
335  {
336  LOG(VB_GENERAL, LOG_INFO, loc + "Loading results of tv_find_grabbers");
337  }
338 
341 #endif
342  }
343 
344  void Save(void) override // StandardSetting
345  {
347 
348  MSqlQuery query(MSqlQuery::InitCon());
349  query.prepare(
350  "UPDATE videosource "
351  "SET userid=NULL, password=NULL "
352  "WHERE xmltvgrabber NOT IN ( 'technovera' )");
353  if (!query.exec())
354  MythDB::DBError("XMLTVGrabber::Save", query);
355  }
356 
357  void LoadXMLTVGrabbers(QStringList name_list, QStringList prog_list)
358  {
359  if (name_list.size() != prog_list.size())
360  return;
361 
362  QString selValue = getValue();
363  int selIndex = getValueIndex(selValue);
364  setValue(0);
365 
366  for (uint i = 0; i < (uint) name_list.size(); i++)
367  {
368  addTargetedChild(prog_list[i],
369  new XMLTV_generic_config(m_parent, prog_list[i],
370  this));
371  addSelection(name_list[i], prog_list[i]);
372  }
373 
374  if (!selValue.isEmpty())
375  selIndex = getValueIndex(selValue);
376  if (selIndex >= 0)
377  setValue(selIndex);
378  }
379 private:
381 
382 private:
383  static QMutex m_lock;
384  static QStringList m_nameList;
385  static QStringList m_progList;
386 };
387 
388 // Results of search for XMLTV grabbers
389 QMutex XMLTVGrabber::m_lock;
390 QStringList XMLTVGrabber::m_nameList;
391 QStringList XMLTVGrabber::m_progList;
392 
394 {
395  public:
397  std::chrono::milliseconds min_val,
398  std::chrono::milliseconds max_val,
399  std::chrono::milliseconds step,
400  const QString &setting) :
401  MythUISpinBoxSetting(new CaptureCardDBStorage(this, parent, setting),
402  min_val.count(), max_val.count(), step.count())
403  {
404  }
405  // Handles integer milliseconds (compiler converts seconds to milliseconds)
406  void setValueMs (std::chrono::milliseconds newValue)
407  { setValue(newValue.count()); }
408  // Handle non-integer seconds
409  template<typename T, typename = typename std::enable_if<!std::is_integral<T>()>>
410  void setValueMs (std::chrono::duration<T> newSecs)
411  { setValueMs(duration_cast<std::chrono::milliseconds>(newSecs)); }
412 };
413 
415 {
416  public:
418  const QString &setting) :
419  MythUITextEditSetting(new CaptureCardDBStorage(this, parent, setting))
420  {
421  }
422 };
423 
425 {
426  public:
427  explicit ScanFrequencyStart(const VideoSource &parent) :
428  MythUITextEditSetting(new VideoSourceDBStorage(this, parent, "scanfrequency"))
429  {
430  setLabel(QObject::tr("Scan Frequency"));
431  setHelpText(QObject::tr("The frequency to start scanning this video source. "
432  "This is then default for 'Full Scan (Tuned)' channel scanning. "
433  "Frequency value in Hz for DVB-T/T2/C, in kHz for DVB-S/S2. "
434  "Leave at 0 if not known. "));
435  };
436 };
437 
439 {
440  public:
441  DVBNetID(const VideoSource &parent, signed int value, signed int min_val) :
442  MythUISpinBoxSetting(new VideoSourceDBStorage(this, parent, "dvb_nit_id"),
443  min_val, 0xffff, 1)
444  {
445  setLabel(QObject::tr("Network ID"));
446  //: Network_ID is the name of an identifier in the DVB's Service
447  //: Information standard specification.
448  setHelpText(QObject::tr("If your provider has asked you to configure a "
449  "specific network identifier (Network_ID), "
450  "enter it here. Leave it at -1 otherwise."));
451  setValue(value);
452  };
453 };
454 
456 {
457  public:
458  BouquetID(const VideoSource &parent, signed int value, signed int min_val) :
459  MythUISpinBoxSetting(new VideoSourceDBStorage(this, parent, "bouquet_id"),
460  min_val, 0xffff, 1)
461  {
462  setLabel(QObject::tr("Bouquet ID"));
463  setHelpText(QObject::tr("Bouquet ID for Freesat or Sky on satellite Astra-2 28.2E. "
464  "Leave this at 0 if you do not receive this satellite. "
465  "This is needed to get the Freesat and Sky channel numbers. "
466  "Value 272 selects Freesat bouquet 'England HD'. "
467  "See the MythTV Wiki https://www.mythtv.org/wiki/DVB_UK."));
468  setValue(value);
469  };
470 };
471 
473 {
474  public:
475  RegionID(const VideoSource &parent, signed int value, signed int min_val) :
476  MythUISpinBoxSetting(new VideoSourceDBStorage(this, parent, "region_id"),
477  min_val, 100, 1)
478  {
479  setLabel(QObject::tr("Region ID"));
480  setHelpText(QObject::tr("Region ID for Freesat or Sky on satellite Astra-2 28.2E. "
481  "Leave this at 0 you do not receive this satellite. "
482  "This is needed to get the Freesat and Sky channel numbers. "
483  "Value 1 selects region London. "
484  "See the MythTV Wiki https://www.mythtv.org/wiki/DVB_UK."));
485  setValue(value);
486  };
487 };
488 
490 {
491  public:
492  LCNOffset(const VideoSource &parent, signed int value, signed int min_val) :
493  MythUISpinBoxSetting(new VideoSourceDBStorage(this, parent, "lcnoffset"),
494  min_val, 20000, 100)
495  {
496  setLabel(QObject::tr("Logical Channel Number Offset"));
497  setHelpText(QObject::tr("The offset is added to each logical channel number found "
498  "during a scan of a DVB video source. This makes it possible "
499  "to give different video sources a non-overlapping range "
500  "of channel numbers. Leave at 0 if you have only one video source "
501  "or if the video sources do not have DVB logical channel numbers."));
502  setValue(value);
503  };
504 };
505 
507  MythUIComboBoxSetting(new VideoSourceDBStorage(this, parent, "freqtable"))
508 {
509  setLabel(QObject::tr("Channel frequency table"));
510  addSelection("default");
511 
512  for (const auto & chanlist : gChanLists)
513  addSelection(chanlist.name);
514 
515  setHelpText(QObject::tr("Use default unless this source uses a "
516  "different frequency table than the system wide table "
517  "defined in the General settings."));
518 }
519 
521  m_sourceId(_sourceid)
522 {
523  setLabel(QObject::tr("Channel frequency table"));
524 
525  for (const auto & chanlist : gChanLists)
526  addSelection(chanlist.name);
527 }
528 
530 {
531  int idx1 = getValueIndex(gCoreContext->GetSetting("FreqTable"));
532  if (idx1 >= 0)
533  setValue(idx1);
534 
535  if (!m_sourceId)
536  return;
537 
538  MSqlQuery query(MSqlQuery::InitCon());
539  query.prepare(
540  "SELECT freqtable "
541  "FROM videosource "
542  "WHERE sourceid = :SOURCEID");
543  query.bindValue(":SOURCEID", m_sourceId);
544 
545  if (!query.exec() || !query.isActive())
546  {
547  MythDB::DBError("TransFreqTableSelector::load", query);
548  return;
549  }
550 
551  m_loadedFreqTable.clear();
552 
553  if (query.next())
554  {
555  m_loadedFreqTable = query.value(0).toString();
556  if (!m_loadedFreqTable.isEmpty() &&
557  (m_loadedFreqTable.toLower() != "default"))
558  {
559  int idx2 = getValueIndex(m_loadedFreqTable);
560  if (idx2 >= 0)
561  setValue(idx2);
562  }
563  }
564 }
565 
567 {
568  LOG(VB_GENERAL, LOG_INFO, "TransFreqTableSelector::Save(void)");
569 
570  if ((m_loadedFreqTable == getValue()) ||
571  ((m_loadedFreqTable.toLower() == "default") &&
572  (getValue() == gCoreContext->GetSetting("FreqTable"))))
573  {
574  return;
575  }
576 
577  MSqlQuery query(MSqlQuery::InitCon());
578  query.prepare(
579  "UPDATE videosource "
580  "SET freqtable = :FREQTABLE "
581  "WHERE sourceid = :SOURCEID");
582 
583  query.bindValue(":FREQTABLE", getValue());
584  query.bindValue(":SOURCEID", m_sourceId);
585 
586  if (!query.exec() || !query.isActive())
587  {
588  MythDB::DBError("TransFreqTableSelector::load", query);
589  return;
590  }
591 }
592 
594 {
595  m_sourceId = sourceid;
596  Load();
597 }
598 
600 {
601  public:
602  explicit UseEIT(const VideoSource &parent) :
603  MythUICheckBoxSetting(new VideoSourceDBStorage(this, parent, "useeit"))
604  {
605  setLabel(QObject::tr("Perform EIT scan"));
606  setHelpText(QObject::tr(
607  "If enabled, program guide data for channels on this "
608  "source will be updated with data provided by the "
609  "channels themselves 'Over-the-Air'."));
610  }
611 };
612 
614  const QString& _grabber,
615  StandardSetting *_setting) :
616  m_parent(_parent), m_grabber(_grabber)
617 {
618  setVisible(false);
619 
620  QString filename = QString("%1/%2.xmltv")
621  .arg(GetConfDir(), m_parent.getSourceName());
622 
623  m_grabberArgs.push_back("--config-file");
624  m_grabberArgs.push_back(filename);
625  m_grabberArgs.push_back("--configure");
626 
627  _setting->addTargetedChild(_grabber, new UseEIT(m_parent));
628 
629  auto *config = new ButtonStandardSetting(tr("Configure"));
630  config->setHelpText(tr("Run XMLTV configure command."));
631 
632  _setting->addTargetedChild(_grabber, config);
633 
635 }
636 
638 {
640 #if 0
641  QString err_msg = QObject::tr(
642  "You MUST run 'mythfilldatabase --manual' the first time,\n"
643  "instead of just 'mythfilldatabase'.\nYour grabber does not provide "
644  "channel numbers, so you have to set them manually.");
645 
647  {
648  LOG(VB_GENERAL, LOG_ERR, err_msg);
649  ShowOkPopup(err_msg);
650  }
651 #endif
652 }
653 
655 {
657  MythScreenType *ssd =
658  new MythTerminal(mainStack, m_grabber, m_grabberArgs);
659 
660  if (ssd->Create())
661  mainStack->AddScreen(ssd);
662  else
663  delete ssd;
664 }
665 
667 {
668  setVisible(false);
669 
670  m_useEit = new UseEIT(_parent);
671  m_useEit->setValue(true);
672  m_useEit->setVisible(false);
674 
675  auto *label=new TransTextEditSetting();
676  label->setValue(QObject::tr("Use only the transmitted guide data."));
677  label->setHelpText(
678  QObject::tr("This will usually only work with ATSC or DVB channels, "
679  "and generally provides data only for the next few days."));
680  _setting->addTargetedChild("eitonly", label);
681 }
682 
684 {
685  // Force this value on
686  m_useEit->setValue(true);
687  m_useEit->Save();
688 }
689 
691 {
692  m_useEit = new UseEIT(_parent);
693  m_useEit->setValue(false);
694  m_useEit->setVisible(false);
696 
697  auto *label = new TransTextEditSetting();
698  label->setValue(QObject::tr("Do not configure a grabber"));
699  addTargetedChild("/bin/true", label);
700 }
701 
703 {
704  m_useEit->setValue(false);
705  m_useEit->Save();
706 }
707 
709 {
710  // must be first
711  m_id = new ID();
712  addChild(m_id = new ID());
713 
714  setLabel(QObject::tr("Video Source Setup"));
715  addChild(m_name = new Name(*this));
716  addChild(new XMLTVGrabber(*this));
717  addChild(new FreqTableSelector(*this));
718  addChild(new ScanFrequencyStart(*this));
719  addChild(new DVBNetID(*this, -1, -1));
720  addChild(new BouquetID(*this, 0, 0));
721  addChild(new RegionID(*this, 0, 0));
722  addChild(new LCNOffset(*this, 0, 0));
723 }
724 
726 {
727  return true;
728 }
729 
731 {
733 }
734 
736  const QString &thecardtype)
737 {
738  MSqlQuery query(MSqlQuery::InitCon());
739  query.prepare("SELECT count(cardtype)"
740  " FROM capturecard "
741  " WHERE capturecard.sourceid = :SOURCEID "
742  " AND capturecard.cardtype = :CARDTYPE ;");
743  query.bindValue(":SOURCEID", sourceID);
744  query.bindValue(":CARDTYPE", thecardtype);
745 
746  if (query.exec() && query.next())
747  {
748  int count = query.value(0).toInt();
749 
750  if (count > 0)
751  return true;
752  }
753 
754  return false;
755 }
756 
758 {
759  MSqlQuery result(MSqlQuery::InitCon());
760  result.prepare("SELECT name, sourceid FROM videosource;");
761 
762  if (result.exec() && result.isActive() && result.size() > 0)
763  {
764  while (result.next())
765  {
766  auto* source = new VideoSource();
767  source->setLabel(result.value(0).toString());
768  source->loadByID(result.value(1).toInt());
769  setting->addChild(source);
770  }
771  }
772 }
773 
775 {
776  MSqlQuery result(MSqlQuery::InitCon());
777  result.prepare("SELECT name, sourceid FROM videosource;");
778 
779  if (result.exec() && result.isActive() && result.size() > 0)
780  {
781  while (result.next())
782  {
783  setting->addSelection(result.value(0).toString(),
784  result.value(1).toString());
785  }
786  }
787 }
788 
789 void VideoSource::loadByID(int sourceid)
790 {
791  m_id->setValue(sourceid);
792 }
793 
795 {
796  public:
797  explicit VideoDevice(const CaptureCard &parent,
798  uint minor_min = 0,
799  uint minor_max = UINT_MAX,
800  const QString& card = QString(),
801  const QRegularExpression& driver = QRegularExpression()) :
802  CaptureCardComboBoxSetting(parent, true, "videodevice")
803  {
804  setLabel(QObject::tr("Video device"));
805 
806  // /dev/v4l/video*
807  QDir dev("/dev/v4l", "video*", QDir::Name, QDir::System);
808  fillSelectionsFromDir(dev, minor_min, minor_max,
809  card, driver, false);
810 
811  // /dev/video*
812  dev.setPath("/dev");
813  fillSelectionsFromDir(dev, minor_min, minor_max,
814  card, driver, false);
815 
816  // /dev/dtv/video*
817  dev.setPath("/dev/dtv");
818  fillSelectionsFromDir(dev, minor_min, minor_max,
819  card, driver, false);
820 
821  // /dev/dtv*
822  dev.setPath("/dev");
823  dev.setNameFilters(QStringList("dtv*"));
824  fillSelectionsFromDir(dev, minor_min, minor_max,
825  card, driver, false);
826  };
827 
832  void fillSelectionsFromDir(const QDir &dir,
833  [[maybe_unused]] bool absPath = true)
834  {
835  fillSelectionsFromDir(dir, 0, 255, QString(), QRegularExpression(), false);
836  }
837 
838  uint fillSelectionsFromDir(const QDir& dir,
839  uint minor_min, uint minor_max,
840  const QString& card, const QRegularExpression& driver,
841  bool allow_duplicates)
842  {
843  uint cnt = 0;
844  QFileInfoList entries = dir.entryInfoList();
845  for (const auto & fi : qAsConst(entries))
846  {
847  struct stat st {};
848  QString filepath = fi.absoluteFilePath();
849  int err = lstat(filepath.toLocal8Bit().constData(), &st);
850 
851  if (err)
852  {
853  LOG(VB_GENERAL, LOG_ERR,
854  QString("Could not stat file: %1").arg(filepath));
855  continue;
856  }
857 
858  // is this is a character device?
859  if (!S_ISCHR(st.st_mode))
860  continue;
861 
862  // is this device is in our minor range?
863  uint minor_num = minor(st.st_rdev);
864  if (minor_min > minor_num || minor_max < minor_num)
865  continue;
866 
867  // ignore duplicates if allow_duplicates not set
868  if (!allow_duplicates && m_minorList[minor_num])
869  continue;
870 
871  // if the driver returns any info add this device to our list
872  QByteArray tmp = filepath.toLatin1();
873  int videofd = open(tmp.constData(), O_RDWR);
874  if (videofd >= 0)
875  {
876  QString card_name;
877  QString driver_name;
878  if (CardUtil::GetV4LInfo(videofd, card_name, driver_name))
879  {
880  auto match = driver.match(driver_name);
881  if ((!driver.pattern().isEmpty() || match.hasMatch()) &&
882  (card.isEmpty() || (card_name == card)))
883  {
884  addSelection(filepath);
885  cnt++;
886  }
887  }
888  close(videofd);
889  }
890 
891  // add to list of minors discovered to avoid duplicates
892  m_minorList[minor_num] = 1;
893  }
894 
895  return cnt;
896  }
897 
898  QString Driver(void) const { return m_driverName; }
899  QString Card(void) const { return m_cardName; }
900 
901  private:
902  QMap<uint, uint> m_minorList;
903  QString m_cardName;
904  QString m_driverName;
905 };
906 
908 {
909  public:
910  explicit VBIDevice(const CaptureCard &parent) :
911  CaptureCardComboBoxSetting(parent, true /*, mustexist true */,
912  "vbidevice")
913  {
914  setLabel(QObject::tr("VBI device"));
915  setFilter(QString(), QString());
916  setHelpText(QObject::tr("Device to read VBI (captions) from."));
917  };
918 
919  uint setFilter(const QString &card, const QString &driver)
920  {
921  uint count = 0;
922  clearSelections();
923  QDir dev("/dev/v4l", "vbi*", QDir::Name, QDir::System);
924  if (!(count = fillSelectionsFromDir(dev, card, driver)))
925  {
926  dev.setPath("/dev");
927  if (((count = fillSelectionsFromDir(dev, card, driver)) == 0U) &&
928  !getValue().isEmpty())
929  {
930  addSelection(getValue(),getValue(),true);
931  }
932  }
933 
934  return count;
935  }
936 
941  void fillSelectionsFromDir(const QDir &dir,
942  [[maybe_unused]] bool absPath = true)
943  {
944  fillSelectionsFromDir(dir, QString(), QString());
945  }
946 
947  uint fillSelectionsFromDir(const QDir &dir, const QString &card,
948  const QString &driver)
949  {
950  QStringList devices;
951  QFileInfoList entries = dir.entryInfoList();
952  for (const auto & fi : qAsConst(entries))
953  {
954  QString device = fi.absoluteFilePath();
955  QByteArray adevice = device.toLatin1();
956  int vbifd = open(adevice.constData(), O_RDWR);
957  if (vbifd < 0)
958  continue;
959 
960  QString cn;
961  QString dn;
962  if (CardUtil::GetV4LInfo(vbifd, cn, dn) &&
963  (driver.isEmpty() || (dn == driver)) &&
964  (card.isEmpty() || (cn == card)))
965  {
966  devices.push_back(device);
967  }
968 
969  close(vbifd);
970  }
971 
972  QString sel = getValue();
973  for (const QString& device : qAsConst(devices))
974  addSelection(device, device, device == sel);
975 
976  return (uint) devices.size();
977  }
978 };
979 
981 {
982  public:
983  explicit CommandPath(const CaptureCard &parent) :
985  "videodevice"))
986  {
987  setLabel(QObject::tr(""));
988  setValue("");
989  setHelpText(QObject::tr("Specify the command to run, with any "
990  "needed arguments."));
991  };
992 };
993 
995 {
996  public:
997  explicit FileDevice(const CaptureCard &parent) :
999  new CaptureCardDBStorage(this, parent, "videodevice")
1000  /* mustexist, false */)
1001  {
1002  setLabel(QObject::tr("File path"));
1003  };
1004 };
1005 
1007 {
1008  public:
1009  explicit AudioDevice(const CaptureCard &parent) :
1010  CaptureCardComboBoxSetting(parent, true /* mustexist false */,
1011  "audiodevice")
1012  {
1013  setLabel(QObject::tr("Audio device"));
1014 #ifdef USING_OSS
1015  QDir dev("/dev", "dsp*", QDir::Name, QDir::System);
1016  fillSelectionsFromDir(dev);
1017  dev.setPath("/dev/sound");
1018  fillSelectionsFromDir(dev);
1019 #endif
1020 #ifdef USING_ALSA
1021  addSelection("ALSA:default", "ALSA:default");
1022 #endif
1023  addSelection(QObject::tr("(None)"), "NULL");
1024  setHelpText(QObject::tr("Device to read audio from, "
1025  "if audio is separate from the video."));
1026  };
1027 };
1028 
1030 {
1031  public:
1032  // Handles integer milliseconds (compiler converts seconds to milliseconds)
1033  SignalTimeout(const CaptureCard &parent, std::chrono::milliseconds value,
1034  std::chrono::milliseconds min_val) :
1035  CaptureCardSpinBoxSetting(parent, min_val, 60s, 250ms, "signal_timeout")
1036  {
1037  setLabel(QObject::tr("Signal timeout (ms)"));
1038  setValueMs(value);
1039  setHelpText(QObject::tr(
1040  "Maximum time (in milliseconds) MythTV waits for "
1041  "a signal when scanning for channels."));
1042  };
1043  // Handle non-integer seconds
1044  template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value>::type >
1045  SignalTimeout(const CaptureCard &parent, std::chrono::milliseconds value, std::chrono::duration<T> min_secs) :
1046  SignalTimeout(parent, value, duration_cast<std::chrono::milliseconds>(min_secs)) {};
1047  template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value>::type >
1048  SignalTimeout(const CaptureCard &parent, std::chrono::duration<T> value, std::chrono::duration<T> min_secs) :
1049  SignalTimeout(parent,
1050  duration_cast<std::chrono::milliseconds>(value),
1051  duration_cast<std::chrono::milliseconds>(min_secs)) {};
1052 };
1053 
1055 {
1056  public:
1057  // Handles integer milliseconds (compiler converts seconds to milliseconds)
1058  ChannelTimeout(const CaptureCard &parent, std::chrono::milliseconds value,
1059  std::chrono::milliseconds min_val) :
1060  CaptureCardSpinBoxSetting(parent, min_val, 65s, 250ms, "channel_timeout")
1061  {
1062  setLabel(QObject::tr("Tuning timeout (ms)"));
1063  setValueMs(value);
1064  setHelpText(QObject::tr(
1065  "Maximum time (in milliseconds) MythTV waits for "
1066  "a channel lock. For recordings, if this time is "
1067  "exceeded, the recording will be marked as failed."));
1068  };
1069  // Handle non-integer seconds
1070  template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value>::type >
1071  ChannelTimeout(const CaptureCard &parent, std::chrono::milliseconds value, std::chrono::duration<T> min_secs) :
1072  ChannelTimeout(parent, value, duration_cast<std::chrono::milliseconds>(min_secs)) {};
1073  template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value>::type >
1074  ChannelTimeout(const CaptureCard &parent, std::chrono::duration<T> value, std::chrono::duration<T> min_secs) :
1075  ChannelTimeout(parent, value, duration_cast<std::chrono::milliseconds>(min_secs)) {};
1076 };
1077 
1079 {
1080  public:
1081  explicit AudioRateLimit(const CaptureCard &parent) :
1082  CaptureCardComboBoxSetting(parent, false, "audioratelimit")
1083  {
1084  setLabel(QObject::tr("Force audio sampling rate"));
1085  setHelpText(
1086  QObject::tr("If non-zero, override the audio sampling "
1087  "rate in the recording profile when this card is "
1088  "used. Use this if your capture card does not "
1089  "support all of the standard rates."));
1090  addSelection(QObject::tr("(None)"), "0");
1091  addSelection("32000");
1092  addSelection("44100");
1093  addSelection("48000");
1094  };
1095 };
1096 
1098 {
1099  public:
1100  explicit SkipBtAudio(const CaptureCard &parent) :
1102  "skipbtaudio"))
1103  {
1104  setLabel(QObject::tr("Do not adjust volume"));
1105  setHelpText(
1106  QObject::tr("Enable this option for budget BT878 based "
1107  "DVB-T cards such as the AverTV DVB-T which "
1108  "require the audio volume to be left alone."));
1109  };
1110 };
1111 
1113 {
1114  public:
1115  explicit DVBCardNum(const CaptureCard &parent) :
1116  CaptureCardComboBoxSetting(parent, true, "videodevice")
1117  {
1118  setLabel(QObject::tr("DVB device"));
1119  setHelpText(
1120  QObject::tr("When you change this setting, the text below "
1121  "should change to the name and type of your card. "
1122  "If the card cannot be opened, an error message "
1123  "will be displayed."));
1124  fillSelections(QString());
1125  };
1126 
1130  void fillSelections(const QString &current)
1131  {
1132  clearSelections();
1133 
1134  // Get devices from filesystem
1135  QStringList sdevs = CardUtil::ProbeVideoDevices("DVB");
1136 
1137  // Add current if needed
1138  if (!current.isEmpty() &&
1139  (std::find(sdevs.begin(), sdevs.end(), current) == sdevs.end()))
1140  {
1141  std::stable_sort(sdevs.begin(), sdevs.end());
1142  }
1143 
1144  QStringList db = CardUtil::GetVideoDevices("DVB");
1145 
1146  QMap<QString,bool> in_use;
1147  QString sel = current;
1148  for (const QString& dev : qAsConst(sdevs))
1149  {
1150  in_use[dev] = std::find(db.begin(), db.end(), dev) != db.end();
1151  if (sel.isEmpty() && !in_use[dev])
1152  sel = dev;
1153  }
1154 
1155  if (sel.isEmpty() && !sdevs.empty())
1156  sel = sdevs[0];
1157 
1158  QString usestr = QString(" -- ");
1159  usestr += QObject::tr("Warning: already in use");
1160 
1161  for (const QString& dev : qAsConst(sdevs))
1162  {
1163  QString desc = dev + (in_use[dev] ? usestr : "");
1164  desc = (current == dev) ? dev : desc;
1165  addSelection(desc, dev, dev == sel);
1166  }
1167  }
1168 
1169  void Load(void) override // StandardSetting
1170  {
1171  clearSelections();
1172  addSelection(QString());
1173 
1175 
1177  fillSelections(dev);
1178  }
1179 };
1180 
1181 // Use capturecard/inputname to store the delivery system selection of the card
1183 {
1184  public:
1185  explicit DVBCardType(const CaptureCard &parent) :
1186  CaptureCardComboBoxSetting(parent, false, "inputname")
1187  {
1188  setLabel(QObject::tr("Delivery system"));
1189  setHelpText(
1190  QObject::tr("If your card supports more than one delivery system "
1191  "then you can select here the one that you want to use."));
1192  };
1193 };
1194 
1196 {
1197  public:
1199  {
1200  setLabel(QObject::tr("Frontend ID"));
1201  setHelpText(
1202  QObject::tr("Identification string reported by the card. "
1203  "If the message \"Could not get card info...\" appears "
1204  "the card can be in use by another program."));
1205  };
1206 };
1207 
1209 {
1210  public:
1211  explicit DVBNoSeqStart(const CaptureCard &parent) :
1213  new CaptureCardDBStorage(this, parent, "dvb_wait_for_seqstart"))
1214  {
1215  setLabel(QObject::tr("Wait for SEQ start header"));
1216  setValue(true);
1217  setHelpText(
1218  QObject::tr("If enabled, drop packets from the start of a DVB "
1219  "recording until a sequence start header is seen."));
1220  };
1221 };
1222 
1224 {
1225  public:
1226  explicit DVBOnDemand(const CaptureCard &parent) :
1228  new CaptureCardDBStorage(this, parent, "dvb_on_demand"))
1229  {
1230  setLabel(QObject::tr("Open DVB card on demand"));
1231  setValue(true);
1232  setHelpText(
1233  QObject::tr("If enabled, only open the DVB card when required, "
1234  "leaving it free for other programs at other times."));
1235  };
1236 };
1237 
1239 {
1240  public:
1241  explicit DVBEITScan(const CaptureCard &parent) :
1243  new CaptureCardDBStorage(this, parent, "dvb_eitscan"))
1244  {
1245  setLabel(QObject::tr("Use DVB card for active EIT scan"));
1246  setValue(true);
1247  setHelpText(
1248  QObject::tr("If enabled, activate active scanning for "
1249  "program data (EIT). When this option is enabled "
1250  "the DVB card is constantly in use."));
1251  };
1252 };
1253 
1255 {
1256  public:
1257  explicit DVBTuningDelay(const CaptureCard &parent) :
1258  CaptureCardSpinBoxSetting(parent, 0ms, 2s, 25ms, "dvb_tuning_delay")
1259  {
1260  setLabel(QObject::tr("DVB tuning delay (ms)"));
1261  setValueMs(0ms);
1262  setHelpText(
1263  QObject::tr("Some Linux DVB drivers, in particular for the "
1264  "Hauppauge Nova-T, require that we slow down "
1265  "the tuning process by specifying a delay "
1266  "(in milliseconds)."));
1267  };
1268 };
1269 
1271 {
1272  public:
1273  explicit FirewireGUID(const CaptureCard &parent) :
1274  CaptureCardComboBoxSetting(parent, false, "videodevice")
1275  {
1276  setLabel(QObject::tr("GUID"));
1277 #ifdef USING_FIREWIRE
1278  std::vector<AVCInfo> list = FirewireDevice::GetSTBList();
1279  for (auto & i : list)
1280  {
1281  QString guid = i.GetGUIDString();
1282  m_guidToAvcInfo[guid] = i;
1283  addSelection(guid);
1284  }
1285 #endif // USING_FIREWIRE
1286  }
1287 
1288  AVCInfo GetAVCInfo(const QString &guid) const
1289  { return m_guidToAvcInfo[guid]; }
1290 
1291  private:
1292  QMap<QString,AVCInfo> m_guidToAvcInfo;
1293 };
1294 
1296  const FirewireGUID *_guid) :
1297  CaptureCardComboBoxSetting(parent, false, "firewire_model"),
1298  m_guid(_guid)
1299 {
1300  setLabel(QObject::tr("Cable box model"));
1301  addSelection(QObject::tr("Motorola Generic"), "MOTO GENERIC");
1302  addSelection(QObject::tr("SA/Cisco Generic"), "SA GENERIC");
1303  addSelection("DCH-3200");
1304  addSelection("DCX-3200");
1305  addSelection("DCT-3412");
1306  addSelection("DCT-3416");
1307  addSelection("DCT-6200");
1308  addSelection("DCT-6212");
1309  addSelection("DCT-6216");
1310  addSelection("QIP-6200");
1311  addSelection("QIP-7100");
1312  addSelection("PACE-550");
1313  addSelection("PACE-779");
1314  addSelection("SA3250HD");
1315  addSelection("SA4200HD");
1316  addSelection("SA4250HDC");
1317  addSelection("SA8300HD");
1318  QString help = QObject::tr(
1319  "Choose the model that most closely resembles your set top box. "
1320  "Depending on firmware revision SA4200HD may work better for a "
1321  "SA3250HD box.");
1322  setHelpText(help);
1323 }
1324 
1325 void FirewireModel::SetGUID([[maybe_unused]] const QString &_guid)
1326 {
1327 #ifdef USING_FIREWIRE
1328  AVCInfo info = m_guid->GetAVCInfo(_guid);
1329  QString model = FirewireDevice::GetModelName(info.m_vendorid, info.m_modelid);
1330  setValue(std::max(getValueIndex(model), 0));
1331 #endif // USING_FIREWIRE
1332 }
1333 
1334 void FirewireDesc::SetGUID([[maybe_unused]] const QString &_guid)
1335 {
1336  setLabel(tr("Description"));
1337 
1338 #ifdef USING_FIREWIRE
1339  QString name = m_guid->GetAVCInfo(_guid).m_product_name;
1340  name.replace("Scientific-Atlanta", "SA");
1341  name.replace(", Inc.", "");
1342  name.replace("Explorer(R)", "");
1343  name = name.simplified();
1344  setValue((name.isEmpty()) ? "" : name);
1345 #endif // USING_FIREWIRE
1346 }
1347 
1349 {
1350  public:
1351  explicit FirewireConnection(const CaptureCard &parent) :
1353  "firewire_connection"))
1354  {
1355  setLabel(QObject::tr("Connection Type"));
1356  addSelection(QObject::tr("Point to Point"),"0");
1357  addSelection(QObject::tr("Broadcast"),"1");
1358  }
1359 };
1360 
1362 {
1363  public:
1364  explicit FirewireSpeed(const CaptureCard &parent) :
1366  "firewire_speed"))
1367  {
1368  setLabel(QObject::tr("Speed"));
1369  addSelection(QObject::tr("100Mbps"),"0");
1370  addSelection(QObject::tr("200Mbps"),"1");
1371  addSelection(QObject::tr("400Mbps"),"2");
1372  addSelection(QObject::tr("800Mbps"),"3");
1373  }
1374 };
1375 
1376 #ifdef USING_FIREWIRE
1377 static void FirewireConfigurationGroup(CaptureCard& parent, CardType& cardtype)
1378 {
1379  auto *dev(new FirewireGUID(parent));
1380  auto *desc(new FirewireDesc(dev));
1381  auto *model(new FirewireModel(parent, dev));
1382  cardtype.addTargetedChild("FIREWIRE", dev);
1383  cardtype.addTargetedChild("FIREWIRE", new EmptyAudioDevice(parent));
1384  cardtype.addTargetedChild("FIREWIRE", new EmptyVBIDevice(parent));
1385  cardtype.addTargetedChild("FIREWIRE", desc);
1386  cardtype.addTargetedChild("FIREWIRE", model);
1387 
1388 #ifdef USING_LINUX_FIREWIRE
1389  cardtype.addTargetedChild("FIREWIRE", new FirewireConnection(parent));
1390  cardtype.addTargetedChild("FIREWIRE", new FirewireSpeed(parent));
1391 #endif // USING_LINUX_FIREWIRE
1392 
1393  cardtype.addTargetedChild("FIREWIRE", new SignalTimeout(parent, 2s, 1s));
1394  cardtype.addTargetedChild("FIREWIRE", new ChannelTimeout(parent, 9s, 1.75s));
1395 
1396  model->SetGUID(dev->getValue());
1397  desc->SetGUID(dev->getValue());
1398  QObject::connect(dev, qOverload<const QString&>(&StandardSetting::valueChanged),
1399  model, &FirewireModel::SetGUID);
1400  QObject::connect(dev, qOverload<const QString&>(&StandardSetting::valueChanged),
1401  desc, &FirewireDesc::SetGUID);
1402 }
1403 #endif
1404 
1405 #ifdef USING_HDHOMERUN
1406 
1407 // -----------------------
1408 // HDHomeRun Configuration
1409 // -----------------------
1410 
1412  HDHomeRunConfigurationGroup &_group) :
1414  new CaptureCardDBStorage(this, parent, "videodevice")),
1415  m_group(_group)
1416 {
1417  setVisible(false);
1418 };
1419 
1421 {
1424 }
1425 
1427 {
1430 }
1431 
1433 {
1434  public:
1435  explicit HDHomeRunEITScan(const CaptureCard &parent) :
1437  new CaptureCardDBStorage(this, parent, "dvb_eitscan"))
1438  {
1439  setLabel(QObject::tr("Use HDHomeRun for active EIT scan"));
1440  setValue(true);
1441  setHelpText(
1442  QObject::tr("If enabled, activate active scanning for "
1443  "program data (EIT). When this option is enabled "
1444  "the HDHomeRun is constantly in use."));
1445  };
1446 };
1447 
1448 
1450 {
1451  public:
1452  explicit UseHDHomeRunDevice(QString &deviceid, QString &model,
1453  QString &ipaddr)
1454  {
1455  setLabel(QObject::tr("Use HDHomeRun %1 (%2 %3)")
1456  .arg(deviceid, model, ipaddr));
1457  setValue(false);
1458  setHelpText(
1459  QObject::tr("If enabled, use tuners from this HDHomeRun "
1460  "device."));
1461  };
1462 };
1463 
1465  (CaptureCard& a_parent, CardType &a_cardtype) :
1466  m_parent(a_parent)
1467 {
1468  setVisible(false);
1469 
1470  // Fill Device list
1471  FillDeviceList();
1472 
1473  m_deviceId = new HDHomeRunDeviceID(m_parent, *this);
1474 
1475  QMap<QString, HDHomeRunDevice>::iterator dit;
1476  for (dit = m_deviceList.begin(); dit != m_deviceList.end(); ++dit)
1477  {
1478  HDHomeRunDevice &dev = *dit;
1479  dev.m_checkbox = new UseHDHomeRunDevice(
1480  dev.m_deviceId, dev.m_model, dev.m_cardIp);
1481  a_cardtype.addTargetedChild("HDHOMERUN", dev.m_checkbox);
1482  }
1483  a_cardtype.addTargetedChild("HDHOMERUN", new EmptyAudioDevice(m_parent));
1484  a_cardtype.addTargetedChild("HDHOMERUN", new EmptyVBIDevice(m_parent));
1485  a_cardtype.addTargetedChild("HDHOMERUN", m_deviceId);
1486 
1487  auto *buttonRecOpt = new GroupSetting();
1488  buttonRecOpt->setLabel(tr("Recording Options"));
1489  buttonRecOpt->addChild(new SignalTimeout(m_parent, 3s, 0.25s));
1490  buttonRecOpt->addChild(new ChannelTimeout(m_parent, 6s, 1.75s));
1491  buttonRecOpt->addChild(new HDHomeRunEITScan(m_parent));
1492  a_cardtype.addTargetedChild("HDHOMERUN", buttonRecOpt);
1493 };
1494 
1496 {
1497  m_deviceList.clear();
1498 
1499  // Find physical devices first
1500  // ProbeVideoDevices returns "deviceid ip" pairs
1501  QStringList devs = CardUtil::ProbeVideoDevices("HDHOMERUN");
1502 
1503  for (const auto & dev : qAsConst(devs))
1504  {
1505  QStringList devinfo = dev.split(" ");
1506  const QString& devid = devinfo.at(0);
1507  const QString& devip = devinfo.at(1);
1508  const QString& model = devinfo.at(2);
1509 
1510  HDHomeRunDevice tmpdevice;
1511  tmpdevice.m_model = model;
1512  tmpdevice.m_cardIp = devip;
1513  tmpdevice.m_deviceId = devid;
1514  // Fully specify object. Checkboxes will be added later when
1515  // the configuration group is created.
1516  tmpdevice.m_checkbox = nullptr;
1517  m_deviceList[tmpdevice.m_deviceId] = tmpdevice;
1518  }
1519 
1520 #if 0
1521  // Debug dump of cards
1522  QMap<QString, HDHomeRunDevice>::iterator debugit;
1523  for (debugit = m_deviceList.begin(); debugit != m_deviceList.end(); ++debugit)
1524  {
1525  LOG(VB_GENERAL, LOG_DEBUG, QString("%1: %2 %3")
1526  .arg(debugit.key()).arg((*debugit).model)
1527  .arg((*debugit).cardip));
1528  }
1529 #endif
1530 }
1531 
1533 {
1534  QStringList devstrs = devices.split(",");
1535  for (const QString& devstr : qAsConst(devstrs))
1536  {
1537  // Get the HDHomeRun device ID using libhdhomerun. We need to
1538  // do it this way because legacy configurations could use an
1539  // IP address and a tuner nubmer.
1540  QByteArray ba = devstr.toUtf8();
1541  hdhomerun_device_t *device = hdhomerun_device_create_from_str(
1542  ba.data(), nullptr);
1543  if (!device)
1544  continue;
1545  QString devid = QString("%1").arg(
1546  hdhomerun_device_get_device_id(device), 8, 16).toUpper();
1547  hdhomerun_device_destroy(device);
1548 
1549  // If we know about this device, set its checkbox to on.
1550  QMap<QString, HDHomeRunDevice>::iterator dit;
1551  dit = m_deviceList.find(devid);
1552  if (dit != m_deviceList.end())
1553  (*dit).m_checkbox->setValue(true);
1554  }
1555 }
1556 
1558 {
1559  // Return a string listing each HDHomeRun device with its checbox
1560  // turned on.
1561  QStringList devstrs;
1562  QMap<QString, HDHomeRunDevice>::iterator dit;
1563  for (dit = m_deviceList.begin(); dit != m_deviceList.end(); ++dit)
1564  {
1565  if ((*dit).m_checkbox->boolValue())
1566  devstrs << (*dit).m_deviceId;
1567  }
1568  QString devices = devstrs.join(",");
1569  return devices;
1570 }
1571 
1572 #endif
1573 
1574 // -----------------------
1575 // VBOX Configuration
1576 // -----------------------
1577 
1579 {
1580  setLabel(QObject::tr("IP Address"));
1581  setHelpText(QObject::tr("Device IP or ID of a VBox device. eg. '192.168.1.100' or 'vbox_3718'"));
1582  VBoxIP::setEnabled(false);
1583  connect(this, qOverload<const QString&>(&StandardSetting::valueChanged),
1584  this, &VBoxIP::UpdateDevices);
1585 };
1586 
1588 {
1590  if (e)
1591  {
1592  if (!m_oldValue.isEmpty())
1594  emit NewIP(getValue());
1595  }
1596  else
1597  {
1598  m_oldValue = getValue();
1599  }
1600 }
1601 
1602 void VBoxIP::UpdateDevices(const QString &v)
1603 {
1604  if (isEnabled())
1605  emit NewIP(v);
1606 }
1607 
1609 {
1610  setLabel(QObject::tr("Tuner"));
1611  setHelpText(QObject::tr("Number and type of the tuner to use. eg '1-DVBT/T2'."));
1613  connect(this, qOverload<const QString&>(&StandardSetting::valueChanged),
1615 };
1616 
1618 {
1620  if (e) {
1621  if (!m_oldValue.isEmpty())
1623  emit NewTuner(getValue());
1624  }
1625  else
1626  {
1627  m_oldValue = getValue();
1628  }
1629 }
1630 
1631 void VBoxTunerIndex::UpdateDevices(const QString &v)
1632 {
1633  if (isEnabled())
1634  emit NewTuner(v);
1635 }
1636 
1638  MythUITextEditSetting(new CaptureCardDBStorage(this, parent, "videodevice"))
1639 {
1640  setLabel(tr("Device ID"));
1641  setHelpText(tr("Device ID of VBox device"));
1642  setReadOnly(true);
1643 }
1644 
1645 void VBoxDeviceID::SetIP(const QString &ip)
1646 {
1647  m_ip = ip;
1648  setValue(QString("%1-%2").arg(m_ip, m_tuner));
1649 }
1650 
1651 void VBoxDeviceID::SetTuner(const QString &tuner)
1652 {
1653  m_tuner = tuner;
1654  setValue(QString("%1-%2").arg(m_ip, m_tuner));
1655 }
1656 
1657 void VBoxDeviceID::SetOverrideDeviceID(const QString &deviceid)
1658 {
1659  m_overrideDeviceId = deviceid;
1660  setValue(deviceid);
1661 }
1662 
1664 {
1665  GetStorage()->Load();
1666  if (!m_overrideDeviceId.isEmpty())
1667  {
1669  m_overrideDeviceId.clear();
1670  }
1671 }
1672 
1674  VBoxDeviceID *deviceid,
1675  StandardSetting *desc,
1676  VBoxIP *cardip,
1677  VBoxTunerIndex *cardtuner,
1678  VBoxDeviceList *devicelist,
1679  const CaptureCard &parent) :
1680  m_deviceId(deviceid),
1681  m_desc(desc),
1682  m_cardIp(cardip),
1683  m_cardTuner(cardtuner),
1684  m_deviceList(devicelist),
1685  m_parent(parent)
1686 {
1687  setLabel(QObject::tr("Available devices"));
1688  setHelpText(
1689  QObject::tr(
1690  "Device IP or ID, tuner number and tuner type of available VBox devices."));
1691 
1692  connect(this, qOverload<const QString&>(&StandardSetting::valueChanged),
1694 };
1695 
1697 void VBoxDeviceIDList::fillSelections(const QString &cur)
1698 {
1699  clearSelections();
1700 
1701  std::vector<QString> devs;
1702  QMap<QString, bool> in_use;
1703 
1704  const QString& current = cur;
1705 
1706  for (auto it = m_deviceList->begin(); it != m_deviceList->end(); ++it)
1707  {
1708  devs.push_back(it.key());
1709  in_use[it.key()] = (*it).m_inUse;
1710  }
1711 
1712  QString man_addr = VBoxDeviceIDList::tr("Manually Enter IP Address");
1713  QString sel = man_addr;
1714  devs.push_back(sel);
1715 
1716  for (const auto & dev : devs)
1717  sel = (current == dev) ? dev : sel;
1718 
1719  QString usestr = QString(" -- ");
1720  usestr += QObject::tr("Warning: already in use");
1721 
1722  for (const auto & dev : devs)
1723  {
1724  QString desc = dev + (in_use[dev] ? usestr : "");
1725  addSelection(desc, dev, dev == sel);
1726  }
1727 
1728  if (current != cur)
1729  {
1731  }
1732  else if (sel == man_addr && !current.isEmpty())
1733  {
1734  // Populate the proper values for IP address and tuner
1735  QStringList selection = current.split("-");
1736 
1737  m_cardIp->SetOldValue(selection.first());
1738  m_cardTuner->SetOldValue(selection.last());
1739 
1740  m_cardIp->setValue(selection.first());
1741  m_cardTuner->setValue(selection.last());
1742  }
1743 }
1744 
1746 {
1747  clearSelections();
1748 
1749  int cardid = m_parent.getCardID();
1750  QString device = CardUtil::GetVideoDevice(cardid);
1751  fillSelections(device);
1752 }
1753 
1754 void VBoxDeviceIDList::UpdateDevices(const QString &v)
1755 {
1756  if (v == VBoxDeviceIDList::tr("Manually Enter IP Address"))
1757  {
1758  m_cardIp->setEnabled(true);
1759  m_cardTuner->setEnabled(true);
1760  }
1761  else if (!v.isEmpty())
1762  {
1763  if (m_oldValue == VBoxDeviceIDList::tr("Manually Enter IP Address"))
1764  {
1765  m_cardIp->setEnabled(false);
1766  m_cardTuner->setEnabled(false);
1767  }
1768  m_deviceId->setValue(v);
1769 
1770  // Update _cardip and _cardtuner
1772  m_cardTuner->setValue(QString("%1").arg((*m_deviceList)[v].m_tunerNo));
1774  }
1775  m_oldValue = v;
1776 };
1777 
1778 // -----------------------
1779 // IPTV Configuration
1780 // -----------------------
1781 
1783 {
1784  public:
1785  explicit IPTVHost(const CaptureCard &parent) :
1786  CaptureCardTextEditSetting(parent, "videodevice")
1787  {
1788  setValue("http://mafreebox.freebox.fr/freeboxtv/playlist.m3u");
1789  setLabel(QObject::tr("M3U URL"));
1790  setHelpText(
1791  QObject::tr("URL of M3U file containing RTSP/RTP/UDP/HTTP channel URLs,"
1792  " example for HDHomeRun: http://<ipv4>/lineup.m3u and for Freebox:"
1793  " http://mafreebox.freebox.fr/freeboxtv/playlist.m3u."
1794  ));
1795  }
1796 };
1797 
1798 static void IPTVConfigurationGroup(CaptureCard& parent, CardType& cardType)
1799 {
1800  cardType.addTargetedChild("FREEBOX", new IPTVHost(parent));
1801  cardType.addTargetedChild("FREEBOX", new ChannelTimeout(parent, 30s, 1.75s));
1802  cardType.addTargetedChild("FREEBOX", new EmptyAudioDevice(parent));
1803  cardType.addTargetedChild("FREEBOX", new EmptyVBIDevice(parent));
1804 }
1805 
1807 {
1808  public:
1809  explicit ASIDevice(const CaptureCard &parent) :
1810  CaptureCardComboBoxSetting(parent, true, "videodevice")
1811  {
1812  setLabel(QObject::tr("ASI device"));
1813  fillSelections(QString());
1814  };
1815 
1819  void fillSelections(const QString &current)
1820  {
1821  clearSelections();
1822 
1823  // Get devices from filesystem
1824  QStringList sdevs = CardUtil::ProbeVideoDevices("ASI");
1825 
1826  // Add current if needed
1827  if (!current.isEmpty() &&
1828  (std::find(sdevs.begin(), sdevs.end(), current) == sdevs.end()))
1829  {
1830  std::stable_sort(sdevs.begin(), sdevs.end());
1831  }
1832 
1833  // Get devices from DB
1834  QStringList db = CardUtil::GetVideoDevices("ASI");
1835 
1836  // Figure out which physical devices are already in use
1837  // by another card defined in the DB, and select a device
1838  // for new configs (preferring non-conflicing devices).
1839  QMap<QString,bool> in_use;
1840  QString sel = current;
1841  for (const QString& dev : qAsConst(sdevs))
1842  {
1843  in_use[dev] = std::find(db.begin(), db.end(), dev) != db.end();
1844  if (sel.isEmpty() && !in_use[dev])
1845  sel = dev;
1846  }
1847 
1848  // Unfortunately all devices are conflicted, select first device.
1849  if (sel.isEmpty() && !sdevs.empty())
1850  sel = sdevs[0];
1851 
1852  QString usestr = QString(" -- ");
1853  usestr += QObject::tr("Warning: already in use");
1854 
1855  // Add the devices to the UI
1856  bool found = false;
1857  for (const QString& dev : qAsConst(sdevs))
1858  {
1859  QString desc = dev + (in_use[dev] ? usestr : "");
1860  desc = (current == dev) ? dev : desc;
1861  addSelection(desc, dev, dev == sel);
1862  found |= (dev == sel);
1863  }
1864 
1865  // If a configured device isn't on the list, add it with warning
1866  if (!found && !current.isEmpty())
1867  {
1868  QString desc = current + " -- " +
1869  QObject::tr("Warning: unable to open");
1870  addSelection(desc, current, true);
1871  }
1872  }
1873 
1874  void Load(void) override // StandardSetting
1875  {
1876  clearSelections();
1877  addSelection(QString());
1878  GetStorage()->Load();
1880  }
1881 };
1882 
1884  CardType &cardType):
1885  m_parent(a_parent),
1886  m_device(new ASIDevice(m_parent)),
1887  m_cardInfo(new TransTextEditSetting())
1888 {
1889  setVisible(false);
1890  m_cardInfo->setLabel(tr("Status"));
1891  m_cardInfo->setEnabled(false);
1892 
1893  cardType.addTargetedChild("ASI", m_device);
1894  cardType.addTargetedChild("ASI", new EmptyAudioDevice(m_parent));
1895  cardType.addTargetedChild("ASI", new EmptyVBIDevice(m_parent));
1896  cardType.addTargetedChild("ASI", m_cardInfo);
1897 
1898  connect(m_device, qOverload<const QString&>(&StandardSetting::valueChanged),
1900 
1902 };
1903 
1904 void ASIConfigurationGroup::probeCard([[maybe_unused]] const QString &device)
1905 {
1906 #ifdef USING_ASI
1907  if (device.isEmpty())
1908  {
1909  m_cardInfo->setValue("");
1910  return;
1911  }
1912 
1913  if ((m_parent.getCardID() != 0) && m_parent.GetRawCardType() != "ASI")
1914  {
1915  m_cardInfo->setValue("");
1916  return;
1917  }
1918 
1919  QString error;
1920  int device_num = CardUtil::GetASIDeviceNumber(device, &error);
1921  if (device_num < 0)
1922  {
1923  m_cardInfo->setValue(tr("Not a valid DVEO ASI card"));
1924  LOG(VB_GENERAL, LOG_WARNING,
1925  "ASIConfigurationGroup::probeCard(), Warning: " + error);
1926  return;
1927  }
1928  m_cardInfo->setValue(tr("Valid DVEO ASI card"));
1929 #else
1930  m_cardInfo->setValue(QString("Not compiled with ASI support"));
1931 #endif
1932 }
1933 
1935  CardType& a_cardtype):
1936  m_parent(a_parent),
1937  m_info(new GroupSetting()), m_size(new GroupSetting())
1938 {
1939  setVisible(false);
1940  auto *device = new FileDevice(m_parent);
1941  device->setHelpText(tr("A local file used to simulate a recording."
1942  " Leave empty to use MythEvents to trigger an"
1943  " external program to import recording files."));
1944  a_cardtype.addTargetedChild("IMPORT", device);
1945 
1946  a_cardtype.addTargetedChild("IMPORT", new EmptyAudioDevice(m_parent));
1947  a_cardtype.addTargetedChild("IMPORT", new EmptyVBIDevice(m_parent));
1948 
1949  m_info->setLabel(tr("File info"));
1950  a_cardtype.addTargetedChild("IMPORT", m_info);
1951 
1952  m_size->setLabel(tr("File size"));
1953  a_cardtype.addTargetedChild("IMPORT", m_size);
1954 
1955  connect(device, qOverload<const QString&>(&StandardSetting::valueChanged),
1957 
1958  probeCard(device->getValue());
1959 };
1960 
1961 void ImportConfigurationGroup::probeCard(const QString &device)
1962 {
1963  QString ci;
1964  QString cs;
1965  QFileInfo fileInfo(device);
1966 
1967  // For convenience, ImportRecorder allows both formats:
1968  if (device.startsWith("file:", Qt::CaseInsensitive))
1969  fileInfo.setFile(device.mid(5));
1970 
1971  if (fileInfo.exists())
1972  {
1973  if (fileInfo.isReadable() && (fileInfo.isFile()))
1974  {
1975  ci = HTTPRequest::TestMimeType(fileInfo.absoluteFilePath());
1976  cs = tr("%1 MB").arg(fileInfo.size() / 1024 / 1024);
1977  }
1978  else
1979  ci = tr("File not readable");
1980  }
1981  else
1982  {
1983  ci = tr("File %1 does not exist").arg(device);
1984  }
1985 
1986  m_info->setValue(ci);
1987  m_size->setValue(cs);
1988 }
1989 
1990 // -----------------------
1991 // VBox Configuration
1992 // -----------------------
1993 
1995  (CaptureCard& a_parent, CardType& a_cardtype) :
1996  m_parent(a_parent)
1997 {
1998  setVisible(false);
1999 
2000  // Fill Device list
2001  FillDeviceList();
2002 
2003  m_deviceId = new VBoxDeviceID(m_parent);
2004  m_desc = new GroupSetting();
2005  m_desc->setLabel(tr("Description"));
2006  m_cardIp = new VBoxIP();
2007  m_cardTuner = new VBoxTunerIndex();
2008  m_deviceIdList = new VBoxDeviceIDList(
2009  m_deviceId, m_desc, m_cardIp, m_cardTuner, &m_deviceList, m_parent);
2010 
2011  a_cardtype.addTargetedChild("VBOX", m_deviceIdList);
2012  a_cardtype.addTargetedChild("VBOX", new EmptyAudioDevice(m_parent));
2013  a_cardtype.addTargetedChild("VBOX", new EmptyVBIDevice(m_parent));
2014  a_cardtype.addTargetedChild("VBOX", m_deviceId);
2015  a_cardtype.addTargetedChild("VBOX", m_desc);
2016  a_cardtype.addTargetedChild("VBOX", m_cardIp);
2017  a_cardtype.addTargetedChild("VBOX", m_cardTuner);
2018  a_cardtype.addTargetedChild("VBOX", new SignalTimeout(m_parent, 7s, 1s));
2019  a_cardtype.addTargetedChild("VBOX", new ChannelTimeout(m_parent, 10s, 1.75s));
2020 
2021  connect(m_cardIp, &VBoxIP::NewIP,
2022  m_deviceId, &VBoxDeviceID::SetIP);
2023  connect(m_cardTuner, &VBoxTunerIndex::NewTuner,
2024  m_deviceId, &VBoxDeviceID::SetTuner);
2025 };
2026 
2028 {
2029  m_deviceList.clear();
2030 
2031  // Find physical devices first
2032  // ProbeVideoDevices returns "deviceid ip tunerno tunertype"
2033  QStringList devs = CardUtil::ProbeVideoDevices("VBOX");
2034 
2035  for (const auto & dev : qAsConst(devs))
2036  {
2037  QStringList devinfo = dev.split(" ");
2038  const QString& id = devinfo.at(0);
2039  const QString& ip = devinfo.at(1);
2040  const QString& tunerNo = devinfo.at(2);
2041  const QString& tunerType = devinfo.at(3);
2042 
2043  VBoxDevice tmpdevice;
2044  tmpdevice.m_deviceId = id;
2045  tmpdevice.m_desc = CardUtil::GetVBoxdesc(id, ip, tunerNo, tunerType);
2046  tmpdevice.m_cardIp = ip;
2047  tmpdevice.m_inUse = false;
2048  tmpdevice.m_discovered = true;
2049  tmpdevice.m_tunerNo = tunerNo;
2050  tmpdevice.m_tunerType = tunerType;
2051  tmpdevice.m_mythDeviceId = id + "-" + tunerNo + "-" + tunerType;
2052  m_deviceList[tmpdevice.m_mythDeviceId] = tmpdevice;
2053  }
2054 
2055  // Now find configured devices
2056 
2057  // returns "ip.ip.ip.ip-n-type" or deviceid-n-type values
2058  QStringList db = CardUtil::GetVideoDevices("VBOX");
2059 
2060  for (const auto & dev : qAsConst(db))
2061  {
2062  QMap<QString, VBoxDevice>::iterator dit;
2063  dit = m_deviceList.find(dev);
2064 
2065  if (dit != m_deviceList.end())
2066  (*dit).m_inUse = true;
2067  }
2068 }
2069 
2070 // -----------------------
2071 // Ceton Configuration
2072 // -----------------------
2073 #ifdef USING_CETON
2074 CetonSetting::CetonSetting(QString label, const QString& helptext)
2075 {
2076  setLabel(std::move(label));
2077  setHelpText(helptext);
2078  connect(this, qOverload<const QString&>(&StandardSetting::valueChanged),
2080 }
2081 
2082 void CetonSetting::UpdateDevices(const QString &v)
2083 {
2084  if (isEnabled())
2085  emit NewValue(v);
2086 }
2087 
2088 void CetonSetting::LoadValue(const QString &value)
2089 {
2090  setValue(value);
2091 }
2092 
2094  MythUITextEditSetting(new CaptureCardDBStorage(this, parent, "videodevice")),
2095  m_parent(parent)
2096 {
2097  setLabel(tr("Device ID"));
2098  setHelpText(tr("Device ID of Ceton device"));
2099 }
2100 
2101 void CetonDeviceID::SetIP(const QString &ip)
2102 {
2103  static const QRegularExpression ipV4Regex
2104  { "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){4}$" };
2105  auto match = ipV4Regex.match(ip + ".");
2106  if (match.hasMatch())
2107  {
2108  m_ip = ip;
2109  setValue(QString("%1-RTP.%3").arg(m_ip, m_tuner));
2110  }
2111 }
2112 
2113 void CetonDeviceID::SetTuner(const QString &tuner)
2114 {
2115  static const QRegularExpression oneDigit { "^\\d$" };
2116  auto match = oneDigit.match(tuner);
2117  if (match.hasMatch())
2118  {
2119  m_tuner = tuner;
2120  setValue(QString("%1-RTP.%2").arg(m_ip, m_tuner));
2121  }
2122 }
2123 
2125 {
2126  GetStorage()->Load();
2127  UpdateValues();
2128 }
2129 
2131 {
2132  static const QRegularExpression newstyle { R"(^([0-9.]+)-(\d|RTP)\.(\d)$)" };
2133  auto match = newstyle.match(getValue());
2134  if (match.hasMatch())
2135  {
2136  emit LoadedIP(match.captured(1));
2137  emit LoadedTuner(match.captured(3));
2138  }
2139 }
2140 
2142 {
2143  auto *deviceid = new CetonDeviceID(parent);
2144  auto *desc = new GroupSetting();
2145  desc->setLabel(tr("CetonConfigurationGroup", "Description"));
2146  auto *ip = new CetonSetting(tr("IP Address"),
2147  tr("IP Address of the Ceton device (192.168.200.1 by default)"));
2148  auto *tuner = new CetonSetting(tr("Tuner"),
2149  tr("Number of the tuner on the Ceton device (first tuner is number 0)"));
2150 
2151  cardtype.addTargetedChild("CETON", ip);
2152  cardtype.addTargetedChild("CETON", tuner);
2153  cardtype.addTargetedChild("CETON", deviceid);
2154  cardtype.addTargetedChild("CETON", desc);
2155  cardtype.addTargetedChild("CETON", new SignalTimeout(parent, 1s, 0.25s));
2156  cardtype.addTargetedChild("CETON", new ChannelTimeout(parent, 3s, 1.75s));
2157 
2158  QObject::connect(ip, &CetonSetting::NewValue,
2159  deviceid, &CetonDeviceID::SetIP);
2160  QObject::connect(tuner, &CetonSetting::NewValue,
2161  deviceid, &CetonDeviceID::SetTuner);
2162 
2163  QObject::connect(deviceid, &CetonDeviceID::LoadedIP,
2165  QObject::connect(deviceid, &CetonDeviceID::LoadedTuner,
2166  tuner, &CetonSetting::LoadValue);
2167 }
2168 #endif
2169 
2170 // Override database schema default, set schedgroup false
2172 {
2173  public:
2174  explicit SchedGroupFalse(const CaptureCard &parent) :
2176  "schedgroup"))
2177  {
2178  setValue(false);
2179  setVisible(false);
2180  };
2181 };
2182 
2184  CardType& cardtype,
2185  const QString &inputtype) :
2186  m_parent(parent),
2187  m_cardInfo(new GroupSetting()),
2188  m_vbiDev(new VBIDevice(m_parent))
2189 {
2190  setVisible(false);
2191  QRegularExpression drv { "^(?!ivtv|hdpvr|(saa7164(.*))).*$" };
2192  auto *device = new VideoDevice(m_parent, 0, 15, QString(), drv);
2193 
2194  m_cardInfo->setLabel(tr("Probed info"));
2195  m_cardInfo->setReadOnly(true);
2196 
2197  cardtype.addTargetedChild(inputtype, device);
2198  cardtype.addTargetedChild(inputtype, m_cardInfo);
2199  cardtype.addTargetedChild(inputtype, m_vbiDev);
2200  cardtype.addTargetedChild(inputtype, new AudioDevice(m_parent));
2201  cardtype.addTargetedChild(inputtype, new AudioRateLimit(m_parent));
2202  cardtype.addTargetedChild(inputtype, new SkipBtAudio(m_parent));
2203 
2204  // Override database schema default, set schedgroup false
2205  cardtype.addTargetedChild(inputtype, new SchedGroupFalse(m_parent));
2206 
2207  connect(device, qOverload<const QString&>(&StandardSetting::valueChanged),
2209 
2210  probeCard(device->getValue());
2211 };
2212 
2213 void V4LConfigurationGroup::probeCard(const QString &device)
2214 {
2215  QString cn = tr("Failed to open");
2216  QString ci = cn;
2217  QString dn;
2218 
2219  QByteArray adevice = device.toLatin1();
2220  int videofd = open(adevice.constData(), O_RDWR);
2221  if (videofd >= 0)
2222  {
2223  if (!CardUtil::GetV4LInfo(videofd, cn, dn))
2224  ci = cn = tr("Failed to probe");
2225  else if (!dn.isEmpty())
2226  ci = cn + " [" + dn + "]";
2227  close(videofd);
2228  }
2229 
2230  m_cardInfo->setValue(ci);
2231  m_vbiDev->setFilter(cn, dn);
2232 }
2233 
2235  CardType &cardtype) :
2236  m_parent(parent),
2237  m_cardInfo(new GroupSetting())
2238 {
2239  setVisible(false);
2240  QRegularExpression drv { "^(ivtv|(saa7164(.*)))$" };
2241  m_device = new VideoDevice(m_parent, 0, 15, QString(), drv);
2243  m_vbiDevice->setVisible(false);
2244 
2245  m_cardInfo->setLabel(tr("Probed info"));
2246  m_cardInfo->setReadOnly(true);
2247 
2248  cardtype.addTargetedChild("MPEG", m_device);
2249  cardtype.addTargetedChild("MPEG", m_vbiDevice);
2250  cardtype.addTargetedChild("MPEG", m_cardInfo);
2251  cardtype.addTargetedChild("MPEG", new ChannelTimeout(m_parent, 12s, 2s));
2252 
2253  // Override database schema default, set schedgroup false
2254  cardtype.addTargetedChild("MPEG", new SchedGroupFalse(m_parent));
2255 
2256  connect(m_device, qOverload<const QString&>(&StandardSetting::valueChanged),
2258 
2260 }
2261 
2262 void MPEGConfigurationGroup::probeCard(const QString &device)
2263 {
2264  QString cn = tr("Failed to open");
2265  QString ci = cn;
2266  QString dn;
2267 
2268  QByteArray adevice = device.toLatin1();
2269  int videofd = open(adevice.constData(), O_RDWR);
2270  if (videofd >= 0)
2271  {
2272  if (!CardUtil::GetV4LInfo(videofd, cn, dn))
2273  ci = cn = tr("Failed to probe");
2274  else if (!dn.isEmpty())
2275  ci = cn + " [" + dn + "]";
2276  close(videofd);
2277  }
2278 
2279  m_cardInfo->setValue(ci);
2280  m_vbiDevice->setVisible(dn!="ivtv");
2281  m_vbiDevice->setFilter(cn, dn);
2282 }
2283 
2285  CardType &a_cardtype) :
2286  m_parent(a_parent),
2287  m_info(new GroupSetting()), m_size(new GroupSetting())
2288 {
2289  setVisible(false);
2290  auto *device = new FileDevice(m_parent);
2291  device->setHelpText(tr("A local MPEG file used to simulate a recording."));
2292 
2293  a_cardtype.addTargetedChild("DEMO", device);
2294 
2295  a_cardtype.addTargetedChild("DEMO", new EmptyAudioDevice(m_parent));
2296  a_cardtype.addTargetedChild("DEMO", new EmptyVBIDevice(m_parent));
2297 
2298  m_info->setLabel(tr("File info"));
2299  a_cardtype.addTargetedChild("DEMO", m_info);
2300 
2301  m_size->setLabel(tr("File size"));
2302  a_cardtype.addTargetedChild("DEMO", m_size);
2303 
2304  connect(device, qOverload<const QString&>(&StandardSetting::valueChanged),
2306 
2307  probeCard(device->getValue());
2308 }
2309 
2310 void DemoConfigurationGroup::probeCard(const QString &device)
2311 {
2312  QString ci;
2313  QString cs;
2314  QFileInfo fileInfo(device);
2315  if (fileInfo.exists())
2316  {
2317  if (fileInfo.isReadable() && (fileInfo.isFile()))
2318  {
2319  ci = HTTPRequest::TestMimeType(fileInfo.absoluteFilePath());
2320  cs = tr("%1 MB").arg(fileInfo.size() / 1024 / 1024);
2321  }
2322  else
2323  ci = tr("File not readable");
2324  }
2325  else
2326  {
2327  ci = tr("File does not exist");
2328  }
2329 
2330  m_info->setValue(ci);
2331  m_size->setValue(cs);
2332 }
2333 
2334 #if !defined( USING_MINGW ) && !defined( _MSC_VER )
2335 ExternalConfigurationGroup::ExternalConfigurationGroup(CaptureCard &a_parent,
2336  CardType &a_cardtype) :
2337  m_parent(a_parent),
2338  m_info(new GroupSetting())
2339 {
2340  setVisible(false);
2341  auto *device = new CommandPath(m_parent);
2342  device->setLabel(tr("Command path"));
2343  device->setHelpText(tr("A 'black box' application controlled via stdin, status on "
2344  "stderr and TransportStream read from stdout.\n"
2345  "Use absolute path or path relative to the current directory."));
2346  a_cardtype.addTargetedChild("EXTERNAL", device);
2347 
2348  m_info->setLabel(tr("File info"));
2349  a_cardtype.addTargetedChild("EXTERNAL", m_info);
2350 
2351  a_cardtype.addTargetedChild("EXTERNAL",
2352  new ChannelTimeout(m_parent, 20s, 1.75s));
2353 
2354  connect(device, qOverload<const QString&>(&StandardSetting::valueChanged),
2355  this, &ExternalConfigurationGroup::probeApp);
2356 
2357  probeApp(device->getValue());
2358 }
2359 
2360 void ExternalConfigurationGroup::probeApp(const QString & path)
2361 {
2362  int idx1 = path.startsWith("file:", Qt::CaseInsensitive) ? 5 : 0;
2363  int idx2 = path.indexOf(' ', idx1);
2364 
2365  QString ci;
2366  QFileInfo fileInfo(path.mid(idx1, idx2 - idx1));
2367 
2368  if (fileInfo.exists())
2369  {
2370  ci = tr("File '%1' is valid.").arg(fileInfo.absoluteFilePath());
2371  if (!fileInfo.isReadable() || !fileInfo.isFile())
2372  ci = tr("WARNING: File '%1' is not readable.")
2373  .arg(fileInfo.absoluteFilePath());
2374  if (!fileInfo.isExecutable())
2375  ci = tr("WARNING: File '%1' is not executable.")
2376  .arg(fileInfo.absoluteFilePath());
2377  }
2378  else
2379  {
2380  ci = tr("WARNING: File '%1' does not exist.")
2381  .arg(fileInfo.absoluteFilePath());
2382  }
2383 
2384  m_info->setValue(ci);
2385  m_info->setHelpText(ci);
2386 }
2387 #endif // !defined( USING_MINGW ) && !defined( _MSC_VER )
2388 
2390  CardType &a_cardtype) :
2391  m_parent(a_parent), m_cardInfo(new GroupSetting()),
2392  m_audioInput(new TunerCardAudioInput(m_parent, QString(), "HDPVR"))
2393 {
2394  setVisible(false);
2395 
2396  auto *device = new VideoDevice(m_parent, 0, 15, QString(),
2397  QRegularExpression("^hdpvr$"));
2398 
2399  m_cardInfo->setLabel(tr("Probed info"));
2400  m_cardInfo->setReadOnly(true);
2401 
2402  a_cardtype.addTargetedChild("HDPVR", device);
2403  a_cardtype.addTargetedChild("HDPVR", new EmptyAudioDevice(m_parent));
2404  a_cardtype.addTargetedChild("HDPVR", new EmptyVBIDevice(m_parent));
2405  a_cardtype.addTargetedChild("HDPVR", m_cardInfo);
2406  a_cardtype.addTargetedChild("HDPVR", m_audioInput);
2407  a_cardtype.addTargetedChild("HDPVR", new ChannelTimeout(m_parent, 15s, 2s));
2408 
2409  // Override database schema default, set schedgroup false
2410  a_cardtype.addTargetedChild("HDPVR", new SchedGroupFalse(m_parent));
2411 
2412  connect(device, qOverload<const QString&>(&StandardSetting::valueChanged),
2414 
2415  probeCard(device->getValue());
2416 }
2417 
2418 void HDPVRConfigurationGroup::probeCard(const QString &device)
2419 {
2420  QString cn = tr("Failed to open");
2421  QString ci = cn;
2422  QString dn;
2423 
2424  int videofd = open(device.toLocal8Bit().constData(), O_RDWR);
2425  if (videofd >= 0)
2426  {
2427  if (!CardUtil::GetV4LInfo(videofd, cn, dn))
2428  ci = cn = tr("Failed to probe");
2429  else if (!dn.isEmpty())
2430  ci = cn + " [" + dn + "]";
2431  close(videofd);
2432  m_audioInput->fillSelections(device);
2433  }
2434 
2435  m_cardInfo->setValue(ci);
2436 }
2437 
2439  m_parent(parent),
2440  m_cardInfo(new GroupSetting())
2441 {
2442  setVisible(false);
2443 
2444  m_device = new VideoDevice(m_parent, 0, 15);
2445 
2446  setLabel(QObject::tr("V4L2 encoder devices (multirec capable)"));
2447 
2448  m_cardInfo->setLabel(tr("Probed info"));
2449  m_cardInfo->setReadOnly(true);
2450 
2451  cardtype.addTargetedChild("V4L2ENC", m_device);
2452  cardtype.addTargetedChild("V4L2ENC", m_cardInfo);
2453 
2454  // Override database schema default, set schedgroup false
2455  cardtype.addTargetedChild("V4L2ENC", new SchedGroupFalse(m_parent));
2456 
2457  connect(m_device, qOverload<const QString&>(&StandardSetting::valueChanged),
2458  this, &V4L2encGroup::probeCard);
2459 
2460  const QString &device_name = m_device->getValue();
2461  if (!device_name.isEmpty())
2462  probeCard(device_name);
2463 }
2464 
2465 void V4L2encGroup::probeCard([[maybe_unused]] const QString &device_name)
2466 {
2467 #ifdef USING_V4L2
2468  QString card_name = tr("Failed to open");
2469  QString card_info = card_name;
2470  V4L2util v4l2(device_name);
2471 
2472  if (!v4l2.IsOpen())
2473  {
2474  m_driverName = tr("Failed to probe");
2475  return;
2476  }
2477  m_driverName = v4l2.DriverName();
2478  card_name = v4l2.CardName();
2479 
2480  if (!m_driverName.isEmpty())
2481  card_info = card_name + " [" + m_driverName + "]";
2482 
2483  m_cardInfo->setValue(card_info);
2484 
2485  if (m_device->getSubSettings()->empty())
2486  {
2487  auto* audioinput = new TunerCardAudioInput(m_parent, QString(), "V4L2");
2488  if (audioinput->fillSelections(device_name) > 1)
2489  {
2490  audioinput->setName("AudioInput");
2491  m_device->addTargetedChild(m_driverName, audioinput);
2492  }
2493  else
2494  delete audioinput;
2495 
2496  if (v4l2.HasSlicedVBI())
2497  {
2498  auto* vbidev = new VBIDevice(m_parent);
2499  if (vbidev->setFilter(card_name, m_driverName) > 0)
2500  {
2501  vbidev->setName("VBIDevice");
2503  }
2504  else
2505  delete vbidev;
2506  }
2507 
2510  new ChannelTimeout(m_parent, 15s, 2s));
2511  }
2512 #endif // USING_V4L2
2513 }
2514 
2516 {
2517  setLabel(QObject::tr("Capture Card Setup"));
2518 
2519  auto* cardtype = new CardType(parent);
2520  parent.addChild(cardtype);
2521 
2522 #ifdef USING_DVB
2523  cardtype->addTargetedChild("DVB",
2524  new DVBConfigurationGroup(parent, *cardtype));
2525 #endif // USING_DVB
2526 
2527 #ifdef USING_V4L2
2528  cardtype->addTargetedChild("HDPVR",
2529  new HDPVRConfigurationGroup(parent, *cardtype));
2530 #endif // USING_V4L2
2531 
2532 #ifdef USING_HDHOMERUN
2533  cardtype->addTargetedChild("HDHOMERUN",
2534  new HDHomeRunConfigurationGroup(parent, *cardtype));
2535 #endif // USING_HDHOMERUN
2536 
2537 #ifdef USING_VBOX
2538  cardtype->addTargetedChild("VBOX",
2539  new VBoxConfigurationGroup(parent, *cardtype));
2540 #endif // USING_VBOX
2541 
2542 #ifdef USING_SATIP
2543  cardtype->addTargetedChild("SATIP",
2544  new SatIPConfigurationGroup(parent, *cardtype));
2545 #endif // USING_SATIP
2546 
2547 #ifdef USING_FIREWIRE
2548  FirewireConfigurationGroup(parent, *cardtype);
2549 #endif // USING_FIREWIRE
2550 
2551 #ifdef USING_CETON
2552  CetonSetting::CetonConfigurationGroup(parent, *cardtype);
2553 #endif // USING_CETON
2554 
2555 #ifdef USING_IPTV
2556  IPTVConfigurationGroup(parent, *cardtype);
2557 #endif // USING_IPTV
2558 
2559 #ifdef USING_V4L2
2560  cardtype->addTargetedChild("V4L2ENC", new V4L2encGroup(parent, *cardtype));
2561  cardtype->addTargetedChild("V4L",
2562  new V4LConfigurationGroup(parent, *cardtype, "V4L"));
2563  cardtype->addTargetedChild("MJPEG",
2564  new V4LConfigurationGroup(parent, *cardtype, "MJPEG"));
2565  cardtype->addTargetedChild("GO7007",
2566  new V4LConfigurationGroup(parent, *cardtype, "GO7007"));
2567  cardtype->addTargetedChild("MPEG",
2568  new MPEGConfigurationGroup(parent, *cardtype));
2569 #endif // USING_V4L2
2570 
2571 #ifdef USING_ASI
2572  cardtype->addTargetedChild("ASI",
2573  new ASIConfigurationGroup(parent, *cardtype));
2574 #endif // USING_ASI
2575 
2576  // for testing without any actual tuner hardware:
2577  cardtype->addTargetedChild("IMPORT",
2578  new ImportConfigurationGroup(parent, *cardtype));
2579  cardtype->addTargetedChild("DEMO",
2580  new DemoConfigurationGroup(parent, *cardtype));
2581 #if !defined( USING_MINGW ) && !defined( _MSC_VER )
2582  cardtype->addTargetedChild("EXTERNAL",
2583  new ExternalConfigurationGroup(parent,
2584  *cardtype));
2585 #endif
2586 }
2587 
2588 CaptureCard::CaptureCard(bool use_card_group)
2589  : m_id(new ID)
2590 {
2591  addChild(m_id);
2592  if (use_card_group)
2593  CaptureCardGroup(*this);
2594  addChild(new Hostname(*this));
2595 }
2596 
2597 QString CaptureCard::GetRawCardType(void) const
2598 {
2599  int cardid = getCardID();
2600  if (cardid <= 0)
2601  return {};
2602  return CardUtil::GetRawInputType(cardid);
2603 }
2604 
2606 {
2607  MSqlQuery query(MSqlQuery::InitCon());
2608  QString qstr =
2609  "SELECT cardid, videodevice, cardtype, displayname "
2610  "FROM capturecard "
2611  "WHERE hostname = :HOSTNAME AND parentid = 0 "
2612  "ORDER BY cardid";
2613 
2614  query.prepare(qstr);
2615  query.bindValue(":HOSTNAME", gCoreContext->GetHostName());
2616 
2617  if (!query.exec())
2618  {
2619  MythDB::DBError("CaptureCard::fillSelections", query);
2620  return;
2621  }
2622 
2624 
2625  while (query.next())
2626  {
2627  uint cardid = query.value(0).toUInt();
2628  QString videodevice = query.value(1).toString();
2629  QString cardtype = query.value(2).toString();
2630  QString displayname = query.value(3).toString();
2631 
2632  QString label = QString("%1 (%2)")
2633  .arg(CardUtil::GetDeviceLabel(cardtype, videodevice), displayname);
2634 
2635  auto *card = new CaptureCard();
2636  card->loadByID(cardid);
2637  card->setLabel(label);
2638  setting->addChild(card);
2639  }
2640 }
2641 
2642 void CaptureCard::loadByID(int cardid)
2643 {
2644  m_id->setValue(cardid);
2645  Load();
2646 }
2647 
2649 {
2650  return true;
2651 }
2652 
2654 {
2656 }
2657 
2658 
2660 {
2661  uint init_cardid = getCardID();
2662  QString init_dev = CardUtil::GetVideoDevice(init_cardid);
2663 
2665 
2667 
2669 
2670  uint cardid = getCardID();
2671  QString type = CardUtil::GetRawInputType(cardid);
2672  QString dev = CardUtil::GetVideoDevice(cardid);
2673 
2674  if (dev != init_dev)
2675  {
2676  if (!init_dev.isEmpty())
2677  {
2678  uint init_groupid = CardUtil::GetDeviceInputGroup(init_cardid);
2679  CardUtil::UnlinkInputGroup(init_cardid, init_groupid);
2680  }
2681  if (!dev.isEmpty())
2682  {
2683  uint groupid =
2685  gCoreContext->GetHostName(), dev);
2686  CardUtil::LinkInputGroup(cardid, groupid);
2687  CardUtil::UnlinkInputGroup(0, groupid);
2688  }
2689  }
2690 
2691  // Handle any cloning we may need to do
2693  {
2694  std::vector<uint> clones = CardUtil::GetChildInputIDs(cardid);
2695  for (uint clone : clones)
2696  CardUtil::CloneCard(cardid, clone);
2697  }
2698 }
2699 
2701 {
2702  if (getCardID() == 0)
2703  {
2704  Save();
2705  Load();
2706  }
2707 }
2708 
2710  CaptureCardComboBoxSetting(parent, false, "cardtype")
2711 {
2712  setLabel(QObject::tr("Card type"));
2713  setHelpText(QObject::tr("Change the cardtype to the appropriate type for "
2714  "the capture card you are configuring."));
2715  fillSelections(this);
2716 }
2717 
2719 {
2720 #ifdef USING_DVB
2721  setting->addSelection(
2722  QObject::tr("DVB-T/S/C, ATSC or ISDB-T tuner card"), "DVB");
2723 #endif // USING_DVB
2724 
2725 #ifdef USING_V4L2
2726  setting->addSelection(
2727  QObject::tr("V4L2 encoder"), "V4L2ENC");
2728  setting->addSelection(
2729  QObject::tr("HD-PVR H.264 encoder"), "HDPVR");
2730 #endif // USING_V4L2
2731 
2732 #ifdef USING_HDHOMERUN
2733  setting->addSelection(
2734  QObject::tr("HDHomeRun networked tuner"), "HDHOMERUN");
2735 #endif // USING_HDHOMERUN
2736 
2737 #ifdef USING_SATIP
2738  setting->addSelection(
2739  QObject::tr("Sat>IP networked tuner"), "SATIP");
2740 #endif // USING_SATIP
2741 
2742 #ifdef USING_VBOX
2743  setting->addSelection(
2744  QObject::tr("V@Box TV Gateway networked tuner"), "VBOX");
2745 #endif // USING_VBOX
2746 
2747 #ifdef USING_FIREWIRE
2748  setting->addSelection(
2749  QObject::tr("FireWire cable box"), "FIREWIRE");
2750 #endif // USING_FIREWIRE
2751 
2752 #ifdef USING_CETON
2753  setting->addSelection(
2754  QObject::tr("Ceton Cablecard tuner"), "CETON");
2755 #endif // USING_CETON
2756 
2757 #ifdef USING_IPTV
2758  setting->addSelection(QObject::tr("IPTV recorder"), "FREEBOX");
2759 #endif // USING_IPTV
2760 
2761 #ifdef USING_V4L2
2762  setting->addSelection(
2763  QObject::tr("Analog to MPEG-2 encoder card (PVR-150/250/350, etc)"), "MPEG");
2764  setting->addSelection(
2765  QObject::tr("Analog to MJPEG encoder card (Matrox G200, DC10, etc)"), "MJPEG");
2766  setting->addSelection(
2767  QObject::tr("Analog to MPEG-4 encoder (Plextor ConvertX USB, etc)"),
2768  "GO7007");
2769  setting->addSelection(
2770  QObject::tr("Analog capture card"), "V4L");
2771 #endif // USING_V4L2
2772 
2773 #ifdef USING_ASI
2774  setting->addSelection(QObject::tr("DVEO ASI recorder"), "ASI");
2775 #endif
2776 
2777  setting->addSelection(QObject::tr("Import test recorder"), "IMPORT");
2778  setting->addSelection(QObject::tr("Demo test recorder"), "DEMO");
2779 #if !defined( USING_MINGW ) && !defined( _MSC_VER )
2780  setting->addSelection(QObject::tr("External (black box) recorder"),
2781  "EXTERNAL");
2782 #endif
2783 }
2784 
2786 {
2787  public:
2788  explicit InputName(const CardInput &parent) :
2789  MythUIComboBoxSetting(new CardInputDBStorage(this, parent, "inputname"))
2790  {
2791  setLabel(QObject::tr("Input name"));
2792  };
2793 
2794  void Load(void) override // StandardSetting
2795  {
2796  fillSelections();
2798  };
2799 
2801  clearSelections();
2802  addSelection(QObject::tr("(None)"), "None");
2803  auto *storage = dynamic_cast<CardInputDBStorage*>(GetStorage());
2804  if (storage == nullptr)
2805  return;
2806  uint cardid = storage->getInputID();
2807  QString type = CardUtil::GetRawInputType(cardid);
2808  QString device = CardUtil::GetVideoDevice(cardid);
2809  QStringList inputs;
2810  CardUtil::GetDeviceInputNames(device, type, inputs);
2811  while (!inputs.isEmpty())
2812  {
2813  addSelection(inputs.front());
2814  inputs.pop_front();
2815  }
2816  };
2817 };
2818 
2820 {
2821  public:
2823  {
2824  setLabel(QObject::tr("Delivery system"));
2825  setHelpText(QObject::tr(
2826  "This shows the delivery system (modulation), for instance DVB-T2, "
2827  "that you have selected when you configured the capture card. "
2828  "This must be the same as the modulation used by the video source. "));
2829  };
2830 };
2831 
2833 {
2835 
2836  public:
2837  explicit InputDisplayName(const CardInput &parent) :
2838  MythUITextEditSetting(new CardInputDBStorage(this, parent, "displayname")), m_parent(parent)
2839  {
2840  setLabel(QObject::tr("Display name"));
2841  setHelpText(QObject::tr(
2842  "This name is displayed on screen when Live TV begins "
2843  "and in various other places. Make sure the last two "
2844  "characters are unique for each input or use a "
2845  "slash ('/') to designate the unique portion."));
2846  };
2847  void Load(void) override {
2849  if (getValue().isEmpty())
2850  setValue(tr("Input %1").arg(m_parent.getInputID()));
2851  }
2852  private:
2854 };
2855 
2857 {
2858  public:
2859  CardInputComboBoxSetting(const CardInput &parent, const QString &setting) :
2860  MythUIComboBoxSetting(new CardInputDBStorage(this, parent, setting))
2861  {
2862  }
2863 };
2864 
2866 {
2867  public:
2868  explicit SourceID(const CardInput &parent) :
2869  CardInputComboBoxSetting(parent, "sourceid")
2870  {
2871  setLabel(QObject::tr("Video source"));
2872  addSelection(QObject::tr("(None)"), "0");
2873  };
2874 
2875  void Load(void) override // StandardSetting
2876  {
2877  fillSelections();
2879  };
2880 
2882  clearSelections();
2883  addSelection(QObject::tr("(None)"), "0");
2885  };
2886 };
2887 
2889 {
2890  public:
2891  InputGroup(const CardInput &parent, uint group_num) :
2892  m_cardInput(parent),
2893  m_groupNum(group_num)
2894  {
2895  setLabel(QObject::tr("Input group") +
2896  QString(" %1").arg(m_groupNum + 1));
2897  setHelpText(QObject::tr(
2898  "Leave as 'Generic' unless this input is shared with "
2899  "another device. Only one of the inputs in an input "
2900  "group will be allowed to record at any given time."));
2901  }
2902 
2903  void Load(void) override; // StandardSetting
2904 
2905  void Save(void) override // StandardSetting
2906  {
2907  uint inputid = m_cardInput.getInputID();
2908  uint new_groupid = getValue().toUInt();
2909 
2910  if (m_groupId && (m_groupId != new_groupid))
2912 
2913  if (new_groupid)
2914  CardUtil::LinkInputGroup(inputid, new_groupid);
2915  }
2916 
2917  virtual void Save(const QString& /*destination*/) { Save(); }
2918 
2919  private:
2923 };
2924 
2926 {
2927 #if 0
2928  LOG(VB_GENERAL, LOG_DEBUG, QString("InputGroup::Load() %1 %2")
2929  .arg(m_groupNum).arg(m_cardInput.getInputID()));
2930 #endif
2931 
2932  uint inputid = m_cardInput.getInputID();
2933  QMap<uint, uint> grpcnt;
2934  std::vector<QString> names;
2935  std::vector<uint> grpid;
2936  std::vector<uint> selected_groupids;
2937 
2938  names.push_back(QObject::tr("Generic"));
2939  grpid.push_back(0);
2940  grpcnt[0]++;
2941 
2942  MSqlQuery query(MSqlQuery::InitCon());
2943  query.prepare(
2944  "SELECT cardinputid, inputgroupid, inputgroupname "
2945  "FROM inputgroup "
2946  "WHERE inputgroupname LIKE 'user:%' "
2947  "ORDER BY inputgroupid, cardinputid, inputgroupname");
2948 
2949  if (!query.exec())
2950  {
2951  MythDB::DBError("InputGroup::Load()", query);
2952  }
2953  else
2954  {
2955  while (query.next())
2956  {
2957  uint groupid = query.value(1).toUInt();
2958  if ((inputid != 0U) && (query.value(0).toUInt() == inputid))
2959  selected_groupids.push_back(groupid);
2960 
2961  grpcnt[groupid]++;
2962 
2963  if (grpcnt[groupid] == 1)
2964  {
2965  names.push_back(query.value(2).toString().mid(5, -1));
2966  grpid.push_back(groupid);
2967  }
2968  }
2969  }
2970 
2971  // makes sure we select something
2972  m_groupId = 0;
2973  if (m_groupNum < selected_groupids.size())
2974  m_groupId = selected_groupids[m_groupNum];
2975 
2976 #if 0
2977  LOG(VB_GENERAL, LOG_DEBUG, QString("Group num: %1 id: %2")
2978  .arg(m_groupNum).arg(m_groupId));
2979  {
2980  QString msg;
2981  for (uint i = 0; i < selected_groupids.size(); i++)
2982  msg += QString("%1 ").arg(selected_groupids[i]);
2983  LOG(VB_GENERAL, LOG_DEBUG, msg);
2984  }
2985 #endif
2986 
2987  // add selections to combobox
2988  clearSelections();
2989  uint index = 0;
2990  for (size_t i = 0; i < names.size(); i++)
2991  {
2992  bool sel = (m_groupId == grpid[i]);
2993  index = (sel) ? i : index;
2994 
2995 #if 0
2996  LOG(VB_GENERAL, LOG_DEBUG, QString("grpid %1, name '%2', i %3, s %4")
2997  .arg(grpid[i]).arg(names[i]) .arg(index).arg(sel ? "T" : "F"));
2998 #endif
2999 
3000  addSelection(names[i], QString::number(grpid[i]), sel);
3001  }
3002 
3003 #if 0
3004  LOG(VB_GENERAL, LOG_DEBUG, QString("Group index: %1").arg(index));
3005 #endif
3006 
3007  if (!names.empty())
3008  setValue(index);
3009 
3011 }
3012 
3014 {
3015  public:
3016  explicit QuickTune(const CardInput &parent) :
3017  CardInputComboBoxSetting(parent, "quicktune")
3018  {
3019  setLabel(QObject::tr("Use quick tuning"));
3020  addSelection(QObject::tr("Never"), "0", true);
3021  addSelection(QObject::tr("Live TV only"), "1", false);
3022  addSelection(QObject::tr("Always"), "2", false);
3023  setHelpText(QObject::tr(
3024  "If enabled, MythTV will tune using only the "
3025  "MPEG program number. The program numbers "
3026  "change more often than DVB or ATSC tuning "
3027  "parameters, so this is slightly less reliable. "
3028  "This will also inhibit EIT gathering during "
3029  "Live TV and recording."));
3030  };
3031 };
3032 
3034 {
3035  public:
3036  explicit ExternalChannelCommand(const CardInput &parent) :
3037  MythUITextEditSetting(new CardInputDBStorage(this, parent, "externalcommand"))
3038  {
3039  setLabel(QObject::tr("External channel change command"));
3040  setValue("");
3041  setHelpText(QObject::tr("If specified, this command will be run to "
3042  "change the channel for inputs which have an external "
3043  "tuner device such as a cable box. The first argument "
3044  "will be the channel number."));
3045  };
3046 };
3047 
3049 {
3050  public:
3051  explicit PresetTuner(const CardInput &parent) :
3052  MythUITextEditSetting(new CardInputDBStorage(this, parent, "tunechan"))
3053  {
3054  setLabel(QObject::tr("Preset tuner to channel"));
3055  setValue("");
3056  setHelpText(QObject::tr("Leave this blank unless you have an external "
3057  "tuner that is connected to the tuner input of your card. "
3058  "If so, you will need to specify the preset channel for "
3059  "the signal (normally 3 or 4)."));
3060  };
3061 };
3062 
3063 void StartingChannel::SetSourceID(const QString &sourceid)
3064 {
3065  clearSelections();
3066  if (sourceid.isEmpty() || !sourceid.toUInt())
3067  return;
3068 
3069  // Get the existing starting channel
3070  auto *storage = dynamic_cast<CardInputDBStorage*>(GetStorage());
3071  if (storage == nullptr)
3072  return;
3073  int inputId = storage->getInputID();
3074  QString startChan = CardUtil::GetStartChannel(inputId);
3075 
3076  ChannelInfoList channels = ChannelUtil::GetAllChannels(sourceid.toUInt());
3077 
3078  if (channels.empty())
3079  {
3080  addSelection(tr("Please add channels to this source"),
3081  startChan.isEmpty() ? "0" : startChan);
3082  return;
3083  }
3084 
3085  // If there are channels sort them, then add theme
3086  // (selecting the old start channel if it is there).
3087  QString order = gCoreContext->GetSetting("ChannelOrdering", "channum");
3088  ChannelUtil::SortChannels(channels, order);
3089  bool has_visible = false;
3090  for (size_t i = 0; i < channels.size() && !has_visible; i++)
3091  has_visible |= channels[i].m_visible;
3092 
3093  for (auto & channel : channels)
3094  {
3095  const QString channum = channel.m_chanNum;
3096  bool sel = channum == startChan;
3097  if (!has_visible || channel.m_visible || sel)
3098  {
3099  addSelection(channum, channum, sel);
3100  }
3101  }
3102 }
3103 
3105 {
3106  public:
3107  explicit InputPriority(const CardInput &parent) :
3108  MythUISpinBoxSetting(new CardInputDBStorage(this, parent, "recpriority"),
3109  -99, 99, 1)
3110  {
3111  setLabel(QObject::tr("Input priority"));
3112  setValue(0);
3113  setHelpText(QObject::tr("If the input priority is not equal for "
3114  "all inputs, the scheduler may choose to record a show "
3115  "at a later time so that it can record on an input with "
3116  "a higher value."));
3117  };
3118 };
3119 
3121 {
3122  public:
3123  ScheduleOrder(const CardInput &parent, int _value) :
3124  MythUISpinBoxSetting(new CardInputDBStorage(this, parent, "schedorder"),
3125  0, 99, 1)
3126  {
3127  setLabel(QObject::tr("Schedule order"));
3128  setValue(_value);
3129  setHelpText(QObject::tr("If priorities and other factors are equal "
3130  "the scheduler will choose the available "
3131  "input with the lowest, non-zero value. "
3132  "Setting this value to zero will make the "
3133  "input unavailable to the scheduler."));
3134  };
3135 };
3136 
3138 {
3139  public:
3140  LiveTVOrder(const CardInput &parent, int _value) :
3141  MythUISpinBoxSetting(new CardInputDBStorage(this, parent, "livetvorder"),
3142  0, 99, 1)
3143  {
3144  setLabel(QObject::tr("Live TV order"));
3145  setValue(_value);
3146  setHelpText(QObject::tr("When entering Live TV, the available, local "
3147  "input with the lowest, non-zero value will "
3148  "be used. If no local inputs are available, "
3149  "the available, remote input with the lowest, "
3150  "non-zero value will be used. "
3151  "Setting this value to zero will make the "
3152  "input unavailable to live TV."));
3153  };
3154 };
3155 
3157 {
3158  public:
3159  explicit DishNetEIT(const CardInput &parent) :
3160  MythUICheckBoxSetting(new CardInputDBStorage(this, parent,
3161  "dishnet_eit"))
3162  {
3163  setLabel(QObject::tr("Use DishNet long-term EIT data"));
3164  setValue(false);
3165  setHelpText(
3166  QObject::tr(
3167  "If you point your satellite dish toward DishNet's birds, "
3168  "you may wish to enable this feature. For best results, "
3169  "enable general EIT collection as well."));
3170  };
3171 };
3172 
3173 CardInput::CardInput(const QString & cardtype, const QString & device,
3174  int _cardid) :
3175  m_id(new ID()),
3176  m_inputName(new InputName(*this)),
3177  m_sourceId(new SourceID(*this)),
3178  m_startChan(new StartingChannel(*this)),
3179  m_scan(new ButtonStandardSetting(tr("Scan for channels"))),
3180  m_srcFetch(new ButtonStandardSetting(tr("Fetch channels from listings source"))),
3181  m_externalInputSettings(new DiSEqCDevSettings()),
3182  m_inputGrp0(new InputGroup(*this, 0)),
3183  m_inputGrp1(new InputGroup(*this, 1))
3184 {
3185  addChild(m_id);
3186 
3188  {
3190  _cardid, true));
3191  }
3192 
3193  // Delivery system for DVB, input name for other,
3194  // same field capturecard/inputname for both
3195  if ("DVB" == cardtype)
3196  {
3197  auto *ds = new DeliverySystem();
3198  ds->setValue(CardUtil::GetDeliverySystemFromDB(_cardid));
3199  addChild(ds);
3200  }
3201  else if (CardUtil::IsV4L(cardtype))
3202  {
3204  }
3205  addChild(new InputDisplayName(*this));
3207 
3208  if (CardUtil::IsEncoder(cardtype) || CardUtil::IsUnscanable(cardtype))
3209  {
3210  addChild(new ExternalChannelCommand(*this));
3211  if (CardUtil::HasTuner(cardtype, device))
3212  addChild(new PresetTuner(*this));
3213  }
3214  else
3215  {
3216  addChild(new QuickTune(*this));
3217  if ("DVB" == cardtype)
3218  addChild(new DishNetEIT(*this));
3219  }
3220 
3222  tr("Use channel scanner to find channels for this input."));
3223 
3225  tr("This uses the listings data source to "
3226  "provide the channels for this input.") + " " +
3227  tr("This can take a long time to run."));
3228 
3229  addChild(m_scan);
3231 
3233 
3234  auto *interact = new GroupSetting();
3235 
3236  interact->setLabel(QObject::tr("Interactions between inputs"));
3237  if (CardUtil::IsTunerSharingCapable(cardtype))
3238  {
3239  m_instanceCount = new InstanceCount(*this);
3240  interact->addChild(m_instanceCount);
3241  m_schedGroup = new SchedGroup(*this);
3242  interact->addChild(m_schedGroup);
3243  }
3244  interact->addChild(new InputPriority(*this));
3245  interact->addChild(new ScheduleOrder(*this, _cardid));
3246  interact->addChild(new LiveTVOrder(*this, _cardid));
3247 
3248  auto *ingrpbtn =
3249  new ButtonStandardSetting(QObject::tr("Create a New Input Group"));
3250  ingrpbtn->setHelpText(
3251  QObject::tr("Input groups are only needed when two or more cards "
3252  "share the same resource such as a FireWire card and "
3253  "an analog card input controlling the same set top box."));
3254  interact->addChild(ingrpbtn);
3255  interact->addChild(m_inputGrp0);
3256  interact->addChild(m_inputGrp1);
3257 
3258  addChild(interact);
3259 
3260  setObjectName("CardInput");
3261  SetSourceID("-1");
3262 
3265  connect(m_sourceId, qOverload<const QString&>(&StandardSetting::valueChanged),
3267  connect(m_sourceId, qOverload<const QString&>(&StandardSetting::valueChanged),
3268  this, &CardInput::SetSourceID);
3269  connect(ingrpbtn, &ButtonStandardSetting::clicked,
3271 }
3272 
3274 {
3276  {
3277  delete m_externalInputSettings;
3278  m_externalInputSettings = nullptr;
3279  }
3280 }
3281 
3282 void CardInput::SetSourceID(const QString &sourceid)
3283 {
3284  uint cid = m_id->getValue().toUInt();
3285  QString raw_card_type = CardUtil::GetRawInputType(cid);
3286  bool enable = (sourceid.toInt() > 0);
3287  m_scan->setEnabled(enable && !raw_card_type.isEmpty() &&
3288  !CardUtil::IsUnscanable(raw_card_type));
3289  m_srcFetch->setEnabled(enable);
3290 }
3291 
3292 QString CardInput::getSourceName(void) const
3293 {
3294  return m_sourceId->getValueLabel();
3295 }
3296 
3298 {
3299  m_inputGrp0->Save();
3300  m_inputGrp1->Save();
3301 
3302  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
3303  auto *settingdialog =
3304  new MythTextInputDialog(popupStack, tr("Enter new group name"));
3305 
3306  if (settingdialog->Create())
3307  {
3308  connect(settingdialog, &MythTextInputDialog::haveResult,
3310  popupStack->AddScreen(settingdialog);
3311  }
3312  else
3313  delete settingdialog;
3314 }
3315 
3316 void CardInput::CreateNewInputGroupSlot(const QString& name)
3317 {
3318  if (name.isEmpty())
3319  {
3320  ShowOkPopup(tr("Sorry, this Input Group name cannot be blank."));
3321  return;
3322  }
3323 
3324  QString new_name = QString("user:") + name;
3325 
3326  MSqlQuery query(MSqlQuery::InitCon());
3327  query.prepare("SELECT inputgroupname "
3328  "FROM inputgroup "
3329  "WHERE inputgroupname = :GROUPNAME");
3330  query.bindValue(":GROUPNAME", new_name);
3331 
3332  if (!query.exec())
3333  {
3334  MythDB::DBError("CreateNewInputGroup 1", query);
3335  return;
3336  }
3337 
3338  if (query.next())
3339  {
3340  ShowOkPopup(tr("Sorry, this Input Group name is already in use."));
3341  return;
3342  }
3343 
3344  uint inputgroupid = CardUtil::CreateInputGroup(new_name);
3345 
3346  m_inputGrp0->Load();
3347  m_inputGrp1->Load();
3348 
3349  if (m_inputGrp0->getValue().toUInt() == 0U)
3350  {
3352  m_inputGrp0->getValueIndex(QString::number(inputgroupid)));
3353  }
3354  else
3355  {
3357  m_inputGrp1->getValueIndex(QString::number(inputgroupid)));
3358  }
3359 }
3360 
3362 {
3363  uint srcid = m_sourceId->getValue().toUInt();
3364  uint crdid = m_id->getValue().toUInt();
3365  QString in = m_inputName->getValue();
3366 
3367 #ifdef USING_BACKEND
3368  uint num_channels_before = SourceUtil::GetChannelCount(srcid);
3369 
3370  Save(); // save info for scanner.
3371 
3372  QString cardtype = CardUtil::GetRawInputType(crdid);
3373  if (CardUtil::IsUnscanable(cardtype))
3374  {
3375  LOG(VB_GENERAL, LOG_ERR,
3376  QString("Sorry, %1 cards do not yet support scanning.")
3377  .arg(cardtype));
3378  return;
3379  }
3380 
3382  auto *ssd = new StandardSettingDialog(mainStack, "generalsettings",
3383  new ScanWizard(srcid, crdid, in));
3384 
3385  if (ssd->Create())
3386  {
3387  connect(ssd, &StandardSettingDialog::Exiting, this,
3388  [=]()
3389  {
3390  if (SourceUtil::GetChannelCount(srcid))
3391  m_startChan->SetSourceID(QString::number(srcid));
3392  if (num_channels_before)
3393  {
3394  m_startChan->Load();
3395  m_startChan->Save();
3396  }
3397  });
3398  mainStack->AddScreen(ssd);
3399  }
3400  else
3401  delete ssd;
3402 
3403 #else
3404  LOG(VB_GENERAL, LOG_ERR, "You must compile the backend "
3405  "to be able to scan for channels");
3406 #endif
3407 }
3408 
3410 {
3411  uint srcid = m_sourceId->getValue().toUInt();
3412  uint crdid = m_id->getValue().toUInt();
3413 
3414  uint num_channels_before = SourceUtil::GetChannelCount(srcid);
3415 
3416  if (crdid && srcid)
3417  {
3418  Save(); // save info for fetch..
3419 
3420  QString cardtype = CardUtil::GetRawInputType(crdid);
3421 
3422  if (!CardUtil::IsCableCardPresent(crdid, cardtype) &&
3423  !CardUtil::IsUnscanable(cardtype) &&
3424  !CardUtil::IsEncoder(cardtype) &&
3425  cardtype != "HDHOMERUN" &&
3426  !num_channels_before)
3427  {
3428  LOG(VB_GENERAL, LOG_ERR, "Skipping channel fetch, you need to "
3429  "scan for channels first.");
3430  return;
3431  }
3432 
3433  SourceUtil::UpdateChannelsFromListings(srcid, cardtype);
3434  }
3435 
3436  if (SourceUtil::GetChannelCount(srcid))
3437  m_startChan->SetSourceID(QString::number(srcid));
3438  if (num_channels_before)
3439  {
3440  m_startChan->Load();
3441  m_startChan->Save();
3442  }
3443 }
3444 
3446 {
3447  QString cardinputidTag(":WHERECARDID");
3448 
3449  QString query("cardid = " + cardinputidTag);
3450 
3451  bindings.insert(cardinputidTag, m_parent.getInputID());
3452 
3453  return query;
3454 }
3455 
3457 {
3458  QString cardinputidTag(":SETCARDID");
3459  QString colTag(":SET" + GetColumnName().toUpper());
3460 
3461  QString query("cardid = " + cardinputidTag + ", " +
3462  GetColumnName() + " = " + colTag);
3463 
3464  bindings.insert(cardinputidTag, m_parent.getInputID());
3465  bindings.insert(colTag, m_user->GetDBValue());
3466 
3467  return query;
3468 }
3469 
3470 void CardInput::loadByID(int inputid)
3471 {
3472  m_id->setValue(inputid);
3473  m_externalInputSettings->Load(inputid);
3475 }
3476 
3477 void CardInput::loadByInput(int _cardid, const QString& _inputname)
3478 {
3479  MSqlQuery query(MSqlQuery::InitCon());
3480  query.prepare("SELECT cardid FROM capturecard "
3481  "WHERE cardid = :CARDID AND inputname = :INPUTNAME");
3482  query.bindValue(":CARDID", _cardid);
3483  query.bindValue(":INPUTNAME", _inputname);
3484 
3485  if (query.exec() && query.isActive() && query.next())
3486  {
3487  loadByID(query.value(0).toInt());
3488  }
3489 }
3490 
3492 {
3493  uint cardid = m_id->getValue().toUInt();
3496 
3497  uint icount = 1;
3498  if (m_instanceCount)
3499  icount = m_instanceCount->getValue().toUInt();
3500 
3501  CardUtil::InputSetMaxRecordings(cardid, icount);
3502 }
3503 
3505 {
3506  return m_parent.getInputID();
3507 }
3508 
3510 {
3511  return m_parent.getCardID();
3512 }
3513 
3515 {
3516  emit Clicked(m_value);
3517 }
3518 
3519 void CaptureCardEditor::AddSelection(const QString &label, const CCESlot slot)
3520 {
3521  auto *button = new ButtonStandardSetting(label);
3522  connect(button, &ButtonStandardSetting::clicked, this, slot);
3523  addChild(button);
3524 }
3525 
3526 void CaptureCardEditor::AddSelection(const QString &label, const CCESlotConst slot)
3527 {
3528  auto *button = new ButtonStandardSetting(label);
3529  connect(button, &ButtonStandardSetting::clicked, this, slot);
3530  addChild(button);
3531 }
3532 
3534 {
3535  ShowOkPopup(
3536  tr("Are you sure you want to delete "
3537  "ALL capture cards on %1?").arg(gCoreContext->GetHostName()),
3539  true);
3540 }
3541 
3543 {
3544  ShowOkPopup(
3545  tr("Are you sure you want to delete "
3546  "ALL capture cards?"),
3548  true);
3549 }
3550 
3552 {
3553  auto *card = new CaptureCard();
3554  card->setLabel(tr("New capture card"));
3555  card->Load();
3556  addChild(card);
3557  emit settingsChanged(this);
3558 }
3559 
3561 {
3562  if (!doDelete)
3563  return;
3564 
3566  Load();
3567  emit settingsChanged(this);
3568 }
3569 
3571 {
3572  if (!doDelete)
3573  return;
3574 
3575  MSqlQuery cards(MSqlQuery::InitCon());
3576 
3577  cards.prepare(
3578  "SELECT cardid "
3579  "FROM capturecard "
3580  "WHERE hostname = :HOSTNAME");
3581  cards.bindValue(":HOSTNAME", gCoreContext->GetHostName());
3582 
3583  if (!cards.exec() || !cards.isActive())
3584  {
3585  ShowOkPopup(
3586  tr("Error getting list of cards for this host. "
3587  "Unable to delete capturecards for %1")
3588  .arg(gCoreContext->GetHostName()));
3589 
3590  MythDB::DBError("Selecting cardids for deletion", cards);
3591  return;
3592  }
3593 
3594  while (cards.next())
3595  CardUtil::DeleteInput(cards.value(0).toUInt());
3596 
3597  Load();
3598  emit settingsChanged(this);
3599 }
3600 
3602 {
3603  setLabel(tr("Capture cards"));
3604 }
3605 
3607 {
3608  clearSettings();
3609  AddSelection(QObject::tr("(New capture card)"), &CaptureCardEditor::AddNewCard);
3610  AddSelection(QObject::tr("(Delete all capture cards on %1)")
3611  .arg(gCoreContext->GetHostName()),
3613  AddSelection(QObject::tr("(Delete all capture cards)"),
3616 }
3617 
3619 {
3620  setLabel(tr("Video sources"));
3621 }
3622 
3624 {
3625  clearSettings();
3626  AddSelection(QObject::tr("(New video source)"), &VideoSourceEditor::NewSource);
3627  AddSelection(QObject::tr("(Delete all video sources)"),
3631 }
3632 
3633 void VideoSourceEditor::AddSelection(const QString &label, const VSESlot slot)
3634 {
3635  auto *button = new ButtonStandardSetting(label);
3636  connect(button, &ButtonStandardSetting::clicked, this, slot);
3637  addChild(button);
3638 }
3639 
3640 void VideoSourceEditor::AddSelection(const QString &label, const VSESlotConst slot)
3641 {
3642  auto *button = new ButtonStandardSetting(label);
3643  connect(button, &ButtonStandardSetting::clicked, this, slot);
3644  addChild(button);
3645 }
3646 
3648 {
3649  ShowOkPopup(
3650  tr("Are you sure you want to delete "
3651  "ALL video sources?"),
3653  true);
3654 }
3655 
3657 {
3658  if (!doDelete)
3659  return;
3660 
3662  Load();
3663  emit settingsChanged(this);
3664 }
3665 
3667 {
3668  auto *source = new VideoSource();
3669  source->setLabel(tr("New video source"));
3670  source->Load();
3671  addChild(source);
3672  emit settingsChanged(this);
3673 }
3674 
3676 {
3677  setLabel(tr("Input connections"));
3678 }
3679 
3681 {
3682  m_cardInputs.clear();
3683  clearSettings();
3684 
3685  // We do this manually because we want custom labels. If
3686  // SelectSetting provided a facility to edit the labels, we
3687  // could use CaptureCard::fillSelections
3688 
3689  MSqlQuery query(MSqlQuery::InitCon());
3690  query.prepare(
3691  "SELECT cardid, videodevice, cardtype, displayname "
3692  "FROM capturecard "
3693  "WHERE hostname = :HOSTNAME "
3694  " AND parentid = 0 "
3695  "ORDER BY cardid");
3696  query.bindValue(":HOSTNAME", gCoreContext->GetHostName());
3697 
3698  if (!query.exec())
3699  {
3700  MythDB::DBError("CardInputEditor::load", query);
3701  return;
3702  }
3703 
3704  while (query.next())
3705  {
3706  uint cardid = query.value(0).toUInt();
3707  QString videodevice = query.value(1).toString();
3708  QString cardtype = query.value(2).toString();
3709  QString displayname = query.value(3).toString();
3710 
3711  auto *cardinput = new CardInput(cardtype, videodevice, cardid);
3712  cardinput->loadByID(cardid);
3713  QString inputlabel = QString("%1 (%2) -> %3")
3714  .arg(CardUtil::GetDeviceLabel(cardtype, videodevice),
3715  displayname, cardinput->getSourceName());
3716  m_cardInputs.push_back(cardinput);
3717  cardinput->setLabel(inputlabel);
3718  addChild(cardinput);
3719  }
3720 
3722 }
3723 
3724 #ifdef USING_DVB
3725 static QString remove_chaff(const QString &name)
3726 {
3727  // Trim off some of the chaff.
3728  QString short_name = name;
3729  if (short_name.startsWith("LG Electronics"))
3730  short_name = short_name.right(short_name.length() - 15);
3731  if (short_name.startsWith("Oren"))
3732  short_name = short_name.right(short_name.length() - 5);
3733  if (short_name.startsWith("Nextwave"))
3734  short_name = short_name.right(short_name.length() - 9);
3735  if (short_name.startsWith("frontend", Qt::CaseInsensitive))
3736  short_name = short_name.left(short_name.length() - 9);
3737  if (short_name.endsWith("VSB/QAM"))
3738  short_name = short_name.left(short_name.length() - 8);
3739  if (short_name.endsWith("VSB"))
3740  short_name = short_name.left(short_name.length() - 4);
3741  if (short_name.endsWith("DVB-T"))
3742  short_name = short_name.left(short_name.length() - 6);
3743 
3744  // It would be infinitely better if DVB allowed us to query
3745  // the vendor ID. But instead we have to guess based on the
3746  // demodulator name. This means cards like the Air2PC HD5000
3747  // and DViCO Fusion HDTV cards are not identified correctly.
3748  short_name = short_name.simplified();
3749  if (short_name.startsWith("or51211", Qt::CaseInsensitive))
3750  short_name = "pcHDTV HD-2000";
3751  else if (short_name.startsWith("or51132", Qt::CaseInsensitive))
3752  short_name = "pcHDTV HD-3000";
3753  else if (short_name.startsWith("bcm3510", Qt::CaseInsensitive))
3754  short_name = "Air2PC v1";
3755  else if (short_name.startsWith("nxt2002", Qt::CaseInsensitive) ||
3756  short_name.startsWith("nxt200x", Qt::CaseInsensitive))
3757  short_name = "Air2PC v2";
3758  else if (short_name.startsWith("lgdt3302", Qt::CaseInsensitive))
3759  short_name = "DViCO HDTV3";
3760  else if (short_name.startsWith("lgdt3303", Qt::CaseInsensitive))
3761  short_name = "DViCO v2 or Air2PC v3 or pcHDTV HD-5500";
3762 
3763  return short_name;
3764 }
3765 #endif // USING_DVB
3766 
3767 void DVBConfigurationGroup::reloadDiseqcTree(const QString &videodevice)
3768 {
3769  if (m_diseqcTree)
3770  m_diseqcTree->Load(videodevice);
3771 
3772  if (m_cardType->getValue() == "DVB-S" ||
3773  m_cardType->getValue() == "DVB-S2" )
3774  {
3775  m_diseqcBtn->setVisible(true);
3776  }
3777  else
3778  {
3779  m_diseqcBtn->setVisible(false);
3780  }
3781  emit getParent()->settingsChanged(this);
3782 }
3783 
3784 void DVBConfigurationGroup::probeCard(const QString &videodevice)
3785 {
3786  if (videodevice.isEmpty())
3787  {
3788  m_cardName->setValue("");
3789  m_cardType->setValue("");
3790  return;
3791  }
3792 
3793  if ((m_parent.getCardID() != 0) && m_parent.GetRawCardType() != "DVB")
3794  {
3795  m_cardName->setValue("");
3796  m_cardType->setValue("");
3797  return;
3798  }
3799 
3800 #ifdef USING_DVB
3801  QString frontend_name = CardUtil::ProbeDVBFrontendName(videodevice);
3802  QString subtype = CardUtil::ProbeDVBType(videodevice);
3803 
3804  QString err_open = tr("Could not open card %1").arg(videodevice);
3805  QString err_other = tr("Could not get card info for card %1").arg(videodevice);
3806 
3807  switch (CardUtil::toInputType(subtype))
3808  {
3809  case CardUtil::ERROR_OPEN:
3810  m_cardName->setValue(err_open);
3811  m_cardType->setValue(strerror(errno));
3812  break;
3814  m_cardName->setValue(err_other);
3815  m_cardType->setValue("Unknown error");
3816  break;
3817  case CardUtil::ERROR_PROBE:
3818  m_cardName->setValue(err_other);
3819  m_cardType->setValue(strerror(errno));
3820  break;
3821  case CardUtil::QPSK:
3822  m_cardType->setValue("DVB-S");
3823  m_cardName->setValue(frontend_name);
3826  break;
3827  case CardUtil::DVBS2:
3828  m_cardType->setValue("DVB-S2");
3829  m_cardName->setValue(frontend_name);
3832  break;
3833  case CardUtil::QAM:
3834  m_cardType->setValue("DVB-C");
3835  m_cardName->setValue(frontend_name);
3838  break;
3839  case CardUtil::DVBT2:
3840  m_cardType->setValue("DVB-T2");
3841  m_cardName->setValue(frontend_name);
3844  break;
3845  case CardUtil::OFDM:
3846  {
3847  m_cardType->setValue("DVB-T");
3848  m_cardName->setValue(frontend_name);
3851  if (frontend_name.toLower().indexOf("usb") >= 0)
3852  {
3854  m_channelTimeout->setValueMs(42.5s);
3855  }
3856 
3857  // slow down tuning for buggy drivers
3858  if ((frontend_name == "DiBcom 3000P/M-C DVB-T") ||
3859  (frontend_name ==
3860  "TerraTec/qanu USB2.0 Highspeed DVB-T Receiver"))
3861  {
3862  m_tuningDelay->setValueMs(200ms);
3863  }
3864 
3865 #if 0 // frontends on hybrid DVB-T/Analog cards
3866  QString short_name = remove_chaff(frontend_name);
3867  m_buttonAnalog->setVisible(
3868  short_name.startsWith("zarlink zl10353",
3869  Qt::CaseInsensitive) ||
3870  short_name.startsWith("wintv hvr 900 m/r: 65008/a1c0",
3871  Qt::CaseInsensitive) ||
3872  short_name.startsWith("philips tda10046h",
3873  Qt::CaseInsensitive));
3874 #endif
3875  }
3876  break;
3877  case CardUtil::ATSC:
3878  {
3879  QString short_name = remove_chaff(frontend_name);
3880  m_cardType->setValue("ATSC");
3881  m_cardName->setValue(short_name);
3884 
3885  // According to #1779 and #1935 the AverMedia 180 needs
3886  // a 3000 ms signal timeout, at least for QAM tuning.
3887  if (frontend_name == "Nextwave NXT200X VSB/QAM frontend")
3888  {
3891  }
3892 
3893 #if 0 // frontends on hybrid DVB-T/Analog cards
3894  if (frontend_name.toLower().indexOf("usb") < 0)
3895  {
3896  m_buttonAnalog->setVisible(
3897  short_name.startsWith("pchdtv", Qt::CaseInsensitive) ||
3898  short_name.startsWith("dvico", Qt::CaseInsensitive) ||
3899  short_name.startsWith("nextwave", Qt::CaseInsensitive));
3900  }
3901 #endif
3902  }
3903  break;
3904  default:
3905  break;
3906  }
3907 
3908  // Create selection list of all delivery systems of this card
3909  {
3911  QStringList delsyslist = CardUtil::ProbeDeliverySystems(videodevice);
3912  for (const auto & item : qAsConst(delsyslist))
3913  {
3914  LOG(VB_GENERAL, LOG_DEBUG, QString("DVBCardType: add deliverysystem:%1")
3915  .arg(item));
3916 
3917  m_cardType->addSelection(item, item);
3918  }
3919 
3920  // Default value, used if not already defined in capturecard/inputname
3921  QString delsys = CardUtil::ProbeDefaultDeliverySystem(videodevice);
3922  if (!delsys.isEmpty())
3923  {
3924  m_cardType->setValue(delsys);
3925  }
3926  }
3927 #
3928 #else
3929  m_cardType->setValue(QString("Recompile with DVB-Support!"));
3930 #endif
3931 }
3932 
3934  QString dev, QString type) :
3935  CaptureCardComboBoxSetting(parent, false, "audiodevice"),
3936  m_lastDevice(std::move(dev)), m_lastCardType(std::move(type))
3937 {
3938  setLabel(QObject::tr("Audio input"));
3939  setHelpText(QObject::tr("If there is more than one audio input, "
3940  "select which one to use."));
3941  int cardid = parent.getCardID();
3942  if (cardid <= 0)
3943  return;
3944 
3947 }
3948 
3949 int TunerCardAudioInput::fillSelections(const QString &device)
3950 {
3951  clearSelections();
3952 
3953  if (device.isEmpty())
3954  return 0;
3955 
3956  m_lastDevice = device;
3957  QStringList inputs =
3959 
3960  for (uint i = 0; i < (uint)inputs.size(); i++)
3961  {
3962  addSelection(inputs[i], QString::number(i),
3963  m_lastDevice == QString::number(i));
3964  }
3965  return inputs.size();
3966 }
3967 
3969  CardType& cardType) :
3970  m_parent(a_parent),
3971  m_diseqcTree(new DiSEqCDevTree())
3972 {
3973  setVisible(false);
3974 
3975  m_cardNum = new DVBCardNum(m_parent);
3976  m_cardName = new DVBCardName();
3978 
3979  m_signalTimeout = new SignalTimeout(m_parent, 0.5s, 0.25s);
3980  m_channelTimeout = new ChannelTimeout(m_parent, 3s, 1.75s);
3981 
3982  cardType.addTargetedChild("DVB", m_cardNum);
3983 
3984  cardType.addTargetedChild("DVB", m_cardName);
3985  cardType.addTargetedChild("DVB", m_cardType);
3986 
3987  cardType.addTargetedChild("DVB", m_signalTimeout);
3988  cardType.addTargetedChild("DVB", m_channelTimeout);
3989 
3990  cardType.addTargetedChild("DVB", new EmptyAudioDevice(m_parent));
3991  cardType.addTargetedChild("DVB", new EmptyVBIDevice(m_parent));
3992 
3993  cardType.addTargetedChild("DVB", new DVBNoSeqStart(m_parent));
3994  cardType.addTargetedChild("DVB", new DVBOnDemand(m_parent));
3995  cardType.addTargetedChild("DVB", new DVBEITScan(m_parent));
3996 
3998  m_diseqcBtn->setLabel(tr("DiSEqC (Switch, LNB and Rotor Configuration)"));
3999  m_diseqcBtn->setHelpText(tr("Input and satellite settings."));
4000 
4002  cardType.addTargetedChild("DVB", m_tuningDelay);
4003  cardType.addTargetedChild("DVB", m_diseqcBtn);
4004  m_tuningDelay->setVisible(false);
4005 
4006  connect(m_cardNum, qOverload<const QString&>(&StandardSetting::valueChanged),
4008  connect(m_cardNum, qOverload<const QString&>(&StandardSetting::valueChanged),
4010 }
4011 
4013 {
4014  if (m_diseqcTree)
4015  {
4016  delete m_diseqcTree;
4017  m_diseqcTree = nullptr;
4018  }
4019 }
4020 
4022 {
4024  m_diseqcBtn->Load();
4026  if (m_cardType->getValue() == "DVB-S" ||
4027  m_cardType->getValue() == "DVB-S2" ||
4029  {
4030  m_diseqcBtn->setVisible(true);
4031  }
4032 }
4033 
4035 {
4039 }
4040 
4041 // -----------------------
4042 // SAT>IP configuration
4043 // -----------------------
4044 #ifdef USING_SATIP
4045 
4046 class DiSEqCPosition : public MythUISpinBoxSetting
4047 {
4048  public:
4049  explicit DiSEqCPosition(const CaptureCard &parent, int value, int min_val) :
4050  MythUISpinBoxSetting(new CaptureCardDBStorage(this, parent, "dvb_diseqc_type"),
4051  min_val, 0xff, 1)
4052  {
4053  setLabel(QObject::tr("DiSEqC position"));
4054  setHelpText(QObject::tr("Position of the LNB on the DiSEqC switch. "
4055  "Leave at 1 if there is no DiSEqC switch "
4056  "and the LNB is directly connected to the SatIP server. "
4057  "This value is used as signal source (attribute src) in "
4058  "the SatIP tune command."));
4059  setValue(value);
4060  };
4061 };
4062 
4063 SatIPConfigurationGroup::SatIPConfigurationGroup
4064  (CaptureCard& a_parent, CardType &a_cardtype) :
4065  m_parent(a_parent)
4066 {
4067  setVisible(false);
4068 
4069  FillDeviceList();
4070 
4071  m_friendlyName = new SatIPDeviceAttribute(tr("Friendly name"), tr("Friendly name of the Sat>IP server"));
4072  m_tunerType = new SatIPDeviceAttribute(tr("Tuner type"), tr("Type of the selected tuner"));
4073  m_tunerIndex = new SatIPDeviceAttribute(tr("Tuner index"), tr("Index of the tuner on the Sat>IP server"));
4074  m_deviceId = new SatIPDeviceID(m_parent);
4075 
4076  m_deviceIdList = new SatIPDeviceIDList(
4077  m_deviceId, m_friendlyName, m_tunerType, m_tunerIndex, &m_deviceList, m_parent);
4078 
4079  a_cardtype.addTargetedChild("SATIP", m_deviceIdList);
4080  a_cardtype.addTargetedChild("SATIP", m_friendlyName);
4081  a_cardtype.addTargetedChild("SATIP", m_tunerType);
4082  a_cardtype.addTargetedChild("SATIP", m_tunerIndex);
4083  a_cardtype.addTargetedChild("SATIP", m_deviceId);
4084  a_cardtype.addTargetedChild("SATIP", new SignalTimeout(m_parent, 7s, 1s));
4085  a_cardtype.addTargetedChild("SATIP", new ChannelTimeout(m_parent, 10s, 2s));
4086  a_cardtype.addTargetedChild("SATIP", new DVBEITScan(m_parent));
4087  a_cardtype.addTargetedChild("SATIP", new DiSEqCPosition(m_parent, 1, 1));
4088 
4089  connect(m_deviceIdList, &SatIPDeviceIDList::NewTuner,
4090  m_deviceId, &SatIPDeviceID::SetTuner);
4091 };
4092 
4093 void SatIPConfigurationGroup::FillDeviceList(void)
4094 {
4095  m_deviceList.clear();
4096 
4097  // Find devices on the network
4098  // Returns each devices as "deviceid friendlyname ip tunerno tunertype"
4099  QStringList devs = CardUtil::ProbeVideoDevices("SATIP");
4100 
4101  for (const auto & dev : qAsConst(devs))
4102  {
4103  QStringList devparts = dev.split(" ");
4104  const QString& id = devparts.value(0);
4105  const QString& name = devparts.value(1);
4106  const QString& ip = devparts.value(2);
4107  const QString& tunerno = devparts.value(3);
4108  const QString& tunertype = devparts.value(4);
4109 
4110  SatIPDevice device;
4111  device.m_deviceId = id;
4112  device.m_cardIP = ip;
4113  device.m_inUse = false;
4114  device.m_friendlyName = name;
4115  device.m_tunerNo = tunerno;
4116  device.m_tunerType = tunertype;
4117  device.m_mythDeviceId = QString("%1:%2:%3").arg(id, tunertype, tunerno);
4118 
4119  QString friendlyIdentifier = QString("%1, %2, Tuner #%3").arg(name, tunertype, tunerno);
4120 
4121  m_deviceList[device.m_mythDeviceId] = device;
4122 
4123  LOG(VB_CHANNEL, LOG_DEBUG, QString("SatIP: Add %1 '%2' '%3'")
4124  .arg(device.m_mythDeviceId, device.m_friendlyName, friendlyIdentifier));
4125  }
4126 
4127  // Now find configured devices
4128  // Returns each devices as "deviceid friendlyname ip tunerno tunertype"
4129  QStringList db = CardUtil::GetVideoDevices("SATIP");
4130  for (const auto& dev : db)
4131  {
4132  auto dit = m_deviceList.find(dev);
4133  if (dit != m_deviceList.end())
4134  {
4135  (*dit).m_inUse = true;
4136  }
4137  }
4138 };
4139 
4140 SatIPDeviceIDList::SatIPDeviceIDList(
4141  SatIPDeviceID *deviceId,
4142  SatIPDeviceAttribute *friendlyName,
4143  SatIPDeviceAttribute *tunerType,
4144  SatIPDeviceAttribute *tunerIndex,
4145  SatIPDeviceList *deviceList,
4146  const CaptureCard &parent) :
4147  m_deviceId(deviceId),
4148  m_friendlyName(friendlyName),
4149  m_tunerType(tunerType),
4150  m_tunerIndex(tunerIndex),
4151  m_deviceList(deviceList),
4152  m_parent(parent)
4153 {
4154  setLabel(tr("Available devices"));
4155  setHelpText(tr("Device IP or ID, tuner number and tuner type of available Sat>IP device"));
4156 
4157  connect(this, qOverload<const QString&>(&StandardSetting::valueChanged),
4158  this, &SatIPDeviceIDList::UpdateDevices);
4159 };
4160 
4161 void SatIPDeviceIDList::Load(void)
4162 {
4163  clearSelections();
4164 
4165  int cardid = m_parent.getCardID();
4166  QString device = CardUtil::GetVideoDevice(cardid);
4167 
4168  fillSelections(device);
4169 };
4170 
4171 void SatIPDeviceIDList::UpdateDevices(const QString &v)
4172 {
4173  SatIPDevice dev = (*m_deviceList)[v];
4174  m_deviceId->setValue(dev.m_mythDeviceId);
4175  m_friendlyName->setValue(dev.m_friendlyName);
4176  m_tunerType->setValue(dev.m_tunerType);
4177  m_tunerIndex->setValue(dev.m_tunerNo);
4178 };
4179 
4180 void SatIPDeviceIDList::fillSelections(const QString &cur)
4181 {
4182  clearSelections();
4183 
4184  std::vector<QString> names;
4185  std::vector<QString> devs;
4186  QMap<QString, bool> in_use;
4187 
4188  const QString& current = cur;
4189  QString sel;
4190 
4191  SatIPDeviceList::iterator it = m_deviceList->begin();
4192  for(; it != m_deviceList->end(); ++it)
4193  {
4194  QString friendlyIdentifier = QString("%1, %2, Tuner #%3")
4195  .arg((*it).m_friendlyName, (*it).m_tunerType, (*it).m_tunerNo);
4196  names.push_back(friendlyIdentifier);
4197 
4198  devs.push_back(it.key());
4199  in_use[it.key()] = (*it).m_inUse;
4200  }
4201 
4202  for (const auto& it2s : devs)
4203  {
4204  sel = (current == it2s) ? it2s : sel;
4205  }
4206 
4207  QString usestr = QString(" -- ");
4208  usestr += tr("Warning: already in use");
4209 
4210  for (uint i = 0; i < devs.size(); ++i)
4211  {
4212  const QString dev = devs[i];
4213  const QString name = names[i];
4214  bool dev_in_use = (dev == sel) ? false : in_use[devs[i]];
4215  QString desc = name + (dev_in_use ? usestr : "");
4216  addSelection(desc, dev, dev == sel);
4217  }
4218 };
4219 
4220 SatIPDeviceID::SatIPDeviceID(const CaptureCard &parent) :
4221  MythUITextEditSetting(new CaptureCardDBStorage(this, parent, "videodevice")),
4222  m_parent(parent)
4223 {
4224  setLabel(tr("Device ID"));
4225  setHelpText(tr("Device ID of the Sat>IP tuner"));
4226  setEnabled(true);
4227  setReadOnly(true);
4228 };
4229 
4230 void SatIPDeviceID::Load(void)
4231 {
4233 };
4234 
4235 void SatIPDeviceID::SetTuner(const QString &tuner)
4236 {
4237  setValue(tuner);
4238 };
4239 
4240 SatIPDeviceAttribute::SatIPDeviceAttribute(const QString& label, const QString& helptext)
4241 {
4242  setLabel(label);
4243  setHelpText(helptext);
4244 };
4245 #endif // USING_SATIP
XMLTVGrabber::m_lock
static QMutex m_lock
Definition: videosource.cpp:383
XMLTVGrabber::m_nameList
static QStringList m_nameList
Definition: videosource.cpp:384
HDPVRConfigurationGroup
Definition: videosource.h:555
DVBConfigurationGroup::m_diseqcBtn
DeviceTree * m_diseqcBtn
Definition: videosource.h:690
NoGrabber_config::NoGrabber_config
NoGrabber_config(const VideoSource &_parent)
Definition: videosource.cpp:690
DeviceTree
Definition: diseqcsettings.h:132
VBoxTunerIndex
Definition: videosource.h:965
VideoSourceShow::VideoSourceShow
VideoSourceShow(uint _initial_sourceid)
Definition: videosource.cpp:133
MSqlBindings
QMap< QString, QVariant > MSqlBindings
typedef for a map of string -> string bindings for generic queries.
Definition: mythdbcon.h:101
ASIConfigurationGroup::m_parent
CaptureCard & m_parent
Definition: videosource.h:603
MSqlQuery::isActive
bool isActive(void) const
Definition: mythdbcon.h:216
InputName
Definition: videosource.cpp:2785
HDHomeRunDeviceID::Save
void Save(void) override
Definition: videosource.cpp:1426
SourceID::fillSelections
void fillSelections()
Definition: videosource.cpp:2881
CardInput::m_inputName
InputName * m_inputName
Definition: videosource.h:928
MSqlQuery::next
bool next(void)
Wrap QSqlQuery::next() so we can display the query results.
Definition: mythdbcon.cpp:811
CardInput::m_inputGrp1
InputGroup * m_inputGrp1
Definition: videosource.h:935
V4L2encGroup::m_parent
CaptureCard & m_parent
Definition: videosource.h:582
MSqlQuery
QSqlQuery wrapper that fetches a DB connection from the connection pool.
Definition: mythdbcon.h:128
build_compdb.args
args
Definition: build_compdb.py:11
FirewireConfigurationGroup
static void FirewireConfigurationGroup(CaptureCard &parent, CardType &cardtype)
Definition: videosource.cpp:1377
MythMainWindow::GetMainStack
MythScreenStack * GetMainStack()
Definition: mythmainwindow.cpp:318
CardInputEditor::m_cardInputs
std::vector< CardInput * > m_cardInputs
Definition: videosource.h:874
MythUIComboBoxSetting::clearSelections
void clearSelections()
Definition: standardsettings.cpp:514
FirewireModel::SetGUID
void SetGUID(const QString &_guid)
Definition: videosource.cpp:1325
CardUtil::GetVBoxdesc
static QString GetVBoxdesc(const QString &id, const QString &ip, const QString &tunerNo, const QString &tunerType)
Get a nicely formatted string describing the device.
Definition: cardutil.cpp:3163
CardUtil::IsInNeedOfExternalInputConf
static bool IsInNeedOfExternalInputConf(uint inputid)
Definition: cardutil.cpp:2298
DVBConfigurationGroup::m_tuningDelay
DVBTuningDelay * m_tuningDelay
Definition: videosource.h:688
SchedGroup::SchedGroup
SchedGroup(const CardInput &parent)
Definition: videosource.cpp:194
HDHomeRunConfigurationGroup::HDHomeRunConfigurationGroup
HDHomeRunConfigurationGroup(CaptureCard &parent, CardType &cardtype)
Definition: videosource.cpp:1465
MSqlQuery::size
int size(void) const
Definition: mythdbcon.h:215
SourceUtil::DeleteSource
static bool DeleteSource(uint sourceid)
Definition: sourceutil.cpp:527
XMLTVGrabber::Save
void Save(void) override
Definition: videosource.cpp:344
CaptureCardEditor::CCESlot
void(CaptureCardEditor::*)(void) CCESlot
Definition: videosource.h:829
FirewireModel::FirewireModel
FirewireModel(const CaptureCard &parent, const FirewireGUID *_guid)
Definition: videosource.cpp:1295
CardInputComboBoxSetting::CardInputComboBoxSetting
CardInputComboBoxSetting(const CardInput &parent, const QString &setting)
Definition: videosource.cpp:2859
SourceID::SourceID
SourceID(const CardInput &parent)
Definition: videosource.cpp:2868
CetonSetting::UpdateDevices
void UpdateDevices(const QString &v)
Definition: videosource.cpp:2082
FreqTableSelector::FreqTableSelector
FreqTableSelector(const VideoSource &parent)
Definition: videosource.cpp:506
TransMythUICheckBoxSetting
Definition: standardsettings.h:411
remove_chaff
static QString remove_chaff(const QString &name)
Definition: videosource.cpp:3725
V4L2encGroup::m_driverName
QString m_driverName
Definition: videosource.h:586
CetonDeviceID::m_tuner
QString m_tuner
Definition: videosource.h:1075
DVBNetID
Definition: videosource.cpp:438
MythUIComboBoxSetting::fillSelectionsFromDir
void fillSelectionsFromDir(const QDir &dir, bool absPath=true)
Definition: standardsettings.cpp:609
HDHomeRunConfigurationGroup::GetDeviceCheckBoxes
QString GetDeviceCheckBoxes(void)
Definition: videosource.cpp:1557
V4LConfigurationGroup::V4LConfigurationGroup
V4LConfigurationGroup(CaptureCard &parent, CardType &cardtype, const QString &inputtype)
Definition: videosource.cpp:2183
CardUtil::GetDeviceLabel
static QString GetDeviceLabel(const QString &inputtype, const QString &videodevice)
Definition: cardutil.cpp:2625
StandardSetting::setValue
virtual void setValue(const QString &newValue)
Definition: standardsettings.cpp:170
VideoSourceEditor::Load
void Load(void) override
Definition: videosource.cpp:3623
VBoxDeviceID::m_tuner
QString m_tuner
Definition: videosource.h:1032
VBoxDevice::m_deviceId
QString m_deviceId
Definition: videosource.h:484
error
static void error(const char *str,...)
Definition: vbi.cpp:36
V4LConfigurationGroup
Definition: videosource.h:519
SignalTimeout::SignalTimeout
SignalTimeout(const CaptureCard &parent, std::chrono::milliseconds value, std::chrono::milliseconds min_val)
Definition: videosource.cpp:1033
FirewireDesc::m_guid
const FirewireGUID * m_guid
Definition: videosource.h:720
CardInputEditor::CardInputEditor
CardInputEditor()
Definition: videosource.cpp:3675
HDHomeRunEITScan::HDHomeRunEITScan
HDHomeRunEITScan(const CaptureCard &parent)
Definition: videosource.cpp:1435
QuickTune::QuickTune
QuickTune(const CardInput &parent)
Definition: videosource.cpp:3016
MPEGConfigurationGroup
Definition: videosource.h:538
mythdb.h
MythSystemLegacy
Definition: mythsystemlegacy.h:67
CardUtil::GetVideoDevices
static QStringList GetVideoDevices(const QString &rawtype, QString hostname=QString())
Returns the videodevices of the matching inputs, duplicates removed.
Definition: cardutil.cpp:394
CaptureCard::getCardID
int getCardID(void) const
Definition: videosource.h:736
false
VERBOSE_PREAMBLE false
Definition: verbosedefs.h:89
CardType::CardType
CardType(const CaptureCard &parent)
Definition: videosource.cpp:2709
CardUtil::ClearVideoDeviceCache
static void ClearVideoDeviceCache()
Definition: cardutil.cpp:439
CetonDeviceID::UpdateValues
void UpdateValues()
Definition: videosource.cpp:2130
XMLTVGrabber
Definition: videosource.cpp:260
VBoxDeviceIDList::m_deviceList
VBoxDeviceList * m_deviceList
Definition: videosource.h:1010
VideoSourceEditor::VSESlot
void(VideoSourceEditor::*)(void) VSESlot
Definition: videosource.h:853
InputDisplayName::InputDisplayName
InputDisplayName(const CardInput &parent)
Definition: videosource.cpp:2837
VideoSource
Definition: videosource.h:176
SourceUtil::GetChannelCount
static uint GetChannelCount(uint sourceid)
Definition: sourceutil.cpp:133
CardUtil::toInputType
static enum INPUT_TYPES toInputType(const QString &name)
Definition: cardutil.h:78
DTVDeviceConfigGroup
Definition: diseqcsettings.h:166
DBStorage::m_user
StorageUser * m_user
Definition: mythstorage.h:50
CetonSetting::LoadValue
void LoadValue(const QString &value)
Definition: videosource.cpp:2088
FirewireModel::m_guid
const FirewireGUID * m_guid
Definition: videosource.h:705
CardUtil::ERROR_UNKNOWN
@ ERROR_UNKNOWN
Definition: cardutil.h:52
CardUtil::DVBT2
@ DVBT2
Definition: cardutil.h:71
TransMythUIComboBoxSetting
Definition: standardsettings.h:272
UseEIT
Definition: videosource.cpp:599
UseHDHomeRunDevice::UseHDHomeRunDevice
UseHDHomeRunDevice(QString &deviceid, QString &model, QString &ipaddr)
Definition: videosource.cpp:1452
ScanFrequencyStart::ScanFrequencyStart
ScanFrequencyStart(const VideoSource &parent)
Definition: videosource.cpp:427
TransTextEditSetting
Definition: standardsettings.h:161
DishNetEIT
Definition: videosource.cpp:3156
CardUtil::GetASIDeviceNumber
static int GetASIDeviceNumber(const QString &device, QString *error=nullptr)
Definition: cardutil.cpp:3232
V4L2util::DriverName
QString DriverName(void) const
Definition: v4l2util.h:48
CardUtil::DeleteAllInputs
static bool DeleteAllInputs(void)
Definition: cardutil.cpp:2870
CommandPath
Definition: videosource.cpp:980
XMLTV_generic_config::m_grabber
QString m_grabber
Definition: videosource.h:134
VideoSource::canDelete
bool canDelete(void) override
Definition: videosource.cpp:725
ButtonStandardSetting
Definition: standardsettings.h:450
MPEGConfigurationGroup::m_cardInfo
GroupSetting * m_cardInfo
Definition: videosource.h:552
CetonDeviceID::SetTuner
void SetTuner(const QString &tuner)
Definition: videosource.cpp:2113
VideoSourceEditor::VideoSourceEditor
VideoSourceEditor()
Definition: videosource.cpp:3618
FirewireDevice::GetModelName
static QString GetModelName(uint vendor_id, uint model_id)
Definition: firewiredevice.cpp:350
FirewireDesc
Definition: videosource.h:708
VBoxDeviceIDList::m_parent
const CaptureCard & m_parent
Definition: videosource.h:1011
DVBConfigurationGroup::m_signalTimeout
SignalTimeout * m_signalTimeout
Definition: videosource.h:686
CaptureCardEditor::CCESlotConst
void(CaptureCardEditor::*)(void) const CCESlotConst
Definition: videosource.h:830
EITOnly_config
Definition: videosource.h:138
CardInput::CreateNewInputGroup
void CreateNewInputGroup()
Definition: videosource.cpp:3297
VideoSourceShow::Load
void Load(void) override
Definition: videosource.cpp:144
VideoSourceDBStorage
Definition: videosource.h:40
HDHomeRunConfigurationGroup::SetDeviceCheckBoxes
void SetDeviceCheckBoxes(const QString &devices)
Definition: videosource.cpp:1532
DVBConfigurationGroup::m_diseqcTree
DiSEqCDevTree * m_diseqcTree
Definition: videosource.h:689
XMLTVGrabber::LoadXMLTVGrabbers
void LoadXMLTVGrabbers(QStringList name_list, QStringList prog_list)
Definition: videosource.cpp:357
HDHomeRunConfigurationGroup::m_deviceList
HDHomeRunDeviceList m_deviceList
Definition: videosource.h:365
XMLTV_generic_config::Save
void Save(void) override
Definition: videosource.cpp:637
CetonSetting::CetonConfigurationGroup
static void CetonConfigurationGroup(CaptureCard &parent, CardType &cardtype)
Definition: videosource.cpp:2141
frequencies.h
CaptureCardDBStorage::GetSetClause
QString GetSetClause(MSqlBindings &bindings) const override
Definition: videosource.cpp:246
ExternalChannelCommand::ExternalChannelCommand
ExternalChannelCommand(const CardInput &parent)
Definition: videosource.cpp:3036
VideoSourceEditor::VSESlotConst
void(VideoSourceEditor::*)(void) const VSESlotConst
Definition: videosource.h:854
VBoxDeviceID
Definition: videosource.h:1016
DVBCardName::DVBCardName
DVBCardName()
Definition: videosource.cpp:1198
VideoDevice
Definition: videosource.cpp:794
VBoxDeviceIDList
Definition: videosource.h:986
DeviceTree::Load
void Load(void) override
Definition: diseqcsettings.cpp:1019
MSqlQuery::value
QVariant value(int i) const
Definition: mythdbcon.h:205
MythScreenStack
Definition: mythscreenstack.h:16
MythScreenType::Create
virtual bool Create(void)
Definition: mythscreentype.cpp:266
DVBConfigurationGroup::DVBConfigurationGroup
DVBConfigurationGroup(CaptureCard &a_parent, CardType &cardType)
Definition: videosource.cpp:3968
InstanceCount
Definition: videosource.cpp:171
VBIDevice
Definition: videosource.cpp:907
VBoxDevice::m_tunerType
QString m_tunerType
Definition: videosource.h:488
VideoSourceSelector::VideoSourceSelector
VideoSourceSelector(uint _initial_sourceid, QString _card_types, bool _must_have_mplexid)
Definition: videosource.cpp:64
CaptureCard::m_id
ID * m_id
Definition: videosource.h:774
TransFreqTableSelector::m_loadedFreqTable
QString m_loadedFreqTable
Definition: videosource.h:115
VBoxDevice::m_cardIp
QString m_cardIp
Definition: videosource.h:486
ASIDevice::fillSelections
void fillSelections(const QString &current)
Adds all available cards to list If current is >= 0 it will be considered available even if no device...
Definition: videosource.cpp:1819
DBStorage::GetColumnName
QString GetColumnName(void) const
Definition: mythstorage.h:47
XMLTV_generic_config::XMLTV_generic_config
XMLTV_generic_config(const VideoSource &_parent, const QString &_grabber, StandardSetting *_setting)
Definition: videosource.cpp:613
MSqlQuery::exec
bool exec(void)
Wrap QSqlQuery::exec() so we can display SQL.
Definition: mythdbcon.cpp:617
XMLTV_generic_config::m_grabberArgs
QStringList m_grabberArgs
Definition: videosource.h:135
ScanFrequencyStart
Definition: videosource.cpp:424
StartingChannel::SetSourceID
void SetSourceID(const QString &sourceid)
Definition: videosource.cpp:3063
StandardSetting::clearSettings
virtual void clearSettings()
Definition: standardsettings.cpp:160
DVBCardType::DVBCardType
DVBCardType(const CaptureCard &parent)
Definition: videosource.cpp:1185
VBoxDeviceID::Load
void Load(void) override
Definition: videosource.cpp:1663
StorageUser::GetDBValue
virtual QString GetDBValue(void) const =0
InputDisplayName::Load
void Load(void) override
Definition: videosource.cpp:2847
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:39
ASIConfigurationGroup::probeCard
void probeCard(const QString &device)
Definition: videosource.cpp:1904
SourceID
Definition: videosource.cpp:2865
StandardSetting::addTargetedChild
void addTargetedChild(const QString &value, StandardSetting *setting)
Definition: standardsettings.cpp:117
MythSystemLegacy::ReadAll
QByteArray & ReadAll()
Definition: mythsystemlegacy.cpp:402
MythScreenType
Screen in which all other widgets are contained and rendered.
Definition: mythscreentype.h:45
EmptyAudioDevice
Definition: videosource.h:276
firewiredevice.h
CaptureCardEditor::AddSelection
void AddSelection(const QString &label, CCESlot slot)
Definition: videosource.cpp:3519
AudioRateLimit::AudioRateLimit
AudioRateLimit(const CaptureCard &parent)
Definition: videosource.cpp:1081
GroupSetting::GroupSetting
GroupSetting()=default
CaptureCardEditor::Load
void Load(void) override
Definition: videosource.cpp:3606
ASIDevice::ASIDevice
ASIDevice(const CaptureCard &parent)
Definition: videosource.cpp:1809
mythdirs.h
CaptureCardButton::Clicked
void Clicked(const QString &choice)
VBoxDeviceID::SetTuner
void SetTuner(const QString &tuner)
Definition: videosource.cpp:1651
TunerCardAudioInput
Definition: videosource.h:260
InputDisplayName::Q_DECLARE_TR_FUNCTIONS
Q_DECLARE_TR_FUNCTIONS(InputDisplayName)
DiSEqCDevSettings::Load
bool Load(uint card_input_id)
Loads configuration chain from DB for specified card input id.
Definition: diseqc.cpp:128
ASIConfigurationGroup::m_cardInfo
TransTextEditSetting * m_cardInfo
Definition: videosource.h:605
DVBConfigurationGroup::m_cardName
DVBCardName * m_cardName
Definition: videosource.h:684
ExternalChannelCommand
Definition: videosource.cpp:3033
HTTPRequest::TestMimeType
static QString TestMimeType(const QString &sFileName)
Definition: httprequest.cpp:1014
DVBNoSeqStart::DVBNoSeqStart
DVBNoSeqStart(const CaptureCard &parent)
Definition: videosource.cpp:1211
FileDevice
Definition: videosource.cpp:994
V4L2encGroup::m_cardInfo
GroupSetting * m_cardInfo
Definition: videosource.h:583
SignalTimeout::SignalTimeout
SignalTimeout(const CaptureCard &parent, std::chrono::milliseconds value, std::chrono::duration< T > min_secs)
Definition: videosource.cpp:1045
GENERIC_EXIT_OK
@ GENERIC_EXIT_OK
Exited with no error.
Definition: exitcodes.h:11
CaptureCardTextEditSetting
Definition: videosource.cpp:414
VBoxDevice
Definition: videosource.h:480
ASIDevice::Load
void Load(void) override
Definition: videosource.cpp:1874
VBoxTunerIndex::setEnabled
void setEnabled(bool e) override
Definition: videosource.cpp:1617
CardUtil::CloneCard
static uint CloneCard(uint src_inputid, uint dst_inputid)
Definition: cardutil.cpp:1546
HDHomeRunDevice::m_deviceId
QString m_deviceId
Definition: videosource.h:339
VBIDevice::setFilter
uint setFilter(const QString &card, const QString &driver)
Definition: videosource.cpp:919
VideoSourceEditor::DeleteAllSources
void DeleteAllSources(bool doDelete)
Definition: videosource.cpp:3656
CardType::fillSelections
static void fillSelections(MythUIComboBoxSetting *setting)
Definition: videosource.cpp:2718
MythTextInputDialog::haveResult
void haveResult(QString)
ASIConfigurationGroup
Definition: videosource.h:592
InputGroup::m_cardInput
const CardInput & m_cardInput
Definition: videosource.cpp:2920
DVBConfigurationGroup::probeCard
void probeCard(const QString &videodevice)
Definition: videosource.cpp:3784
CaptureCardDBStorage::m_parent
const CaptureCard & m_parent
Definition: videosource.h:245
FirewireDevice::GetSTBList
static std::vector< AVCInfo > GetSTBList(void)
Definition: firewiredevice.cpp:363
XMLTVGrabber::m_parent
const VideoSource & m_parent
Definition: videosource.cpp:380
FirewireGUID::GetAVCInfo
AVCInfo GetAVCInfo(const QString &guid) const
Definition: videosource.cpp:1288
CardInput::loadByID
void loadByID(int id)
Definition: videosource.cpp:3470
VBoxIP
Definition: videosource.h:944
ScanWizard
Definition: scanwizard.h:44
IPTVHost::IPTVHost
IPTVHost(const CaptureCard &parent)
Definition: videosource.cpp:1785
HDHomeRunDeviceID
Definition: videosource.h:368
NoGrabber_config
Definition: videosource.h:150
VBoxDeviceList
QMap< QString, VBoxDevice > VBoxDeviceList
Definition: videosource.h:493
MythDate::current
QDateTime current(bool stripped)
Returns current Date and Time in UTC.
Definition: mythdate.cpp:14
TransFreqTableSelector::Load
void Load(void) override
Definition: videosource.cpp:529
DiSEqCDevTree::Exists
static bool Exists(int cardid)
Check if a Diseqc device tree exists.
Definition: diseqc.cpp:393
CaptureCardEditor::DeleteAllCaptureCards
void DeleteAllCaptureCards(bool doDelete)
Definition: videosource.cpp:3560
AVCInfo
Definition: avcinfo.h:22
true
VERBOSE_PREAMBLE Most true
Definition: verbosedefs.h:95
DemoConfigurationGroup
Definition: videosource.h:624
scanwizard.h
VBoxConfigurationGroup::FillDeviceList
void FillDeviceList(void)
Definition: videosource.cpp:2027
XMLTV_generic_config::RunConfig
void RunConfig(void)
Definition: videosource.cpp:654
AudioRateLimit
Definition: videosource.cpp:1078
QuickTune
Definition: videosource.cpp:3013
HDHomeRunEITScan
Definition: videosource.cpp:1432
CaptureCard::loadByID
void loadByID(int id)
Definition: videosource.cpp:2642
VBoxDevice::m_discovered
bool m_discovered
Definition: videosource.h:490
close
#define close
Definition: compat.h:43
tmp
static guint32 * tmp
Definition: goom_core.cpp:26
VideoSourceDBStorage::m_parent
const VideoSource & m_parent
Definition: videosource.h:54
EITOnly_config::Save
void Save(void) override
Definition: videosource.cpp:683
DVBEITScan
Definition: videosource.cpp:1238
CardInputDBStorage::GetWhereClause
QString GetWhereClause(MSqlBindings &bindings) const override
Definition: videosource.cpp:3445
mythsystemlegacy.h
CardInput::m_srcFetch
ButtonStandardSetting * m_srcFetch
Definition: videosource.h:932
CaptureCardDBStorage::getCardID
int getCardID(void) const
Definition: videosource.cpp:3509
CardUtil::ProbeDefaultDeliverySystem
static QString ProbeDefaultDeliverySystem(const QString &device)
Definition: cardutil.cpp:705
ButtonStandardSetting::clicked
void clicked()
V4LConfigurationGroup::m_parent
CaptureCard & m_parent
Definition: videosource.h:530
MPEGConfigurationGroup::m_parent
CaptureCard & m_parent
Definition: videosource.h:549
CardUtil::ProbeDVBType
static QString ProbeDVBType(const QString &device)
Definition: cardutil.cpp:721
ChannelUtil::SortChannels
static void SortChannels(ChannelInfoList &list, const QString &order, bool eliminate_duplicates=false)
Definition: channelutil.cpp:2320
ImportConfigurationGroup::m_size
GroupSetting * m_size
Definition: videosource.h:621
DemoConfigurationGroup::m_size
GroupSetting * m_size
Definition: videosource.h:637
TunerCardAudioInput::TunerCardAudioInput
TunerCardAudioInput(const CaptureCard &parent, QString dev=QString(), QString type=QString())
Definition: videosource.cpp:3933
DVBNetID::DVBNetID
DVBNetID(const VideoSource &parent, signed int value, signed int min_val)
Definition: videosource.cpp:441
LCNOffset::LCNOffset
LCNOffset(const VideoSource &parent, signed int value, signed int min_val)
Definition: videosource.cpp:492
CardUtil::ProbeVideoDevices
static QStringList ProbeVideoDevices(const QString &rawtype)
Definition: cardutil.cpp:445
DiSEqCDevSettings
DVB-S device settings class.
Definition: diseqc.h:36
DVBTuningDelay::DVBTuningDelay
DVBTuningDelay(const CaptureCard &parent)
Definition: videosource.cpp:1257
CetonDeviceID::SetIP
void SetIP(const QString &ip)
Definition: videosource.cpp:2101
CardUtil::ProbeDVBFrontendName
static QString ProbeDVBFrontendName(const QString &device)
Returns the input type from the video device.
Definition: cardutil.cpp:742
VideoDevice::Driver
QString Driver(void) const
Definition: videosource.cpp:898
VBoxDevice::m_inUse
bool m_inUse
Definition: videosource.h:489
VBoxDeviceIDList::m_cardIp
VBoxIP * m_cardIp
Definition: videosource.h:1008
InputName::fillSelections
void fillSelections()
Definition: videosource.cpp:2800
HDHomeRunDevice
Definition: videosource.h:336
StandardSetting::settingsChanged
void settingsChanged(StandardSetting *selectedSetting=nullptr)
StandardSettingDialog
Definition: standardsettings.h:468
StandardSetting::addChild
virtual void addChild(StandardSetting *child)
Definition: standardsettings.cpp:71
V4L2encGroup
Definition: videosource.h:574
CardUtil::DVBS2
@ DVBS2
Definition: cardutil.h:64
VideoSourceDBStorage::GetSetClause
QString GetSetClause(MSqlBindings &bindings) const override
Definition: videosource.cpp:221
StandardSetting::GetStorage
Storage * GetStorage(void) const
Definition: standardsettings.h:79
sourceutil.h
InputName::Load
void Load(void) override
Definition: videosource.cpp:2794
SourceUtil::UpdateChannelsFromListings
static bool UpdateChannelsFromListings(uint sourceid, const QString &inputtype=QString(), bool wait=false)
Definition: sourceutil.cpp:393
CardInputDBStorage::getInputID
int getInputID(void) const
Definition: videosource.cpp:3504
CardUtil::UnlinkInputGroup
static bool UnlinkInputGroup(uint inputid, uint inputgroupid)
Definition: cardutil.cpp:2145
ImportConfigurationGroup::probeCard
void probeCard(const QString &device)
Definition: videosource.cpp:1961
minor
#define minor(X)
Definition: compat.h:78
XMLTV_generic_config
Definition: videosource.h:118
VideoDevice::VideoDevice
VideoDevice(const CaptureCard &parent, uint minor_min=0, uint minor_max=UINT_MAX, const QString &card=QString(), const QRegularExpression &driver=QRegularExpression())
Definition: videosource.cpp:797
CardUtil::QPSK
@ QPSK
Definition: cardutil.h:54
VBoxDeviceID::VBoxDeviceID
VBoxDeviceID(const CaptureCard &parent)
Definition: videosource.cpp:1637
VBoxTunerIndex::VBoxTunerIndex
VBoxTunerIndex()
Definition: videosource.cpp:1608
dvbtypes.h
MPEGConfigurationGroup::m_vbiDevice
VBIDevice * m_vbiDevice
Definition: videosource.h:551
mythlogging.h
LCNOffset
Definition: videosource.cpp:489
RegionID
Definition: videosource.cpp:472
GetConfDir
QString GetConfDir(void)
Definition: mythdirs.cpp:256
StandardSetting::getSubSettings
virtual QList< StandardSetting * > * getSubSettings()
Definition: standardsettings.cpp:146
ScheduleOrder::ScheduleOrder
ScheduleOrder(const CardInput &parent, int _value)
Definition: videosource.cpp:3123
DVBCardName
Definition: videosource.cpp:1195
MythUIComboBoxSetting
Definition: standardsettings.h:218
CardUtil::IsEncoder
static bool IsEncoder(const QString &rawtype)
Definition: cardutil.h:135
TransFreqTableSelector::TransFreqTableSelector
TransFreqTableSelector(uint sourceid)
Definition: videosource.cpp:520
FreqTableSelector
Definition: videosource.h:91
ImportConfigurationGroup::ImportConfigurationGroup
ImportConfigurationGroup(CaptureCard &parent, CardType &cardtype)
Definition: videosource.cpp:1934
CardUtil::GetV4LInfo
static bool GetV4LInfo(int videofd, QString &input, QString &driver, uint32_t &version, uint32_t &capabilities)
Definition: cardutil.cpp:2342
InputGroup::Save
void Save(void) override
Definition: videosource.cpp:2905
CardInput::Save
void Save(void) override
Definition: videosource.cpp:3491
V4LConfigurationGroup::m_cardInfo
GroupSetting * m_cardInfo
Definition: videosource.h:531
AudioDevice::AudioDevice
AudioDevice(const CaptureCard &parent)
Definition: videosource.cpp:1009
HDPVRConfigurationGroup::HDPVRConfigurationGroup
HDPVRConfigurationGroup(CaptureCard &parent, CardType &cardtype)
Definition: videosource.cpp:2389
CardInput::CreateNewInputGroupSlot
void CreateNewInputGroupSlot(const QString &name)
Definition: videosource.cpp:3316
DemoConfigurationGroup::m_parent
CaptureCard & m_parent
Definition: videosource.h:635
v4l2util.h
VideoDevice::fillSelectionsFromDir
void fillSelectionsFromDir(const QDir &dir, [[maybe_unused]] bool absPath=true)
Definition: videosource.cpp:832
V4LConfigurationGroup::m_vbiDev
VBIDevice * m_vbiDev
Definition: videosource.h:532
CaptureCardButton::edit
void edit(MythScreenType *screen) override
Definition: videosource.cpp:3514
VideoDevice::fillSelectionsFromDir
uint fillSelectionsFromDir(const QDir &dir, uint minor_min, uint minor_max, const QString &card, const QRegularExpression &driver, bool allow_duplicates)
Definition: videosource.cpp:838
ASIConfigurationGroup::ASIConfigurationGroup
ASIConfigurationGroup(CaptureCard &parent, CardType &cardType)
Definition: videosource.cpp:1883
V4L2util::HasSlicedVBI
bool HasSlicedVBI(void) const
Definition: v4l2util.cpp:117
CardUtil::CreateDeviceInputGroup
static uint CreateDeviceInputGroup(uint inputid, const QString &type, const QString &host, const QString &device)
Definition: cardutil.cpp:2057
HDHomeRunDeviceID::HDHomeRunDeviceID
HDHomeRunDeviceID(const CaptureCard &parent, HDHomeRunConfigurationGroup &_group)
Definition: videosource.cpp:1411
BouquetID
Definition: videosource.cpp:455
Storage::Load
virtual void Load(void)=0
CardUtil::GetChildInputIDs
static std::vector< uint > GetChildInputIDs(uint inputid)
Definition: cardutil.cpp:1369
MSqlQuery::InitCon
static MSqlQueryInfo InitCon(ConnectionReuse _reuse=kNormalConnection)
Only use this in combination with MSqlQuery constructor.
Definition: mythdbcon.cpp:549
compat.h
StandardSetting::getParent
StandardSetting * getParent() const
Definition: standardsettings.h:49
HDPVRConfigurationGroup::probeCard
void probeCard(const QString &device)
Definition: videosource.cpp:2418
VBoxIP::setEnabled
void setEnabled(bool e) override
Definition: videosource.cpp:1587
MythDB::DBError
static void DBError(const QString &where, const MSqlQuery &query)
Definition: mythdb.cpp:226
VideoSource::m_name
Name * m_name
Definition: videosource.h:226
CardUtil::QAM
@ QAM
Definition: cardutil.h:55
PresetTuner
Definition: videosource.cpp:3048
HDHomeRunDevice::m_checkbox
UseHDHomeRunDevice * m_checkbox
Definition: videosource.h:342
VBoxDeviceIDList::fillSelections
void fillSelections(const QString &current)
Adds all available device-tuner combinations to list.
Definition: videosource.cpp:1697
StandardSetting::Load
virtual void Load(void)
Definition: standardsettings.cpp:214
CaptureCard::Save
void Save(void) override
Definition: videosource.cpp:2659
SourceID::Load
void Load(void) override
Definition: videosource.cpp:2875
CardInput::m_inputGrp0
InputGroup * m_inputGrp0
Definition: videosource.h:934
VideoSourceSelector::m_mustHaveMplexId
bool m_mustHaveMplexId
Definition: videosource.h:73
FirewireGUID::m_guidToAvcInfo
QMap< QString, AVCInfo > m_guidToAvcInfo
Definition: videosource.cpp:1292
VBoxConfigurationGroup
Definition: videosource.h:499
AudioDevice
Definition: videosource.cpp:1006
HDHomeRunDeviceID::Load
void Load(void) override
Definition: videosource.cpp:1420
NoGrabber_config::m_useEit
UseEIT * m_useEit
Definition: videosource.h:159
StandardSetting::setHelpText
virtual void setHelpText(const QString &str)
Definition: standardsettings.h:37
V4LConfigurationGroup::probeCard
void probeCard(const QString &device)
Definition: videosource.cpp:2213
CaptureCardEditor::ShowDeleteAllCaptureCardsDialogOnHost
void ShowDeleteAllCaptureCardsDialogOnHost(void) const
Definition: videosource.cpp:3533
MythSystemLegacy::Wait
uint Wait(std::chrono::seconds timeout=0s)
Definition: mythsystemlegacy.cpp:243
is_grabber_external
static bool is_grabber_external(const QString &grabber)
Definition: videosource.h:29
CardUtil::GetAudioDevice
static QString GetAudioDevice(uint inputid)
Definition: cardutil.h:296
vboxutils.h
CaptureCard
Definition: videosource.h:730
XMLTVGrabber::m_progList
static QStringList m_progList
Definition: videosource.cpp:385
EmptyVBIDevice
Definition: videosource.h:301
FirewireConnection
Definition: videosource.cpp:1348
DiSEqCDevTree::Load
bool Load(const QString &device)
Loads the device tree from the database.
Definition: diseqc.cpp:311
CaptureCard::ID
Definition: videosource.h:752
HDHomeRunDevice::m_model
QString m_model
Definition: videosource.h:340
CardInputComboBoxSetting
Definition: videosource.cpp:2856
ChannelTimeout::ChannelTimeout
ChannelTimeout(const CaptureCard &parent, std::chrono::milliseconds value, std::chrono::milliseconds min_val)
Definition: videosource.cpp:1058
MythUIComboBoxSetting::getValueIndex
int getValueIndex(const QString &value) const
Definition: standardsettings.cpp:488
CaptureCardGroup
Definition: videosource.h:723
StandardSetting::Save
virtual void Save(void)
Definition: standardsettings.cpp:233
VBoxDevice::m_mythDeviceId
QString m_mythDeviceId
Definition: videosource.h:483
HDPVRConfigurationGroup::m_parent
CaptureCard & m_parent
Definition: videosource.h:566
CardUtil::GetDeliverySystemFromDB
static QString GetDeliverySystemFromDB(uint inputid)
Definition: cardutil.h:300
CaptureCardButton::m_value
QString m_value
Definition: videosource.h:816
VideoSource::VideoSource
VideoSource()
Definition: videosource.cpp:708
VBoxIP::UpdateDevices
void UpdateDevices(const QString &v)
Definition: videosource.cpp:1602
CardUtil::HasTuner
static bool HasTuner(const QString &rawtype, const QString &device)
Definition: cardutil.cpp:213
CaptureCardEditor::CaptureCardEditor
CaptureCardEditor()
Definition: videosource.cpp:3601
XMLTVGrabber::XMLTVGrabber
XMLTVGrabber(const VideoSource &parent)
Definition: videosource.cpp:263
mythnotification.h
CaptureCard::CaptureCard
CaptureCard(bool use_card_group=true)
Definition: videosource.cpp:2588
AVCInfo::m_vendorid
uint m_vendorid
Definition: avcinfo.h:49
CardUtil::GetDeviceInputGroup
static uint GetDeviceInputGroup(uint inputid)
Definition: cardutil.cpp:2070
DishNetEIT::DishNetEIT
DishNetEIT(const CardInput &parent)
Definition: videosource.cpp:3159
VBoxDeviceID::SetIP
void SetIP(const QString &ip)
Definition: videosource.cpp:1645
CardInput::ID
Definition: videosource.h:919
StandardSetting::setReadOnly
virtual void setReadOnly(bool readonly)
Definition: standardsettings.cpp:54
ChannelTimeout::ChannelTimeout
ChannelTimeout(const CaptureCard &parent, std::chrono::milliseconds value, std::chrono::duration< T > min_secs)
Definition: videosource.cpp:1071
StandardSetting::getValue
virtual QString getValue(void) const
Definition: standardsettings.h:52
IPTVHost
Definition: videosource.cpp:1782
AVCInfo::m_product_name
QString m_product_name
Definition: avcinfo.h:52
CaptureCardEditor::ShowDeleteAllCaptureCardsDialog
void ShowDeleteAllCaptureCardsDialog(void) const
Definition: videosource.cpp:3542
DemoConfigurationGroup::probeCard
void probeCard(const QString &device)
Definition: videosource.cpp:2310
LiveTVOrder
Definition: videosource.cpp:3137
InputGroup::InputGroup
InputGroup(const CardInput &parent, uint group_num)
Definition: videosource.cpp:2891
CardInput::m_sourceId
SourceID * m_sourceId
Definition: videosource.h:929
CardInput::m_startChan
StartingChannel * m_startChan
Definition: videosource.h:930
FirewireSpeed
Definition: videosource.cpp:1361
uint
unsigned int uint
Definition: compat.h:81
gCoreContext
MythCoreContext * gCoreContext
This global variable contains the MythCoreContext instance for the app.
Definition: mythcorecontext.cpp:55
VBoxTunerIndex::UpdateDevices
void UpdateDevices(const QString &v)
Definition: videosource.cpp:1631
InputGroup
Definition: videosource.cpp:2888
V4L2encGroup::probeCard
void probeCard(const QString &device)
Definition: videosource.cpp:2465
CardInputDBStorage::m_parent
const CardInput & m_parent
Definition: videosource.h:796
CardUtil::ProbeDeliverySystems
static QStringList ProbeDeliverySystems(const QString &device)
IPTVConfigurationGroup
static void IPTVConfigurationGroup(CaptureCard &parent, CardType &cardType)
Definition: videosource.cpp:1798
CardUtil::IsV4L
static bool IsV4L(const QString &rawtype)
Definition: cardutil.h:145
DVBConfigurationGroup::Save
void Save(void) override
Definition: videosource.cpp:4034
CaptureCard::fillSelections
static void fillSelections(GroupSetting *setting)
Definition: videosource.cpp:2605
InstanceCount::InstanceCount
InstanceCount(const CardInput &parent)
Definition: videosource.cpp:174
DVBCardNum::Load
void Load(void) override
Definition: videosource.cpp:1169
DemoConfigurationGroup::m_info
GroupSetting * m_info
Definition: videosource.h:636
FirewireGUID
Definition: videosource.cpp:1270
CardUtil::InputSetMaxRecordings
static bool InputSetMaxRecordings(uint parentid, uint max_recordings)
Definition: cardutil.cpp:1557
VideoSourceSelector::m_cardTypes
QString m_cardTypes
Definition: videosource.h:72
CardInput::m_instanceCount
MythUISpinBoxSetting * m_instanceCount
Definition: videosource.h:936
VBoxConfigurationGroup::VBoxConfigurationGroup
VBoxConfigurationGroup(CaptureCard &parent, CardType &cardtype)
Definition: videosource.cpp:1995
kMSRunShell
@ kMSRunShell
run process through shell
Definition: mythsystem.h:43
VBIDevice::fillSelectionsFromDir
uint fillSelectionsFromDir(const QDir &dir, const QString &card, const QString &driver)
Definition: videosource.cpp:947
DVBConfigurationGroup::Load
void Load(void) override
Definition: videosource.cpp:4021
StandardSetting::setLabel
virtual void setLabel(QString str)
Definition: standardsettings.h:34
channelutil.h
CardInputDBStorage::GetSetClause
QString GetSetClause(MSqlBindings &bindings) const override
Definition: videosource.cpp:3456
VBoxIP::SetOldValue
void SetOldValue(const QString &s)
Definition: videosource.h:952
DVBConfigurationGroup::~DVBConfigurationGroup
~DVBConfigurationGroup() override
Definition: videosource.cpp:4012
CaptureCardSpinBoxSetting
Definition: videosource.cpp:393
VBoxDeviceIDList::Load
void Load(void) override
Definition: videosource.cpp:1745
DVBTuningDelay
Definition: videosource.cpp:1254
CardInput::SetSourceID
void SetSourceID(const QString &sourceid)
Definition: videosource.cpp:3282
StartingChannel
Definition: videosource.h:877
CardInput::~CardInput
~CardInput() override
Definition: videosource.cpp:3273
FirewireModel
Definition: videosource.h:694
CardInput
Definition: videosource.h:895
VBoxDevice::m_desc
QString m_desc
Definition: videosource.h:485
AVCInfo::m_modelid
uint m_modelid
Definition: avcinfo.h:50
CardType
Definition: videosource.h:326
CaptureCardDBStorage::GetWhereClause
QString GetWhereClause(MSqlBindings &bindings) const override
Definition: videosource.cpp:235
InputGroup::Load
void Load(void) override
Definition: videosource.cpp:2925
HDHomeRunConfigurationGroup::FillDeviceList
void FillDeviceList(void)
Definition: videosource.cpp:1495
VBoxDeviceIDList::m_cardTuner
VBoxTunerIndex * m_cardTuner
Definition: videosource.h:1009
CardUtil::GetDeviceName
static QString GetDeviceName(dvb_dev_type_t type, const QString &device)
Definition: cardutil.cpp:2945
ASIDevice
Definition: videosource.cpp:1806
gChanLists
const CHANLISTS_vec gChanLists
Definition: frequencies.cpp:2215
channelinfo.h
VBoxDeviceIDList::VBoxDeviceIDList
VBoxDeviceIDList(VBoxDeviceID *deviceid, StandardSetting *desc, VBoxIP *cardip, VBoxTunerIndex *cardtuner, VBoxDeviceList *devicelist, const CaptureCard &parent)
Definition: videosource.cpp:1673
DVBConfigurationGroup::m_cardNum
DVBCardNum * m_cardNum
Definition: videosource.h:683
CardUtil::GetRawInputType
static QString GetRawInputType(uint inputid)
Definition: cardutil.h:292
VideoSource::deleteEntry
void deleteEntry(void) override
Definition: videosource.cpp:730
CaptureCardTextEditSetting::CaptureCardTextEditSetting
CaptureCardTextEditSetting(const CaptureCard &parent, const QString &setting)
Definition: videosource.cpp:417
SignalTimeout::SignalTimeout
SignalTimeout(const CaptureCard &parent, std::chrono::duration< T > value, std::chrono::duration< T > min_secs)
Definition: videosource.cpp:1048
StandardSetting::valueChanged
void valueChanged(const QString &newValue)
ImportConfigurationGroup
Definition: videosource.h:608
VideoDevice::m_driverName
QString m_driverName
Definition: videosource.cpp:904
CetonSetting::CetonSetting
CetonSetting(QString label, const QString &helptext)
Definition: videosource.cpp:2074
lstat
#define lstat
Definition: compat.h:121
CaptureCardGroup::CaptureCardGroup
CaptureCardGroup(CaptureCard &parent)
Definition: videosource.cpp:2515
DVBOnDemand
Definition: videosource.cpp:1223
V4L2util::IsOpen
bool IsOpen(void) const
Definition: v4l2util.h:29
StandardSetting::setEnabled
virtual void setEnabled(bool enabled)
Definition: standardsettings.cpp:48
SkipBtAudio::SkipBtAudio
SkipBtAudio(const CaptureCard &parent)
Definition: videosource.cpp:1100
CardUtil::IsCableCardPresent
static bool IsCableCardPresent(uint inputid, const QString &inputType)
Definition: cardutil.cpp:105
MythUIComboBoxSetting::addSelection
void addSelection(const QString &label, QString value=QString(), bool select=false)
Definition: standardsettings.cpp:499
DiSEqCDevSettings::Store
bool Store(uint card_input_id) const
Stores configuration chain to DB for specified card input id.
Definition: diseqc.cpp:162
DiSEqCDev::InvalidateTrees
static void InvalidateTrees(void)
Invalidate cached trees.
Definition: diseqc.cpp:245
ScheduleOrder
Definition: videosource.cpp:3120
MythUITextEditSetting
Definition: standardsettings.h:146
CardInput::sourceFetch
void sourceFetch()
Definition: videosource.cpp:3409
MythUIFileBrowserSetting
Definition: standardsettings.h:187
VideoSource::getSourceID
int getSourceID(void) const
Definition: videosource.h:182
V4L2util
Definition: v4l2util.h:16
CardInput::channelScanner
void channelScanner()
Definition: videosource.cpp:3361
VBoxIP::m_oldValue
QString m_oldValue
Definition: videosource.h:962
DVBCardNum::fillSelections
void fillSelections(const QString &current)
Adds all available cards to list If current is >= 0 it will be considered available even if no device...
Definition: videosource.cpp:1130
mythcorecontext.h
MPEGConfigurationGroup::m_device
VideoDevice * m_device
Definition: videosource.h:550
VideoSource::ID
Definition: videosource.h:206
cardutil.h
CardInput::m_externalInputSettings
DiSEqCDevSettings * m_externalInputSettings
Definition: videosource.h:933
InputGroup::m_groupId
uint m_groupId
Definition: videosource.cpp:2922
InputName::InputName
InputName(const CardInput &parent)
Definition: videosource.cpp:2788
EITOnly_config::m_useEit
UseEIT * m_useEit
Definition: videosource.h:147
MPEGConfigurationGroup::MPEGConfigurationGroup
MPEGConfigurationGroup(CaptureCard &parent, CardType &cardtype)
Definition: videosource.cpp:2234
CetonDeviceID::m_ip
QString m_ip
Definition: videosource.h:1073
CaptureCardSpinBoxSetting::setValueMs
void setValueMs(std::chrono::milliseconds newValue)
Definition: videosource.cpp:406
MPEGConfigurationGroup::probeCard
void probeCard(const QString &device)
Definition: videosource.cpp:2262
VideoSourceSelector::Load
void Load(void) override
Definition: videosource.cpp:80
V4L2encGroup::m_device
VideoDevice * m_device
Definition: videosource.h:584
VideoSource::fillSelections
static void fillSelections(GroupSetting *setting)
Definition: videosource.cpp:757
ASIConfigurationGroup::m_device
ASIDevice * m_device
Definition: videosource.h:604
VideoSourceEditor::ShowDeleteAllSourcesDialog
void ShowDeleteAllSourcesDialog(void) const
Definition: videosource.cpp:3647
VideoSource::loadByID
void loadByID(int id)
Definition: videosource.cpp:789
MSqlQuery::bindValue
void bindValue(const QString &placeholder, const QVariant &val)
Add a single binding.
Definition: mythdbcon.cpp:887
InputDisplayName::m_parent
const CardInput & m_parent
Definition: videosource.cpp:2853
DVBConfigurationGroup::m_channelTimeout
ChannelTimeout * m_channelTimeout
Definition: videosource.h:687
std
Definition: mythchrono.h:23
VBoxConfigurationGroup::m_deviceList
VBoxDeviceList m_deviceList
Definition: videosource.h:516
CommandPath::CommandPath
CommandPath(const CaptureCard &parent)
Definition: videosource.cpp:983
V4L2encGroup::V4L2encGroup
V4L2encGroup(CaptureCard &parent, CardType &cardType)
Definition: videosource.cpp:2438
StandardSetting::isEnabled
bool isEnabled() const
Definition: standardsettings.h:45
FirewireSpeed::FirewireSpeed
FirewireSpeed(const CaptureCard &parent)
Definition: videosource.cpp:1364
VideoSource::m_id
ID * m_id
Definition: videosource.h:225
HDPVRConfigurationGroup::m_cardInfo
GroupSetting * m_cardInfo
Definition: videosource.h:567
CardInput::getSourceName
QString getSourceName(void) const
Definition: videosource.cpp:3292
SkipBtAudio
Definition: videosource.cpp:1097
DeliverySystem
Definition: videosource.cpp:2819
VBoxIP::VBoxIP
VBoxIP()
Definition: videosource.cpp:1578
VBoxDeviceID::SetOverrideDeviceID
void SetOverrideDeviceID(const QString &deviceid)
Definition: videosource.cpp:1657
CaptureCard::deleteEntry
void deleteEntry(void) override
Definition: videosource.cpp:2653
DVBConfigurationGroup::m_parent
CaptureCard & m_parent
Definition: videosource.h:681
CaptureCard::reload
void reload(void)
Definition: videosource.cpp:2700
CardUtil::ProbeAudioInputs
static QStringList ProbeAudioInputs(const QString &device, const QString &inputtype=QString())
Definition: cardutil.cpp:2529
CetonDeviceID::Load
void Load(void) override
Definition: videosource.cpp:2124
HDHomeRunConfigurationGroup
Definition: videosource.h:348
CardInputEditor::Load
void Load(void) override
Definition: videosource.cpp:3680
DVBOnDemand::DVBOnDemand
DVBOnDemand(const CaptureCard &parent)
Definition: videosource.cpp:1226
TransFreqTableSelector::SetSourceID
void SetSourceID(uint sourceid)
Definition: videosource.cpp:593
HDHomeRunDeviceID::m_group
HDHomeRunConfigurationGroup & m_group
Definition: videosource.h:379
VBoxTunerIndex::NewTuner
void NewTuner(const QString &)
InputDisplayName
Definition: videosource.cpp:2832
FirewireDesc::SetGUID
void SetGUID(const QString &_guid)
Definition: videosource.cpp:1334
IdSetting::setValue
void setValue(int value) override
Definition: videosource.h:171
CaptureCardEditor::AddNewCard
void AddNewCard(void)
Definition: videosource.cpp:3551
MythUISpinBoxSetting
Definition: standardsettings.h:328
GetMythMainWindow
MythMainWindow * GetMythMainWindow(void)
Definition: mythmainwindow.cpp:104
SchedGroupFalse
Definition: videosource.cpp:2171
DVBCardNum
Definition: videosource.cpp:1112
mythterminal.h
FileDevice::FileDevice
FileDevice(const CaptureCard &parent)
Definition: videosource.cpp:997
SourceUtil::DeleteAllSources
static bool DeleteAllSources(void)
Definition: sourceutil.cpp:583
DVBConfigurationGroup
Definition: videosource.h:662
VBoxIP::NewIP
void NewIP(const QString &)
CaptureCardSpinBoxSetting::setValueMs
void setValueMs(std::chrono::duration< T > newSecs)
Definition: videosource.cpp:410
CardUtil::IsTunerSharingCapable
static bool IsTunerSharingCapable(const QString &rawtype)
Definition: cardutil.h:177
CetonDeviceID::LoadedTuner
void LoadedTuner(const QString &)
InputGroup::Save
virtual void Save(const QString &)
Definition: videosource.cpp:2917
DiSEqCDevTree
DVB-S device tree class. Represents a tree of DVB-S devices.
Definition: diseqc.h:74
CardInput::m_schedGroup
MythUICheckBoxSetting * m_schedGroup
Definition: videosource.h:937
VBoxDeviceID::m_ip
QString m_ip
Definition: videosource.h:1031
BouquetID::BouquetID
BouquetID(const VideoSource &parent, signed int value, signed int min_val)
Definition: videosource.cpp:458
build_compdb.help
help
Definition: build_compdb.py:10
VBoxTunerIndex::m_oldValue
QString m_oldValue
Definition: videosource.h:983
TransFreqTableSelector::m_sourceId
uint m_sourceId
Definition: videosource.h:114
MythScreenType::Exiting
void Exiting()
CardUtil::OFDM
@ OFDM
Definition: cardutil.h:56
StandardSetting::m_visible
bool m_visible
Definition: standardsettings.h:117
UseEIT::UseEIT
UseEIT(const VideoSource &parent)
Definition: videosource.cpp:602
VideoSourceEditor::AddSelection
void AddSelection(const QString &label, VSESlot slot)
Definition: videosource.cpp:3633
CaptureCardComboBoxSetting
Definition: videosource.h:248
MythMainWindow::GetStack
MythScreenStack * GetStack(const QString &Stackname)
Definition: mythmainwindow.cpp:323
VideoSourceEditor::cardTypesInclude
static bool cardTypesInclude(int SourceID, const QString &thecardtype)
Definition: videosource.cpp:735
VBoxDevice::m_tunerNo
QString m_tunerNo
Definition: videosource.h:487
CetonDeviceID::CetonDeviceID
CetonDeviceID(const CaptureCard &parent)
Definition: videosource.cpp:2093
CaptureCardDBStorage
Definition: videosource.h:229
StandardSetting::setVisible
void setVisible(bool visible)
Definition: standardsettings.cpp:60
StandardSetting
Definition: standardsettings.h:29
DemoConfigurationGroup::DemoConfigurationGroup
DemoConfigurationGroup(CaptureCard &parent, CardType &cardtype)
Definition: videosource.cpp:2284
SourceUtil::GetListingsLoginData
static bool GetListingsLoginData(uint sourceid, QString &grabber, QString &userid, QString &passwd, QString &lineupid)
Definition: sourceutil.cpp:169
CaptureCardSpinBoxSetting::CaptureCardSpinBoxSetting
CaptureCardSpinBoxSetting(const CaptureCard &parent, std::chrono::milliseconds min_val, std::chrono::milliseconds max_val, std::chrono::milliseconds step, const QString &setting)
Definition: videosource.cpp:396
SchedGroup
Definition: videosource.cpp:191
MythCoreContext::GetHostName
QString GetHostName(void)
Definition: mythcorecontext.cpp:837
TransFreqTableSelector::Save
void Save(void) override
Definition: videosource.cpp:566
CardInput::m_scan
ButtonStandardSetting * m_scan
Definition: videosource.h:931
ChannelTimeout::ChannelTimeout
ChannelTimeout(const CaptureCard &parent, std::chrono::duration< T > value, std::chrono::duration< T > min_secs)
Definition: videosource.cpp:1074
HDPVRConfigurationGroup::m_audioInput
TunerCardAudioInput * m_audioInput
Definition: videosource.h:568
TunerCardAudioInput::m_lastCardType
QString m_lastCardType
Definition: videosource.h:273
DVB_DEV_FRONTEND
@ DVB_DEV_FRONTEND
Definition: cardutil.h:30
DiSEqCDevTree::Store
bool Store(uint cardid, const QString &device="")
Stores the device tree to the database.
Definition: diseqc.cpp:422
MythSystemLegacy::Run
void Run(std::chrono::seconds timeout=0s)
Runs a command inside the /bin/sh shell. Returns immediately.
Definition: mythsystemlegacy.cpp:213
TunerCardAudioInput::fillSelections
int fillSelections(const QString &device)
Definition: videosource.cpp:3949
DVBEITScan::DVBEITScan
DVBEITScan(const CaptureCard &parent)
Definition: videosource.cpp:1241
MythTerminal
Definition: mythterminal.h:25
HDHomeRunDevice::m_cardIp
QString m_cardIp
Definition: videosource.h:341
RegionID::RegionID
RegionID(const VideoSource &parent, signed int value, signed int min_val)
Definition: videosource.cpp:475
VideoDevice::m_minorList
QMap< uint, uint > m_minorList
Definition: videosource.cpp:902
SignalTimeout
Definition: videosource.cpp:1029
CardInput::getInputID
int getInputID(void) const
Definition: videosource.h:903
FirewireGUID::FirewireGUID
FirewireGUID(const CaptureCard &parent)
Definition: videosource.cpp:1273
CetonSetting::NewValue
void NewValue(const QString &)
CaptureCard::canDelete
bool canDelete(void) override
Definition: videosource.cpp:2648
MythUICheckBoxSetting
Definition: standardsettings.h:390
VBoxDeviceIDList::m_deviceId
VBoxDeviceID * m_deviceId
Definition: videosource.h:1006
EITOnly_config::EITOnly_config
EITOnly_config(const VideoSource &_parent, StandardSetting *_setting)
Definition: videosource.cpp:666
InputGroup::m_groupNum
uint m_groupNum
Definition: videosource.cpp:2921
kMSDontDisableDrawing
@ kMSDontDisableDrawing
avoid disabling UI drawing
Definition: mythsystem.h:37
CardInput::CardInput
CardInput(const QString &cardtype, const QString &device, int cardid)
Definition: videosource.cpp:3173
MythTextInputDialog
Dialog prompting the user to enter a text string.
Definition: mythdialogbox.h:314
SchedGroupFalse::SchedGroupFalse
SchedGroupFalse(const CaptureCard &parent)
Definition: videosource.cpp:2174
CardUtil::ATSC
@ ATSC
Definition: cardutil.h:57
VBoxDeviceIDList::UpdateDevices
void UpdateDevices(const QString &v)
Definition: videosource.cpp:1754
NoGrabber_config::Save
void Save(void) override
Definition: videosource.cpp:702
VideoSource::Name
Definition: videosource.h:214
VBoxTunerIndex::SetOldValue
void SetOldValue(const QString &s)
Definition: videosource.h:973
VBIDevice::VBIDevice
VBIDevice(const CaptureCard &parent)
Definition: videosource.cpp:910
exitcodes.h
CardUtil::IsUnscanable
static bool IsUnscanable(const QString &rawtype)
Definition: cardutil.h:158
DVBCardNum::DVBCardNum
DVBCardNum(const CaptureCard &parent)
Definition: videosource.cpp:1115
CardUtil::GetDeviceInputNames
static void GetDeviceInputNames(const QString &device, const QString &inputtype, QStringList &inputs)
Definition: cardutil.cpp:2647
VideoSource::getSourceName
QString getSourceName(void) const
Definition: videosource.h:190
ChannelUtil::GetAllChannels
static ChannelInfoList GetAllChannels(uint sourceid)
Returns channels that are not connected to an input and channels that are not marked as visible.
Definition: channelutil.h:264
PresetTuner::PresetTuner
PresetTuner(const CardInput &parent)
Definition: videosource.cpp:3051
build_compdb.filename
filename
Definition: build_compdb.py:21
CardInput::m_id
ID * m_id
Definition: videosource.h:927
V4L2util::CardName
QString CardName(void) const
Definition: v4l2util.h:49
VBoxDeviceID::m_overrideDeviceId
QString m_overrideDeviceId
Definition: videosource.h:1033
XMLTV_generic_config::m_parent
const VideoSource & m_parent
Definition: videosource.h:133
ChannelTimeout
Definition: videosource.cpp:1054
MythUIComboBoxSetting::getValueLabel
QString getValueLabel(void) const
Definition: standardsettings.cpp:493
MythUICheckBoxSetting::setValue
void setValue(const QString &newValue) override
Definition: standardsettings.cpp:721
VideoSourceEditor::NewSource
void NewSource(void)
Definition: videosource.cpp:3666
UseHDHomeRunDevice
Definition: videosource.cpp:1449
httprequest.h
XMLTVGrabber::Load
void Load(void) override
Definition: videosource.cpp:271
VideoDevice::Card
QString Card(void) const
Definition: videosource.cpp:899
MythScreenStack::AddScreen
virtual void AddScreen(MythScreenType *screen, bool allowFade=true)
Definition: mythscreenstack.cpp:52
VideoSourceSelector::m_initialSourceId
uint m_initialSourceId
Definition: videosource.h:71
LiveTVOrder::LiveTVOrder
LiveTVOrder(const CardInput &parent, int _value)
Definition: videosource.cpp:3140
DeliverySystem::DeliverySystem
DeliverySystem()
Definition: videosource.cpp:2822
ShowOkPopup
MythConfirmationDialog * ShowOkPopup(const QString &message, bool showCancel)
Non-blocking version of MythPopupBox::showOkPopup()
Definition: mythdialogbox.cpp:562
kMSStdOut
@ kMSStdOut
allow access to stdout
Definition: mythsystem.h:41
CetonDeviceID::LoadedIP
void LoadedIP(const QString &)
ImportConfigurationGroup::m_parent
CaptureCard & m_parent
Definition: videosource.h:619
VBoxDeviceIDList::m_desc
StandardSetting * m_desc
Definition: videosource.h:1007
VideoSourceShow::m_initialSourceId
uint m_initialSourceId
Definition: videosource.h:88
CardUtil::CreateInputGroup
static uint CreateInputGroup(const QString &name)
Definition: cardutil.cpp:2015
DVBCardType
Definition: videosource.cpp:1182
CardUtil::LinkInputGroup
static bool LinkInputGroup(uint inputid, uint inputgroupid)
Definition: cardutil.cpp:2094
videosource.h
ImportConfigurationGroup::m_info
GroupSetting * m_info
Definition: videosource.h:620
MythUIComboBoxSetting::setValue
void setValue(int value) override
Definition: standardsettings.cpp:479
CardUtil::GetStartChannel
static QString GetStartChannel(uint inputid)
Definition: cardutil.cpp:1783
CardInputDBStorage
Definition: videosource.h:777
CaptureCard::GetRawCardType
QString GetRawCardType(void) const
Definition: videosource.cpp:2597
VideoSourceDBStorage::GetWhereClause
QString GetWhereClause(MSqlBindings &bindings) const override
Definition: videosource.cpp:210
VBIDevice::fillSelectionsFromDir
void fillSelectionsFromDir(const QDir &dir, [[maybe_unused]] bool absPath=true)
Definition: videosource.cpp:941
VBoxDeviceIDList::m_oldValue
QString m_oldValue
Definition: videosource.h:1013
TunerCardAudioInput::m_lastDevice
QString m_lastDevice
Definition: videosource.h:272
InputPriority::InputPriority
InputPriority(const CardInput &parent)
Definition: videosource.cpp:3107
GroupSetting
Definition: standardsettings.h:435
find
static pid_list_t::iterator find(const PIDInfoMap &map, pid_list_t &list, pid_list_t::iterator begin, pid_list_t::iterator end, bool find_open)
Definition: dvbstreamhandler.cpp:363
diseqcsettings.h
CardUtil::ERROR_OPEN
@ ERROR_OPEN
Definition: cardutil.h:51
FirewireConnection::FirewireConnection
FirewireConnection(const CaptureCard &parent)
Definition: videosource.cpp:1351
DVBNoSeqStart
Definition: videosource.cpp:1208
CardUtil::GetVideoDevice
static QString GetVideoDevice(uint inputid)
Definition: cardutil.h:294
CetonDeviceID
Definition: videosource.h:1053
CaptureCard::Hostname
Definition: videosource.h:760
MythCoreContext::GetSetting
QString GetSetting(const QString &key, const QString &defaultval="")
Definition: mythcorecontext.cpp:897
InputPriority
Definition: videosource.cpp:3104
DVBConfigurationGroup::m_cardType
DVBCardType * m_cardType
Definition: videosource.h:685
MSqlQuery::prepare
bool prepare(const QString &query)
QSqlQuery::prepare() is not thread safe in Qt <= 3.3.2.
Definition: mythdbcon.cpp:836
VideoDevice::m_cardName
QString m_cardName
Definition: videosource.cpp:903
CardUtil::ERROR_PROBE
@ ERROR_PROBE
Definition: cardutil.h:53
DVBConfigurationGroup::reloadDiseqcTree
void reloadDiseqcTree(const QString &device)
Definition: videosource.cpp:3767
CaptureCardEditor::DeleteAllCaptureCardsOnHost
void DeleteAllCaptureCardsOnHost(bool doDelete)
Definition: videosource.cpp:3570
ChannelInfoList
std::vector< ChannelInfo > ChannelInfoList
Definition: channelinfo.h:131
CardUtil::DeleteInput
static bool DeleteInput(uint inputid)
Definition: cardutil.cpp:2800
CardInput::loadByInput
void loadByInput(int cardid, const QString &inputname)
Definition: videosource.cpp:3477