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) : value(_value) { }
57  DTVParamHelper &operator=(int _value) { value = _value; return *this; }
58 
59  operator int() const { return value; }
60  bool operator==(const int& v) const { return value == v; }
61  bool operator!=(const int& v) const { return 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 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) { value = type; return *this; }
128 
129  bool Parse(const QString &_value)
130  { return ParseParam(_value, value, s_parseTable); }
131 
132  bool IsFECVariable(void) const
133  {
134  return ((kTunerTypeDVBC == value) ||
135  (kTunerTypeDVBS1 == value) ||
136  (kTunerTypeDVBS2 == value));
137  }
138 
139  bool IsModulationVariable(void) const
140  {
141  return ((kTunerTypeDVBC == value) ||
142  (kTunerTypeATSC == value) ||
143  (kTunerTypeDVBS2 == value));
144  }
145 
146  bool IsDiSEqCSupported(void) const
147  {
148  return ((kTunerTypeDVBS1 == value) ||
149  (kTunerTypeDVBS2 == value));
150  }
151 
152  QString toString() const { return toString(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  { value = _value; return *this; }
184 #ifdef USING_DVB
185  DTVInversion& operator=(const fe_spectral_inversion_t type)
186  { value = type; return *this; }
187 #endif
188 
189  bool IsCompatible(const DTVInversion &other) const
190  { return value == other.value || value == kInversionAuto ||
191  other.value == kInversionAuto;
192  }
193 
194  bool ParseConf(const QString &_value)
195  { return ParseParam(_value, value, s_confTable); }
196  bool ParseVDR(const QString &_value)
197  { return ParseParam(_value, value, s_vdrTable); }
198  bool Parse(const QString &_value)
199  { return ParseParam(_value, value, s_parseTable); }
200 
201  QString toString() const { return toString(value); }
202  QChar toChar() const
203  { if (toString().length() > 0)
204  return toString()[0]; else return QChar(0); }
205 
206  static QString toString(int _value)
207  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
208 };
209 
211 {
212  protected:
216  static const uint kDBStrCnt = 4;
217  static const char *s_dbStr[kDBStrCnt];
218 
219  public:
220  enum Types
221  {
226  };
227 #ifdef USING_DVB
228  static_assert((kBandwidth8MHz == (Types)BANDWIDTH_8_MHZ)
229  && (kBandwidthAuto == (Types)BANDWIDTH_AUTO),
230  "Bandwidth types don't match DVB includes.");
231 #endif
232 
233  explicit DTVBandwidth(Types _default = kBandwidthAuto)
234  : DTVParamHelper(_default) { }
235  DTVBandwidth& operator=(const Types _value)
236  { value = _value; return *this; }
237 #ifdef USING_DVB
238  DTVBandwidth& operator=(const fe_bandwidth_t bwidth)
239  { value = bwidth; return *this; }
240 #endif
241 
242  bool IsCompatible(const DTVBandwidth &other) const
243  { return value == other.value || value == kBandwidthAuto ||
244  other.value == kBandwidthAuto;
245  }
246 
247  bool ParseConf(const QString &_value)
248  { return ParseParam(_value, value, s_confTable); }
249  bool ParseVDR(const QString &_value)
250  { return ParseParam(_value, value, s_vdrTable); }
251  bool Parse(const QString &_value)
252  { return ParseParam(_value, value, s_parseTable); }
253 
254  QString toString() const { return toString(value); }
255  QChar toChar() const
256  { if (toString().length() > 0)
257  return toString()[0]; else return QChar(0); }
258 
259  static QString toString(int _value)
260  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
261 };
262 
264 {
265  protected:
269  static const uint kDBStrCnt = 12;
270  static const char *s_dbStr[kDBStrCnt];
271 
272  public:
273  enum Types
274  {
287  };
288 #ifdef USING_DVB
289  static_assert((kFECNone == (Types)FEC_NONE)
290  && (kFEC_9_10 == (Types)FEC_9_10),
291  "FEC types don't match DVB includes.");
292 #endif
293 
294  explicit DTVCodeRate(Types _default = kFECAuto)
295  : DTVParamHelper(_default) { }
296  DTVCodeRate& operator=(const Types _value)
297  { value = _value; return *this; }
298 #ifdef USING_DVB
299  DTVCodeRate& operator=(const fe_code_rate_t rate)
300  { value = rate; return *this; }
301 #endif
302 
303  bool IsCompatible(const DTVCodeRate &other) const
304  { return value == other.value || value == kFECAuto ||
305  other.value == kFECAuto;
306  }
307 
308  bool ParseConf(const QString &_value)
309  { return ParseParam(_value, value, s_confTable); }
310  bool ParseVDR(const QString &_value)
311  { return ParseParam(_value, value, s_vdrTable); }
312  bool Parse(const QString &_value)
313  { return ParseParam(_value, value, s_parseTable); }
314 
315  QString toString() const { return toString(value); }
316 
317  static QString toString(int _value)
318  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
319 };
320 
322 {
323  protected:
327  static const uint kDBStrCnt = 13;
328  static const char *s_dbStr[kDBStrCnt];
329 
330  public:
331  enum Types
332  {
346  kModulationInvalid = 0x100, /* for removed modulations */
347  kModulationAnalog = 0x200, /* for analog channel scanner */
348  };
349 #ifdef USING_DVB
350  static_assert((kModulationQPSK == (Types)QPSK)
351  && (kModulationDQPSK == (Types)DQPSK),
352  "Modulation types don't match DVB includes.");
353 #endif
354 
356  : DTVParamHelper(_default) { }
358  { value = _value; return *this; }
359 #ifdef USING_DVB
360  DTVModulation& operator=(const fe_modulation_t modulation)
361  { value = modulation; return *this; }
362 #endif
363 
364  bool IsCompatible(const DTVModulation &other) const
365  { return value == other.value || value == kModulationQAMAuto ||
366  other.value == kModulationQAMAuto;
367  }
368 
369  bool ParseConf(const QString &_value)
370  { return ParseParam(_value, value, s_confTable); }
371  bool ParseVDR(const QString &_value)
372  { return ParseParam(_value, value, s_vdrTable); }
373  bool Parse(const QString &_value)
374  { return ParseParam(_value, value, s_parseTable); }
375 
376  QString toString() const { return toString(value); }
377 
378  static QString toString(int _value)
379  {
380  if (kModulationInvalid == _value)
381  return "invalid";
382  else if (kModulationAnalog == _value)
383  return "analog";
384  return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt);
385  }
386 };
387 
389 {
390  protected:
394  static const uint kDBStrCnt = 3;
395  static const char *s_dbStr[kDBStrCnt];
396 
397  public:
398  enum Types
399  {
403  };
404 #ifdef USING_DVB
405  static_assert((kTransmissionMode2K == (Types)TRANSMISSION_MODE_2K)
406  && (kTransmissionModeAuto == (Types)TRANSMISSION_MODE_AUTO),
407  "Transmission types don't match DVB includes.");
408 #endif
409 
411  : DTVParamHelper(_default) { }
413  { value = _value; return *this; }
414 #ifdef USING_DVB
415  DTVTransmitMode& operator=(const fe_transmit_mode_t mode)
416  { value = mode; return *this; }
417 #endif
418 
419  bool IsCompatible(const DTVTransmitMode &other) const
420  { return value == other.value || value == kTransmissionModeAuto ||
421  other.value == kTransmissionModeAuto;
422  }
423 
424  bool ParseConf(const QString &_value)
425  { return ParseParam(_value, value, s_confTable); }
426  bool ParseVDR(const QString &_value)
427  { return ParseParam(_value, value, s_vdrTable); }
428  bool Parse(const QString &_value)
429  { return ParseParam(_value, value, s_parseTable); }
430 
431  QString toString() const { return toString(value); }
432  QChar toChar() const
433  { if (toString().length() > 0)
434  return toString()[0]; else return QChar(0); }
435 
436  static QString toString(int _value)
437  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
438 };
439 
441 {
442  protected:
446  static const uint kDBStrCnt = 5;
447  static const char *s_dbStr[kDBStrCnt];
448 
449  public:
450  enum Types
451  {
457  };
458 #ifdef USING_DVB
459  static_assert((kGuardInterval_1_32 == (Types)GUARD_INTERVAL_1_32)
460  && (kGuardIntervalAuto == (Types)GUARD_INTERVAL_AUTO),
461  "Guard Interval types don't match DVB includes.");
462 #endif
463 
465  : DTVParamHelper(_default) { }
467  { value = _value; return *this; }
468 #ifdef USING_DVB
469  DTVGuardInterval& operator=(const fe_guard_interval_t interval)
470  { value = interval; return *this; }
471 #endif
472 
473  bool IsCompatible(const DTVGuardInterval &other) const
474  { return value == other.value || value == kGuardIntervalAuto ||
475  other.value == kGuardIntervalAuto;
476  }
477 
478  bool ParseConf(const QString &_value)
479  { return ParseParam(_value, value, s_confTable); }
480  bool ParseVDR(const QString &_value)
481  { return ParseParam(_value, value, s_vdrTable); }
482  bool Parse(const QString &_value)
483  { return ParseParam(_value, value, s_parseTable); }
484 
485  QString toString() const { return toString(value); }
486 
487  static QString toString(int _value)
488  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
489 };
490 
492 {
493  protected:
497  static const uint kDBStrCnt = 5;
498  static const char *s_dbStr[kDBStrCnt];
499 
500  public:
501  enum Types
502  {
508  };
509 #ifdef USING_DVB
510  static_assert((kHierarchyNone == (Types)HIERARCHY_NONE)
511  && (kHierarchyAuto == (Types)HIERARCHY_AUTO),
512  "Hierarchy types don't match DVB includes.");
513 #endif
514 
515  explicit DTVHierarchy(Types _default = kHierarchyAuto)
516  : DTVParamHelper(_default) { }
517  DTVHierarchy& operator=(const Types _value)
518  { value = _value; return *this; }
519 #ifdef USING_DVB
520  DTVHierarchy& operator=(const fe_hierarchy_t hierarchy)
521  { value = hierarchy; return *this; }
522 #endif
523 
524  bool IsCompatible(const DTVHierarchy &other) const
525  { return value == other.value || value == kHierarchyAuto ||
526  other.value == kHierarchyAuto;
527  }
528 
529  bool ParseConf(const QString &_value)
530  { return ParseParam(_value, value, s_confTable); }
531  bool ParseVDR(const QString &_value)
532  { return ParseParam(_value, value, s_vdrTable); }
533  bool Parse(const QString &_value)
534  { return ParseParam(_value, value, s_parseTable); }
535 
536  QString toString() const { return toString(value); }
537  QChar toChar() const
538  { if (toString().length() > 0)
539  return toString()[0]; else return QChar(0); }
540 
541  static QString toString(int _value)
542  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
543 };
544 
546 {
547  protected:
549  static const uint kDBStrCnt = 4;
550  static const char *s_dbStr[kDBStrCnt];
551 
552  public:
554  {
559  };
560 
562  : DTVParamHelper(_default) { }
564  { value = _value; return *this; }
565 
566  bool ParseConf(const QString &_value)
567  { return ParseParam(_value, value, s_parseTable); }
568  bool ParseVDR(const QString &_value)
569  { return ParseParam(_value, value, s_parseTable); }
570  bool Parse(const QString &_value)
571  { return ParseParam(_value, value, s_parseTable); }
572 
573  QString toString() const { return toString(value); }
574  QChar toChar() const
575  { if (toString().length() > 0)
576  return toString()[0]; else return QChar(0); }
577 
578  static QString toString(int _value)
579  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
580 };
581 
583 {
584  protected:
588  static const uint kDBStrCnt = 19;
589  static const char *s_dbStr[kDBStrCnt];
590 
591  public:
592  enum Types
593  {
594  // see fe_delivery_system in frontend.h
614  };
615 #ifdef USING_DVB
616  static_assert((kModulationSystem_UNDEFINED == (Types)SYS_UNDEFINED)
617  && (kModulationSystem_DVBC_ANNEX_C == (Types)SYS_DVBC_ANNEX_C),
618  "Modulation System types don't match DVB includes.");
619 #endif
620 
622  : DTVParamHelper(_default) { }
624  { value = _value; return *this; }
625 #ifdef USING_DVB
626  DTVModulationSystem& operator=(fe_delivery_system_t type)
627  { value = type; return *this; }
628 #endif
629  bool IsCompatible(const DTVModulationSystem &other) const
630  { return
631  (value == other.value) ||
634  }
635 
636  bool ParseConf(const QString &_value)
637  { return ParseParam(_value, value, s_confTable); }
638  bool ParseVDR(const QString &_value)
639  { return ParseParam(_value, value, s_vdrTable); }
640  bool Parse(const QString &_value)
641  { return ParseParam(_value, value, s_parseTable); }
642 
643  QString toString() const { return toString(value); }
644 
645  static QString toString(int _value)
646  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
647 };
648 
650 {
651  protected:
655  static const uint kDBStrCnt = 4;
656  static const char *s_dbStr[kDBStrCnt];
657 
658  public:
659  enum Types
660  {
665  };
666 #ifdef USING_DVB
667  static_assert((kRollOff_35 == (Types)ROLLOFF_35)
668  && (kRollOff_Auto == (Types)ROLLOFF_AUTO),
669  "Rolloff types don't match DVB includes.");
670 #endif
671 
672  explicit DTVRollOff(Types _default = kRollOff_35)
673  : DTVParamHelper(_default) { }
674  DTVRollOff& operator=(const Types _value)
675  { value = _value; return *this; }
676 #ifdef USING_DVB
677  DTVRollOff& operator=(fe_rolloff_t type)
678  { value = type; return *this; }
679 #endif
680 
681  bool IsCompatible(const DTVRollOff &other) const
682  { return value == other.value || value == kRollOff_Auto ||
683  other.value == kRollOff_Auto;
684  }
685 
686  bool ParseConf(const QString &_value)
687  { return ParseParam(_value, value, s_confTable); }
688  bool ParseVDR(const QString &_value)
689  { return ParseParam(_value, value, s_vdrTable); }
690  bool Parse(const QString &_value)
691  { return ParseParam(_value, value, s_parseTable); }
692 
693  QString toString() const { return toString(value); }
694 
695  static QString toString(int _value)
696  { return DTVParamHelper::toString(s_dbStr, _value, kDBStrCnt); }
697 };
698 
699 #endif // _DTVCONFPARSERHELPERS_H_
static const DTVParamHelperStruct s_confTable[]
static const DTVParamHelperStruct s_parseTable[]
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)
static const DTVParamHelperStruct s_confTable[]
static const DTVParamHelperStruct s_parseTable[]
bool ParseConf(const QString &_value)
bool Parse(const QString &_value)
static const DTVParamHelperStruct s_vdrTable[]
DTVHierarchy & operator=(const fe_hierarchy_t hierarchy)
static const int kTunerTypeDVBT
static const uint kDBStrCnt
static const char * s_dbStr[kDBStrCnt]
DTVBandwidth(Types _default=kBandwidthAuto)
static const int kTunerTypeATSC
static QString toString(int _value)
static const DTVParamHelperStruct s_vdrTable[]
static const uint kDBStrCnt
DTVInversion & operator=(const fe_spectral_inversion_t type)
static const DTVParamHelperStruct s_vdrTable[]
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 DTVParamHelperStruct s_confTable[]
static const uint kDBStrCnt
static const DTVParamHelperStruct s_parseTable[]
bool ParseConf(const QString &_value)
static const DTVParamHelperStruct s_vdrTable[]
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 s_parseTable[]
unsigned int uint
Definition: compat.h:140
DTVTransmitMode & operator=(const Types _value)
static const int kTunerTypeDVBS1
DTVModulationSystem & operator=(fe_delivery_system_t type)
bool Parse(const QString &_value)
static const DTVParamHelperStruct s_parseTable[]
QString toString() const
static const DTVParamHelperStruct s_confTable[]
DTVCodeRate & operator=(const Types _value)
bool operator!=(const int &v) const
QChar toChar() const
QString toString() const
DTVInversion & operator=(const Types _value)
DTVModulationSystem & operator=(const Types _value)
bool IsFECVariable(void) const
static const uint kDBStrCnt
bool Parse(const QString &_value)
DTVCodeRate & operator=(const fe_code_rate_t rate)
static const int kTunerTypeDVBS2
QString toString() const
static const DTVParamHelperStruct s_parseTable[]
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)
DTVHierarchy(Types _default=kHierarchyAuto)
static const DTVParamHelperStruct s_confTable[]
static QString toString(int _value)
static const DTVParamHelperStruct s_parseTable[]
DTVInversion(Types _default=kInversionAuto)
static const char * s_dbStr[kDBStrCnt]
bool operator==(const int &v) const
DTVRollOff(Types _default=kRollOff_35)
QString toString() const
static const uint kDBStrCnt
bool IsCompatible(const DTVCodeRate &other) const
bool ParseConf(const QString &_value)
static const DTVParamHelperStruct s_vdrTable[]
static const char * s_dbStr[kDBStrCnt]
QString toString() const
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 const DTVParamHelperStruct s_vdrTable[]
static const DTVParamHelperStruct s_confTable[]
static QString toString(int _value)
bool IsCompatible(const DTVRollOff &other) const
bool ParseVDR(const QString &_value)
static const DTVParamHelperStruct s_parseTable[]
QChar toChar() const
DTVTransmitMode(Types _default=kTransmissionModeAuto)
DTVRollOff & operator=(const Types _value)
DTVGuardInterval(Types _default=kGuardIntervalAuto)
static const DTVParamHelperStruct s_vdrTable[]
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 s_parseTable[]
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 char * s_dbStr[kDBStrCnt]
static bool ParseParam(const QString &symbol, int &value, const DTVParamHelperStruct *table)
QString toString() const
static const DTVParamHelperStruct s_parseTable[]
DTVBandwidth & operator=(const fe_bandwidth_t bwidth)
static const DTVParamHelperStruct s_confTable[]
static const int kTunerTypeIPTV
bool IsCompatible(const DTVInversion &other) const
bool IsDiSEqCSupported(void) const
static const int kTunerTypeASI
DTVCodeRate(Types _default=kFECAuto)
static const DTVParamHelperStruct s_vdrTable[]
static const DTVParamHelperStruct s_parseTable[]
bool ParseConf(const QString &_value)
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 DTVParamHelperStruct s_confTable[]
static const char * s_dbStr[kDBStrCnt]
static const uint kDBStrCnt
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)
static const DTVParamHelperStruct s_vdrTable[]
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
static const DTVParamHelperStruct s_confTable[]
bool ParseConf(const QString &_value)
QChar toChar() const
bool Parse(const QString &_value)
bool ParseConf(const QString &_value)
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