MythTV  master
dtvconfparserhelpers.h
Go to the documentation of this file.
1 /* -*- Mode: c++ -*-
2  * vim: set expandtab tabstop=4 shiftwidth=4:
3  *
4  * Original Project
5  * MythTV http://www.mythtv.org
6  *
7  * Author(s):
8  * John Pullan (john@pullan.org)
9  *
10  * Description:
11  * Collection of classes to provide dvb channel scanning
12  * functionallity
13  *
14  *
15  * This program is free software; you can redistribute it and/or
16  * modify it under the terms of the GNU General Public License
17  * as published by the Free Software Foundation; either version 2
18  * of the License, or (at your option) any later version.
19  *
20  * This program is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this program; if not, write to the Free Software
27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
28  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
29  *
30  */
31 
32 #ifndef _DTVCONFPARSERHELPERS_H_
33 #define _DTVCONFPARSERHELPERS_H_
34 
35 #include <QString>
36 #ifdef USING_DVB
37 #include <linux/dvb/frontend.h>
38 #endif
39 
40 // The following are a set of helper classes to allow easy translation
41 // between the different string representations of various tuning params.
42 
44 {
45  QString symbol;
46  int value;
47 };
48 
54 {
55  public:
56  explicit DTVParamHelper(int _value) : m_value(_value) { }
57  DTVParamHelper &operator=(int _value) { m_value = _value; return *this; }
58 
59  operator int() const { return m_value; }
60  bool operator==(const int& v) const { return m_value == v; }
61  bool operator!=(const int& v) const { return m_value != v; }
62 
63  protected:
64  static bool ParseParam(const QString &symbol, int &value,
65  const DTVParamHelperStruct *table);
66 
67  static QString toString(const char *strings[], int index,
68  uint strings_size);
69 
70  protected:
71  int m_value;
72 };
73 
75 {
77 
78  public:
79  // WARNING: kTunerTypes cannot be defined by a C++03 enum
80  // because gcc 4.3.3 will reportedly promote an enum inconsistently
81  // to int on IA-32 platforms. I don't know whether this is
82  // correct or not, it comes down to interpretation of section
83  // 7.2.5 and whether 0x80000000 should be considered to big
84  // for a 32 bit integer or not. Using an enum to represent int
85  // bitmasks is valid C code, but the C++03 standard was still a
86  // bit loosey gosey on this point. It looks like the breakage
87  // was caused by work in gcc to support C++0x which will allow
88  // one to specify things as exactly as C does. -- dtk 2009-10-05
89 
90  // // Modulations which may be supported
91  static const int kTunerTypeDVBS1; // QPSK
92  static const int kTunerTypeDVBS2; // QPSK, 8PSK, 16APSK, 32APSK
93  static const int kTunerTypeDVBC; // QAM-64, QAM-256
94  static const int kTunerTypeDVBT; // OFDM
95  static const int kTunerTypeDVBT2; // OFDM
96  static const int kTunerTypeATSC; // 8-VSB, 16-VSB,
97  // QAM-16, QAM-64, QAM-256, QPSK
98  static const int kTunerTypeASI; // baseband
99  static const int kTunerTypeOCUR; // Virtual Channel tuning of QAM-64/256
100  static const int kTunerTypeIPTV; // IPTV
101  static const int kTunerTypeUnknown;
102 
103  // Note: Just because some cards sold in different regions support the same
104  // modulation scheme does not mean that they decode the same signals, there
105  // are also region specific FEC algorithms and the tuner which precedes the
106  // demodulator may be limited to frequencies used in that specific market.
107  // The tuner may also be bandwidth limited to 6 or 7 Mhz, so it could not
108  // support the 8 Mhz channels used in some contries, and/or the ADC which
109  // sits between the tuner and the demodulator may be bandwidth limited.
110  // While often the same hardware could physically support more than it
111  // is designed for the card/device maker does not write the firmware
112  // but licenses blocks of it and so only selects the pieces absolutely
113  // necessary for their market segment. Some ATSC cards only supported
114  // 8-VSB, newer cards don't support the unpopular 16-VSB, no consumer
115  // card supports the QAM-16 or QPSK used for USA Cable PSIP, etc.
116  // DVB-S cards also generally support DiSEqC signaling, and future
117  // ATSC cards may support similar but incompatible signalling for
118  // pointable antennas.
119  //
120  // Note 2: These values are keyed to the Linux DVB driver values, in
121  // reality some hardware does support multiple formats and this should
122  // be a mask. Also the transmission schemes used in Asia and South
123  // America are not represented here.
124 
125  explicit DTVTunerType(int _default = kTunerTypeUnknown)
126  : DTVParamHelper(_default) { initStr(); }
127  DTVTunerType& operator=(int type) { m_value = type; return *this; }
128 
129  bool Parse(const QString &_value)
130  { return ParseParam(_value, m_value, kParseTable); }
131 
132  bool IsFECVariable(void) const
133  {
134  return ((kTunerTypeDVBC == m_value) ||
135  (kTunerTypeDVBS1 == m_value) ||
136  (kTunerTypeDVBS2 == m_value));
137  }
138 
139  bool IsModulationVariable(void) const
140  {
141  return ((kTunerTypeDVBC == m_value) ||
142  (kTunerTypeATSC == m_value) ||
143  (kTunerTypeDVBS2 == m_value));
144  }
145 
146  bool IsDiSEqCSupported(void) const
147  {
148  return ((kTunerTypeDVBS1 == m_value) ||
149  (kTunerTypeDVBS2 == m_value));
150  }
151 
152  QString toString() const { return toString(m_value); }
153 
154  static void initStr(void);
155  static QString toString(int _value);
156 };
157 
159 {
160  protected:
164  static const uint kDBStrCnt = 3;
165  static const char *s_dbStr[kDBStrCnt];
166 
167  public:
168  enum Types
169  {
173  };
174 #ifdef USING_DVB
175  static_assert((kInversionOff == (Types)INVERSION_OFF)
176  && (kInversionAuto == (Types)INVERSION_AUTO),
177  "Inversion types don't match DVB includes.");
178 #endif
179 
180  explicit DTVInversion(Types _default = kInversionAuto)
181  : DTVParamHelper(_default) { }
182  DTVInversion& operator=(const Types _value)
183  { m_value = _value; return *this; }
184 #ifdef USING_DVB
185  DTVInversion& operator=(const fe_spectral_inversion_t type)
186  { m_value = type; return *this; }
187 #endif
188 
189  bool IsCompatible(const DTVInversion &other) const
190  { return m_value == other.m_value || m_value == kInversionAuto ||
191  other.m_value == kInversionAuto;
192  }
193 
194  bool ParseConf(const QString &_value)
195  { return ParseParam(_value, m_value, kConfTable); }
196  bool ParseVDR(const QString &_value)
197  { return ParseParam(_value, m_value, kVdrTable); }
198  bool Parse(const QString &_value)
199  { return ParseParam(_value, m_value, kParseTable); }
200 
201  QString toString() const { return toString(m_value); }
202  QChar toChar() const
203  {
204  if (toString().length() > 0)
205  return toString()[0];
206  return {0};
207  }
208 
209  static QString toString(int _value)
210  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
211 };
212 
214 {
215  protected:
219  static const uint kDBStrCnt = 4;
220  static const char *s_dbStr[kDBStrCnt];
221 
222  public:
223  enum Types
224  {
229  };
230 #ifdef USING_DVB
231  static_assert((kBandwidth8MHz == (Types)BANDWIDTH_8_MHZ)
232  && (kBandwidthAuto == (Types)BANDWIDTH_AUTO),
233  "Bandwidth types don't match DVB includes.");
234 #endif
235 
236  explicit DTVBandwidth(Types _default = kBandwidthAuto)
237  : DTVParamHelper(_default) { }
238  DTVBandwidth& operator=(const Types _value)
239  { m_value = _value; return *this; }
240 #ifdef USING_DVB
241  DTVBandwidth& operator=(const fe_bandwidth_t bwidth)
242  { m_value = bwidth; return *this; }
243 #endif
244 
245  bool IsCompatible(const DTVBandwidth &other) const
246  { return m_value == other.m_value || m_value == kBandwidthAuto ||
247  other.m_value == kBandwidthAuto;
248  }
249 
250  bool ParseConf(const QString &_value)
251  { return ParseParam(_value, m_value, kConfTable); }
252  bool ParseVDR(const QString &_value)
253  { return ParseParam(_value, m_value, kVdrTable); }
254  bool Parse(const QString &_value)
255  { return ParseParam(_value, m_value, kParseTable); }
256 
257  QString toString() const { return toString(m_value); }
258  QChar toChar() const
259  {
260  if (toString().length() > 0)
261  return toString()[0];
262  return {0};
263  }
264 
265  static QString toString(int _value)
266  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
267 };
268 
270 {
271  protected:
275  static const uint kDBStrCnt = 12;
276  static const char *s_dbStr[kDBStrCnt];
277 
278  public:
279  enum Types
280  {
293  };
294 #ifdef USING_DVB
295  static_assert((kFECNone == (Types)FEC_NONE)
296  && (kFEC_9_10 == (Types)FEC_9_10),
297  "FEC types don't match DVB includes.");
298 #endif
299 
300  explicit DTVCodeRate(Types _default = kFECAuto)
301  : DTVParamHelper(_default) { }
302  DTVCodeRate& operator=(const Types _value)
303  { m_value = _value; return *this; }
304 #ifdef USING_DVB
305  DTVCodeRate& operator=(const fe_code_rate_t rate)
306  { m_value = rate; return *this; }
307 #endif
308 
309  bool IsCompatible(const DTVCodeRate &other) const
310  { return m_value == other.m_value || m_value == kFECAuto ||
311  other.m_value == kFECAuto;
312  }
313 
314  bool ParseConf(const QString &_value)
315  { return ParseParam(_value, m_value, kConfTable); }
316  bool ParseVDR(const QString &_value)
317  { return ParseParam(_value, m_value, kVdrTable); }
318  bool Parse(const QString &_value)
319  { return ParseParam(_value, m_value, kParseTable); }
320 
321  QString toString() const { return toString(m_value); }
322 
323  static QString toString(int _value)
324  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
325 };
326 
328 {
329  protected:
333  static const uint kDBStrCnt = 13;
334  static const char *s_dbStr[kDBStrCnt];
335 
336  public:
337  enum Types
338  {
352  kModulationInvalid = 0x100, /* for removed modulations */
353  kModulationAnalog = 0x200, /* for analog channel scanner */
354  };
355 #ifdef USING_DVB
356  static_assert((kModulationQPSK == (Types)QPSK)
357  && (kModulationDQPSK == (Types)DQPSK),
358  "Modulation types don't match DVB includes.");
359 #endif
360 
362  : DTVParamHelper(_default) { }
364  { m_value = _value; return *this; }
365 #ifdef USING_DVB
366  DTVModulation& operator=(const fe_modulation_t modulation)
367  { m_value = modulation; return *this; }
368 #endif
369 
370  bool IsCompatible(const DTVModulation &other) const
371  { return m_value == other.m_value || m_value == kModulationQAMAuto ||
372  other.m_value == kModulationQAMAuto;
373  }
374 
375  bool ParseConf(const QString &_value)
376  { return ParseParam(_value, m_value, kConfTable); }
377  bool ParseVDR(const QString &_value)
378  { return ParseParam(_value, m_value, kVdrTable); }
379  bool Parse(const QString &_value)
380  { return ParseParam(_value, m_value, kParseTable); }
381 
382  QString toString() const { return toString(m_value); }
383 
384  static QString toString(int _value)
385  {
386  if (kModulationInvalid == _value)
387  return "invalid";
388  if (kModulationAnalog == _value)
389  return "analog";
390  return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt);
391  }
392 };
393 
395 {
396  protected:
400  static const uint kDBStrCnt = 3;
401  static const char *s_dbStr[kDBStrCnt];
402 
403  public:
404  enum Types
405  {
409  };
410 #ifdef USING_DVB
411  static_assert((kTransmissionMode2K == (Types)TRANSMISSION_MODE_2K)
412  && (kTransmissionModeAuto == (Types)TRANSMISSION_MODE_AUTO),
413  "Transmission types don't match DVB includes.");
414 #endif
415 
417  : DTVParamHelper(_default) { }
419  { m_value = _value; return *this; }
420 #ifdef USING_DVB
421  DTVTransmitMode& operator=(const fe_transmit_mode_t mode)
422  { m_value = mode; return *this; }
423 #endif
424 
425  bool IsCompatible(const DTVTransmitMode &other) const
426  { return m_value == other.m_value || m_value == kTransmissionModeAuto ||
428  }
429 
430  bool ParseConf(const QString &_value)
431  { return ParseParam(_value, m_value, kConfTable); }
432  bool ParseVDR(const QString &_value)
433  { return ParseParam(_value, m_value, kVdrTable); }
434  bool Parse(const QString &_value)
435  { return ParseParam(_value, m_value, kParseTable); }
436 
437  QString toString() const { return toString(m_value); }
438  QChar toChar() const
439  {
440  if (toString().length() > 0)
441  return toString()[0];
442  return {0};
443  }
444 
445  static QString toString(int _value)
446  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
447 };
448 
450 {
451  protected:
455  static const uint kDBStrCnt = 5;
456  static const char *s_dbStr[kDBStrCnt];
457 
458  public:
459  enum Types
460  {
466  };
467 #ifdef USING_DVB
468  static_assert((kGuardInterval_1_32 == (Types)GUARD_INTERVAL_1_32)
469  && (kGuardIntervalAuto == (Types)GUARD_INTERVAL_AUTO),
470  "Guard Interval types don't match DVB includes.");
471 #endif
472 
474  : DTVParamHelper(_default) { }
476  { m_value = _value; return *this; }
477 #ifdef USING_DVB
478  DTVGuardInterval& operator=(const fe_guard_interval_t interval)
479  { m_value = interval; return *this; }
480 #endif
481 
482  bool IsCompatible(const DTVGuardInterval &other) const
483  { return m_value == other.m_value || m_value == kGuardIntervalAuto ||
484  other.m_value == kGuardIntervalAuto;
485  }
486 
487  bool ParseConf(const QString &_value)
488  { return ParseParam(_value, m_value, kConfTable); }
489  bool ParseVDR(const QString &_value)
490  { return ParseParam(_value, m_value, kVdrTable); }
491  bool Parse(const QString &_value)
492  { return ParseParam(_value, m_value, kParseTable); }
493 
494  QString toString() const { return toString(m_value); }
495 
496  static QString toString(int _value)
497  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
498 };
499 
501 {
502  protected:
506  static const uint kDBStrCnt = 5;
507  static const char *s_dbStr[kDBStrCnt];
508 
509  public:
510  enum Types
511  {
517  };
518 #ifdef USING_DVB
519  static_assert((kHierarchyNone == (Types)HIERARCHY_NONE)
520  && (kHierarchyAuto == (Types)HIERARCHY_AUTO),
521  "Hierarchy types don't match DVB includes.");
522 #endif
523 
524  explicit DTVHierarchy(Types _default = kHierarchyAuto)
525  : DTVParamHelper(_default) { }
526  DTVHierarchy& operator=(const Types _value)
527  { m_value = _value; return *this; }
528 #ifdef USING_DVB
529  DTVHierarchy& operator=(const fe_hierarchy_t hierarchy)
530  { m_value = hierarchy; return *this; }
531 #endif
532 
533  bool IsCompatible(const DTVHierarchy &other) const
534  { return m_value == other.m_value || m_value == kHierarchyAuto ||
535  other.m_value == kHierarchyAuto;
536  }
537 
538  bool ParseConf(const QString &_value)
539  { return ParseParam(_value, m_value, kConfTable); }
540  bool ParseVDR(const QString &_value)
541  { return ParseParam(_value, m_value, kVdrTable); }
542  bool Parse(const QString &_value)
543  { return ParseParam(_value, m_value, kParseTable); }
544 
545  QString toString() const { return toString(m_value); }
546  QChar toChar() const
547  {
548  if (toString().length() > 0)
549  return toString()[0];
550  return {0};
551  }
552 
553  static QString toString(int _value)
554  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
555 };
556 
558 {
559  protected:
561  static const uint kDBStrCnt = 4;
562  static const char *s_dbStr[kDBStrCnt];
563 
564  public:
566  {
571  };
572 
574  : DTVParamHelper(_default) { }
576  { m_value = _value; return *this; }
577 
578  bool ParseConf(const QString &_value)
579  { return ParseParam(_value, m_value, kParseTable); }
580  bool ParseVDR(const QString &_value)
581  { return ParseParam(_value, m_value, kParseTable); }
582  bool Parse(const QString &_value)
583  { return ParseParam(_value, m_value, kParseTable); }
584 
585  QString toString() const { return toString(m_value); }
586  QChar toChar() const
587  {
588  if (toString().length() > 0)
589  return toString()[0];
590  return {0};
591  }
592 
593  static QString toString(int _value)
594  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
595 };
596 
598 {
599  protected:
603  static const uint kDBStrCnt = 19;
604  static const char *s_dbStr[kDBStrCnt];
605 
606  public:
607  enum Types
608  {
609  // see fe_delivery_system in frontend.h
629  };
630 #ifdef USING_DVB
631  static_assert((kModulationSystem_UNDEFINED == (Types)SYS_UNDEFINED)
632  && (kModulationSystem_DVBC_ANNEX_C == (Types)SYS_DVBC_ANNEX_C),
633  "Modulation System types don't match DVB includes.");
634 #endif
635 
637  : DTVParamHelper(_default) { }
639  { m_value = _value; return *this; }
640 #ifdef USING_DVB
641  DTVModulationSystem& operator=(fe_delivery_system_t type)
642  { m_value = type; return *this; }
643 #endif
644  bool IsCompatible(const DTVModulationSystem &other) const
645  { return
646  (m_value == other.m_value) ||
649  }
650 
651  bool ParseConf(const QString &_value)
652  { return ParseParam(_value, m_value, kConfTable); }
653  bool ParseVDR(const QString &_value)
654  { return ParseParam(_value, m_value, kVdrTable); }
655  bool Parse(const QString &_value)
656  { return ParseParam(_value, m_value, kParseTable); }
657 
658  QString toString() const { return toString(m_value); }
659 
660  static QString toString(int _value)
661  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
662 };
663 
665 {
666  protected:
670  static const uint kDBStrCnt = 4;
671  static const char *s_dbStr[kDBStrCnt];
672 
673  public:
674  enum Types
675  {
680  };
681 #ifdef USING_DVB
682  static_assert((kRollOff_35 == (Types)ROLLOFF_35)
683  && (kRollOff_Auto == (Types)ROLLOFF_AUTO),
684  "Rolloff types don't match DVB includes.");
685 #endif
686 
687  explicit DTVRollOff(Types _default = kRollOff_35)
688  : DTVParamHelper(_default) { }
689  DTVRollOff& operator=(const Types _value)
690  { m_value = _value; return *this; }
691 #ifdef USING_DVB
692  DTVRollOff& operator=(fe_rolloff_t type)
693  { m_value = type; return *this; }
694 #endif
695 
696  bool IsCompatible(const DTVRollOff &other) const
697  { return m_value == other.m_value || m_value == kRollOff_Auto ||
698  other.m_value == kRollOff_Auto;
699  }
700 
701  bool ParseConf(const QString &_value)
702  { return ParseParam(_value, m_value, kConfTable); }
703  bool ParseVDR(const QString &_value)
704  { return ParseParam(_value, m_value, kVdrTable); }
705  bool Parse(const QString &_value)
706  { return ParseParam(_value, m_value, kParseTable); }
707 
708  QString toString() const { return toString(m_value); }
709 
710  static QString toString(int _value)
711  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
712 };
713 
714 #endif // _DTVCONFPARSERHELPERS_H_
static const DTVParamHelperStruct kConfTable[]
bool ParseConf(const QString &_value)
bool Parse(const QString &_value)
static QString toString(int _value)
bool IsCompatible(const DTVGuardInterval &other) const
bool Parse(const QString &_value)
bool ParseConf(const QString &_value)
bool Parse(const QString &_value)
DTVHierarchy & operator=(const fe_hierarchy_t hierarchy)
static const DTVParamHelperStruct kConfTable[]
static const int kTunerTypeDVBT
static const uint kDBStrCnt
static const char * s_dbStr[kDBStrCnt]
DTVBandwidth(Types _default=kBandwidthAuto)
static const DTVParamHelperStruct kParseTable[]
static const DTVParamHelperStruct kConfTable[]
static const int kTunerTypeATSC
static QString toString(int _value)
static const uint kDBStrCnt
DTVInversion & operator=(const fe_spectral_inversion_t type)
static const int kTunerTypeUnknown
bool Parse(const QString &_value)
bool ParseVDR(const QString &_value)
DTVModulation(Types _default=kModulationQAMAuto)
static const char * s_dbStr[kDBStrCnt]
bool ParseVDR(const QString &_value)
static const uint kDBStrCnt
bool ParseConf(const QString &_value)
bool ParseVDR(const QString &_value)
bool IsCompatible(const DTVHierarchy &other) const
bool IsCompatible(const DTVTransmitMode &other) const
static const int kTunerTypeOCUR
DTVTunerType(int _default=kTunerTypeUnknown)
static const uint kDBStrCnt
bool ParseConf(const QString &_value)
bool Parse(const QString &_value)
QString toString() const
static QString toString(const char *strings[], int index, uint strings_size)
static const DTVParamHelperStruct kVdrTable[]
static const DTVParamHelperStruct kParseTable[]
DTVTransmitMode & operator=(const Types _value)
static const DTVParamHelperStruct kVdrTable[]
static const int kTunerTypeDVBS1
DTVModulationSystem & operator=(fe_delivery_system_t type)
static const DTVParamHelperStruct kVdrTable[]
bool Parse(const QString &_value)
static const DTVParamHelperStruct kVdrTable[]
QString toString() const
DTVCodeRate & operator=(const Types _value)
static const DTVParamHelperStruct kVdrTable[]
bool operator!=(const int &v) const
QChar toChar() const
static const DTVParamHelperStruct kParseTable[]
static const DTVParamHelperStruct kConfTable[]
QString toString() const
DTVInversion & operator=(const Types _value)
DTVModulationSystem & operator=(const Types _value)
bool IsFECVariable(void) const
static const DTVParamHelperStruct kConfTable[]
static const uint kDBStrCnt
static const DTVParamHelperStruct kVdrTable[]
bool Parse(const QString &_value)
DTVCodeRate & operator=(const fe_code_rate_t rate)
static const int kTunerTypeDVBS2
QString toString() const
DTVPolarity & operator=(const PolarityValues _value)
static const int kTunerTypeDVBT2
static QString toString(int _value)
DTVGuardInterval & operator=(const fe_guard_interval_t interval)
static const int kTunerTypeDVBC
bool Parse(const QString &_value)
static const DTVParamHelperStruct kParseTable[]
DTVHierarchy(Types _default=kHierarchyAuto)
static QString toString(int _value)
DTVInversion(Types _default=kInversionAuto)
static const char * s_dbStr[kDBStrCnt]
bool operator==(const int &v) const
static const DTVParamHelperStruct kVdrTable[]
DTVRollOff(Types _default=kRollOff_35)
QString toString() const
static const DTVParamHelperStruct kParseTable[]
static const uint kDBStrCnt
bool IsCompatible(const DTVCodeRate &other) const
bool ParseConf(const QString &_value)
static const DTVParamHelperStruct kParseTable[]
static const char * s_dbStr[kDBStrCnt]
QString toString() const
static const DTVParamHelperStruct kConfTable[]
static const DTVParamHelperStruct kParseTable[]
static QString toString(int _value)
Helper abstract template to do some of the mundane portions of translating and comparing the paramate...
static const uint kDBStrCnt
static QString toString(int _value)
unsigned int uint
Definition: compat.h:140
bool IsCompatible(const DTVRollOff &other) const
bool ParseVDR(const QString &_value)
QChar toChar() const
DTVTransmitMode(Types _default=kTransmissionModeAuto)
DTVRollOff & operator=(const Types _value)
static const DTVParamHelperStruct kParseTable[]
DTVGuardInterval(Types _default=kGuardIntervalAuto)
QChar toChar() const
DTVParamHelper & operator=(int _value)
bool ParseVDR(const QString &_value)
static const uint kDBStrCnt
static const char * s_dbStr[kDBStrCnt]
static const DTVParamHelperStruct kParseTable[]
DTVHierarchy & operator=(const Types _value)
DTVTransmitMode & operator=(const fe_transmit_mode_t mode)
bool ParseConf(const QString &_value)
static QString toString(int _value)
bool ParseVDR(const QString &_value)
static const DTVParamHelperStruct kVdrTable[]
static const char * s_dbStr[kDBStrCnt]
static bool ParseParam(const QString &symbol, int &value, const DTVParamHelperStruct *table)
QString toString() const
DTVBandwidth & operator=(const fe_bandwidth_t bwidth)
static const int kTunerTypeIPTV
bool IsCompatible(const DTVInversion &other) const
bool IsDiSEqCSupported(void) const
static const int kTunerTypeASI
DTVCodeRate(Types _default=kFECAuto)
bool ParseConf(const QString &_value)
static const DTVParamHelperStruct kParseTable[]
static const DTVParamHelperStruct kConfTable[]
static const DTVParamHelperStruct kVdrTable[]
QString toString() const
DTVModulation & operator=(const fe_modulation_t modulation)
QString toString() const
DTVTunerType & operator=(int type)
DTVGuardInterval & operator=(const Types _value)
DTVParamHelper(int _value)
static const char * s_dbStr[kDBStrCnt]
static const uint kDBStrCnt
static const DTVParamHelperStruct kConfTable[]
DTVRollOff & operator=(fe_rolloff_t type)
bool IsCompatible(const DTVModulation &other) const
DTVModulation & operator=(const Types _value)
static QString toString(int _value)
bool Parse(const QString &_value)
static const char * s_dbStr[kDBStrCnt]
static QString toString(int _value)
DTVPolarity(PolarityValues _default=kPolarityVertical)
bool ParseVDR(const QString &_value)
bool IsCompatible(const DTVBandwidth &other) const
bool ParseVDR(const QString &_value)
static void initStr(void)
static QString toString(int _value)
bool IsCompatible(const DTVModulationSystem &other) const
bool ParseConf(const QString &_value)
QChar toChar() const
bool Parse(const QString &_value)
static const DTVParamHelperStruct kConfTable[]
bool ParseConf(const QString &_value)
static const DTVParamHelperStruct kParseTable[]
bool ParseConf(const QString &_value)
static const char * s_dbStr[kDBStrCnt]
static const char * s_dbStr[kDBStrCnt]
DTVBandwidth & operator=(const Types _value)
DTVModulationSystem(Types _default=kModulationSystem_UNDEFINED)
QString toString() const
bool Parse(const QString &_value)
bool ParseVDR(const QString &_value)
bool IsModulationVariable(void) const
bool ParseVDR(const QString &_value)
static const uint kDBStrCnt