Ticket #5882: t5882_S2Api_3.diff

File t5882_S2Api_3.diff, 87.8 KB (added by wagabunda, 7 years ago)

work with latest r18989, corrected DVB-S/DVB-S2 behavior, note: 8PSK is not the same as modulation system DVB-S2, modulation system it is information about additional parameters (eg roll-off)

  • 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

     
    191191    static const DTVParamHelperStruct confTable[];
    192192    static const DTVParamHelperStruct vdrTable[];
    193193    static const DTVParamHelperStruct parseTable[];
    194     static const uint kDBStrCnt = 10;
     194    static const uint kDBStrCnt = 12;
    195195    static const char *dbStr[kDBStrCnt];
    196196
    197197  public:
     
    207207        kFEC_7_8,
    208208        kFEC_8_9,
    209209        kFECAuto,
     210        kFEC_3_5,
     211        kFEC_9_10,
    210212    };
    211213
    212214    DTVCodeRate(int _default = kFECAuto) : DTVParamHelper(_default) { }
     
    236238  public:
    237239    enum
    238240    {
    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 */
     241        kModulationQPSK,
     242        kModulationQAM16,
     243        kModulationQAM32,
     244        kModulationQAM64,
     245        kModulationQAM128,
     246        kModulationQAM256,
     247        kModulationQAMAuto,
     248        kModulation8VSB,
     249        kModulation16VSB,
     250        kModulation16APSK,
     251        kModulation32APSK,
     252        kModulation8PSK,
     253        kModulationDQPSK,
     254        kModulationAnalog = 99, /* for analog channel scanner */
    256255    };
    257256
    258257    DTVModulation(int _default = kModulationQAMAuto)
     
    414413        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
    415414};
    416415
     416class DTVModulationSystem : public DTVParamHelper
     417{
     418  protected:
     419    static const DTVParamHelperStruct confTable[];
     420    static const DTVParamHelperStruct vdrTable[];
     421    static const DTVParamHelperStruct parseTable[];
     422    static const uint kDBStrCnt = 2;
     423    static const char *dbStr[kDBStrCnt];
     424
     425  public:
     426    enum
     427    {
     428        kModulationSystemDVBS,
     429        kModulationSystemDVBS2,
     430    };
     431
     432    DTVModulationSystem(int _default = kModulationSystemDVBS)
     433        : DTVParamHelper(_default) { }
     434
     435    bool ParseConf(const QString &_value)
     436       { return ParseParam(_value, value, confTable); }
     437    bool ParseVDR(const QString &_value)
     438       { return ParseParam(_value, value, vdrTable); }
     439    bool Parse(const QString &_value)
     440       { return ParseParam(_value, value, parseTable); }
     441
     442    QString toString() const { return toString(value); }
     443
     444    static QString toString(int _value)
     445        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     446};
     447
     448class DTVRollOff : public DTVParamHelper
     449{
     450  protected:
     451    static const DTVParamHelperStruct confTable[];
     452    static const DTVParamHelperStruct vdrTable[];
     453    static const DTVParamHelperStruct parseTable[];
     454    static const uint kDBStrCnt = 4;
     455    static const char *dbStr[kDBStrCnt];
     456
     457  public:
     458    enum
     459    {
     460        kRollOff35,
     461        kRollOff20,
     462        kRollOff25,
     463        kRollOffAuto,
     464    };
     465
     466    DTVRollOff(int _default = kRollOff35)
     467        : DTVParamHelper(_default) { }
     468
     469    bool ParseConf(const QString &_value)
     470       { return ParseParam(_value, value, confTable); }
     471    bool ParseVDR(const QString &_value)
     472       { return ParseParam(_value, value, vdrTable); }
     473    bool Parse(const QString &_value)
     474       { return ParseParam(_value, value, parseTable); }
     475
     476    QString toString() const { return toString(value); }
     477
     478    static QString toString(int _value)
     479        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     480};
     481
     482class DTVPilot : public DTVParamHelper
     483{
     484  protected:
     485    static const DTVParamHelperStruct confTable[];
     486    static const DTVParamHelperStruct vdrTable[];
     487    static const DTVParamHelperStruct parseTable[];
     488    static const uint kDBStrCnt = 3;
     489    static const char *dbStr[kDBStrCnt];
     490
     491  public:
     492    enum
     493    {
     494        kPilotOn,
     495        kPilotOff,
     496        kPilotAuto,
     497    };
     498
     499    DTVPilot(int _default = kPilotAuto)
     500        : DTVParamHelper(_default) { }
     501
     502    bool ParseConf(const QString &_value)
     503       { return ParseParam(_value, value, confTable); }
     504
     505    QString toString() const { return toString(value); }
     506
     507    static QString toString(int _value)
     508        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     509};
     510
    417511#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

     
    146146        addSelection("1/2");
    147147        addSelection("2/3");
    148148        addSelection("3/4");
     149        addSelection("3/5");
    149150        addSelection("4/5");
    150151        addSelection("5/6");
    151152        addSelection("6/7");
    152153        addSelection("7/8");
    153154        addSelection("8/9");
     155        addSelection("9/10");
    154156    }
    155157};
    156158
     
    165167    }
    166168};
    167169
     170class ScanModulationSystem: public ComboBoxSetting, public TransientStorage
     171{
     172  public:
     173    ScanModulationSystem() : ScanModulationSystemSetting(this)
     174    {
     175        setLabel(QObject::tr("Modul. System"));
     176        setHelpText(QObject::tr("Modulation System (Default: DVB-S)"));
     177        addSelection("DVB-S","dvbs",true);
     178        addSelection("DVB-S2","dvbs2");
     179    };
     180};
     181
     182
     183class ScanRollOff: public ComboBoxSetting
     184{
     185  public:
     186    ScanRollOff(Storage *_storage) : ComboBoxSetting(_storage)
     187    {
     188        setLabel(QObject::tr("Roll-off"));
     189        setHelpText(QObject::tr(
     190                        "Roll-off (Default: Auto):\n"
     191                        "The  DVB-S2  standard  in  addition \n"
     192                        " to  the  single  DVB-S    35%  roll-off\n"
     193                        " factor,  provides  two  additional roll-off\n"
     194                        " factors to further increase transponder efficiency"));
     195        addSelection(QObject::tr("Auto"),"auto");
     196        addSelection("0.35","0.35",true);
     197        addSelection("0.20");
     198        addSelection("0.25");
     199    }
     200};
     201
    168202class ScanCodeRateLP: public ScanFecSetting, public TransientStorage
    169203{
    170204  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:
    4044    ScanFrequency  *pfrequency;
     
    4347    ScanFec        *pfec;
    4448    ScanPolarity   *ppolarity;
    4549    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  },
     76
    7677    { "UNKNOWN", kTunerTypeUnknown },
    7778    { NULL,      kTunerTypeUnknown },
    7879};
     
    145146
    146147const DTVParamHelperStruct DTVCodeRate::confTable[] =
    147148{
    148     { "FEC_AUTO", kFECAuto },
     149    { "FEC_NONE", kFECNone },
    149150    { "FEC_1_2",  kFEC_1_2  },
    150151    { "FEC_2_3",  kFEC_2_3  },
    151152    { "FEC_3_4",  kFEC_3_4  },
     
    154155    { "FEC_6_7",  kFEC_6_7  },
    155156    { "FEC_7_8",  kFEC_7_8  },
    156157    { "FEC_8_9",  kFEC_8_9  },
    157     { "FEC_NONE", kFECNone },
     158    { "FEC_AUTO", kFECAuto  },
     159    { "FEC_3_5",  kFEC_3_5  },
     160    { "FEC_9_10", kFEC_9_10 },
    158161    { NULL,       kFECAuto },
    159162};
    160163
     
    164167    { "12",  kFEC_1_2 },
    165168    { "23",  kFEC_2_3 },
    166169    { "34",  kFEC_3_4 },
     170    { "35",  kFEC_3_5 },
    167171    { "45",  kFEC_4_5 },
    168172    { "56",  kFEC_5_6 },
    169173    { "67",  kFEC_6_7 },
    170174    { "78",  kFEC_7_8 },
    171175    { "89",  kFEC_8_9 },
     176    { "910", kFEC_9_10},
    172177    { "0",   kFECNone },
    173178    { NULL,  kFECAuto }
    174179};
    175180
    176181const DTVParamHelperStruct DTVCodeRate::parseTable[] =
    177182{
    178     { "auto", kFECAuto },
     183    { "none", kFECNone },
    179184    { "1/2",  kFEC_1_2 },
    180185    { "2/3",  kFEC_2_3 },
    181186    { "3/4",  kFEC_3_4 },
     
    184189    { "6/7",  kFEC_6_7 },
    185190    { "7/8",  kFEC_7_8 },
    186191    { "8/9",  kFEC_8_9 },
    187     { "none", kFECNone },
     192    { "auto", kFECAuto },
     193    { "3/5",  kFEC_3_5 },
     194    { "9/10", kFEC_9_10},
    188195    { NULL,   kFECAuto }
    189196};
    190197
     
    199206     "6/7",  ///< kFEC_6_7
    200207     "7/8",  ///< kFEC_7_8
    201208     "8/9",  ///< kFEC_8_9
    202      "auto"  ///< kFECAuto
     209     "auto", ///< kFECAuto
     210     "3/5",  ///< kFEC_3_5
     211     "9/10", ///< kFEC_9_10
    203212};
    204213
    205214const DTVParamHelperStruct DTVModulation::confTable[] =
     
    213222   { "QPSK",     kModulationQPSK    },
    214223   { "8VSB",     kModulation8VSB    },
    215224   { "16VSB",    kModulation16VSB   },
    216    { "2VSB",     kModulation2VSB    },
    217    { "4VSB",     kModulation4VSB    },
    218    { "BPSK",     kModulationBPSK    },
    219225   { "16APSK",   kModulation16APSK  },
    220226   { "32APSK",   kModulation32APSK  },
    221227   { "8PSK",     kModulation8PSK    },
    222    { "16PSK",    kModulation16PSK   },
     228   { "DQPSK",    kModulationDQPSK   },
    223229   { "analog",   kModulationAnalog  },
    224230   { NULL,       kModulationQAMAuto },
    225231};
     
    232238   { "64",  kModulationQAM64   },
    233239   { "128", kModulationQAM128  },
    234240   { "256", kModulationQAM256  },
     241   { "2",   kModulationQPSK    },
     242   { "10",  kModulation8VSB    },
     243   { "11",  kModulation16VSB   },
     244   { "6",   kModulation16APSK  },
     245   { "7",   kModulation32APSK  },
     246   { "5",   kModulation8PSK    },
    235247   { "0",   kModulationQPSK    },
    236248   { NULL,  kModulationQAMAuto },
    237249};
     
    247259   { "qpsk",     kModulationQPSK    },
    248260   { "8vsb",     kModulation8VSB    },
    249261   { "16vsb",    kModulation16VSB   },
    250    { "2vsb",     kModulation2VSB    },
    251    { "4vsb",     kModulation4VSB    },
    252    { "bpsk",     kModulationBPSK    },
     262   { "8psk",     kModulation8PSK    },
    253263   { "16apsk",   kModulation16APSK  },
    254264   { "32apsk",   kModulation32APSK  },
    255    { "8psk",     kModulation8PSK    },
    256    { "16psk",    kModulation16PSK   },
     265   { "dqpsk",    kModulationDQPSK   },
    257266   // alternates
    258267   { "a",        kModulationQAMAuto },
    259268   { "qam_auto", kModulationQAMAuto },
     
    262271   { "qam-64",   kModulationQAM64   },
    263272   { "qam-128",  kModulationQAM128  },
    264273   { "qam-256",  kModulationQAM256  },
    265    // qpsk, no alternative
    266    { "8-vsb",    kModulation8VSB    },
    267    { "16-vsb",   kModulation16VSB   },
    268    { "2-vsb",    kModulation2VSB    },
    269    { "4-vsb",    kModulation4VSB    },
    270    // bpsk, no alternative
    271274   { "16-apsk",  kModulation16APSK  },
    272275   { "32-apsk",  kModulation32APSK  },
    273276   { "8-psk",    kModulation8PSK    },
    274    { "16-psk",   kModulation16PSK   },
     277   { "16-psk",   kModulationDQPSK   },
     278   { "dq-psk",   kModulationDQPSK   },
     279   { "16psk",    kModulationDQPSK   },
    275280   { NULL,       kModulationQAMAuto },
    276281};
    277282
     
    286291    "auto",    ///< kModulationQAMAuto
    287292    "8vsb",    ///< kModulation8VSB
    288293    "16vsb",   ///< kModulation16VSB
    289     "2vsb",    ///< kModulation2VSB
    290     "4vsb",    ///< kModulation4VSB
    291     "bpsk",    ///< kModulationBPSK
     294    "8psk",    ///< kModulation8PSK
    292295    "16apsk",  ///< kModulation16APSK
    293296    "32apsk",  ///< kModulation32APSK
    294     "8psk",    ///< kModulation8PSK
    295     "16psk",   ///< kModulation16PSK
     297    "dqpsk",   ///< kModulationDQPSK
    296298};
    297299
    298300const DTVParamHelperStruct DTVTransmitMode::confTable[] =
     
    420422   "r", ///< kPolarityRight
    421423   "l"  ///< kPolarityLeft
    422424};
     425
     426const DTVParamHelperStruct DTVModulationSystem::confTable[] =
     427{
     428   { "SYS_DVBS",  kModulationSystemDVBS  },
     429   { "SYS_DVBS2", kModulationSystemDVBS2 },
     430   { NULL,        kModulationSystemDVBS  },
     431};
     432
     433const DTVParamHelperStruct DTVModulationSystem::vdrTable[] =
     434{
     435   { "0",  kModulationSystemDVBS  },
     436   { "1",  kModulationSystemDVBS2 },
     437   { NULL, kModulationSystemDVBS  },
     438};
     439
     440const DTVParamHelperStruct DTVModulationSystem::parseTable[] =
     441{
     442   { "dvbs2", kModulationSystemDVBS2 },
     443   { "dvbs",  kModulationSystemDVBS  },
     444   { NULL,    kModulationSystemDVBS  },
     445};
     446
     447const char *DTVModulationSystem::dbStr[DTVModulationSystem::kDBStrCnt] =
     448{
     449    "dvbs",  ///< kModulationSystemDVBS
     450    "dvbs2", ///< kModulationSystemDVBS2
     451};
     452
     453const DTVParamHelperStruct DTVRollOff::confTable[] =
     454{
     455   { "ROLLOFF_35",   kRollOff35   },
     456   { "ROLLOFF_20",   kRollOff20   },
     457   { "ROLLOFF_25",   kRollOff25   },
     458   { "ROLLOFF_AUTO", kRollOffAuto },
     459   { NULL,           kRollOffAuto },
     460};
     461
     462const DTVParamHelperStruct DTVRollOff::vdrTable[] =
     463{
     464   { "35",   kRollOff35   },
     465   { "20",   kRollOff20   },
     466   { "25",   kRollOff25   },
     467   { "0",    kRollOffAuto },
     468   { NULL,   kRollOff35   },
     469};
     470
     471const DTVParamHelperStruct DTVRollOff::parseTable[] =
     472{
     473   { "0.35",   kRollOff35   },
     474   { "0.20",   kRollOff20   },
     475   { "0.25",   kRollOff25   },
     476   { "auto",   kRollOffAuto },
     477   { NULL,     kRollOff35   },
     478};
     479
     480const char *DTVRollOff::dbStr[DTVRollOff::kDBStrCnt] =
     481{
     482   "0.35",   ///< kRollOff35
     483   "0.20",   ///< kRollOff20
     484   "0.25",   ///< kRollOff25
     485   "auto",   ///< kRollOffAuto
     486};
  • 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

     
    4949        const QString &symbol_rate,  const QString &fec_inner,
    5050        const QString &modulation,   const QString &polarity);
    5151
     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);
     57
    5258    bool ParseTuningParams(
    5359        DTVTunerType type,
    5460        QString frequency,    QString inversion,      QString symbolrate,
    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/dbcheck.cpp

     
    43024302            return false;
    43034303    }
    43044304
     4305    if (dbver == "1223")
     4306    {
     4307        const char *updates[] = {
     4308"ALTER TABLE dtv_multiplex ADD msystem VARCHAR(10) DEFAULT NULL AFTER polarity;",
     4309"ALTER TABLE dtv_multiplex ADD rolloff VARCHAR(10) DEFAULT NULL AFTER modulation;",
     4310NULL
     4311};
     4312        if (!performActualUpdate(updates, "1224", dbver))
     4313            return false;
     4314    }
     4315
    43054316    return true;
    43064317}
    43074318
  • 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

     
    117117    QString           frontend_name;
    118118    DTVTunerType      card_type;
    119119    uint64_t          capabilities;
    120     uint64_t          ext_modulations;
    121120    uint64_t          frequency_minimum;
    122121    uint64_t          frequency_maximum;
    123122    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,
     379            QString::null,        QString::null,
    360380            QString::null,        QString::null);
    361381
    362382        if (mux)
     
    377397        -1,
    378398        QString::null,      QString::null,
    379399        -1,                 QString::null,
     400        QString::null,      QString::null,
    380401        QString::null,      QString::null);
    381402}
    382403
     
    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
    750757    {
     758        kModulationSystemDVBS  = 0x0,
     759        kModulationSystemDVBS2 = 0x1,
     760    };
     761    uint ModulationSystem() const { return _data[8]>>2&0x1; }
     762    QString ModulationSystemString() const
     763    {
     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
     
    3939#    define VSB_16        (fe_modulation)(QAM_AUTO+2)
    4040#endif
    4141
    42 #ifdef FE_GET_EXTENDED_INFO
    43   #define dvb_fe_params dvb_frontend_parameters_new
    44 #else
    45   #define dvb_fe_params dvb_frontend_parameters
    46 #endif
     42#define dvb_fe_params dvb_frontend_parameters
    4743
    4844class QString;
    4945QString toString(fe_status);
  • 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&);
    5657
     58static bool dtvmultiplex_to_dtvproperties(
     59    DTVTunerType, const DTVMultiplex&, struct dtv_properties*, bool do_tune);
     60
     61static bool dtvmultiplex_to_dtvproperties(
     62    DTVTunerType, const DTVMultiplex&, struct dtv_properties*);
     63
     64static DTVMultiplex dtvproperties_to_dtvmultiplex(
     65    DTVTunerType, const dtv_properties&);
     66
     67
    5768#define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(device)
    5869#define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \
    5970                 .arg(GetCardID()).arg(device)
     
    167178        frontend_name       = master->frontend_name;
    168179        card_type           = master->card_type;
    169180        capabilities        = master->capabilities;
    170         ext_modulations     = master->ext_modulations;
    171181        frequency_minimum   = master->frequency_minimum;
    172182        frequency_maximum   = master->frequency_maximum;
    173183        symbol_rate_minimum = master->symbol_rate_minimum;
     
    210220        return false;
    211221    }
    212222
    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 
    256223    frontend_name       = info.name;
    257     card_type           = info.type;
     224    //card_type           = info.type;
     225    card_type.Parse(CardUtil::ProbeDVBType(device));
    258226    capabilities        = info.caps;
    259227    frequency_minimum   = info.frequency_min;
    260228    frequency_maximum   = info.frequency_max;
     
    309277bool DVBChannel::TuneMultiplex(uint mplexid, QString inputname)
    310278{
    311279    DTVMultiplex tuning;
    312     if (!tuning.FillFromDB(card_type, mplexid))
     280    bool ok = true;
     281    //card_type.Parse(CardUtil::ProbeDVBType(inputname));
     282    ok = tuning.FillFromDB(card_type, mplexid);
     283    if (!ok)
    313284        return false;
    314285
    315     CheckOptions(tuning);
     286    //CheckOptions(tuning);
    316287
    317288    return Tune(tuning, inputname);
    318289}
     
    365336
    366337    // Get the input data for the channel
    367338    QString tvformat, modulation, freqtable, freqid, si_std;
     339    QString msystem, rolloff;
    368340    int finetune;
    369341    uint64_t frequency;
    370342    int mpeg_prog_num;
     
    375347        tvformat, modulation, freqtable, freqid,
    376348        finetune, frequency,
    377349        si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
     350        msystem, rolloff,
    378351        mplexid, commfree))
    379352    {
    380353        VERBOSE(VB_IMPORTANT, loc_err +
     
    596569    const DTVModulation m = modulation;
    597570    const uint64_t      c = capabilities;
    598571
    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 
    608572    return
    609573        ((DTVModulation::kModulationQPSK    == m) && (c & FE_CAN_QPSK))     ||
    610574        ((DTVModulation::kModulationQAM16   == m) && (c & FE_CAN_QAM_16))   ||
     
    680644    }
    681645
    682646    bool reset = (force_reset || first_tune);
    683     struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
     647    //struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
    684648
     649    struct dtv_properties cmds;
     650
     651    //clear card cache
     652    dtv_property props[11];
     653    memset(&props, 0, sizeof(props));
     654    props[0].cmd = DTV_CLEAR;
     655    cmds.num = 1;
     656    cmds.props = props;
     657    if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
     658    {
     659        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     660                "Clearing tuner cache failed." + ENO);
     661        return false;
     662    }
     663
     664    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds);
     665
    685666    bool is_dvbs = (DTVTunerType::kTunerTypeQPSK   == card_type ||
    686667                    DTVTunerType::kTunerTypeDVB_S2 == card_type);
    687668
     
    737718            // make sure we tune to frequency, if the lnb has changed
    738719            reset = first_tune = true;
    739720        }
    740        
    741         params.frequency = lnb->GetIntermediateFrequency(
    742             diseqc_settings, tuning);
    743721
     722        for (uint i = 0; i < cmds.num; i++)
     723        {
     724            if (cmds.props[i].cmd == DTV_FREQUENCY)
     725            {
     726                cmds.props[i].u.data = lnb->GetIntermediateFrequency(
     727                    diseqc_settings, tuning);
     728                break;
     729            }
     730        }
     731        //params.frequency = lnb->GetIntermediateFrequency(
     732        //    diseqc_settings, tuning);
     733
    744734        // 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;
     735        //if (capabilities & FE_CAN_FEC_AUTO)
     736        //    params.u.qpsk.fec_inner = FEC_AUTO;
    747737    }
    748738
    749739    VERBOSE(VB_CHANNEL, LOC + "Old Params: " +
     
    753743
    754744    // DVB-S is in kHz, other DVB is in Hz
    755745    int     freq_mult = (is_dvbs) ? 1 : 1000;
    756     QString suffix    = (is_dvbs) ? "kHz" : "Hz";
     746    //QString suffix    = (is_dvbs) ? "kHz" : "Hz";
    757747
    758748    if (reset || !prev_tuning.IsEqual(card_type, tuning, 500 * freq_mult))
    759749    {
    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)
     750        VERBOSE(VB_CHANNEL, LOC + "Tune(): Tuning ...");
     751        if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
    765752        {
    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             }
     753            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     754                    "Setting Frontend tuning parameters failed." + ENO);
     755            return false;
    772756        }
    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         }
    783757
    784758        // Extra delay to add for broken DVB drivers
    785759        if (tuning_delay)
     
    835809        return false;
    836810    }
    837811
    838     dvb_fe_params params;
    839     return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
     812    //dvb_fe_params params;
     813    //return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
     814    struct dtv_properties cmds;
     815    cmds.num = 0;
     816    return ioctl(fd_frontend, FE_GET_PROPERTY, &cmds) >= 0;
    840817}
    841818
    842819/** \fn DVBChannel::ProbeTuningParams(DTVMultiplex&) const
     
    868845        return false;
    869846    }
    870847
    871     dvb_fe_params params;
    872     if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0)
     848    struct dtv_properties cmds;
     849    dtv_property props[11];
     850    memset(&props, 0, sizeof(props));
     851    cmds.props = props;
     852    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds, false);
     853    if (ioctl(fd_frontend, FE_GET_PROPERTY, &cmds) < 0)
    873854    {
    874855        VERBOSE(VB_IMPORTANT, LOC_ERR +
    875856                "Getting Frontend tuning parameters failed." + ENO);
     
    880861    uint    mplex      = tuning.mplex;
    881862    QString sistandard = tuning.sistandard; sistandard.detach();
    882863
    883     tuning = dvbparams_to_dtvmultiplex(card_type, params);
     864    tuning = dtvproperties_to_dtvmultiplex(card_type, cmds);
    884865
    885866    tuning.mplex       = mplex;
    886867    tuning.sistandard  = sistandard;
     
    10941075    return true;
    10951076}
    10961077
    1097 static struct dvb_fe_params dtvmultiplex_to_dvbparams(
    1098     DTVTunerType tuner_type, const DTVMultiplex &tuning)
     1078
     1079static DTVMultiplex dtvproperties_to_dtvmultiplex(
     1080    DTVTunerType tuner_type, const dtv_properties &cmds)
    10991081{
    1100     dvb_fe_params params;
    1101     bzero(&params, sizeof(params));
     1082    DTVMultiplex tuning;
    11021083
    1103     params.frequency = tuning.frequency;
    1104     params.inversion = (fe_spectral_inversion_t) (int) tuning.inversion;
    1105 
    1106     if (DTVTunerType::kTunerTypeQPSK == tuner_type)
     1084    for (uint i = 0; i < cmds.num; i++)
    11071085    {
    1108         params.u.qpsk.symbol_rate = tuning.symbolrate;
    1109         params.u.qpsk.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
     1086        switch (cmds.props[i].cmd)
     1087        {
     1088            case DTV_MODULATION:
     1089                tuning.modulation = cmds.props[i].u.data;
     1090                break;
     1091            case DTV_DELIVERY_SYSTEM:
     1092                switch (cmds.props[i].u.data)
     1093                {
     1094                    case SYS_DVBS:
     1095                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS;
     1096                        break;
     1097                    case SYS_DVBS2:
     1098                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS2;
     1099                        break;
     1100                    case SYS_DVBT:
     1101                    case SYS_DVBC_ANNEX_AC:
     1102                    case SYS_DVBC_ANNEX_B:
     1103#ifdef USE_ATSC
     1104                    case SYS_ATSC:
     1105#endif
     1106                        break;
     1107                    default:
     1108                        VERBOSE(VB_IMPORTANT, "Unknown DVB delivery system." + ENO);
     1109                };
     1110                break;
     1111            case DTV_FREQUENCY:
     1112                if (tuning.modulation == DTVModulation::kModulationQPSK ||
     1113                    tuning.modulation == DTVModulation::kModulation8PSK)
     1114                    tuning.frequency = cmds.props[i].u.data / 1000UL;
     1115                else
     1116                    tuning.frequency = cmds.props[i].u.data;
     1117                break;
     1118            case DTV_SYMBOL_RATE:
     1119                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
     1120                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
     1121                    tuner_type == DTVTunerType::kTunerTypeQAM)
     1122                {
     1123                    if (tuning.modulation == DTVModulation::kModulationQPSK ||
     1124                        tuning.modulation == DTVModulation::kModulation8PSK)
     1125                        tuning.symbolrate = cmds.props[i].u.data / 1000UL;
     1126                    else
     1127                        tuning.symbolrate = cmds.props[i].u.data;
     1128                };
     1129                break;
     1130            case DTV_INNER_FEC:
     1131                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
     1132                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
     1133                    tuner_type == DTVTunerType::kTunerTypeQAM)
     1134                {
     1135                    tuning.symbolrate = cmds.props[i].u.data;
     1136                }
     1137                break;
     1138            case DTV_PILOT:
     1139                break;
     1140            case DTV_ROLLOFF:
     1141                if (tuner_type == DTVTunerType::kTunerTypeDVB_S2)
     1142                    tuning.rolloff = cmds.props[i].u.data;
     1143                break;
     1144            case DTV_INVERSION:
     1145                tuning.inversion = cmds.props[i].u.data;
     1146                break;
     1147            case DTV_BANDWIDTH_HZ:
     1148                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1149                    tuning.bandwidth = cmds.props[i].u.data;
     1150                break;
     1151            case DTV_CODE_RATE_HP:
     1152                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1153                    tuning.hp_code_rate = cmds.props[i].u.data;
     1154                break;
     1155            case DTV_CODE_RATE_LP:
     1156                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1157                    tuning.lp_code_rate = cmds.props[i].u.data;
     1158                break;
     1159            case DTV_TRANSMISSION_MODE:
     1160                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1161                    tuning.trans_mode = cmds.props[i].u.data;
     1162                break;
     1163            case DTV_GUARD_INTERVAL:
     1164                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1165                    tuning.guard_interval = cmds.props[i].u.data;
     1166                break;
     1167            case DTV_HIERARCHY:
     1168                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1169                    tuning.hierarchy = cmds.props[i].u.data;
     1170                break;
     1171            case DTV_TUNE:
     1172                break;
     1173            default:
     1174                VERBOSE(VB_IMPORTANT, "Unknown DTV command." + ENO);
     1175        }
    11101176    }
     1177    return tuning;
     1178}
    11111179
    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     }
     1180static bool dtvmultiplex_to_dtvproperties(
     1181    DTVTunerType tuner_type,
     1182    const DTVMultiplex &tuning,
     1183    struct dtv_properties *cmdseq)
     1184{
     1185    return dtvmultiplex_to_dtvproperties(tuner_type, tuning, cmdseq, true);
     1186}
    11231187
    1124     if (DTVTunerType::kTunerTypeQAM  == tuner_type)
     1188static bool dtvmultiplex_to_dtvproperties(
     1189    DTVTunerType tuner_type,
     1190    const DTVMultiplex &tuning,
     1191    struct dtv_properties *cmdseq,
     1192    bool do_tune)
     1193{
     1194    if (tuner_type == DTVTunerType::kTunerTypeQPSK ||
     1195        (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
     1196         tuning.modulation == DTVModulation::kModulationQPSK))
    11251197    {
    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;
     1198        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1199        cmdseq->props[0].u.data = SYS_DVBS;
     1200        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1201        cmdseq->props[1].u.data = tuning.frequency;
     1202        cmdseq->props[2].cmd    = DTV_MODULATION;
     1203        cmdseq->props[2].u.data = tuning.modulation;
     1204        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1205        cmdseq->props[3].u.data = tuning.symbolrate;
     1206        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1207        cmdseq->props[4].u.data = tuning.fec;
     1208        cmdseq->props[5].cmd    = DTV_INVERSION;
     1209        cmdseq->props[5].u.data = tuning.inversion;
     1210        if (do_tune)
     1211        {
     1212            cmdseq->props[6].cmd    = DTV_TUNE;
     1213            cmdseq->num = 7;
     1214        }
     1215        else
     1216        {
     1217            cmdseq->num = 6;
     1218        }
    11291219    }
    1130 
    1131     if (DTVTunerType::kTunerTypeOFDM == tuner_type)
     1220    else if (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
     1221             tuning.modulation == DTVModulation::kModulation8PSK)
    11321222    {
    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;
     1223        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1224        cmdseq->props[0].u.data = SYS_DVBS2;
     1225        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1226        cmdseq->props[1].u.data = tuning.frequency;
     1227        cmdseq->props[2].cmd    = DTV_MODULATION;
     1228        cmdseq->props[2].u.data = tuning.modulation;
     1229        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1230        cmdseq->props[3].u.data = tuning.symbolrate;
     1231        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1232        cmdseq->props[4].u.data = tuning.fec;
     1233        cmdseq->props[5].cmd    = DTV_INVERSION;
     1234        cmdseq->props[5].u.data = tuning.inversion;
     1235        cmdseq->props[6].cmd    = DTV_PILOT;
     1236        cmdseq->props[6].u.data = PILOT_AUTO;
     1237        cmdseq->props[7].cmd    = DTV_ROLLOFF;
     1238        if (tuning.msystem == DTVModulationSystem::kModulationSystemDVBS2)
     1239            cmdseq->props[7].u.data = tuning.rolloff;
     1240        else
     1241            cmdseq->props[7].u.data = DTVRollOff::kRollOff35;
     1242        if (do_tune)
     1243        {
     1244            cmdseq->props[8].cmd = DTV_TUNE;
     1245            cmdseq->num = 9;
     1246        }
     1247        else
     1248            cmdseq->num = 8;
    11471249    }
    1148 
    1149     if (DTVTunerType::kTunerTypeATSC == tuner_type)
     1250    else if (tuner_type == DTVTunerType::kTunerTypeQAM)
    11501251    {
    1151 #ifdef USE_ATSC
    1152         params.u.vsb.modulation   =
    1153             (fe_modulation_t) (int) tuning.modulation;
    1154 #endif // USE_ATSC
     1252        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1253        cmdseq->props[0].u.data = (fe_delivery_system_t) (int) tuning.msystem;
     1254        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1255        cmdseq->props[1].u.data = tuning.frequency;
     1256        cmdseq->props[2].cmd    = DTV_MODULATION;
     1257        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
     1258        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1259        cmdseq->props[3].u.data = tuning.symbolrate;
     1260        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1261        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
     1262        cmdseq->props[5].cmd    = DTV_INVERSION;
     1263        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1264        if (do_tune)
     1265        {
     1266            cmdseq->props[6].cmd    = DTV_TUNE;
     1267            cmdseq->num = 7;
     1268        }
     1269        else
     1270            cmdseq->num = 6;
    11551271    }
    1156 
    1157     return params;
    1158 }
    1159 
    1160 static DTVMultiplex dvbparams_to_dtvmultiplex(
    1161     DTVTunerType tuner_type, const dvb_fe_params &params)
    1162 {
    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))
     1272    else if (tuner_type == DTVTunerType::kTunerTypeOFDM)
    11701273    {
    1171         tuning.symbolrate     = params.u.qpsk.symbol_rate;
    1172         tuning.fec            = params.u.qpsk.fec_inner;
     1274        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1275        cmdseq->props[0].u.data = SYS_DVBC_ANNEX_AC;
     1276        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1277        cmdseq->props[1].u.data = tuning.frequency;
     1278        cmdseq->props[2].cmd    = DTV_MODULATION;
     1279        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
     1280        cmdseq->props[3].cmd    = DTV_INVERSION;
     1281        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1282        cmdseq->props[4].cmd    = DTV_BANDWIDTH_HZ;
     1283        cmdseq->props[4].u.data = (fe_bandwidth_t) (int) tuning.bandwidth;
     1284        cmdseq->props[5].cmd    = DTV_CODE_RATE_HP;
     1285        cmdseq->props[5].u.data = (fe_code_rate_t) (int) tuning.hp_code_rate;
     1286        cmdseq->props[6].cmd    = DTV_CODE_RATE_LP;
     1287        cmdseq->props[6].u.data = (fe_code_rate_t) (int) tuning.lp_code_rate;
     1288        cmdseq->props[7].cmd    = DTV_TRANSMISSION_MODE;
     1289        cmdseq->props[7].u.data = (fe_transmit_mode_t) (int) tuning.trans_mode;
     1290        cmdseq->props[8].cmd    = DTV_GUARD_INTERVAL;
     1291        cmdseq->props[8].u.data = (fe_guard_interval_t) (int) tuning.guard_interval;
     1292        cmdseq->props[9].cmd    = DTV_HIERARCHY;
     1293        cmdseq->props[9].u.data = (fe_hierarchy_t) (int) tuning.hierarchy;
     1294        if (do_tune)
     1295        {
     1296            cmdseq->props[10].cmd    = DTV_TUNE;
     1297            cmdseq->num = 11;
     1298        }
     1299        else
     1300            cmdseq->num = 10;
    11731301    }
    1174 
    1175     if (DTVTunerType::kTunerTypeQAM  == tuner_type)
     1302#ifdef USE_ATSC
     1303    else if (tuner_type == DTVTunerType::kTunerTypeATSC)
    11761304    {
    1177         tuning.symbolrate     = params.u.qam.symbol_rate;
    1178         tuning.fec            = params.u.qam.fec_inner;
    1179         tuning.modulation     = params.u.qam.modulation;
     1305        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1306        cmdseq->props[0].u.data = SYS_ATSC;
     1307        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1308        cmdseq->props[1].u.data = tuning.frequency * 1000UL;
     1309        cmdseq->props[2].cmd    = DTV_MODULATION;
     1310        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;;
     1311        cmdseq->props[3].cmd    = DTV_INVERSION;
     1312        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1313        if (do_tune)
     1314        {
     1315            cmdseq->props[4].cmd    = DTV_TUNE;
     1316            cmdseq->num = 5;
     1317        }
     1318        else
     1319            cmdseq->num = 4;
    11801320    }
    1181 
    1182     if (DTVTunerType::kTunerTypeOFDM == tuner_type)
     1321#endif
     1322    else
    11831323    {
    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;
     1324        VERBOSE(VB_IMPORTANT, "Unknown tuner type." + ENO);
    11911325    }
     1326   return true;
     1327}
    11921328
    1193     if (DTVTunerType::kTunerTypeATSC == tuner_type)
    1194     {
    1195 #ifdef USE_ATSC
    1196         tuning.modulation     = params.u.vsb.modulation;
    1197 #endif // USE_ATSC
    1198     }
    1199 
    1200     return tuning;
    1201 }
  • libs/libmythtv/cardutil.cpp

     
    242242        VERBOSE(VB_IMPORTANT, "FE_GET_INFO ioctl failed (" + dvbdev + ").");
    243243        return ret;
    244244    }
     245    DTVTunerType type(info.type);
     246    if (type == DTVTunerType::kTunerTypeQPSK)
     247    {
     248        /* XXX TODO
     249         * there is currently no way to detect if the frontend supports DVB-S2
     250         * so every DVB-S frontend is handled as DVB-S2 */
     251        type = DTVTunerType::kTunerTypeDVB_S2;
     252    }
    245253    close(fd_frontend);
    246254
    247     DTVTunerType type(info.type);
    248255    ret = (type.toString() != "UNKNOWN") ? type.toString().toUpper() : ret;
    249256#endif // USING_DVB
    250257
     
    337344{
    338345    QString ct = card_type.toUpper();
    339346    return (ct == "DVB") || (ct == "QAM") || (ct == "QPSK") ||
    340         (ct == "OFDM") || (ct == "ATSC");
     347        (ct == "OFDM") || (ct == "ATSC") || (ct == "DVB_S2");
    341348}
    342349
    343350QString 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"),
  • 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}
     
    102107        return
    103108            (inversion  == other.inversion)  &&
    104109            (symbolrate == other.symbolrate) &&
    105             (fec        == other.fec);
     110            (fec        == other.fec)        &&
     111            (msystem    == other.msystem)    &&
     112            (rolloff    == other.rolloff);
    106113    }
    107114
    108115    return false;
     
    182189    return ok;
    183190}
    184191
     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
     237    return ok;
     238}
     239
    185240bool DTVMultiplex::ParseTuningParams(
    186241    DTVTunerType type,
    187242    QString _frequency,    QString _inversion,      QString _symbolrate,
    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(
     
    207262            _fec,             _modulation,    _polarity);
    208263    }
    209264
     265    if (DTVTunerType::kTunerTypeDVB_S2 == type)
     266    {
     267        return ParseDVB_S2(
     268            _frequency,       _inversion,     _symbolrate,
     269            _fec,             _modulation,    _polarity,
     270            _msystem,         _rolloff);
     271    }
     272
    210273    if (DTVTunerType::kTunerTypeATSC == type)
    211274        return ParseATSC(_frequency, _modulation);
    212275
     
    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////////////////////////////////////////////////////////////////////////////
     
    318383        "    mplexid,            frequency,       inversion,  "
    319384        "    symbolrate,         fec,             polarity,   "
    320385        "    hp_code_rate,       lp_code_rate,    modulation, "
     386        "    msystem,            rolloff,                     "
    321387        "    transmission_mode,  guard_interval,  hierarchy,  "
    322388        "    bandwidth,          sistandard,      tuner_type  "
    323389        " ) "
     
    326392        "   :MPLEXID,           :FREQUENCY,      :INVERSION,  "
    327393        "   :SYMBOLRATE,        :FEC,            :POLARITY,   "
    328394        "   :HP_CODE_RATE,      :LP_CODE_RATE,   :MODULATION, "
     395        "   :MSYSTEM,           :ROLLOFF,                     "
    329396        "   :TRANSMISSION_MODE, :GUARD_INTERVAL, :HIERARCHY,  "
    330397        "   :BANDWIDTH,         :SISTANDARD,     :TUNER_TYPE  "
    331398        " );");
     
    340407    query.bindValue(":HP_CODE_RATE", hp_code_rate.toString());
    341408    query.bindValue(":LP_CODE_RATE", lp_code_rate.toString());
    342409    query.bindValue(":MODULATION", modulation.toString());
     410    query.bindValue(":MSYSTEM", msystem.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());