MythTV: dtvconfparserhelpers.h Source File

00001 /* -*- Mode: c++ -*-
00002  * vim: set expandtab tabstop=4 shiftwidth=4:
00003  *
00004  * Original Project
00005  *      MythTV      http://www.mythtv.org
00006  *
00007  * Author(s):
00008  *      John Pullan  (john@pullan.org)
00009  *
00010  * Description:
00011  *     Collection of classes to provide dvb channel scanning
00012  *     functionallity
00013  *
00014  *
00015  * This program is free software; you can redistribute it and/or
00016  * modify it under the terms of the GNU General Public License
00017  * as published by the Free Software Foundation; either version 2
00018  * of the License, or (at your option) any later version.
00019  *
00020  * This program is distributed in the hope that it will be useful,
00021  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00023  * GNU General Public License for more details.
00024  *
00025  * You should have received a copy of the GNU General Public License
00026  * along with this program; if not, write to the Free Software
00027  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00028  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
00029  *
00030  */
00031 
00032 #ifndef _DTVCONFPARSERHELPERS_H_
00033 #define _DTVCONFPARSERHELPERS_H_
00034 
00035 #include <qstring.h>
00036 
00037 // The following are a set of helper classes to allow easy translation
00038 // between the different string representations of various tuning params.
00039 
00040 struct DTVParamHelperStruct
00041 {
00042     QString symbol;
00043     int     value;
00044 };
00045 
00050 class DTVParamHelper
00051 {
00052   public:
00053     DTVParamHelper(int _value) : value(_value) { }
00054 
00055     operator int()                const { return value;          }
00056     int operator=(int _value)           { return value = _value; }
00057     bool operator==(const int& v) const { return value == v;     }
00058 
00059   protected:
00060     static bool ParseParam(const QString &symbol, int &value,
00061                            const DTVParamHelperStruct *table);
00062 
00063     static QString toString(const char *strings[], int index,
00064                             uint strings_size);
00065 
00066   protected:
00067     int value;
00068 };
00069 
00070 class DTVTunerType : public DTVParamHelper
00071 {
00072     static const DTVParamHelperStruct parseTable[];
00073 
00074   public:
00075     enum
00076     {
00077         kTunerTypeQPSK    = 0,
00078         kTunerTypeQAM     = 1,
00079         kTunerTypeOFDM    = 2,
00080         kTunerTypeATSC    = 3,
00081         kTunerTypeDVB_S   = (1 << 2), // same as QPSK but for new API
00082         kTunerTypeDVB_C   = (1 << 3), // same as QAM  but for new API
00083         kTunerTypeDVB_T   = (1 << 4), // same as OFDM but for new API
00084         kTunerTypeDVB_S2  = (1 << 5),
00085         kTunerTypeUnknown = (1 << 31),
00086     };
00087 
00088     DTVTunerType(int _default = kTunerTypeUnknown)
00089         : DTVParamHelper(_default) { initStr(); }
00090 
00091     bool Parse(const QString &_value)
00092         { return ParseParam(_value, value, parseTable); }
00093 
00094     bool IsFECVariable(void) const
00095     {
00096         return ((kTunerTypeQPSK   == value) ||
00097                 (kTunerTypeQAM    == value) ||
00098                 (kTunerTypeDVB_S  == value) ||
00099                 (kTunerTypeDVB_C  == value) ||
00100                 (kTunerTypeDVB_S2 == value));
00101     }
00102 
00103     bool IsModulationVariable(void) const
00104     {
00105         return ((DTVTunerType::kTunerTypeQAM    == value) ||
00106                 (DTVTunerType::kTunerTypeATSC   == value) ||
00107                 (DTVTunerType::kTunerTypeDVB_S2 == value));
00108     }
00109 
00110     QString toString() const { return toString(value); }
00111 
00112     static void initStr(void);
00113     static QString toString(int _value);
00114 };
00115 
00116 class DTVInversion : public DTVParamHelper
00117 {
00118   protected:
00119     static const DTVParamHelperStruct confTable[];
00120     static const DTVParamHelperStruct vdrTable[];
00121     static const DTVParamHelperStruct parseTable[];
00122     static const uint kDBStrCnt = 3;
00123     static const char *dbStr[kDBStrCnt];
00124 
00125   public:
00126     enum
00127     {
00128         kInversionOff,
00129         kInversionOn,
00130         kInversionAuto,
00131     };
00132 
00133     DTVInversion(int _default = kInversionAuto)
00134         : DTVParamHelper(_default) { }
00135 
00136     bool ParseConf(const QString &_value)
00137        { return ParseParam(_value, value, confTable); }
00138     bool ParseVDR(const QString &_value)
00139        { return ParseParam(_value, value, vdrTable); }
00140     bool Parse(const QString &_value)
00141        { return ParseParam(_value, value, parseTable); }
00142 
00143     QString toString() const { return toString(value); }
00144     QChar   toChar() const
00145         { if (toString().length() > 0)
00146               return toString()[0]; else return QChar(0); }
00147 
00148     static QString toString(int _value)
00149         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
00150 };
00151 
00152 class DTVBandwidth : public DTVParamHelper
00153 {
00154   protected:
00155     static const DTVParamHelperStruct confTable[];
00156     static const DTVParamHelperStruct vdrTable[];
00157     static const DTVParamHelperStruct parseTable[];
00158     static const uint kDBStrCnt = 4;
00159     static const char *dbStr[kDBStrCnt];
00160 
00161   public:
00162     enum
00163     {
00164         kBandwidth8MHz,
00165         kBandwidth7MHz,
00166         kBandwidth6MHz,
00167         kBandwidthAuto,
00168     };
00169 
00170     DTVBandwidth(int _default = kBandwidthAuto) : DTVParamHelper(_default) { }
00171 
00172     bool ParseConf(const QString &_value)
00173        { return ParseParam(_value, value, confTable); }
00174     bool ParseVDR(const QString &_value)
00175        { return ParseParam(_value, value, vdrTable); }
00176     bool Parse(const QString &_value)
00177        { return ParseParam(_value, value, parseTable); }
00178 
00179     QString toString() const { return toString(value); }
00180     QChar   toChar() const
00181         { if (toString().length() > 0)
00182               return toString()[0]; else return QChar(0); }
00183 
00184     static QString toString(int _value)
00185         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
00186 };
00187 
00188 class DTVCodeRate : public DTVParamHelper
00189 {
00190   protected:
00191     static const DTVParamHelperStruct confTable[];
00192     static const DTVParamHelperStruct vdrTable[];
00193     static const DTVParamHelperStruct parseTable[];
00194     static const uint kDBStrCnt = 10;
00195     static const char *dbStr[kDBStrCnt];
00196 
00197   public:
00198     enum
00199     {
00200         kFECNone,
00201         kFEC_1_2,
00202         kFEC_2_3,
00203         kFEC_3_4,
00204         kFEC_4_5,
00205         kFEC_5_6,
00206         kFEC_6_7,
00207         kFEC_7_8,
00208         kFEC_8_9,
00209         kFECAuto,
00210     };
00211 
00212     DTVCodeRate(int _default = kFECAuto) : DTVParamHelper(_default) { }
00213 
00214     bool ParseConf(const QString &_value)
00215        { return ParseParam(_value, value, confTable); }
00216     bool ParseVDR(const QString &_value)
00217        { return ParseParam(_value, value, vdrTable); }
00218     bool Parse(const QString &_value)
00219        { return ParseParam(_value, value, parseTable); }
00220 
00221     QString toString() const { return toString(value); }
00222 
00223     static QString toString(int _value)
00224         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
00225 };
00226 
00227 class DTVModulation : public DTVParamHelper
00228 {
00229   protected:
00230     static const DTVParamHelperStruct confTable[];
00231     static const DTVParamHelperStruct vdrTable[];
00232     static const DTVParamHelperStruct parseTable[];
00233     static const uint kDBStrCnt = 17;
00234     static const char *dbStr[kDBStrCnt];
00235 
00236   public:
00237     enum
00238     {
00239         kModulationQPSK    = 0,
00240         kModulationQAM16   = 1,
00241         kModulationQAM32   = 2,
00242         kModulationQAM64   = 3,
00243         kModulationQAM128  = 4,
00244         kModulationQAM256  = 5,
00245         kModulationQAMAuto = 6,
00246         kModulation8VSB    = 7,
00247         kModulation16VSB   = 8,
00248         kModulation2VSB    = 9,
00249         kModulation4VSB    = 10,
00250         kModulationBPSK    = 11,
00251         kModulation16APSK  = 12,
00252         kModulation32APSK  = 13,
00253         kModulation8PSK    = 14,
00254         kModulation16PSK   = 15,
00255         kModulationAnalog  = 16, /* for analog channel scanner */
00256     };
00257 
00258     DTVModulation(int _default = kModulationQAMAuto)
00259         : DTVParamHelper(_default) { }
00260 
00261     bool ParseConf(const QString &_value)
00262        { return ParseParam(_value, value, confTable); }
00263     bool ParseVDR(const QString &_value)
00264        { return ParseParam(_value, value, vdrTable); }
00265     bool Parse(const QString &_value)
00266        { return ParseParam(_value, value, parseTable); }
00267 
00268     QString toString() const { return toString(value); }
00269 
00270     static QString toString(int _value)
00271         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
00272 };
00273 
00274 class DTVTransmitMode : public DTVParamHelper
00275 {
00276   protected:
00277     static const DTVParamHelperStruct confTable[];
00278     static const DTVParamHelperStruct vdrTable[];
00279     static const DTVParamHelperStruct parseTable[];
00280     static const uint kDBStrCnt = 3;
00281     static const char *dbStr[kDBStrCnt];
00282 
00283   public:
00284     enum
00285     {
00286         kTransmissionMode2K,
00287         kTransmissionMode8K,
00288         kTransmissionModeAuto,
00289     };
00290 
00291     DTVTransmitMode(int _default = kTransmissionModeAuto)
00292         : DTVParamHelper(_default) { }
00293 
00294     bool ParseConf(const QString &_value)
00295        { return ParseParam(_value, value, confTable); }
00296     bool ParseVDR(const QString &_value)
00297        { return ParseParam(_value, value, vdrTable); }
00298     bool Parse(const QString &_value)
00299        { return ParseParam(_value, value, parseTable); }
00300 
00301     QString toString() const { return toString(value); }
00302     QChar   toChar() const
00303         { if (toString().length() > 0)
00304               return toString()[0]; else return QChar(0); }
00305 
00306     static QString toString(int _value)
00307         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
00308 };
00309 
00310 class DTVGuardInterval : public DTVParamHelper
00311 {
00312   protected:
00313     static const DTVParamHelperStruct confTable[];
00314     static const DTVParamHelperStruct vdrTable[];
00315     static const DTVParamHelperStruct parseTable[];
00316     static const uint kDBStrCnt = 5;
00317     static const char *dbStr[kDBStrCnt];
00318 
00319   public:
00320     enum
00321     {
00322         kGuardInterval_1_32,
00323         kGuardInterval_1_16,
00324         kGuardInterval_1_8,
00325         kGuardInterval_1_4,
00326         kGuardIntervalAuto,
00327     };
00328 
00329     DTVGuardInterval(int _default = kGuardIntervalAuto)
00330         : DTVParamHelper(_default) { }
00331 
00332     bool ParseConf(const QString &_value)
00333        { return ParseParam(_value, value, confTable); }
00334     bool ParseVDR(const QString &_value)
00335        { return ParseParam(_value, value, vdrTable); }
00336     bool Parse(const QString &_value)
00337        { return ParseParam(_value, value, parseTable); }
00338 
00339     QString toString() const { return toString(value); }
00340 
00341     static QString toString(int _value)
00342         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
00343 };
00344 
00345 class DTVHierarchy : public DTVParamHelper
00346 {
00347   protected:
00348     static const DTVParamHelperStruct confTable[];
00349     static const DTVParamHelperStruct vdrTable[];
00350     static const DTVParamHelperStruct parseTable[];
00351     static const uint kDBStrCnt = 5;
00352     static const char *dbStr[kDBStrCnt];
00353 
00354   public:
00355     enum
00356     {
00357         kHierarchyNone,
00358         kHierarchy1,
00359         kHierarchy2,
00360         kHierarchy4,
00361         kHierarchyAuto,
00362     };
00363 
00364     DTVHierarchy(int _default = kHierarchyAuto) : DTVParamHelper(_default) { }
00365 
00366     bool ParseConf(const QString &_value)
00367        { return ParseParam(_value, value, confTable); }
00368     bool ParseVDR(const QString &_value)
00369        { return ParseParam(_value, value, vdrTable); }
00370     bool Parse(const QString &_value)
00371        { return ParseParam(_value, value, parseTable); }
00372 
00373     QString toString() const { return toString(value); }
00374     QChar   toChar() const
00375         { if (toString().length() > 0)
00376               return toString()[0]; else return QChar(0); }
00377 
00378     static QString toString(int _value)
00379         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
00380 };
00381 
00382 class DTVPolarity : public DTVParamHelper
00383 {
00384   protected:
00385     static const DTVParamHelperStruct parseTable[];
00386     static const uint kDBStrCnt = 4;
00387     static const char *dbStr[kDBStrCnt];
00388 
00389   public:
00390     enum PolarityValues
00391     {
00392         kPolarityVertical,
00393         kPolarityHorizontal,
00394         kPolarityRight,
00395         kPolarityLeft
00396     };
00397 
00398     DTVPolarity(int _default = kPolarityVertical)
00399         : DTVParamHelper(_default) { }
00400 
00401     bool ParseConf(const QString &_value)
00402        { return ParseParam(_value, value, parseTable); }
00403     bool ParseVDR(const QString &_value)
00404        { return ParseParam(_value, value, parseTable); }
00405     bool Parse(const QString &_value)
00406        { return ParseParam(_value, value, parseTable); }
00407 
00408     QString toString() const { return toString(value); }
00409     QChar   toChar() const
00410         { if (toString().length() > 0)
00411               return toString()[0]; else return QChar(0); }
00412 
00413     static QString toString(int _value)
00414         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
00415 };
00416 
00417 #endif // _DTVCONFPARSERHELPERS_H_