Ticket #5882: s2api.01.patch

File s2api.01.patch, 86.7 KB (added by wagabunda, 11 years ago)

not fully tested after cleaning my private changes

  • libs/libmythtv/firewirechannel.cpp

     
    6060
    6161    // Fetch tuning data from the database.
    6262    QString tvformat, modulation, freqtable, freqid, dtv_si_std;
     63    QString msystem, rolloff;
    6364    int finetune;
    6465    uint64_t frequency;
    6566    int mpeg_prog_num;
     
    7071        tvformat, modulation, freqtable, freqid,
    7172        finetune, frequency,
    7273        dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
     74        msyste, rolloff,
    7375        mplexid, commfree))
    7476    {
    7577        VERBOSE(VB_IMPORTANT, loc + " " + QString(
  • libs/libmythtv/dtvconfparserhelpers.h

     
    3333#define _DTVCONFPARSERHELPERS_H_
    3434
    3535#include <qstring.h>
     36#include <dvbtypes.h>
    3637
    3738// The following are a set of helper classes to allow easy translation
    3839// between the different string representations of various tuning params.
     
    191192    static const DTVParamHelperStruct confTable[];
    192193    static const DTVParamHelperStruct vdrTable[];
    193194    static const DTVParamHelperStruct parseTable[];
    194     static const uint kDBStrCnt = 10;
     195    static const uint kDBStrCnt = 12;
    195196    static const char *dbStr[kDBStrCnt];
    196197
    197198  public:
     
    207208        kFEC_7_8,
    208209        kFEC_8_9,
    209210        kFECAuto,
     211        kFEC_3_5,
     212        kFEC_9_10,
    210213    };
    211214
    212215    DTVCodeRate(int _default = kFECAuto) : DTVParamHelper(_default) { }
     
    236239  public:
    237240    enum
    238241    {
    239         kModulationQPSK    = 0,
    240         kModulationQAM16   = 1,
    241         kModulationQAM32   = 2,
    242         kModulationQAM64   = 3,
    243         kModulationQAM128  = 4,
    244         kModulationQAM256  = 5,
    245         kModulationQAMAuto = 6,
    246         kModulation8VSB    = 7,
    247         kModulation16VSB   = 8,
    248         kModulation2VSB    = 9,
    249         kModulation4VSB    = 10,
    250         kModulationBPSK    = 11,
    251         kModulation16APSK  = 12,
    252         kModulation32APSK  = 13,
    253         kModulation8PSK    = 14,
    254         kModulation16PSK   = 15,
    255         kModulationAnalog  = 16, /* for analog channel scanner */
     242        kModulationQPSK,
     243        kModulationQAM16,
     244        kModulationQAM32,
     245        kModulationQAM64,
     246        kModulationQAM128,
     247        kModulationQAM256,
     248        kModulationQAMAuto,
     249        kModulation8VSB,
     250        kModulation16VSB,
     251        kModulation8PSK,
     252        kModulation16APSK,
     253        kModulation32APSK,
     254        kModulationDQPSK,
     255        kModulationAnalog  = 99, /* for analog channel scanner */
    256256    };
    257257
    258258    DTVModulation(int _default = kModulationQAMAuto)
     
    414414        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
    415415};
    416416
     417class DTVModulationSystem : public DTVParamHelper
     418{
     419  protected:
     420    static const DTVParamHelperStruct confTable[];
     421    static const DTVParamHelperStruct vdrTable[];
     422    static const DTVParamHelperStruct parseTable[];
     423    static const uint kDBStrCnt = 2;
     424    static const char *dbStr[kDBStrCnt];
     425
     426  public:
     427    enum
     428    {
     429        kModulationSystemDVBS,
     430        kModulationSystemDVBS2,
     431    };
     432
     433    DTVModulationSystem(int _default = kModulationSystemDVBS)
     434        : DTVParamHelper(_default) { }
     435
     436    bool ParseConf(const QString &_value)
     437       { return ParseParam(_value, value, confTable); }
     438    bool ParseVDR(const QString &_value)
     439       { return ParseParam(_value, value, vdrTable); }
     440    bool Parse(const QString &_value)
     441       { return ParseParam(_value, value, parseTable); }
     442
     443    QString toString() const { return toString(value); }
     444
     445    static QString toString(int _value)
     446        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     447};
     448
     449class DTVRollOff : public DTVParamHelper
     450{
     451  protected:
     452    static const DTVParamHelperStruct confTable[];
     453    static const DTVParamHelperStruct vdrTable[];
     454    static const DTVParamHelperStruct parseTable[];
     455    static const uint kDBStrCnt = 4;
     456    static const char *dbStr[kDBStrCnt];
     457
     458  public:
     459    enum
     460    {
     461        kRollOff35,
     462        kRollOff20,
     463        kRollOff25,
     464        kRollOffAuto,
     465    };
     466
     467    DTVRollOff(int _default = kRollOff35)
     468        : DTVParamHelper(_default) { }
     469
     470    bool ParseConf(const QString &_value)
     471       { return ParseParam(_value, value, confTable); }
     472    bool ParseVDR(const QString &_value)
     473       { return ParseParam(_value, value, vdrTable); }
     474    bool Parse(const QString &_value)
     475       { return ParseParam(_value, value, parseTable); }
     476
     477    QString toString() const { return toString(value); }
     478
     479    static QString toString(int _value)
     480        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     481};
     482
     483class DTVPilot : public DTVParamHelper
     484{
     485  protected:
     486    static const DTVParamHelperStruct confTable[];
     487    static const DTVParamHelperStruct vdrTable[];
     488    static const DTVParamHelperStruct parseTable[];
     489    static const uint kDBStrCnt = 3;
     490    static const char *dbStr[kDBStrCnt];
     491
     492  public:
     493    enum
     494    {
     495        kPilotOn,
     496        kPilotOff,
     497        kPilotAuto,
     498    };
     499
     500    DTVPilot(int _default = kPilotAuto)
     501        : DTVParamHelper(_default) { }
     502
     503    bool ParseConf(const QString &_value)
     504       { return ParseParam(_value, value, confTable); }
     505
     506    QString toString() const { return toString(value); }
     507
     508    static QString toString(int _value)
     509        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     510};
     511
    417512#endif // _DTVCONFPARSERHELPERS_H_
  • libs/libmythtv/channelscan/scaninfo.cpp

     
    7676        "       hp_code_rate,      lp_code_rate,   modulation, "
    7777        "       transmission_mode, guard_interval, hierarchy, "
    7878        "       modulation,        bandwidth,      sistandard, "
    79         "       tuner_type,        transportid "
     79        "       tuner_type,        transportid, "
     80        "       msystem,           rolloff "
    8081        "FROM channelscan_dtv_multiplex "
    8182        "WHERE scanid = :SCANID");
    8283    query.bindValue(":SCANID", scanid);
     
    9798            query.value(6).toString(),  query.value(7).toString(),
    9899            query.value(8).toString(),  query.value(9).toString(),
    99100            query.value(10).toString(), query.value(11).toString(),
    100             query.value(12).toString());
     101            query.value(12).toString(), query.value(16).toString(),
     102            query.value(17).toString());
    101103
    102104        query2.prepare(
    103105            "SELECT "
  • libs/libmythtv/channelscan/channelscan_sm.cpp

     
    14391439            startChan["coderate_hp"],    startChan["coderate_lp"],
    14401440            startChan["constellation"],  startChan["trans_mode"],
    14411441            startChan["guard_interval"], startChan["hierarchy"],
    1442             startChan["modulation"],     startChan["bandwidth"]);
     1442            startChan["modulation"],     startChan["bandwidth"],
     1443            startChan["msystem"],        startChan["rolloff"]);
    14431444    }
    14441445
    14451446    if (ok)
  • libs/libmythtv/channelscan/modulationsetting.h

     
    5858    {
    5959        addSelection(QObject::tr("Auto"),"auto",true);
    6060        addSelection("QPSK","qpsk");
    61 #ifdef FE_GET_EXTENDED_INFO
    6261        addSelection("8PSK","8psk");
    63 #endif
    6462        addSelection("QAM 16","qam_16");
    6563        addSelection("QAM 32","qam_32");
    6664        addSelection("QAM 64","qam_64");
  • libs/libmythtv/channelscan/channelscanmiscsettings.h

     
    151151        addSelection("6/7");
    152152        addSelection("7/8");
    153153        addSelection("8/9");
     154        addSelection("3/5");
     155        addSelection("4/5");
     156        addSelection("9/10");
    154157    }
    155158};
    156159
     
    165168    }
    166169};
    167170
     171class ScanModulationSystem: public ComboBoxSetting, public TransientStorage
     172{
     173  public:
     174    ScanModulationSystem() : ScanModulationSystemSetting(this)
     175    {
     176        setLabel(QObject::tr("Modul. System"));
     177        setHelpText(QObject::tr("Modulation System (Default: DVB-S)"));
     178        addSelection("DVB-S","dvbs",true);
     179        addSelection("DVB-S2","dvbs2");
     180    };
     181};
     182
     183
     184class ScanRollOff: public ComboBoxSetting
     185{
     186  public:
     187    ScanRollOff(Storage *_storage) : ComboBoxSetting(_storage)
     188    {
     189        setLabel(QObject::tr("Roll-off"));
     190        setHelpText(QObject::tr(
     191                        "Roll-off (Default: Auto):\n"
     192                        "The  DVB-S2  standard  in  addition \n"
     193                        " to  the  single  DVB-S    35%  roll-off\n"
     194                        " factor,  provides  two  additional roll-off\n"
     195                        " factors to further increase transponder efficiency"));
     196        addSelection(QObject::tr("Auto"),"auto");
     197        addSelection("0.35","0.35",true);
     198        addSelection("0.20");
     199        addSelection("0.25");
     200    }
     201};
     202
    168203class ScanCodeRateLP: public ScanFecSetting, public TransientStorage
    169204{
    170205  public:
  • libs/libmythtv/channelscan/channelscanner.cpp

     
    143143    }
    144144    else if ((ScanTypeSetting::NITAddScan_DVBT == scantype) ||
    145145             (ScanTypeSetting::NITAddScan_DVBS == scantype) ||
     146             (ScanTypeSetting::NITAddScan_DVBS2 == scantype) ||     
    146147             (ScanTypeSetting::NITAddScan_DVBC == scantype))
    147148    {
    148149        VERBOSE(VB_SIPARSER, LOC + "ScanTransports()");
     
    219220    DTVConfParser::cardtype_t type = DTVConfParser::UNKNOWN;
    220221    type = (CardUtil::DVBT == cardtype) ? DTVConfParser::OFDM : type;
    221222    type = (CardUtil::QPSK == cardtype) ? DTVConfParser::QPSK : type;
     223    type = (CardUtil::DVBS2 == cardtype) ? DTVConfParser::DVBS2 : type;
    222224    type = (CardUtil::DVBC == cardtype) ? DTVConfParser::QAM  : type;
    223225    type = ((CardUtil::ATSC == cardtype) ||
    224226            (CardUtil::HDHOMERUN == cardtype)) ? DTVConfParser::ATSC : type;
     
    302304        QString sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper();
    303305        bool need_nit = (("QAM"  == sub_type) ||
    304306                         ("QPSK" == sub_type) ||
     307                         ("DVB_S2" == sub_type) ||
    305308                         ("OFDM" == sub_type));
    306309
    307310        // Ugh, Some DVB drivers don't fully support signal monitoring...
  • libs/libmythtv/channelscan/panedvbs2.h

     
    2222        left->addChild( pfrequency  = new ScanFrequency());
    2323        left->addChild( ppolarity   = new ScanPolarity());
    2424        left->addChild( psymbolrate = new ScanSymbolRate());
    25         right->addChild(pfec        = new ScanFec());
     25        left->addChild( pfec        = new ScanFec());
     26        right->addChild(pmsystem    = new ScanModulationSystem());
    2627        right->addChild(pmodulation = new ScanModulation());
    2728        right->addChild(pinversion  = new ScanInversion());
     29        right->addChild(prolloff    = new ScanRollOff());
    2830        addChild(left);
    2931        addChild(right);     
    3032    }
     
    3537    QString fec(void)        const { return pfec->getValue();        }
    3638    QString polarity(void)   const { return ppolarity->getValue();   }
    3739    QString modulation(void) const { return pmodulation->getValue(); }
     40    QString rolloff(void)    const { return prolloff->getValue();     }
     41    QString msystem(void)    const { return pmsystem->getValue();     }
    3842
    3943  protected:
    40     ScanFrequency  *pfrequency;
    41     ScanSymbolRate *psymbolrate;
    42     ScanInversion  *pinversion;
    43     ScanFec        *pfec;
    44     ScanPolarity   *ppolarity;
    45     ScanModulation *pmodulation;
     44    ScanFrequency           *pfrequency;
     45    ScanSymbolRate          *psymbolrate;
     46    ScanInversion           *pinversion;
     47    ScanFec                 *pfec;
     48    ScanPolarity            *ppolarity;
     49    ScanModulation          *pmodulation;
     50    ScanRollOff             *prolloff;
     51    ScanModulationSystem    *pmsystem;
    4652};
    4753
    4854#endif // _PANE_DVBS2_H_
  • libs/libmythtv/channelscan/scanwizardconfig.cpp

     
    133133        addSelection(tr("Import channels.conf"),
    134134                     QString::number(DVBUtilsImport));
    135135        break;
     136    case CardUtil::DVBS2:
     137        addSelection(tr("Full Scan (Tuned)"),
     138                     QString::number(NITAddScan_DVBS2));
     139        addSelection(tr("Import channels.conf"),
     140                     QString::number(DVBUtilsImport));
     141        break;
    136142    case CardUtil::QAM:
    137143        addSelection(tr("Full Scan (Tuned)"),
    138144                     QString::number(NITAddScan_DVBC));
     
    329335        startChan["modulation"] = "qpsk";
    330336        startChan["polarity"]   = pane->polarity();
    331337    }
     338    else if (ScanTypeSetting::NITAddScan_DVBS2 == st)
     339    {
     340        const PaneDVBS2 *pane = paneDVBS2;
     341
     342        startChan["std"]        = "dvb";
     343        startChan["frequency"]  = pane->frequency();
     344        startChan["inversion"]  = pane->inversion();
     345        startChan["symbolrate"] = pane->symbolrate();
     346        startChan["fec"]        = pane->fec();
     347        startChan["modulation"] = pane->modulation();;
     348        startChan["polarity"]   = pane->polarity();
     349        startChan["rolloff"]    = pane->rolloff();
     350    }
    332351    else if (ScanTypeSetting::NITAddScan_DVBC == st)
    333352    {
    334353        const PaneDVBC *pane = paneDVBC;
  • libs/libmythtv/dtvconfparserhelpers.cpp

     
    6969    { "QAM",     kTunerTypeQAM     },
    7070    { "OFDM",    kTunerTypeOFDM    },
    7171    { "ATSC",    kTunerTypeATSC    },
     72    { "DVB_S2",  kTunerTypeDVB_S2  },   
    7273    { "DVB_S",   kTunerTypeDVB_S   },
    7374    { "DVB_C",   kTunerTypeDVB_C   },
    7475    { "DVB_T",   kTunerTypeDVB_T   },
    75     { "DVB_S2",  kTunerTypeDVB_S2  },
    7676    { "UNKNOWN", kTunerTypeUnknown },
    7777    { NULL,      kTunerTypeUnknown },
    7878};
     
    149149    { "FEC_1_2",  kFEC_1_2  },
    150150    { "FEC_2_3",  kFEC_2_3  },
    151151    { "FEC_3_4",  kFEC_3_4  },
     152    { "FEC_3_5",  kFEC_3_5  },
    152153    { "FEC_4_5",  kFEC_4_5  },
    153154    { "FEC_5_6",  kFEC_5_6  },
    154155    { "FEC_6_7",  kFEC_6_7  },
    155156    { "FEC_7_8",  kFEC_7_8  },
    156157    { "FEC_8_9",  kFEC_8_9  },
     158    { "FEC_9_10", kFEC_9_10  },
    157159    { "FEC_NONE", kFECNone },
    158160    { NULL,       kFECAuto },
    159161};
     
    164166    { "12",  kFEC_1_2 },
    165167    { "23",  kFEC_2_3 },
    166168    { "34",  kFEC_3_4 },
     169    { "35",  kFEC_3_5 },
    167170    { "45",  kFEC_4_5 },
    168171    { "56",  kFEC_5_6 },
    169172    { "67",  kFEC_6_7 },
    170173    { "78",  kFEC_7_8 },
    171174    { "89",  kFEC_8_9 },
     175    { "910",  kFEC_9_10 },
    172176    { "0",   kFECNone },
    173177    { NULL,  kFECAuto }
    174178};
     
    179183    { "1/2",  kFEC_1_2 },
    180184    { "2/3",  kFEC_2_3 },
    181185    { "3/4",  kFEC_3_4 },
     186    { "3/5",  kFEC_3_5 },
    182187    { "4/5",  kFEC_4_5 },
    183188    { "5/6",  kFEC_5_6 },
    184189    { "6/7",  kFEC_6_7 },
    185190    { "7/8",  kFEC_7_8 },
    186191    { "8/9",  kFEC_8_9 },
     192    { "9/10", kFEC_9_10 },
    187193    { "none", kFECNone },
    188194    { NULL,   kFECAuto }
    189195};
     
    199205     "6/7",  ///< kFEC_6_7
    200206     "7/8",  ///< kFEC_7_8
    201207     "8/9",  ///< kFEC_8_9
    202      "auto"  ///< kFECAuto
     208     "auto", ///< kFECAuto
     209     "3/5",  ///< kFEC_3_5
     210     "9/10", ///< kFEC_9_10
    203211};
    204212
    205213const DTVParamHelperStruct DTVModulation::confTable[] =
     
    213221   { "QPSK",     kModulationQPSK    },
    214222   { "8VSB",     kModulation8VSB    },
    215223   { "16VSB",    kModulation16VSB   },
    216    { "2VSB",     kModulation2VSB    },
    217    { "4VSB",     kModulation4VSB    },
    218    { "BPSK",     kModulationBPSK    },
    219224   { "16APSK",   kModulation16APSK  },
    220225   { "32APSK",   kModulation32APSK  },
    221226   { "8PSK",     kModulation8PSK    },
    222    { "16PSK",    kModulation16PSK   },
    223    { "analog",   kModulation16PSK   },
     227   { "DQPSK",    kModulationDQPSK   },
     228   { "analog",   kModulationAnalog  },
    224229   { NULL,       kModulationQAMAuto },
    225230};
    226231
     
    232237   { "64",  kModulationQAM64   },
    233238   { "128", kModulationQAM128  },
    234239   { "256", kModulationQAM256  },
     240   { "2",   kModulationQPSK    },
     241   { "10",  kModulation8VSB    },
     242   { "11",  kModulation16VSB   },
     243   { "6",   kModulation16APSK  },
     244   { "7",   kModulation32APSK  },
     245   { "5",   kModulation8PSK    },   
    235246   { "0",   kModulationQPSK    },
    236247   { NULL,  kModulationQAMAuto },
    237248};
     
    247258   { "qpsk",     kModulationQPSK    },
    248259   { "8vsb",     kModulation8VSB    },
    249260   { "16vsb",    kModulation16VSB   },
    250    { "2vsb",     kModulation2VSB    },
    251    { "4vsb",     kModulation4VSB    },
    252    { "bpsk",     kModulationBPSK    },
    253261   { "16apsk",   kModulation16APSK  },
    254262   { "32apsk",   kModulation32APSK  },
    255263   { "8psk",     kModulation8PSK    },
    256    { "16psk",    kModulation16PSK   },
     264   { "dqpsk",    kModulationDQPSK   },
    257265   // alternates
    258266   { "a",        kModulationQAMAuto },
    259267   { "qam_auto", kModulationQAMAuto },
     
    262270   { "qam-64",   kModulationQAM64   },
    263271   { "qam-128",  kModulationQAM128  },
    264272   { "qam-256",  kModulationQAM256  },
    265    // qpsk, no alternative
    266273   { "8-vsb",    kModulation8VSB    },
    267274   { "16-vsb",   kModulation16VSB   },
    268    { "2-vsb",    kModulation2VSB    },
    269    { "4-vsb",    kModulation4VSB    },
    270    // bpsk, no alternative
    271275   { "16-apsk",  kModulation16APSK  },
    272276   { "32-apsk",  kModulation32APSK  },
    273277   { "8-psk",    kModulation8PSK    },
    274    { "16-psk",   kModulation16PSK   },
     278   { "16psk",    kModulationDQPSK   },
     279   { "16-psk",   kModulationDQPSK   },   
     280   { "dq-psk",   kModulationDQPSK   },
    275281   { NULL,       kModulationQAMAuto },
    276282};
    277283
     
    286292    "auto",    ///< kModulationQAMAuto
    287293    "8vsb",    ///< kModulation8VSB
    288294    "16vsb",   ///< kModulation16VSB
    289     "2vsb",    ///< kModulation2VSB
    290     "4vsb",    ///< kModulation4VSB
    291     "bpsk",    ///< kModulationBPSK
     295    "8psk",    ///< kModulation8PSK
    292296    "16apsk",  ///< kModulation16APSK
    293297    "32apsk",  ///< kModulation32APSK
    294     "8psk",    ///< kModulation8PSK
    295     "16psk",   ///< kModulation16PSK
     298    "dqpsk",   ///< kModulationDQPSK
    296299};
    297300
    298301const DTVParamHelperStruct DTVTransmitMode::confTable[] =
     
    420423   "r", ///< kPolarityRight
    421424   "l"  ///< kPolarityLeft
    422425};
     426
     427const DTVParamHelperStruct DTVModulationSystem::confTable[] =
     428{
     429   { "SYS_DVBS",  kModulationSystemDVBS  },
     430   { "SYS_DVBS2", kModulationSystemDVBS2 },
     431   { NULL,        kModulationSystemDVBS  },
     432};
     433
     434const DTVParamHelperStruct DTVModulationSystem::vdrTable[] =
     435{
     436   { "0",  kModulationSystemDVBS  },
     437   { "1",  kModulationSystemDVBS2 },
     438   { NULL, kModulationSystemDVBS  },
     439};
     440
     441const DTVParamHelperStruct DTVModulationSystem::parseTable[] =
     442{
     443   { "dvbs2", kModulationSystemDVBS2 },
     444   { "dvbs",  kModulationSystemDVBS  },
     445   { NULL,    kModulationSystemDVBS  },
     446};
     447
     448const char *DTVModulationSystem::dbStr[DTVModulationSystem::kDBStrCnt] =
     449{
     450    "dvbs",  ///< kModulationSystemDVBS
     451    "dvbs2", ///< kModulationSystemDVBS2
     452};
     453
     454const DTVParamHelperStruct DTVRollOff::confTable[] =
     455{
     456   { "ROLLOFF_35",   kRollOff35   },
     457   { "ROLLOFF_20",   kRollOff20   },
     458   { "ROLLOFF_25",   kRollOff25   },
     459   { "ROLLOFF_AUTO", kRollOffAuto },
     460   { NULL,           kRollOffAuto },
     461};
     462
     463const DTVParamHelperStruct DTVRollOff::vdrTable[] =
     464{
     465   { "35",   kRollOff35   },
     466   { "20",   kRollOff20   },
     467   { "25",   kRollOff25   },
     468   { "0",    kRollOffAuto },
     469   { NULL,   kRollOff35   },
     470};
     471
     472const DTVParamHelperStruct DTVRollOff::parseTable[] =
     473{
     474   { "0.35",   kRollOff35   },
     475   { "0.20",   kRollOff20   },
     476   { "0.25",   kRollOff25   },
     477   { "auto",   kRollOffAuto },
     478   { NULL,     kRollOff35   },
     479};
     480
     481const char *DTVRollOff::dbStr[DTVRollOff::kDBStrCnt] =
     482{
     483   "0.35",   ///< kRollOff35
     484   "0.20",   ///< kRollOff20
     485   "0.25",   ///< kRollOff25
     486   "auto",   ///< kRollOffAuto
     487};
  • libs/libmythtv/dtvconfparser.cpp

     
    112112        {
    113113            if ((type == OFDM) && (str == "T"))
    114114                ok &= ParseVDR(list, channelNo);
    115             else if ((type == QPSK) && (str == "S"))
     115            else if (((type == QPSK) || (type == DVBS2)) && (str == "S"))
    116116                ok &= ParseVDR(list, channelNo);
    117117            else if ((type == QAM) && (str == "C"))
    118118                ok &= ParseVDR(list, channelNo);
     
    121121            ok &= ParseConfOFDM(list);
    122122        else if (type == ATSC)
    123123            ok &= ParseConfATSC(list);
    124         else if (type == QPSK)
     124        else if ((type == QPSK) || (type == DVBS2))
    125125            ok &= ParseConfQPSK(list);
    126126        else if (type == QAM)
    127127            ok &= ParseConfQAM(list);
     
    274274            case 'R':
    275275            case 'L':
    276276                mux.polarity.ParseVDR(ori);
     277            case 'S':
     278                mux.msystem.ParseVDR(params);
     279            case 'O':
     280                mux.rolloff.ParseVDR(params);
    277281                break;
    278282            default:
    279283                return false;
  • libs/libmythtv/dtvmultiplex.h

     
    4848        const QString &frequency,    const QString &inversion,
    4949        const QString &symbol_rate,  const QString &fec_inner,
    5050        const QString &modulation,   const QString &polarity);
     51       
     52    bool ParseDVB_S2(
     53        const QString &frequency,    const QString &inversion,
     54        const QString &symbol_rate,  const QString &fec_inner,
     55        const QString &modulation,   const QString &polarity,
     56        const QString &msystem,      const QString &rolloff);
    5157
    5258    bool ParseTuningParams(
    5359        DTVTunerType type,
     
    5561        QString fec,          QString polarity,
    5662        QString hp_code_rate, QString lp_code_rate,   QString constellation,
    5763        QString trans_mode,   QString guard_interval, QString hierarchy,
    58         QString modulation,   QString bandwidth);
     64        QString modulation,   QString bandwidth,
     65        QString msystem,      QString rolloff);
    5966
    6067    QString toString() const;
    6168
     
    7481    DTVHierarchy     hierarchy;
    7582    DTVPolarity      polarity;
    7683    DTVCodeRate      fec; ///< Inner Forward Error Correction rate
     84    DTVModulationSystem msystem;
     85    DTVRollOff          rolloff;
    7786
    7887    // Optional additional info
    7988    uint             mplex;
  • libs/libmythtv/channelutil.h

     
    6767        signed char trans_mode,
    6868        QString     inner_FEC,    QString     constellation,
    6969        signed char hierarchy,    QString     hp_code_rate,
    70         QString     lp_code_rate, QString     guard_interval);
     70        QString     lp_code_rate, QString     guard_interval,
     71        QString     msystem,      QString     rolloff);
    7172
    7273    static uint    CreateMultiplex(uint sourceid, const DTVMultiplex&,
    7374                                   int transport_id, int network_id);
     
    9091                                   uint64_t &frequency,
    9192                                   uint     &dvb_transportid,
    9293                                   uint     &dvb_networkid,
     94                                   QString  &msystem,
     95                                   QString  &rolloff,
    9396                                   QString  &si_std);
    9497
    9598    static bool    GetATSCChannel(uint sourceid, const QString &channum,
     
    159162        QString &dtv_si_std,      int     &mpeg_prog_num,
    160163        uint    &atsc_major,      uint          &atsc_minor,
    161164        uint    &dvb_transportid, uint          &dvb_networkid,
     165        QString &msystem,         QString       &rolloff,
    162166        uint    &mplexid,         bool          &commfree);
    163167    static bool    GetChannelSettings(int chanid, bool &useonairguide,
    164168                                    bool &hidden);
  • libs/libmythtv/cardutil.h

     
    5454        HDHOMERUN = 10,
    5555        FREEBOX   = 11,
    5656        HDPVR     = 12,
     57        DVBS2     = 13,
    5758    };
    5859
    5960    static enum CARD_TYPES toCardType(const QString &name)
     
    8485            return FREEBOX;
    8586        if ("HDPVR" == name)
    8687            return HDPVR;
     88        if ("DVB_S2" == name)
     89            return DVBS2;
    8790        return ERROR_UNKNOWN;
    8891    }
    8992
  • libs/libmythtv/scanwizardhelpers.h

     
    243243        // seen in the Network Information Tables to the scan.
    244244        NITAddScan_OFDM,
    245245        NITAddScan_QPSK,
     246        NITAddScan_DVBS2,
    246247        NITAddScan_QAM,
    247248        // Scan of all transports already in the database
    248249        FullTransportScan,
     
    274275    QString GetATSCFormat(const QString&)    const;
    275276    QString GetFrequencyStandard(void)       const;
    276277    QString GetModulation(void)              const;
     278    QString GetRollOff(void)                 const;
    277279    QString GetFrequencyTable(void)          const;
    278280    bool    DoIgnoreSignalTimeout(void)      const;
    279281    QString GetFilename(void)                const;
     
    510512    {
    511513        addSelection(QObject::tr("Auto"),"auto",true);
    512514        addSelection("QPSK","qpsk");
    513 #ifdef FE_GET_EXTENDED_INFO
    514515        addSelection("8PSK","8psk");
    515 #endif
    516516        addSelection("QAM 16","qam_16");
    517517        addSelection("QAM 32","qam_32");
    518518        addSelection("QAM 64","qam_64");
     
    531531    };
    532532};
    533533
     534class ScanModulationSystemSetting: public ComboBoxSetting
     535{
     536  public:
     537    ScanModulationSystemSetting(Storage *_storage) : ComboBoxSetting(_storage)
     538    {
     539        addSelection("DVB-S","dvbs",true);
     540        addSelection("DVB-S2","dvbs2");
     541    };
     542};
     543
     544class ScanModulationSystem: public ScanModulationSystemSetting, public TransientStorage
     545{
     546  public:
     547    ScanModulationSystem() : ScanModulationSystemSetting(this)
     548    {
     549        setLabel(QObject::tr("Modul. System"));
     550        setHelpText(QObject::tr("Modulation System (Default: DVB-S)"));
     551    };
     552};
     553
     554class ScanRollOffSetting: public ComboBoxSetting
     555{
     556  public:
     557    ScanRollOffSetting(Storage *_storage) : ComboBoxSetting(_storage)
     558    {
     559        addSelection(QObject::tr("Auto"),"auto");
     560        addSelection("0.35","0.35",true);
     561        addSelection("0.20","0.20");
     562        addSelection("0.25","0.25");
     563    };
     564};
     565
     566class ScanRollOff: public ScanRollOffSetting, public TransientStorage
     567{
     568  public:
     569    ScanRollOff() : ScanRollOffSetting(this)
     570    {
     571        setLabel(QObject::tr("RollOff"));
     572        setHelpText(QObject::tr("RollOff (Default: 0.35)"));
     573    };
     574};
     575
    534576class ScanConstellation: public ScanModulationSetting,
    535577                         public TransientStorage
    536578{
     
    552594        addSelection("1/2");
    553595        addSelection("2/3");
    554596        addSelection("3/4");
     597        addSelection("3/5");
    555598        addSelection("4/5");
    556599        addSelection("5/6");
    557600        addSelection("6/7");
    558601        addSelection("7/8");
    559602        addSelection("8/9");
     603        addSelection("9/10");
    560604    }
    561605};
    562606
     
    692736        left->addChild( pfrequency  = new ScanFrequency());
    693737        left->addChild( ppolarity   = new ScanPolarity());
    694738        left->addChild( psymbolrate = new ScanSymbolRate());
    695         right->addChild(pfec        = new ScanFec());
     739        left->addChild(pfec         = new ScanFec());
     740        right->addChild(pmsystem    = new ScanModulationSystem());
    696741        right->addChild(pmodulation = new ScanModulation());
    697742        right->addChild(pinversion  = new ScanInversion());
     743        right->addChild(prolloff    = new ScanRollOff());
    698744        addChild(left);
    699745        addChild(right);
    700746    }
     
    704750    QString inversion(void)  const { return pinversion->getValue();  }
    705751    QString fec(void)        const { return pfec->getValue();        }
    706752    QString polarity(void)   const { return ppolarity->getValue();   }
     753    QString msystem(void)    const { return pmsystem->getValue();    }
    707754    QString modulation(void) const { return pmodulation->getValue(); }
     755    QString rolloff(void)    const { return prolloff->getValue();    }
    708756
    709757  protected:
    710758    ScanFrequency  *pfrequency;
     
    713761    ScanFec        *pfec;
    714762    ScanPolarity   *ppolarity;
    715763    ScanModulation *pmodulation;
     764    ScanModulationSystem *pmsystem;
     765    ScanRollOff          *prolloff;
    716766};
    717767
    718768class QPSKPane : public HorizontalConfigurationGroup
  • libs/libmythtv/scanwizardscanner.cpp

     
    364364    }
    365365    else if ((ScanTypeSetting::NITAddScan_OFDM == scantype) ||
    366366             (ScanTypeSetting::NITAddScan_QPSK == scantype) ||
     367             (ScanTypeSetting::NITAddScan_DVBS2 == scantype) ||
    367368             (ScanTypeSetting::NITAddScan_QAM  == scantype))
    368369    {
    369370        VERBOSE(VB_SIPARSER, LOC + "ScanTransports()");
     
    490491        QString sub_type = CardUtil::ProbeDVBType(device).toUpper();
    491492        bool need_nit = (("QAM"  == sub_type) ||
    492493                         ("QPSK" == sub_type) ||
     494                         ("DVB_S2" == sub_type) ||
    493495                         ("OFDM" == sub_type));
    494496
    495497        // Ugh, Some DVB drivers don't fully support signal monitoring...
  • libs/libmythtv/hdhrchannel.cpp

     
    291291
    292292    // Fetch tuning data from the database.
    293293    QString tvformat, modulation, freqtable, freqid, si_std;
     294    QString msystem, rolloff;
    294295    int finetune;
    295296    uint64_t frequency;
    296297    int mpeg_prog_num;
     
    301302        tvformat, modulation, freqtable, freqid,
    302303        finetune, frequency,
    303304        si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
     305        msystem, rolloff,
    304306        mplexid, commfree))
    305307    {
    306308        return false;
     
    369371    uint64_t frequency;
    370372    uint     transportid;
    371373    uint     dvb_networkid;
     374    QString  dvb_msystem;
     375    QString  dvb_rolloff;
    372376
    373377    if (!ChannelUtil::GetTuningParams(
    374378            mplexid, modulation, frequency,
    375             transportid, dvb_networkid, si_std))
     379            transportid, dvb_networkid,
     380            dvb_msystem, dvb_rolloff, si_std))
    376381    {
    377382        VERBOSE(VB_IMPORTANT, LOC_ERR + "TuneMultiplex(): " +
    378383                QString("Could not find tuning parameters for multiplex %1.")
  • libs/libmythtv/siscan.cpp

     
    903903    nextIt = transport_scan_items_it_t( scanTransports.end() );
    904904
    905905    DTVMultiplex tuning;
    906 
     906    DTVModulation modulation;
     907    DTVModulationSystem msystem;
    907908    DTVTunerType type;
    908909
    909910    if (std == "dvb")
    910911    {
    911         ok = type.Parse(mod);
     912        if (!modulation.Parse(*(startChan.find("modulation"))))
     913        {
     914            VERBOSE(VB_IMPORTANT, LOC + "Wrong modulation.");
     915            return false;
     916        }
     917
     918        if (modulation == DTVModulation::kModulationQPSK)
     919        {
     920            type = DTVTunerType::kTunerTypeQPSK;
     921            ok = true;
     922            if (startChan.find("msystem") != startChan.end())
     923            {
     924                if (!msystem.Parse(*(startChan.find("msystem"))))
     925                {
     926                    VERBOSE(VB_IMPORTANT, LOC + "Wrong modulation system.");
     927                    return false;
     928                }
     929                if (msystem == DTVModulationSystem::kModulationSystemDVBS2)
     930                    type = DTVTunerType::kTunerTypeDVB_S2;
     931            }
     932        }       
     933        else if (modulation == DTVModulation::kModulation8PSK)
     934        {
     935            type = DTVTunerType::kTunerTypeDVB_S2;
     936            ok = true;
     937        }
     938        else
     939            ok = type.Parse(mod);
    912940    }
    913941    else if (std == "atsc")
    914942    {
     
    926954            startChan["coderate_hp"],    startChan["coderate_lp"],
    927955            startChan["constellation"],  startChan["trans_mode"],
    928956            startChan["guard_interval"], startChan["hierarchy"],
    929             startChan["modulation"],     startChan["bandwidth"]);
     957            startChan["modulation"],     startChan["bandwidth"],
     958            startChan["msystem"],        startChan["rolloff"]);
    930959    }
    931960
    932961    if (ok)
     
    15661595    const uint transportid, const uint networkid)
    15671596{
    15681597    uint64_t    db_freq;
    1569     QString     tmp_modulation;
     1598    QString     tmp_modulation, tmp_msystem, tmp_rolloff;
    15701599    QString     tmp_si_std;
    15711600    uint        tmp_transportid, tmp_networkid;
    15721601    int         mplexid;
     
    15801609
    15811610    if (!ChannelUtil::GetTuningParams(
    15821611            (uint)mplexid, tmp_modulation,
    1583             db_freq, tmp_transportid, tmp_networkid, tmp_si_std))
     1612            db_freq, tmp_transportid, tmp_networkid,
     1613            tmp_msystem, tmp_rolloff, tmp_si_std))
    15841614    {
    15851615        return tuning_freq;
    15861616    }
  • libs/libmythtv/dtvconfparser.h

     
    8080{
    8181  public:
    8282    enum return_t   { ERROR_CARDTYPE, ERROR_OPEN, ERROR_PARSE, OK };
    83     enum cardtype_t { ATSC, OFDM, QPSK, QAM, UNKNOWN };
     83    enum cardtype_t { ATSC, OFDM, QPSK, DVBS2, QAM, UNKNOWN };
    8484
    8585    DTVConfParser(enum cardtype_t _type, uint sourceid, const QString &_file);
    8686    virtual ~DTVConfParser() { }
  • libs/libmythtv/channelbase.cpp

     
    190190
    191191    // Fetch tuning data from the database.
    192192    QString tvformat, modulation, freqtable, freqid, dtv_si_std;
     193    QString msystem, rolloff;
    193194    int finetune;
    194195    uint64_t frequency;
    195196    int mpeg_prog_num;
     
    201202        tvformat, modulation, freqtable, freqid,
    202203        finetune, frequency,
    203204        dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
     205        msystem, rolloff,
    204206        mplexid, commfree))
    205207    {
    206208        VERBOSE(VB_IMPORTANT, loc + " " + QString(
  • libs/libmythtv/dvbchannel.h

     
    1818#include "streamlisteners.h"
    1919#include "diseqc.h"
    2020
     21#ifdef USING_DVB
     22#include "dvbtypes.h"
     23#endif
     24
    2125class TVRec;
    2226class DVBCam;
    2327class DVBRecorder;
     
    117121    QString           frontend_name;
    118122    DTVTunerType      card_type;
    119123    uint64_t          capabilities;
    120     uint64_t          ext_modulations;
    121124    uint64_t          frequency_minimum;
    122125    uint64_t          frequency_maximum;
    123126    uint              symbol_rate_minimum;
  • libs/libmythtv/channelutil.cpp

     
    121121    signed char trans_mode,
    122122    QString     inner_FEC,     QString      constellation,
    123123    signed char hierarchy,     QString      hp_code_rate,
    124     QString     lp_code_rate,  QString      guard_interval)
     124    QString     lp_code_rate,  QString     guard_interval,
     125    QString     msystem,       QString     rolloff)
    125126{
    126127    MSqlQuery query(MSqlQuery::InitCon());
    127128
     
    165166        "lp_code_rate     = :LP_CODE_RATE, " : "";
    166167    updateStr += (!guard_interval.isNull()) ?
    167168        "guard_interval   = :GUARD_INTERVAL, " : "";
     169    updateStr += (!msystem.isNull()) ?
     170        "msystem          = :MSYSTEM, " : "";
     171    updateStr += (!rolloff.isNull()) ?
     172        "rolloff          = :ROLLOFF, " : "";
    168173
    169174    updateStr = updateStr.left(updateStr.length()-2) + " ";
    170175
     
    194199    insertStr += (!hp_code_rate.isNull())   ? "hp_code_rate, "      : "";
    195200    insertStr += (!lp_code_rate.isNull())   ? "lp_code_rate, "      : "";
    196201    insertStr += (!guard_interval.isNull()) ? "guard_interval, "    : "";
     202    insertStr += (!msystem.isNull())        ? "msystem, "           : "";
     203    insertStr += (!rolloff.isNull())        ? "rolloff, "           : "";
    197204    insertStr = insertStr.left(insertStr.length()-2) + ") ";
    198205
    199206    insertStr +=
     
    213220    insertStr += (!hp_code_rate.isNull())   ? ":HP_CODE_RATE, "     : "";
    214221    insertStr += (!lp_code_rate.isNull())   ? ":LP_CODE_RATE, "     : "";
    215222    insertStr += (!guard_interval.isNull()) ? ":GUARD_INTERVAL, "   : "";
     223    insertStr += (!msystem.isNull())        ? ":MSYSTEM, "          : "";
     224    insertStr += (!rolloff.isNull())        ? ":ROLLOFF, "          : "";
    216225    insertStr = insertStr.left(insertStr.length()-2) + ");";
    217226
    218227    query.prepare((mplex) ? updateStr : insertStr);
     
    254263        query.bindValue(":LP_CODE_RATE",  lp_code_rate);
    255264    if (!guard_interval.isNull())
    256265        query.bindValue(":GUARD_INTERVAL",guard_interval);
     266    if (!msystem.isNull())
     267        query.bindValue(":MSYSTEM",       msystem);
     268    if (!rolloff.isNull())
     269        query.bindValue(":ROLLOFF",       rolloff);
    257270
    258271    if (!query.exec() || !query.isActive())
    259272    {
     
    292305        {
    293306            QString dummy_mod;
    294307            QString dummy_sistd;
     308            QString dummy_msystem;
     309            QString dummy_rolloff;
    295310            uint dummy_tsid, dummy_netid;
    296311            ChannelUtil::GetTuningParams(mux, dummy_mod, freq,
    297                                          dummy_tsid, dummy_netid, dummy_sistd);
     312                                         dummy_tsid, dummy_netid,
     313                                         dummy_msystem, dummy_rolloff,
     314                                         dummy_sistd);
    298315        }
    299316
    300317        mux = ChannelUtil::CreateMultiplex(
     
    307324            cd.TransmissionModeString()[0].toAscii(),
    308325            QString(),                         cd.ConstellationString(),
    309326            cd.HierarchyString()[0].toAscii(), cd.CodeRateHPString(),
    310             cd.CodeRateLPString(),             cd.GuardIntervalString());
     327            cd.CodeRateLPString(),             cd.GuardIntervalString(),
     328            QString(),                         QString());
    311329
    312330        if (mux)
    313331            muxes.push_back(mux);
     
    334352            -1,
    335353            cd.FECInnerString(),  QString(),
    336354            -1,                   QString(),
    337             QString(),            QString());
     355            QString(),                   QString(),
     356            cd.ModulationSystemString(), cd.RollOffString());
    338357
    339358        if (mux)
    340359            muxes.push_back(mux);
     
    357376            -1,
    358377            cd.FECInnerString(),  QString::null,
    359378            -1,                   QString::null,
    360             QString::null,        QString::null);
     379            QString::null,        QString::null,
     380            QString::null,        QString::null);
    361381
    362382        if (mux)
    363383            muxes.push_back(mux);
     
    377397        -1,
    378398        QString::null,      QString::null,
    379399        -1,                 QString::null,
    380         QString::null,      QString::null);
     400        QString::null,      QString::null,
     401        QString::null,      QString::null);
    381402}
    382403
    383404uint ChannelUtil::CreateMultiplex(
     
    390411    signed char trans_mode,
    391412    QString     inner_FEC,    QString     constellation,
    392413    signed char hierarchy,    QString     hp_code_rate,
    393     QString     lp_code_rate, QString     guard_interval)
     414    QString     lp_code_rate, QString     guard_interval,
     415    QString     msystem,      QString     rolloff)
    394416{
    395417    return insert_dtv_multiplex(
    396418        sourceid,           sistandard,
     
    402424        trans_mode,
    403425        inner_FEC,          constellation,
    404426        hierarchy,          hp_code_rate,
    405         lp_code_rate,       guard_interval);
     427        lp_code_rate,       guard_interval,
     428        msystem,            rolloff);
    406429}
    407430
    408431uint ChannelUtil::CreateMultiplex(uint sourceid, const DTVMultiplex &mux,
     
    418441        mux.trans_mode.toChar().toAscii(),
    419442        mux.fec.toString(),               mux.modulation.toString(),
    420443        mux.hierarchy.toChar().toAscii(), mux.hp_code_rate.toString(),
    421         mux.lp_code_rate.toString(),      mux.guard_interval.toString());
     444        mux.lp_code_rate.toString(),      mux.guard_interval.toString(),
     445        mux.msystem.toString(),           mux.rolloff.toString());
    422446}
    423447
    424448
     
    706730                                  uint64_t &frequency,
    707731                                  uint     &dvb_transportid,
    708732                                  uint     &dvb_networkid,
     733                                  QString  &dvb_msystem,
     734                                  QString  &dvb_rolloff,
    709735                                  QString  &si_std)
    710736{
    711737    if (!mplexid || (mplexid == 32767)) /* 32767 deals with old lineups */
     
    713739
    714740    MSqlQuery query(MSqlQuery::InitCon());
    715741    query.prepare(
    716         "SELECT transportid, networkid, frequency, modulation, sistandard "
     742        "SELECT transportid, networkid, frequency, modulation, sistandard, "
     743        "msystem, rolloff "
    717744        "FROM dtv_multiplex "
    718745        "WHERE mplexid = :MPLEXID");
    719746    query.bindValue(":MPLEXID", mplexid);
     
    732759    frequency       = (uint64_t) query.value(2).toDouble(); // Qt 3.1 compat
    733760    modulation      = query.value(3).toString();
    734761    si_std          = query.value(4).toString();
     762    dvb_msystem     = query.value(5).toString();
     763    dvb_rolloff     = query.value(6).toString();
    735764
    736765    return true;
    737766}
     
    14831512    QString &dtv_si_std,      int           &mpeg_prog_num,
    14841513    uint    &atsc_major,      uint          &atsc_minor,
    14851514    uint    &dvb_transportid, uint          &dvb_networkid,
     1515    QString &dvb_msystem,     QString       &dvb_rolloff,
    14861516    uint    &mplexid,
    14871517    bool    &commfree)
    14881518{
     
    15351565        return true;
    15361566
    15371567    return GetTuningParams(mplexid, modulation, frequency,
    1538                            dvb_transportid, dvb_networkid, dtv_si_std);
     1568                           dvb_transportid, dvb_networkid,
     1569                           dvb_msystem, dvb_rolloff, dtv_si_std);
    15391570}
    15401571
    15411572bool ChannelUtil::GetChannelSettings(int chanid, bool &useonairguide,
  • libs/libmythtv/mpeg/dvbdescriptors.h

     
    745745    bool IsLinearPolarization()   const { return !((_data[8]>>6)&0x1); }
    746746    bool IsHorizontalLeftPolarization() const { return (_data[8]>>5)&0x1; }
    747747    bool IsVerticalRightPolarization() const { return !((_data[8]>>5)&0x1); }
    748     // modulation               5   8.3
     748    // rolloff                  2   8.3
     749    uint RollOff() const { return (_data[8]>>3)&0x3; }
     750    QString RollOffString()  const
     751    {
     752        static QString ps[] = { "0.35", "0.20", "0.25", "AUTO" };
     753        return ps[Polarization()];
     754    }
     755    // modulation system        3   8.5
    749756    enum
     757    {   
     758        kModulationSystemDVBS  = 0x0,
     759        kModulationSystemDVBS2 = 0x1,
     760    };
     761    uint ModulationSystem() const { return _data[8]>>2&0x1; }
     762    QString ModulationSystemString() const
    750763    {
     764        static QString mss[] = { "dvbs", "dvbs2" };
     765        return (mss[ModulationSystem()]);
     766    }
     767    // modulation               4   8.6
     768   
     769    enum
     770    {
    751771        kModulationQPSK_NS = 0x0, // Non standard QPSK for Bell ExpressVu
    752772        kModulationQPSK   = 0x1,
    753773        kModulation8PSK   = 0x2,
    754774        kModulationQAM16  = 0x3,
    755775    };
    756     uint Modulation() const { return _data[8]&0x1f; }
     776    uint Modulation() const { return _data[8]&0x7; }
    757777    QString ModulationString() const
    758778    {
    759779        static QString ms[] = { "qpsk", "qpsk", "8psk", "qam_16" };
     
    779799        kInnerFEC_5_6_ConvolutionCodeRate = 0x4,
    780800        kInnerFEC_7_8_ConvolutionCodeRate = 0x5,
    781801        kInnerFEC_8_9_ConvolutionCodeRate = 0x6,
     802        kInnerFEC_3_5_ConvolutionCodeRate  = 0x7,
     803        kInnerFEC_4_5_ConvolutionCodeRate  = 0x8,
     804        kInnerFEC_9_10_ConvolutionCodeRate = 0x9,
     805        kInnerFEC_Auto                     = 0xA,
    782806        kInnerFEC_None                    = 0xF,
    783807    };
    784808    uint FECInner() const { return _data[12] & 0xf; }
     
    17561780{
    17571781    switch (cr)
    17581782    {
    1759         case 0x0:  return "auto"; // not actually defined in spec
     1783        case 0x0:  return "none"; // not actually defined in spec
    17601784        case 0x1:  return "1/2";
    17611785        case 0x2:  return "2/3";
    17621786        case 0x3:  return "3/4";
    17631787        case 0x4:  return "5/6";
    17641788        case 0x5:  return "7/8";
    1765         case 0x8:  return "8/9";
     1789        case 0x6:  return "8/9";
     1790        case 0x7:  return "3/5";
     1791        case 0x8:  return "4/5";
     1792        case 0x9:  return "9/10";
    17661793        case 0xf:  return "none";
    17671794        default:   return "auto"; // not actually defined in spec
    17681795    }
  • libs/libmythtv/mpeg/dvbdescriptors.cpp

     
    369369    QString str = QString("SatelliteDeliverySystemDescriptor: ");
    370370
    371371    str.append(QString("Frequency: %1\n").arg(FrequencyHz()));
    372     str.append(QString("      Mod=%1, SymbR=%2, FECInner=%3, Orbit=%4, Pol=%5")
     372    str.append(QString("      ModSys=%1, Mod=%2, RollOff=%3. SymbR=%4, FECInner=%5, Orbit=%6, Pol=%7")
     373        .arg(ModulationSystemString())
    373374        .arg(ModulationString())
     375        .arg(RollOffString())
    374376        .arg(SymbolRateHz())
    375377        .arg(FECInnerString())
    376378        .arg(OrbitalPositionString())
  • libs/libmythtv/v4lchannel.cpp

     
    453453
    454454    // Fetch tuning data from the database.
    455455    QString tvformat, modulation, freqtable, freqid, dtv_si_std;
     456    QString msystem, rolloff;
    456457    int finetune;
    457458    uint64_t frequency;
    458459    int mpeg_prog_num;
     
    463464        tvformat, modulation, freqtable, freqid,
    464465        finetune, frequency,
    465466        dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
     467        msystem, rolloff,
    466468        mplexid, commfree))
    467469    {
    468470        return false;
     
    738740    uint64_t frequency;
    739741    uint     transportid;
    740742    uint     dvb_networkid;
     743    QString  dvb_msystem;
     744    QString  dvb_rolloff;
    741745
    742746    if (!ChannelUtil::GetTuningParams(
    743747            mplexid, modulation, frequency,
    744             transportid, dvb_networkid, si_std))
     748            transportid, dvb_networkid,
     749            dvb_msystem, dvb_rolloff, si_std))
    745750    {
    746751        VERBOSE(VB_IMPORTANT, LOC_ERR + "TuneMultiplex(): " +
    747752                QString("Could not find tuning parameters for multiplex %1.")
  • libs/libmythtv/dvbtypes.h

     
    1919#include <linux/dvb/frontend.h>
    2020#include <linux/dvb/dmx.h>
    2121
    22 #if (DVB_API_VERSION != 3)
    23 #    error "DVB driver includes with API version 3 not found!"
     22#if (DVB_API_VERSION != 3 && DVB_API_VERSION != 5)
     23#    error "DVB driver includes with correct API version not found!"
    2424#endif
    2525
    2626#ifndef DVB_API_VERSION_MINOR
    2727#    define DVB_API_VERSION_MINOR 0
    2828#endif
    2929
    30 #if (DVB_API_VERSION >= 3 && DVB_API_VERSION_MINOR >= 1)
     30#if ((DVB_API_VERSION >= 3 && DVB_API_VERSION_MINOR >= 1) || (DVB_API_VERSION == 5 && DVB_API_VERSION_MINOR >= 0))
    3131#    define USE_ATSC
    3232#else
    3333#warning DVB API version < 3.1
  • libs/libmythtv/dvbchannel.cpp

     
    4949
    5050static void drain_dvb_events(int fd);
    5151static bool wait_for_backend(int fd, int timeout_ms);
     52/*
    5253static struct dvb_fe_params dtvmultiplex_to_dvbparams(
    5354    DTVTunerType, const DTVMultiplex&);
    5455static DTVMultiplex dvbparams_to_dtvmultiplex(
    5556    DTVTunerType, const dvb_fe_params&);
     57*/   
    5658
     59static bool dtvmultiplex_to_dtvproperties(
     60    DTVTunerType, const DTVMultiplex&, struct dtv_properties*, bool do_tune);
     61
     62static bool dtvmultiplex_to_dtvproperties(
     63    DTVTunerType, const DTVMultiplex&, struct dtv_properties*);
     64
     65static DTVMultiplex dtvproperties_to_dtvmultiplex(
     66    DTVTunerType, const dtv_properties&);
     67
     68
    5769#define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(device)
    5870#define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \
    5971                 .arg(GetCardID()).arg(device)
     
    149161bool DVBChannel::Open(DVBChannel *who)
    150162{
    151163    VERBOSE(VB_CHANNEL, LOC + "Opening DVB channel");
     164    VERBOSE(VB_IMPORTANT, LOC + "Opening DVB channel");
    152165
    153166    QMutexLocker locker(&hw_lock);
    154167
     
    167180        frontend_name       = master->frontend_name;
    168181        card_type           = master->card_type;
    169182        capabilities        = master->capabilities;
    170         ext_modulations     = master->ext_modulations;
    171183        frequency_minimum   = master->frequency_minimum;
    172184        frequency_maximum   = master->frequency_maximum;
    173185        symbol_rate_minimum = master->symbol_rate_minimum;
     
    210222        return false;
    211223    }
    212224
    213 #ifdef FE_GET_EXTENDED_INFO
    214     if (info.caps & FE_HAS_EXTENDED_INFO)
    215     {
    216         bool ok = true;
    217         dvb_fe_caps_extended extinfo;
    218         bzero(&extinfo, sizeof(extinfo));
    219         if (ioctl(fd_frontend, FE_GET_EXTENDED_INFO, &extinfo) < 0)
    220         {
    221             VERBOSE(VB_IMPORTANT, LOC_ERR +
    222                     "Failed to get frontend extended information." + ENO);
    223 
    224             ok = false;
    225         }
    226 
    227         if (ok && (extinfo.modulations & MOD_8PSK))
    228         {
    229             if (ioctl(fd_frontend, FE_SET_STANDARD, FE_DVB_S2) < 0)
    230             {
    231                 VERBOSE(VB_IMPORTANT, LOC_ERR +
    232                         "Failed to set frontend standard to DVB-S2." + ENO);
    233 
    234                 ok = false;
    235             }
    236             else if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0)
    237             {
    238                 VERBOSE(VB_IMPORTANT, LOC_ERR +
    239                         "Failed to get frontend information." + ENO);
    240 
    241                 ok = false;
    242             }
    243         }
    244 
    245         if (!ok)
    246         {
    247             close(fd_frontend);
    248             fd_frontend = -1;
    249             return false;
    250         }
    251 
    252         ext_modulations   = extinfo.modulations;
    253     }
    254 #endif
    255 
    256225    frontend_name       = info.name;
    257     card_type           = info.type;
     226    //card_type           = info.type;
     227    card_type.Parse(CardUtil::ProbeDVBType(device));
    258228    capabilities        = info.caps;
    259229    frequency_minimum   = info.frequency_min;
    260230    frequency_maximum   = info.frequency_max;
    261231    symbol_rate_minimum = info.symbol_rate_min;
    262232    symbol_rate_maximum = info.symbol_rate_max;
    263 
     233   
    264234    VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.")
    265235            .arg(device).arg(frontend_name));
    266236
     
    309279bool DVBChannel::TuneMultiplex(uint mplexid, QString inputname)
    310280{
    311281    DTVMultiplex tuning;
    312     if (!tuning.FillFromDB(card_type, mplexid))
     282    bool ok = true;
     283    //card_type.Parse(CardUtil::ProbeDVBType(inputname));
     284    ok = tuning.FillFromDB(card_type, mplexid);
     285    if (!ok)
    313286        return false;
    314287
    315     CheckOptions(tuning);
     288    //CheckOptions(tuning);
    316289
    317290    return Tune(tuning, inputname);
    318291}
     
    365338
    366339    // Get the input data for the channel
    367340    QString tvformat, modulation, freqtable, freqid, si_std;
     341    QString msystem, rolloff;
    368342    int finetune;
    369343    uint64_t frequency;
    370344    int mpeg_prog_num;
     
    375349        tvformat, modulation, freqtable, freqid,
    376350        finetune, frequency,
    377351        si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
     352        msystem, rolloff,
    378353        mplexid, commfree))
    379354    {
    380355        VERBOSE(VB_IMPORTANT, loc_err +
     
    596571    const DTVModulation m = modulation;
    597572    const uint64_t      c = capabilities;
    598573
    599 #ifdef FE_GET_EXTENDED_INFO
    600     if ((c & FE_HAS_EXTENDED_INFO)            &&
    601         (DTVModulation::kModulation8PSK == m) &&
    602         (ext_modulations & DTVModulation::kModulation8PSK))
    603     {
    604         return true;
    605     }
    606 #endif // FE_GET_EXTENDED_INFO
    607 
    608574    return
    609575        ((DTVModulation::kModulationQPSK    == m) && (c & FE_CAN_QPSK))     ||
    610576        ((DTVModulation::kModulationQAM16   == m) && (c & FE_CAN_QAM_16))   ||
     
    671637                      bool same_input)
    672638{
    673639    QMutexLocker lock(&tune_lock);
    674 
    675640    if (master)
    676641    {
    677642        VERBOSE(VB_CHANNEL, LOC + "tuning on slave channel");
     
    680645    }
    681646
    682647    bool reset = (force_reset || first_tune);
    683     struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
    684 
     648    //struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
     649   
     650    struct dtv_properties cmds;
     651   
     652    //clear card cache
     653    dtv_property props[11];
     654    memset(&props, 0, sizeof(props));
     655    props[0].cmd = DTV_CLEAR;
     656    cmds.num = 1;
     657    cmds.props = props;
     658    if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
     659    {
     660        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     661                "Clearing tuner cache failed." + ENO);
     662        return false;
     663    }
     664   
     665    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds);
     666   
    685667    bool is_dvbs = (DTVTunerType::kTunerTypeQPSK   == card_type ||
    686668                    DTVTunerType::kTunerTypeDVB_S2 == card_type);
    687669
     
    738720            reset = first_tune = true;
    739721        }
    740722       
    741         params.frequency = lnb->GetIntermediateFrequency(
    742             diseqc_settings, tuning);
     723        for (uint i = 0; i < cmds.num; i++)
     724        {
     725            if (cmds.props[i].cmd == DTV_FREQUENCY)
     726            {
     727                cmds.props[i].u.data = lnb->GetIntermediateFrequency(
     728                    diseqc_settings, tuning);
     729                break;
     730            }
     731        }
     732        //params.frequency = lnb->GetIntermediateFrequency(
     733        //    diseqc_settings, tuning);
    743734
    744735        // if card can auto-FEC, use it -- sometimes NITs are inaccurate
    745         if (capabilities & FE_CAN_FEC_AUTO)
    746             params.u.qpsk.fec_inner = FEC_AUTO;
     736        //if (capabilities & FE_CAN_FEC_AUTO)
     737        //    params.u.qpsk.fec_inner = FEC_AUTO;
    747738    }
    748739
    749740    VERBOSE(VB_CHANNEL, LOC + "Old Params: " +
     
    753744
    754745    // DVB-S is in kHz, other DVB is in Hz
    755746    int     freq_mult = (is_dvbs) ? 1 : 1000;
    756     QString suffix    = (is_dvbs) ? "kHz" : "Hz";
     747    //QString suffix    = (is_dvbs) ? "kHz" : "Hz";
    757748
    758749    if (reset || !prev_tuning.IsEqual(card_type, tuning, 500 * freq_mult))
    759750    {
    760         VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2")
    761                 .arg(params.frequency).arg(suffix));
    762 
    763 #ifdef FE_GET_EXTENDED_INFO
    764         if (card_type == DTVTunerType::kTunerTypeDVB_S2)
     751        //VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2")
     752        //        .arg(params.frequency).arg(suffix));
     753        VERBOSE(VB_CHANNEL, LOC + "Tune(): Tuning ...");
     754        //if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
     755        VERBOSE(VB_IMPORTANT, "ioctl");
     756        if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
    765757        {
    766             if (ioctl(fd_frontend, FE_SET_FRONTEND2, &params) < 0)
    767             {
    768                 VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
    769                         "Setting Frontend(2) tuning parameters failed." + ENO);
    770                 return false;
    771             }
     758            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     759                    "Setting Frontend tuning parameters failed." + ENO);
     760            return false;
    772761        }
    773         else
    774 #endif // FE_GET_EXTENDED_INFO
    775         {
    776             if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
    777             {
    778                 VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
    779                         "Setting Frontend tuning parameters failed." + ENO);
    780                 return false;
    781             }
    782         }
    783762
    784763        // Extra delay to add for broken DVB drivers
    785764        if (tuning_delay)
     
    835814        return false;
    836815    }
    837816
    838     dvb_fe_params params;
    839     return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
     817    //dvb_fe_params params;
     818    //return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
     819    struct dtv_properties cmds;
     820    cmds.num = 0;
     821    return ioctl(fd_frontend, FE_GET_PROPERTY, &cmds) >= 0;
    840822}
    841823
    842824/** \fn DVBChannel::ProbeTuningParams(DTVMultiplex&) const
     
    868850        return false;
    869851    }
    870852
    871     dvb_fe_params params;
    872     if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0)
     853    struct dtv_properties cmds;
     854    dtv_property props[11];
     855    memset(&props, 0, sizeof(props));
     856    cmds.props = props;
     857    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds, false);
     858    if (ioctl(fd_frontend, FE_GET_PROPERTY, &cmds) < 0)
    873859    {
    874860        VERBOSE(VB_IMPORTANT, LOC_ERR +
    875861                "Getting Frontend tuning parameters failed." + ENO);
     
    880866    uint    mplex      = tuning.mplex;
    881867    QString sistandard = tuning.sistandard; sistandard.detach();
    882868
    883     tuning = dvbparams_to_dtvmultiplex(card_type, params);
     869    tuning = dtvproperties_to_dtvmultiplex(card_type, cmds);
    884870
    885871    tuning.mplex       = mplex;
    886872    tuning.sistandard  = sistandard;
     
    10171003
    10181004    uint32_t ublocks = 0;
    10191005    int ret = ioctl(fd_frontend, FE_READ_UNCORRECTED_BLOCKS, &ublocks);
    1020 
    10211006    if (ok)
    10221007        *ok = (0 == ret);
    10231008
     
    10941079    return true;
    10951080}
    10961081
    1097 static struct dvb_fe_params dtvmultiplex_to_dvbparams(
    1098     DTVTunerType tuner_type, const DTVMultiplex &tuning)
     1082
     1083static DTVMultiplex dtvproperties_to_dtvmultiplex(
     1084    DTVTunerType tuner_type, const dtv_properties &cmds)
    10991085{
    1100     dvb_fe_params params;
    1101     bzero(&params, sizeof(params));
    1102 
    1103     params.frequency = tuning.frequency;
    1104     params.inversion = (fe_spectral_inversion_t) (int) tuning.inversion;
    1105 
    1106     if (DTVTunerType::kTunerTypeQPSK == tuner_type)
     1086    DTVMultiplex tuning;
     1087       
     1088    for (uint i = 0; i < cmds.num; i++)
    11071089    {
    1108         params.u.qpsk.symbol_rate = tuning.symbolrate;
    1109         params.u.qpsk.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
    1110     }
    1111 
    1112     if (DTVTunerType::kTunerTypeDVB_S2 == tuner_type)
    1113     {
    1114 #ifdef FE_GET_EXTENDED_INFO
    1115         params.u.qpsk2.symbol_rate = tuning.symbolrate;
    1116         params.u.qpsk2.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
    1117         params.u.qpsk2.modulation  = (fe_modulation_t) (int) tuning.modulation;
    1118 #else // if !FE_GET_EXTENDED_INFO
    1119         VERBOSE(VB_IMPORTANT, "DVBChan Error, MythTV was compiled without "
    1120                 "DVB-S2 headers being present so DVB-S2 tuning will fail.");
    1121 #endif // !FE_GET_EXTENDED_INFO
    1122     }
    1123 
    1124     if (DTVTunerType::kTunerTypeQAM  == tuner_type)
    1125     {
    1126         params.u.qam.symbol_rate  = tuning.symbolrate;
    1127         params.u.qam.fec_inner    = (fe_code_rate_t) (int) tuning.fec;
    1128         params.u.qam.modulation   = (fe_modulation_t) (int) tuning.modulation;
    1129     }
    1130 
    1131     if (DTVTunerType::kTunerTypeOFDM == tuner_type)
    1132     {
    1133         params.u.ofdm.bandwidth             =
    1134             (fe_bandwidth_t) (int) tuning.bandwidth;
    1135         params.u.ofdm.code_rate_HP          =
    1136             (fe_code_rate_t) (int) tuning.hp_code_rate;
    1137         params.u.ofdm.code_rate_LP          =
    1138             (fe_code_rate_t) (int) tuning.lp_code_rate;
    1139         params.u.ofdm.constellation         =
    1140             (fe_modulation_t) (int) tuning.modulation;
    1141         params.u.ofdm.transmission_mode     =
    1142             (fe_transmit_mode_t) (int) tuning.trans_mode;
    1143         params.u.ofdm.guard_interval        =
    1144             (fe_guard_interval_t) (int) tuning.guard_interval;
    1145         params.u.ofdm.hierarchy_information =
    1146             (fe_hierarchy_t) (int) tuning.hierarchy;
    1147     }
    1148 
    1149     if (DTVTunerType::kTunerTypeATSC == tuner_type)
    1150     {
     1090        switch (cmds.props[i].cmd)
     1091        {
     1092            case DTV_MODULATION:
     1093                tuning.modulation = cmds.props[i].u.data;
     1094                break;
     1095            case DTV_DELIVERY_SYSTEM:
     1096                switch (cmds.props[i].u.data)
     1097                {
     1098                    case SYS_DVBS:
     1099                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS;
     1100                        break;
     1101                    case SYS_DVBS2:
     1102                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS2;
     1103                        break;
     1104                    case SYS_DVBT:
     1105                    case SYS_DVBC_ANNEX_AC:
     1106                    case SYS_DVBC_ANNEX_B:
    11511107#ifdef USE_ATSC
    1152         params.u.vsb.modulation   =
    1153             (fe_modulation_t) (int) tuning.modulation;
    1154 #endif // USE_ATSC
     1108                    case SYS_ATSC:
     1109#endif
     1110                        break;
     1111                    default:
     1112                        VERBOSE(VB_IMPORTANT, "Unknown DVB delivery system." + ENO);
     1113                };
     1114                break;
     1115            case DTV_FREQUENCY:
     1116                if (tuning.modulation == DTVModulation::kModulationQPSK ||
     1117                        tuning.modulation == DTVModulation::kModulation8PSK)
     1118                    tuning.frequency = cmds.props[i].u.data / 1000UL;
     1119                else
     1120                    tuning.frequency = cmds.props[i].u.data;
     1121                break;
     1122            case DTV_SYMBOL_RATE:
     1123                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
     1124                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
     1125                    tuner_type == DTVTunerType::kTunerTypeQAM)
     1126                {                   
     1127                    if (tuning.modulation == DTVModulation::kModulationQPSK ||
     1128                            tuning.modulation == DTVModulation::kModulation8PSK)
     1129                        tuning.symbolrate = cmds.props[i].u.data / 1000UL;
     1130                    else
     1131                        tuning.symbolrate = cmds.props[i].u.data;
     1132                };
     1133                break;
     1134            case DTV_INNER_FEC:
     1135                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
     1136                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
     1137                    tuner_type == DTVTunerType::kTunerTypeQAM)
     1138                {
     1139                    tuning.symbolrate = cmds.props[i].u.data;
     1140                }
     1141                break;
     1142            case DTV_PILOT:
     1143                break;
     1144            case DTV_ROLLOFF:
     1145                if (tuner_type == DTVTunerType::kTunerTypeDVB_S2)
     1146                    tuning.rolloff = cmds.props[i].u.data;
     1147                break;
     1148            case DTV_INVERSION:
     1149                tuning.inversion = cmds.props[i].u.data;
     1150                break;
     1151            case DTV_BANDWIDTH_HZ:
     1152                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1153                    tuning.bandwidth = cmds.props[i].u.data;
     1154                break;
     1155            case DTV_CODE_RATE_HP:
     1156                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1157                    tuning.hp_code_rate = cmds.props[i].u.data;
     1158                break;
     1159            case DTV_CODE_RATE_LP:
     1160                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1161                    tuning.lp_code_rate = cmds.props[i].u.data;
     1162                break;
     1163            case DTV_TRANSMISSION_MODE:
     1164                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1165                    tuning.trans_mode = cmds.props[i].u.data;
     1166                break;
     1167            case DTV_GUARD_INTERVAL:
     1168                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1169                    tuning.guard_interval = cmds.props[i].u.data;
     1170                break;
     1171            case DTV_HIERARCHY:
     1172                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1173                    tuning.hierarchy = cmds.props[i].u.data;
     1174                break;
     1175            case DTV_TUNE:
     1176                break;
     1177            default:
     1178                VERBOSE(VB_IMPORTANT, "Unknown DTV command." + ENO);
     1179        }
    11551180    }
     1181    return tuning;
     1182}
    11561183
    1157     return params;
     1184static bool dtvmultiplex_to_dtvproperties(
     1185    DTVTunerType tuner_type,
     1186    const DTVMultiplex &tuning,
     1187    struct dtv_properties *cmdseq)
     1188{
     1189    return dtvmultiplex_to_dtvproperties(tuner_type, tuning, cmdseq, true);
    11581190}
    11591191
    1160 static DTVMultiplex dvbparams_to_dtvmultiplex(
    1161     DTVTunerType tuner_type, const dvb_fe_params &params)
     1192static bool dtvmultiplex_to_dtvproperties(
     1193    DTVTunerType tuner_type,
     1194    const DTVMultiplex &tuning,
     1195    struct dtv_properties *cmdseq,
     1196    bool do_tune)
    11621197{
    1163     DTVMultiplex tuning;
    1164 
    1165     tuning.frequency = params.frequency;
    1166     tuning.inversion = params.inversion;
    1167 
    1168     if ((DTVTunerType::kTunerTypeQPSK   == tuner_type) ||
    1169         (DTVTunerType::kTunerTypeDVB_S2 == tuner_type))
     1198    VERBOSE(VB_IMPORTANT, tuner_type.toString());
     1199    if (tuner_type == DTVTunerType::kTunerTypeQPSK ||
     1200        (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
     1201        tuning.msystem == DTVModulationSystem::kModulationSystemDVBS))
    11701202    {
    1171         tuning.symbolrate     = params.u.qpsk.symbol_rate;
    1172         tuning.fec            = params.u.qpsk.fec_inner;
     1203        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1204        cmdseq->props[0].u.data = SYS_DVBS;
     1205        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1206        cmdseq->props[1].u.data = tuning.frequency;
     1207        cmdseq->props[2].cmd    = DTV_MODULATION;
     1208        cmdseq->props[2].u.data = QPSK;
     1209        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1210        cmdseq->props[3].u.data = tuning.symbolrate;
     1211        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1212        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
     1213        cmdseq->props[5].cmd    = DTV_INVERSION;
     1214        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1215        if (do_tune)
     1216        {
     1217            cmdseq->props[6].cmd    = DTV_TUNE;
     1218            cmdseq->num = 7;
     1219        }
     1220        else
     1221        {
     1222            cmdseq->num = 6;
     1223        }
    11731224    }
    1174 
    1175     if (DTVTunerType::kTunerTypeQAM  == tuner_type)
     1225    else if (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
     1226        tuning.msystem == DTVModulationSystem::kModulationSystemDVBS2)
    11761227    {
    1177         tuning.symbolrate     = params.u.qam.symbol_rate;
    1178         tuning.fec            = params.u.qam.fec_inner;
    1179         tuning.modulation     = params.u.qam.modulation;
     1228        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1229        cmdseq->props[0].u.data = SYS_DVBS2;
     1230        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1231        cmdseq->props[1].u.data = tuning.frequency;
     1232        cmdseq->props[2].cmd    = DTV_MODULATION;
     1233        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
     1234        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1235        cmdseq->props[3].u.data = tuning.symbolrate;
     1236        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1237        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
     1238        cmdseq->props[5].cmd    = DTV_INVERSION;
     1239        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1240        cmdseq->props[6].cmd    = DTV_PILOT;
     1241        cmdseq->props[6].u.data = PILOT_AUTO;
     1242        cmdseq->props[7].cmd    = DTV_ROLLOFF;
     1243        cmdseq->props[7].u.data = (fe_rolloff_t) (int) tuning.rolloff;
     1244       
     1245        if (do_tune)
     1246        {
     1247            cmdseq->props[8].cmd = DTV_TUNE;
     1248            cmdseq->num = 9;
     1249        }
     1250        else
     1251            cmdseq->num = 8;
    11801252    }
    1181 
    1182     if (DTVTunerType::kTunerTypeOFDM == tuner_type)
     1253    else if (tuner_type == DTVTunerType::kTunerTypeQAM)
    11831254    {
    1184         tuning.bandwidth      = params.u.ofdm.bandwidth;
    1185         tuning.hp_code_rate   = params.u.ofdm.code_rate_HP;
    1186         tuning.lp_code_rate   = params.u.ofdm.code_rate_LP;
    1187         tuning.modulation     = params.u.ofdm.constellation;
    1188         tuning.trans_mode     = params.u.ofdm.transmission_mode;
    1189         tuning.guard_interval = params.u.ofdm.guard_interval;
    1190         tuning.hierarchy      = params.u.ofdm.hierarchy_information;
     1255        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1256        cmdseq->props[0].u.data = (fe_delivery_system_t) (int) tuning.msystem;
     1257        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1258        cmdseq->props[1].u.data = tuning.frequency;
     1259        cmdseq->props[2].cmd    = DTV_MODULATION;
     1260        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
     1261        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1262        cmdseq->props[3].u.data = tuning.symbolrate;
     1263        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1264        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
     1265        cmdseq->props[5].cmd    = DTV_INVERSION;
     1266        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1267        if (do_tune)
     1268        {
     1269            cmdseq->props[6].cmd    = DTV_TUNE;
     1270            cmdseq->num = 7;
     1271        }
     1272        else
     1273            cmdseq->num = 6;
    11911274    }
    1192 
    1193     if (DTVTunerType::kTunerTypeATSC == tuner_type)
     1275    else if (tuner_type == DTVTunerType::kTunerTypeOFDM)
    11941276    {
     1277        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1278        cmdseq->props[0].u.data = SYS_DVBC_ANNEX_AC;
     1279        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1280        cmdseq->props[1].u.data = tuning.frequency;
     1281        cmdseq->props[2].cmd    = DTV_MODULATION;
     1282        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
     1283        cmdseq->props[3].cmd    = DTV_INVERSION;
     1284        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1285        cmdseq->props[4].cmd    = DTV_BANDWIDTH_HZ;
     1286        cmdseq->props[4].u.data = (fe_bandwidth_t) (int) tuning.bandwidth;
     1287        cmdseq->props[5].cmd    = DTV_CODE_RATE_HP;
     1288        cmdseq->props[5].u.data = (fe_code_rate_t) (int) tuning.hp_code_rate;
     1289        cmdseq->props[6].cmd    = DTV_CODE_RATE_LP;
     1290        cmdseq->props[6].u.data = (fe_code_rate_t) (int) tuning.lp_code_rate;
     1291        cmdseq->props[7].cmd    = DTV_TRANSMISSION_MODE;
     1292        cmdseq->props[7].u.data = (fe_transmit_mode_t) (int) tuning.trans_mode;
     1293        cmdseq->props[8].cmd    = DTV_GUARD_INTERVAL;
     1294        cmdseq->props[8].u.data = (fe_guard_interval_t) (int) tuning.guard_interval;
     1295        cmdseq->props[9].cmd    = DTV_HIERARCHY;
     1296        cmdseq->props[9].u.data = (fe_hierarchy_t) (int) tuning.hierarchy;
     1297        if (do_tune)
     1298        {
     1299            cmdseq->props[10].cmd    = DTV_TUNE;
     1300            cmdseq->num = 11;
     1301        }
     1302        else
     1303            cmdseq->num = 10;
     1304    }
    11951305#ifdef USE_ATSC
    1196         tuning.modulation     = params.u.vsb.modulation;
    1197 #endif // USE_ATSC
     1306    else if (tuner_type == DTVTunerType::kTunerTypeATSC)
     1307    {
     1308        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1309        cmdseq->props[0].u.data = SYS_ATSC;
     1310        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1311        cmdseq->props[1].u.data = tuning.frequency * 1000UL;
     1312        cmdseq->props[2].cmd    = DTV_MODULATION;
     1313        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;;
     1314        cmdseq->props[3].cmd    = DTV_INVERSION;
     1315        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1316        if (do_tune)
     1317        {
     1318            cmdseq->props[4].cmd    = DTV_TUNE;
     1319            cmdseq->num = 5;
     1320        }
     1321        else
     1322            cmdseq->num = 4;
    11981323    }
     1324#endif
     1325    else
     1326    {
     1327        VERBOSE(VB_IMPORTANT, "Unknown tuner type." + ENO);
     1328    }   
     1329    return true;
     1330}
    11991331
    1200     return tuning;
    1201 }
  • libs/libmythtv/cardutil.cpp

     
    241241        close(fd_frontend);
    242242        VERBOSE(VB_IMPORTANT, "FE_GET_INFO ioctl failed (" + dvbdev + ").");
    243243        return ret;
     244    }     
     245    DTVTunerType type(info.type);
     246    //to do: support for DTV_FE_CAPABILITY
     247    if (type == DTVTunerType::kTunerTypeQPSK){
     248        type = DTVTunerType::kTunerTypeDVB_S2;
    244249    }
    245250    close(fd_frontend);
    246251
    247     DTVTunerType type(info.type);
    248252    ret = (type.toString() != "UNKNOWN") ? type.toString().toUpper() : ret;
    249253#endif // USING_DVB
    250254
     
    337341{
    338342    QString ct = card_type.toUpper();
    339343    return (ct == "DVB") || (ct == "QAM") || (ct == "QPSK") ||
    340         (ct == "OFDM") || (ct == "ATSC");
     344        (ct == "OFDM") || (ct == "ATSC") || (ct == "DVB_S2");
    341345}
    342346
    343347QString get_on_cardid(const QString &to_get, uint cardid)
  • libs/libmythtv/videosource.cpp

     
    29292929            signal_timeout->setValue(60000);
    29302930            channel_timeout->setValue(62500);
    29312931            break;
     2932        case CardUtil::DVBS2:
     2933            cardtype->setValue("DVB-S2");
     2934            cardname->setValue(frontend_name);
     2935            signal_timeout->setValue(60000);
     2936            channel_timeout->setValue(62500);
     2937            break;
    29322938        case CardUtil::QAM:
    29332939            cardtype->setValue("DVB-C");
    29342940            cardname->setValue(frontend_name);
  • libs/libmythtv/frequencytables.cpp

     
    6868        _tuning.lp_code_rate.toString(),     _tuning.modulation.toString(),
    6969        _tuning.trans_mode.toString(),       _tuning.guard_interval.toString(),
    7070        _tuning.hierarchy.toString(),        _tuning.modulation.toString(),
    71         _tuning.bandwidth.toString());
     71        _tuning.bandwidth.toString(),        _tuning.msystem.toString(),
     72        _tuning.rolloff.toString());
    7273}
    7374
    7475TransportScanItem::TransportScanItem(uint sourceid,
  • libs/libmythtv/scanwizard.cpp

     
    9898        start_chan = configPane->GetStartChan();
    9999        parse_type = DTVTunerType::kTunerTypeQPSK;
    100100    }
     101    else if (scantype == ScanTypeSetting::NITAddScan_DVBS2)
     102    {
     103        start_chan = configPane->GetStartChan();
     104        parse_type = DTVTunerType::kTunerTypeDVB_S2;
     105    }
    101106    else if (scantype == ScanTypeSetting::NITAddScan_QAM)
    102107    {
    103108        start_chan = configPane->GetStartChan();
     
    139144            start_chan["coderate_hp"],    start_chan["coderate_lp"],
    140145            start_chan["constellation"],  start_chan["trans_mode"],
    141146            start_chan["guard_interval"], start_chan["hierarchy"],
    142             start_chan["modulation"],     start_chan["bandwidth"]))
     147            start_chan["modulation"],     start_chan["bandwidth"],
     148            start_chan["msystem"],        start_chan["rolloff"]))
    143149    {
    144150        MythPopupBox::showOkPopup(
    145151            gContext->GetMainWindow(), tr("ScanWizard"),
     
    150156
    151157    if (do_scan)
    152158    {
     159        VERBOSE(VB_IMPORTANT, LOC + "do_scan");
    153160        scannerPane->Scan(
    154161            configPane->GetScanType(),       configPane->GetCardID(),
    155162            configPane->GetInputName(),      configPane->GetSourceID(),
  • libs/libmythtv/scanwizardscanner.h

     
    8282              const QString &freq_std,
    8383              const QString &mod,
    8484              const QString &tbl,
    85               const QString &atsc_format);
     85              const QString &atsc_format
     86              );
    8687
    8788    void ImportDVBUtils(uint sourceid, int cardtype, const QString &file);
    8889    void ImportM3U(     uint cardid, const QString &inputname, uint sourceid);
  • libs/libmythtv/transporteditor.cpp

     
    9898    MSqlQuery query(MSqlQuery::InitCon());
    9999    query.prepare(
    100100        "SELECT mplexid, modulation, frequency, "
    101         "       symbolrate, networkid, transportid, constellation "
     101        "       symbolrate, networkid, transportid, constellation, msystem "
    102102        "FROM dtv_multiplex, videosource "
    103103        "WHERE dtv_multiplex.sourceid = :SOURCEID AND "
    104104        "      dtv_multiplex.sourceid = videosource.sourceid "
     
    129129        QString tid = query.value(5).toUInt() ?
    130130            QString("tid %1").arg(query.value(5).toUInt(), 5) : "";
    131131
    132         QString hz = (CardUtil::QPSK == cardtype) ? "kHz" : "Hz";
     132        QString hz = (CardUtil::QPSK == cardtype ||
     133            CardUtil::DVBS2 == cardtype) ? "kHz" : "Hz";
    133134
    134135        QString type = "";
    135136        if (CardUtil::OFDM == cardtype)
    136137            type = "(DVB-T)";
    137138        if (CardUtil::QPSK == cardtype)
    138139            type = "(DVB-S)";
     140        if (CardUtil::DVBS2 == cardtype)
     141            type = (query.value(7).toString() == "dvbs2")?"(DVB-S2)":"DVB-S";
     142       
    139143        if (CardUtil::QAM == cardtype)
    140144            type = "(DVB-C)";
    141145
     
    487491    };
    488492};
    489493
     494class DVBS2ModulationSystem: public ComboBoxSetting, public MuxDBStorage
     495{
     496  public:
     497    DVBS2ModulationSystem(const MultiplexID *id) :
     498        ComboBoxSetting(this), MuxDBStorage(this, id, "msystem")
     499    {
     500        setLabel(QObject::tr("Modulation system"));
     501        setHelpText(QObject::tr("Modulation system (Default: DVB-S)\n"
     502                "Standard selection: DVB-S/DVB-S2"));
     503        addSelection(QObject::tr("DVB-S"), "dvbs");
     504        addSelection(QObject::tr("DVB-S2"), "dvbs2");
     505    };
     506};
     507
    490508class Modulation : public ComboBoxSetting, public MuxDBStorage
    491509{
    492510  public:
     
    506524        // no modulation options
    507525        setVisible(false);
    508526    }
     527    if (CardUtil::QPSK == nType)
     528    {
     529        addSelection("QPSK", "qpsk");
     530    }
     531    if (CardUtil::DVBS2 == nType)
     532    {
     533        addSelection("QPSK", "qpsk");
     534        addSelection("8PSK", "8psk");
     535    }
    509536    else if ((CardUtil::QAM == nType) || (CardUtil::OFDM == nType))
    510537    {
    511538        addSelection(QObject::tr("QAM Auto"), "auto");
     
    576603        addSelection("1/2");
    577604        addSelection("2/3");
    578605        addSelection("3/4");
     606        addSelection("3/5");
    579607        addSelection("4/5");
    580608        addSelection("5/6");
    581609        addSelection("6/7");
    582610        addSelection("7/8");
    583611        addSelection("8/9");
     612        addSelection("9/10");
    584613    };
    585614};
    586615
     
    597626    };
    598627};
    599628
     629class DVBS2RollOff: public ComboBoxSetting, public MuxDBStorage
     630{
     631  public:
     632    DVBS2RollOff(const MultiplexID *id) :
     633        ComboBoxSetting(this), MuxDBStorage(this, id, "rolloff")
     634    {
     635        setLabel(QObject::tr("Roll-off"));
     636        setHelpText(QObject::tr("Roll-off (Default: 0.35)"));
     637        addSelection(QObject::tr("0.35"), "0.35");
     638        addSelection(QObject::tr("0.20"), "0.20");
     639        addSelection(QObject::tr("0.25"), "0.25");
     640        addSelection(QObject::tr("Auto"), "auto");
     641    };
     642};
     643
    600644class DVBTCoderateLP :
    601645    public DVBForwardErrorCorrectionSelector, public MuxDBStorage
    602646{
     
    715759        right->addChild(new DVBForwardErrorCorrection(id));
    716760        right->addChild(new SignalPolarity(id));
    717761    }
     762    else if (CardUtil::DVBS2 == nType)
     763    {
     764        left->addChild(new DTVStandard(id, true, false));
     765        left->addChild(new Frequency(id, true));
     766        left->addChild(new DVBSymbolRate(id));
     767        left->addChild(new DVBInversion(id));
     768        left->addChild(new SignalPolarity(id));
     769
     770        right = new VerticalConfigurationGroup(false, true, false, false);
     771        right->addChild(new DVBS2ModulationSystem(id));
     772        right->addChild(new Modulation(id, nType));
     773        right->addChild(new DVBForwardErrorCorrection(id));
     774        right->addChild(new DVBS2RollOff(id));
     775    }
    718776    else if (CardUtil::QAM == nType)
    719777    {
    720778        left->addChild(new DTVStandard(id, true, false));
  • libs/libmythtv/scanwizardhelpers.cpp

     
    455455        addSelection(tr("Import channels.conf"),
    456456                     QString::number(DVBUtilsImport));
    457457        break;
     458    case CardUtil::DVBS2:
     459        addSelection(tr("Full Scan (Tuned)"),
     460                     QString::number(NITAddScan_DVBS2));
     461        addSelection(tr("Import channels.conf"),
     462                     QString::number(DVBUtilsImport));
     463        break;
    458464    case CardUtil::QAM:
    459465        addSelection(tr("Full Scan (Tuned)"),
    460466                     QString::number(NITAddScan_QAM));
     
    574580              paneQAM);
    575581    addTarget(QString::number(ScanTypeSetting::NITAddScan_QPSK),
    576582              paneQPSK);
     583    addTarget(QString::number(ScanTypeSetting::NITAddScan_DVBS2),
     584              paneDVBS2);
    577585    addTarget(QString::number(ScanTypeSetting::NITAddScan_OFDM),
    578586              paneOFDM);
    579587    addTarget(QString::number(ScanTypeSetting::FullScan_ATSC),
     
    766774        startChan["modulation"] = "qpsk";
    767775        startChan["polarity"]   = pane->polarity();
    768776    }
     777    else if (ScanTypeSetting::NITAddScan_DVBS2 == st)
     778    {
     779        const DVBS2Pane *pane = paneDVBS2;
     780
     781        startChan["std"]        = "dvb";
     782        startChan["frequency"]  = pane->frequency();
     783        startChan["inversion"]  = pane->inversion();
     784        startChan["symbolrate"] = pane->symbolrate();
     785        startChan["fec"]        = pane->fec();
     786        startChan["msystem"]    = pane->msystem();
     787        startChan["modulation"] = pane->modulation();
     788        startChan["polarity"]   = pane->polarity();
     789        startChan["rolloff"]    = pane->rolloff();
     790    }
    769791    else if (ScanTypeSetting::NITAddScan_QAM == st)
    770792    {
    771793        const QAMPane *pane = paneQAM;
  • libs/libmythtv/dtvmultiplex.cpp

     
    2424    fec            = other.fec;
    2525    mplex          = other.mplex;
    2626    sistandard     = other.sistandard;
     27    msystem        = other.msystem;
     28    rolloff        = other.rolloff;
    2729    sistandard.detach();
    2830    return *this;
    2931}
     
    4042            (guard_interval == m.guard_interval) &&
    4143            (fec == m.fec) &&
    4244            (polarity == m.polarity) &&
    43             (hierarchy == m.hierarchy));
     45            (hierarchy == m.hierarchy) &&
     46            (msystem == m.msystem) &&
     47            (rolloff == m.rolloff));
    4448}
    4549
    4650///////////////////////////////////////////////////////////////////////////////
     
    4852
    4953QString DTVMultiplex::toString() const
    5054{
    51     QString ret = QString("%1 %2 %3 ")
    52         .arg(frequency).arg(modulation.toString()).arg(inversion.toString());
     55    QString ret = QString("f: %1 mod: %2 inv: %3 fec: %4")
     56        .arg(frequency).arg(modulation.toString()).arg(inversion.toString()).arg(fec.toString());
    5357
    54     ret += QString("%1 %2 %3 %4 %5 %6 %7")
     58    ret += QString("hp: %1 lp: %2 bandw: %3 transmode: %4 guardi: %5 hier: %6 polar: %7 msys: %8 rolloff: %9")
    5559        .arg(hp_code_rate.toString()).arg(lp_code_rate.toString())
    5660        .arg(bandwidth.toString()).arg(trans_mode.toString())
    5761        .arg(guard_interval.toString()).arg(hierarchy.toString())
    58         .arg(polarity.toString());
     62        .arg(polarity.toString())
     63        .arg(msystem.toString()).arg(rolloff.toString());
    5964
    6065    return ret;
    6166}
     
    103108            (inversion  == other.inversion)  &&
    104109            (symbolrate == other.symbolrate) &&
    105110            (fec        == other.fec);
     111            (msystem    == other.msystem);
     112            (rolloff    == other.rolloff);
    106113    }
    107114
    108115    return false;
     
    178185
    179186    if (ok)
    180187        frequency = _frequency.toInt(&ok);
     188       
     189    return ok;
     190}
    181191
     192bool DTVMultiplex::ParseDVB_S2(
     193    const QString &_frequency,   const QString &_inversion,
     194    const QString &_symbol_rate, const QString &_fec_inner,
     195    const QString &_modulation,  const QString &_polarity,
     196    const QString &_msystem,     const QString &_rolloff)
     197{
     198    bool ok = inversion.Parse(_inversion);
     199    if (!ok)
     200    {
     201        VERBOSE(VB_GENERAL, LOC_WARN +
     202                "Invalid inversion, falling back to 'auto'");
     203
     204        ok = true;
     205    }
     206
     207    symbolrate = _symbol_rate.toInt();
     208    if (!symbolrate)
     209    {
     210        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid symbol rate " +
     211                QString("parameter '%1', aborting.").arg(_symbol_rate));
     212
     213        return false;
     214    }
     215
     216    ok &= fec.Parse(_fec_inner);
     217    ok &= modulation.Parse(_modulation);
     218   
     219    if (!_polarity.isEmpty())
     220        ok &= polarity.Parse(_polarity.toLower());
     221
     222    ok &= msystem.Parse(_msystem);
     223
     224    if (!ok)
     225    {
     226        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid S2 modulation system " +
     227                QString("parameter '%1', aborting.").arg(_symbol_rate));
     228        return false;
     229    }
     230
     231    if (!_rolloff.isEmpty())
     232        ok &= rolloff.Parse(_rolloff);
     233
     234    if (ok)
     235        frequency = _frequency.toInt(&ok);
     236   
    182237    return ok;
    183238}
    184239
     
    188243    QString _fec,          QString _polarity,
    189244    QString _hp_code_rate, QString _lp_code_rate,   QString _ofdm_modulation,
    190245    QString _trans_mode,   QString _guard_interval, QString _hierarchy,
    191     QString _modulation,   QString _bandwidth)
     246    QString _modulation,   QString _bandwidth,
     247    QString _msystem,      QString _rolloff)
    192248{
    193249    if (DTVTunerType::kTunerTypeOFDM == type)
    194250    {
     
    199255    }
    200256
    201257    if ((DTVTunerType::kTunerTypeQPSK   == type) ||
    202         (DTVTunerType::kTunerTypeDVB_S2 == type) ||
    203258        (DTVTunerType::kTunerTypeQAM    == type))
    204259    {
    205260        return ParseDVB_S_and_C(
    206261            _frequency,       _inversion,     _symbolrate,
    207262            _fec,             _modulation,    _polarity);
    208263    }
     264   
     265    if (DTVTunerType::kTunerTypeDVB_S2 == type)
     266    {
     267        return ParseDVB_S2(
     268            _frequency,       _inversion,     _symbolrate,
     269            _fec,             _modulation,    _polarity,
     270            _msystem,         _rolloff);
     271    }
    209272
    210273    if (DTVTunerType::kTunerTypeATSC == type)
    211274        return ParseATSC(_frequency, _modulation);
     
    223286        "       fec,               polarity, "
    224287        "       hp_code_rate,      lp_code_rate,   constellation, "
    225288        "       transmission_mode, guard_interval, hierarchy, "
    226         "       modulation,        bandwidth,      sistandard "
     289        "       modulation,        bandwidth,      sistandard, "
     290        "       msystem,           rolloff "
    227291        "FROM dtv_multiplex "
    228292        "WHERE dtv_multiplex.mplexid = :MPLEXID");
    229293    query.bindValue(":MPLEXID", mplexid);
     
    256320        query.value(6).toString(),  query.value(7).toString(),
    257321        query.value(8).toString(),  query.value(9).toString(),
    258322        query.value(10).toString(), query.value(11).toString(),
    259         query.value(12).toString());
     323        query.value(12).toString(), query.value(14).toString(),
     324        query.value(15).toString());
    260325}
    261326
    262327////////////////////////////////////////////////////////////////////////////
     
    317382        " (  scanid, "
    318383        "    mplexid,            frequency,       inversion,  "
    319384        "    symbolrate,         fec,             polarity,   "
    320         "    hp_code_rate,       lp_code_rate,    modulation, "
    321         "    transmission_mode,  guard_interval,  hierarchy,  "
     385        "    hp_code_rate,       lp_code_rate, "
     386        "    msystem,            modulation,      rolloff,    "
     387        "    transmission_mode,  guard_interval,  hierarchy,  "
    322388        "    bandwidth,          sistandard,      tuner_type  "
    323389        " ) "
    324390        "VALUES "
    325391        " ( :SCANID, "
    326392        "   :MPLEXID,           :FREQUENCY,      :INVERSION,  "
    327393        "   :SYMBOLRATE,        :FEC,            :POLARITY,   "
    328         "   :HP_CODE_RATE,      :LP_CODE_RATE,   :MODULATION, "
     394        "   :HP_CODE_RATE,      :LP_CODE_RATE,   "
     395        "   :MSYSTEM,           :MODULATION,     :ROLLOFF,    "
    329396        "   :TRANSMISSION_MODE, :GUARD_INTERVAL, :HIERARCHY,  "
    330397        "   :BANDWIDTH,         :SISTANDARD,     :TUNER_TYPE  "
    331398        " );");
     
    339406    query.bindValue(":POLARITY", polarity.toString());
    340407    query.bindValue(":HP_CODE_RATE", hp_code_rate.toString());
    341408    query.bindValue(":LP_CODE_RATE", lp_code_rate.toString());
     409    query.bindValue(":MSYSTEM", msystem.toString());
    342410    query.bindValue(":MODULATION", modulation.toString());
     411    query.bindValue(":ROLLOFF", rolloff.toString());
    343412    query.bindValue(":TRANSMISSION_MODE", trans_mode.toString());
    344413    query.bindValue(":GUARD_INTERVAL", guard_interval.toString());
    345414    query.bindValue(":HIERARCHY", hierarchy.toString());