Ticket #5882: t5882_S2Api_2.diff

mythtv/libs/libmythtv/cardutil.cpp

@@ -242 +242 @@
         VERBOSE(VB_IMPORTANT, "FE_GET_INFO ioctl failed (" + dvbdev + ").");
         return ret;
     }
+    DTVTunerType type(info.type);
+    if (type == DTVTunerType::kTunerTypeQPSK)
+    {
+        /* XXX TODO
+         * there is currently no way to detect if the frontend supports DVB-S2
+         * so every DVB-S frontend is handled as DVB-S2 */
+        type = DTVTunerType::kTunerTypeDVB_S2;
+    }
     close(fd_frontend);
 
-    DTVTunerType type(info.type);
     ret = (type.toString() != "UNKNOWN") ? type.toString().toUpper() : ret;
 #endif // USING_DVB
 
@@ -337 +344 @@
 {
     QString ct = card_type.toUpper();
     return (ct == "DVB") || (ct == "QAM") || (ct == "QPSK") ||
-        (ct == "OFDM") || (ct == "ATSC");
+        (ct == "OFDM") || (ct == "ATSC") || (ct == "DVB_S2");
 }
 
 QString get_on_cardid(const QString &to_get, uint cardid)

mythtv/libs/libmythtv/cardutil.h

@@ -54 +54 @@
         HDHOMERUN = 10,
         FREEBOX   = 11,
         HDPVR     = 12,
+        DVBS2     = 13,
     };
 
     static enum CARD_TYPES toCardType(const QString &name)
@@ -84 +85 @@
             return FREEBOX;
         if ("HDPVR" == name)
             return HDPVR;
+        if ("DVB_S2" == name)
+            return DVBS2;
         return ERROR_UNKNOWN;
     }
 

mythtv/libs/libmythtv/channelbase.cpp

@@ -190 +190 @@
 
     // Fetch tuning data from the database.
     QString tvformat, modulation, freqtable, freqid, dtv_si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -201 +202 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff,
         mplexid, commfree))
     {
         VERBOSE(VB_IMPORTANT, loc + " " + QString(

mythtv/libs/libmythtv/channelscan/channelscan_sm.cpp

@@ -1439 +1439 @@
             startChan["coderate_hp"],    startChan["coderate_lp"],
             startChan["constellation"],  startChan["trans_mode"],
             startChan["guard_interval"], startChan["hierarchy"],
-            startChan["modulation"],     startChan["bandwidth"]);
+            startChan["modulation"],     startChan["bandwidth"],
+            startChan["msystem"],        startChan["rolloff"]);
     }
 
     if (ok)

mythtv/libs/libmythtv/channelscan/channelscanmiscsettings.h

@@ -146 +146 @@
         addSelection("1/2");
         addSelection("2/3");
         addSelection("3/4");
+        addSelection("3/5");
         addSelection("4/5");
         addSelection("5/6");
         addSelection("6/7");
         addSelection("7/8");
         addSelection("8/9");
+        addSelection("9/10");
     }
 };
 
@@ -165 +167 @@
     }
 };
 
+class ScanModulationSystem: public ComboBoxSetting, public TransientStorage
+{
+  public:
+    ScanModulationSystem() : ScanModulationSystemSetting(this)
+    {
+        setLabel(QObject::tr("Modul. System"));
+        setHelpText(QObject::tr("Modulation System (Default: DVB-S)"));
+        addSelection("DVB-S","dvbs",true);
+        addSelection("DVB-S2","dvbs2");
+    };
+};
+
+
+class ScanRollOff: public ComboBoxSetting
+{
+  public:
+    ScanRollOff(Storage *_storage) : ComboBoxSetting(_storage)
+    {
+        setLabel(QObject::tr("Roll-off"));
+        setHelpText(QObject::tr(
+                        "Roll-off (Default: Auto):\n"
+                        "The  DVB-S2  standard  in  addition \n"
+                        " to  the  single  DVB-S    35%  roll-off\n"
+                        " factor,  provides  two  additional roll-off\n"
+                        " factors to further increase transponder efficiency"));
+        addSelection(QObject::tr("Auto"),"auto");
+        addSelection("0.35","0.35",true);
+        addSelection("0.20");
+        addSelection("0.25");
+    }
+};
+
 class ScanCodeRateLP: public ScanFecSetting, public TransientStorage
 {
   public:

mythtv/libs/libmythtv/channelscan/channelscanner.cpp

@@ -143 +143 @@
     }
     else if ((ScanTypeSetting::NITAddScan_DVBT == scantype) ||
              (ScanTypeSetting::NITAddScan_DVBS == scantype) ||
+             (ScanTypeSetting::NITAddScan_DVBS2 == scantype) ||
              (ScanTypeSetting::NITAddScan_DVBC == scantype))
     {
         VERBOSE(VB_SIPARSER, LOC + "ScanTransports()");
@@ -219 +220 @@
     DTVConfParser::cardtype_t type = DTVConfParser::UNKNOWN;
     type = (CardUtil::DVBT == cardtype) ? DTVConfParser::OFDM : type;
     type = (CardUtil::QPSK == cardtype) ? DTVConfParser::QPSK : type;
+    type = (CardUtil::DVBS2 == cardtype) ? DTVConfParser::DVBS2 : type;
     type = (CardUtil::DVBC == cardtype) ? DTVConfParser::QAM  : type;
     type = ((CardUtil::ATSC == cardtype) ||
             (CardUtil::HDHOMERUN == cardtype)) ? DTVConfParser::ATSC : type;
@@ -302 +304 @@
         QString sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper();
         bool need_nit = (("QAM"  == sub_type) ||
                          ("QPSK" == sub_type) ||
+                         ("DVB_S2" == sub_type) ||
                          ("OFDM" == sub_type));
 
         // Ugh, Some DVB drivers don't fully support signal monitoring...

mythtv/libs/libmythtv/channelscan/modulationsetting.h

@@ -58 +58 @@
     {
         addSelection(QObject::tr("Auto"),"auto",true);
         addSelection("QPSK","qpsk");
-#ifdef FE_GET_EXTENDED_INFO
         addSelection("8PSK","8psk");
-#endif
         addSelection("QAM 16","qam_16");
         addSelection("QAM 32","qam_32");
         addSelection("QAM 64","qam_64");

mythtv/libs/libmythtv/channelscan/panedvbs2.h

@@ -22 +22 @@
         left->addChild( pfrequency  = new ScanFrequency());
         left->addChild( ppolarity   = new ScanPolarity());
         left->addChild( psymbolrate = new ScanSymbolRate());
-        right->addChild(pfec        = new ScanFec());
+        left->addChild( pfec        = new ScanFec());
+        right->addChild(pmsystem    = new ScanModulationSystem());
         right->addChild(pmodulation = new ScanModulation());
         right->addChild(pinversion  = new ScanInversion());
+        right->addChild(prolloff    = new ScanRollOff());
         addChild(left);
         addChild(right);     
     }
@@ -35 +37 @@
     QString fec(void)        const { return pfec->getValue();        }
     QString polarity(void)   const { return ppolarity->getValue();   }
     QString modulation(void) const { return pmodulation->getValue(); }
+    QString rolloff(void)    const { return prolloff->getValue();    }
+    QString msystem(void)    const { return pmsystem->getValue();    }
 
   protected:
     ScanFrequency  *pfrequency;
@@ -43 +47 @@
     ScanFec        *pfec;
     ScanPolarity   *ppolarity;
     ScanModulation *pmodulation;
+    ScanRollOff    *prolloff;
+    ScanModulationSystem    *pmsystem;
 };
 
 #endif // _PANE_DVBS2_H_

mythtv/libs/libmythtv/channelscan/scaninfo.cpp

@@ -76 +76 @@
         "       hp_code_rate,      lp_code_rate,   modulation, "
         "       transmission_mode, guard_interval, hierarchy, "
         "       modulation,        bandwidth,      sistandard, "
-        "       tuner_type,        transportid "
+        "       tuner_type,        transportid, "
+        "       msystem,           rolloff "
         "FROM channelscan_dtv_multiplex "
         "WHERE scanid = :SCANID");
     query.bindValue(":SCANID", scanid);
@@ -97 +98 @@
             query.value(6).toString(),  query.value(7).toString(),
             query.value(8).toString(),  query.value(9).toString(),
             query.value(10).toString(), query.value(11).toString(),
-            query.value(12).toString());
+            query.value(12).toString(), query.value(16).toString(),
+            query.value(17).toString());
 
         query2.prepare(
             "SELECT "

mythtv/libs/libmythtv/channelscan/scanwizardconfig.cpp

@@ -133 +133 @@
         addSelection(tr("Import channels.conf"),
                      QString::number(DVBUtilsImport));
         break;
+    case CardUtil::DVBS2:
+        addSelection(tr("Full Scan (Tuned)"),
+                     QString::number(NITAddScan_DVBS2));
+        addSelection(tr("Import channels.conf"),
+                     QString::number(DVBUtilsImport));
+        break;
     case CardUtil::QAM:
         addSelection(tr("Full Scan (Tuned)"),
                      QString::number(NITAddScan_DVBC));
@@ -329 +335 @@
         startChan["modulation"] = "qpsk";
         startChan["polarity"]   = pane->polarity();
     }
+    else if (ScanTypeSetting::NITAddScan_DVBS2 == st)
+    {
+        const PaneDVBS2 *pane = paneDVBS2;
+
+        startChan["std"]        = "dvb";
+        startChan["frequency"]  = pane->frequency();
+        startChan["inversion"]  = pane->inversion();
+        startChan["symbolrate"] = pane->symbolrate();
+        startChan["fec"]        = pane->fec();
+        startChan["modulation"] = pane->modulation();;
+        startChan["polarity"]   = pane->polarity();
+        startChan["rolloff"]    = pane->rolloff();
+    }
     else if (ScanTypeSetting::NITAddScan_DVBC == st)
     {
         const PaneDVBC *pane = paneDVBC;

mythtv/libs/libmythtv/channelutil.cpp

@@ -121 +121 @@
     signed char trans_mode,
     QString     inner_FEC,     QString      constellation,
     signed char hierarchy,     QString      hp_code_rate,
-    QString     lp_code_rate,  QString      guard_interval)
+    QString     lp_code_rate,  QString      guard_interval,
+    QString     msystem,       QString      rolloff)
 {
     MSqlQuery query(MSqlQuery::InitCon());
 
@@ -165 +166 @@
         "lp_code_rate     = :LP_CODE_RATE, " : "";
     updateStr += (!guard_interval.isNull()) ?
         "guard_interval   = :GUARD_INTERVAL, " : "";
+    updateStr += (!msystem.isNull()) ?
+        "msystem          = :MSYSTEM, " : "";
+    updateStr += (!rolloff.isNull()) ?
+        "rolloff          = :ROLLOFF, " : "";
 
     updateStr = updateStr.left(updateStr.length()-2) + " ";
 
@@ -194 +199 @@
     insertStr += (!hp_code_rate.isNull())   ? "hp_code_rate, "      : "";
     insertStr += (!lp_code_rate.isNull())   ? "lp_code_rate, "      : "";
     insertStr += (!guard_interval.isNull()) ? "guard_interval, "    : "";
+    insertStr += (!msystem.isNull())        ? "msystem, "           : "";
+    insertStr += (!rolloff.isNull())        ? "rolloff, "           : "";
     insertStr = insertStr.left(insertStr.length()-2) + ") ";
 
     insertStr +=
@@ -213 +220 @@
     insertStr += (!hp_code_rate.isNull())   ? ":HP_CODE_RATE, "     : "";
     insertStr += (!lp_code_rate.isNull())   ? ":LP_CODE_RATE, "     : "";
     insertStr += (!guard_interval.isNull()) ? ":GUARD_INTERVAL, "   : "";
+    insertStr += (!msystem.isNull())        ? ":MSYSTEM, "          : "";
+    insertStr += (!rolloff.isNull())        ? ":ROLLOFF, "          : "";
     insertStr = insertStr.left(insertStr.length()-2) + ");";
 
     query.prepare((mplex) ? updateStr : insertStr);
@@ -254 +263 @@
         query.bindValue(":LP_CODE_RATE",  lp_code_rate);
     if (!guard_interval.isNull())
         query.bindValue(":GUARD_INTERVAL",guard_interval);
+    if (!msystem.isNull())
+        query.bindValue(":MSYSTEM",       msystem);
+    if (!rolloff.isNull())
+        query.bindValue(":ROLLOFF",       rolloff);
 
     if (!query.exec() || !query.isActive())
     {
@@ -292 +305 @@
         {
             QString dummy_mod;
             QString dummy_sistd;
+            QString dummy_msystem;
+            QString dummy_rolloff;
             uint dummy_tsid, dummy_netid;
             ChannelUtil::GetTuningParams(mux, dummy_mod, freq,
-                                         dummy_tsid, dummy_netid, dummy_sistd);
+                                         dummy_tsid, dummy_netid,
+                                         dummy_msystem, dummy_rolloff,
+                                         dummy_sistd);
         }
 
         mux = ChannelUtil::CreateMultiplex(
@@ -307 +324 @@
             cd.TransmissionModeString()[0].toAscii(),
             QString(),                         cd.ConstellationString(),
             cd.HierarchyString()[0].toAscii(), cd.CodeRateHPString(),
-            cd.CodeRateLPString(),             cd.GuardIntervalString());
+            cd.CodeRateLPString(),             cd.GuardIntervalString(),
+            QString(),                         QString());
 
         if (mux)
             muxes.push_back(mux);
@@ -334 +352 @@
             -1,
             cd.FECInnerString(),  QString(),
             -1,                   QString(),
-            QString(),            QString());
+            QString(),                   QString(),
+            cd.ModulationSystemString(), cd.RollOffString());
 
         if (mux)
             muxes.push_back(mux);
@@ -357 +376 @@
             -1,
             cd.FECInnerString(),  QString::null,
             -1,                   QString::null,
+            QString::null,        QString::null,
             QString::null,        QString::null);
 
         if (mux)
@@ -377 +397 @@
         -1,
         QString::null,      QString::null,
         -1,                 QString::null,
+        QString::null,      QString::null,
         QString::null,      QString::null);
 }
 
@@ -390 +411 @@
     signed char trans_mode,
     QString     inner_FEC,    QString     constellation,
     signed char hierarchy,    QString     hp_code_rate,
-    QString     lp_code_rate, QString     guard_interval)
+    QString     lp_code_rate, QString     guard_interval,
+    QString     msystem,      QString     rolloff)
 {
     return insert_dtv_multiplex(
         sourceid,           sistandard,
@@ -402 +424 @@
         trans_mode,
         inner_FEC,          constellation,
         hierarchy,          hp_code_rate,
-        lp_code_rate,       guard_interval);
+        lp_code_rate,       guard_interval,
+        msystem,            rolloff);
 }
 
 uint ChannelUtil::CreateMultiplex(uint sourceid, const DTVMultiplex &mux,
@@ -418 +441 @@
         mux.trans_mode.toChar().toAscii(),
         mux.fec.toString(),               mux.modulation.toString(),
         mux.hierarchy.toChar().toAscii(), mux.hp_code_rate.toString(),
-        mux.lp_code_rate.toString(),      mux.guard_interval.toString());
+        mux.lp_code_rate.toString(),      mux.guard_interval.toString(),
+        mux.msystem.toString(),           mux.rolloff.toString());
 }
 
 
@@ -706 +730 @@
                                   uint64_t &frequency,
                                   uint     &dvb_transportid,
                                   uint     &dvb_networkid,
+                                  QString  &dvb_msystem,
+                                  QString  &dvb_rolloff,
                                   QString  &si_std)
 {
     if (!mplexid || (mplexid == 32767)) /* 32767 deals with old lineups */
@@ -713 +739 @@
 
     MSqlQuery query(MSqlQuery::InitCon());
     query.prepare(
-        "SELECT transportid, networkid, frequency, modulation, sistandard "
+        "SELECT transportid, networkid, frequency, modulation, sistandard, "
+        "msystem, rolloff "
         "FROM dtv_multiplex "
         "WHERE mplexid = :MPLEXID");
     query.bindValue(":MPLEXID", mplexid);
@@ -732 +759 @@
     frequency       = (uint64_t) query.value(2).toDouble(); // Qt 3.1 compat
     modulation      = query.value(3).toString();
     si_std          = query.value(4).toString();
+    dvb_msystem     = query.value(5).toString();
+    dvb_rolloff     = query.value(6).toString();
 
     return true;
 }
@@ -1483 +1512 @@
     QString &dtv_si_std,      int           &mpeg_prog_num,
     uint    &atsc_major,      uint          &atsc_minor,
     uint    &dvb_transportid, uint          &dvb_networkid,
+    QString &dvb_msystem,     QString       &dvb_rolloff,
     uint    &mplexid,
     bool    &commfree)
 {
@@ -1535 +1565 @@
         return true;
 
     return GetTuningParams(mplexid, modulation, frequency,
-                           dvb_transportid, dvb_networkid, dtv_si_std);
+                           dvb_transportid, dvb_networkid,
+                           dvb_msystem, dvb_rolloff, dtv_si_std);
 }
 
 bool ChannelUtil::GetChannelSettings(int chanid, bool &useonairguide,

mythtv/libs/libmythtv/channelutil.h

@@ -67 +67 @@
         signed char trans_mode,
         QString     inner_FEC,    QString     constellation,
         signed char hierarchy,    QString     hp_code_rate,
-        QString     lp_code_rate, QString     guard_interval);
+        QString     lp_code_rate, QString     guard_interval,
+        QString     msystem,      QString     rolloff);
 
     static uint    CreateMultiplex(uint sourceid, const DTVMultiplex&,
                                    int transport_id, int network_id);
@@ -90 +91 @@
                                    uint64_t &frequency,
                                    uint     &dvb_transportid,
                                    uint     &dvb_networkid,
+                                   QString  &msystem,
+                                   QString  &rolloff,
                                    QString  &si_std);
 
     static bool    GetATSCChannel(uint sourceid, const QString &channum,
@@ -159 +162 @@
         QString &dtv_si_std,      int     &mpeg_prog_num,
         uint    &atsc_major,      uint          &atsc_minor,
         uint    &dvb_transportid, uint          &dvb_networkid,
+        QString &msystem,         QString       &rolloff,
         uint    &mplexid,         bool          &commfree);
     static bool    GetChannelSettings(int chanid, bool &useonairguide,
                                     bool &hidden);

mythtv/libs/libmythtv/dbcheck.cpp

@@ -4302 +4302 @@
             return false;
     }
 
+    if (dbver == "1223")
+    {
+        const char *updates[] = {
+"ALTER TABLE dtv_multiplex ADD msystem VARCHAR(10) DEFAULT NULL AFTER polarity;",
+"ALTER TABLE dtv_multiplex ADD rolloff VARCHAR(10) DEFAULT NULL AFTER modulation;",
+NULL
+};
+        if (!performActualUpdate(updates, "1224", dbver))
+            return false;
+    }
+
     return true;
 }
 

mythtv/libs/libmythtv/dtvconfparser.cpp

@@ -112 +112 @@
         {
             if ((type == OFDM) && (str == "T"))
                 ok &= ParseVDR(list, channelNo);
-            else if ((type == QPSK) && (str == "S"))
+            else if (((type == QPSK) || (type == DVBS2)) && (str == "S"))
                 ok &= ParseVDR(list, channelNo);
             else if ((type == QAM) && (str == "C"))
                 ok &= ParseVDR(list, channelNo);
@@ -121 +121 @@
             ok &= ParseConfOFDM(list);
         else if (type == ATSC)
             ok &= ParseConfATSC(list);
-        else if (type == QPSK)
+        else if ((type == QPSK) || (type == DVBS2))
             ok &= ParseConfQPSK(list);
         else if (type == QAM)
             ok &= ParseConfQAM(list);
@@ -274 +274 @@
             case 'R':
             case 'L':
                 mux.polarity.ParseVDR(ori);
+            case 'S':
+                mux.msystem.ParseVDR(params);
+            case 'O':
+                mux.rolloff.ParseVDR(params);
                 break;
             default:
                 return false;

mythtv/libs/libmythtv/dtvconfparser.h

@@ -80 +80 @@
 {
   public:
     enum return_t   { ERROR_CARDTYPE, ERROR_OPEN, ERROR_PARSE, OK };
-    enum cardtype_t { ATSC, OFDM, QPSK, QAM, UNKNOWN };
+    enum cardtype_t { ATSC, OFDM, QPSK, DVBS2, QAM, UNKNOWN };
 
     DTVConfParser(enum cardtype_t _type, uint sourceid, const QString &_file);
     virtual ~DTVConfParser() { }

mythtv/libs/libmythtv/dtvconfparserhelpers.cpp

@@ -145 +145 @@
 
 const DTVParamHelperStruct DTVCodeRate::confTable[] =
 {
-    { "FEC_AUTO", kFECAuto },
+    { "FEC_NONE", kFECNone  },
     { "FEC_1_2",  kFEC_1_2  },
     { "FEC_2_3",  kFEC_2_3  },
     { "FEC_3_4",  kFEC_3_4  },
@@ -154 +154 @@
     { "FEC_6_7",  kFEC_6_7  },
     { "FEC_7_8",  kFEC_7_8  },
     { "FEC_8_9",  kFEC_8_9  },
-    { "FEC_NONE", kFECNone },
+    { "FEC_AUTO", kFECAuto  },
+    { "FEC_3_5",  kFEC_3_5  },
+    { "FEC_9_10", kFEC_9_10 },
     { NULL,       kFECAuto },
 };
 
@@ -164 +166 @@
     { "12",  kFEC_1_2 },
     { "23",  kFEC_2_3 },
     { "34",  kFEC_3_4 },
+    { "35",  kFEC_3_5 },
     { "45",  kFEC_4_5 },
     { "56",  kFEC_5_6 },
     { "67",  kFEC_6_7 },
     { "78",  kFEC_7_8 },
     { "89",  kFEC_8_9 },
+    { "910", kFEC_9_10},
     { "0",   kFECNone },
     { NULL,  kFECAuto }
 };
 
 const DTVParamHelperStruct DTVCodeRate::parseTable[] =
 {
-    { "auto", kFECAuto },
+    { "none", kFECNone },
     { "1/2",  kFEC_1_2 },
     { "2/3",  kFEC_2_3 },
     { "3/4",  kFEC_3_4 },
@@ -184 +188 @@
     { "6/7",  kFEC_6_7 },
     { "7/8",  kFEC_7_8 },
     { "8/9",  kFEC_8_9 },
-    { "none", kFECNone },
+    { "auto", kFECAuto },
+    { "3/5",  kFEC_3_5 },
+    { "9/10", kFEC_9_10},
     { NULL,   kFECAuto }
 };
 
@@ -199 +205 @@
      "6/7",  ///< kFEC_6_7
      "7/8",  ///< kFEC_7_8
      "8/9",  ///< kFEC_8_9
-     "auto"  ///< kFECAuto
+     "auto", ///< kFECAuto
+     "3/5",  ///< kFEC_3_5
+     "9/10", ///< kFEC_9_10
 };
 
 const DTVParamHelperStruct DTVModulation::confTable[] =
@@ -213 +221 @@
    { "QPSK",     kModulationQPSK    },
    { "8VSB",     kModulation8VSB    },
    { "16VSB",    kModulation16VSB   },
-   { "2VSB",     kModulation2VSB    },
-   { "4VSB",     kModulation4VSB    },
-   { "BPSK",     kModulationBPSK    },
    { "16APSK",   kModulation16APSK  },
    { "32APSK",   kModulation32APSK  },
    { "8PSK",     kModulation8PSK    },
-   { "16PSK",    kModulation16PSK   },
+   { "DQPSK",    kModulationDQPSK   },
    { "analog",   kModulationAnalog  },
    { NULL,       kModulationQAMAuto },
 };
@@ -232 +237 @@
    { "64",  kModulationQAM64   },
    { "128", kModulationQAM128  },
    { "256", kModulationQAM256  },
+   { "2",   kModulationQPSK    },
+   { "10",  kModulation8VSB    },
+   { "11",  kModulation16VSB   },
+   { "6",   kModulation16APSK  },
+   { "7",   kModulation32APSK  },
+   { "5",   kModulation8PSK    },
    { "0",   kModulationQPSK    },
    { NULL,  kModulationQAMAuto },
 };
@@ -247 +258 @@
    { "qpsk",     kModulationQPSK    },
    { "8vsb",     kModulation8VSB    },
    { "16vsb",    kModulation16VSB   },
-   { "2vsb",     kModulation2VSB    },
-   { "4vsb",     kModulation4VSB    },
-   { "bpsk",     kModulationBPSK    },
+   { "8psk",     kModulation8PSK    },
    { "16apsk",   kModulation16APSK  },
    { "32apsk",   kModulation32APSK  },
-   { "8psk",     kModulation8PSK    },
-   { "16psk",    kModulation16PSK   },
+   { "dqpsk",    kModulationDQPSK   },
    // alternates
    { "a",        kModulationQAMAuto },
    { "qam_auto", kModulationQAMAuto },
@@ -262 +270 @@
    { "qam-64",   kModulationQAM64   },
    { "qam-128",  kModulationQAM128  },
    { "qam-256",  kModulationQAM256  },
-   // qpsk, no alternative
-   { "8-vsb",    kModulation8VSB    },
-   { "16-vsb",   kModulation16VSB   },
-   { "2-vsb",    kModulation2VSB    },
-   { "4-vsb",    kModulation4VSB    },
-   // bpsk, no alternative
    { "16-apsk",  kModulation16APSK  },
    { "32-apsk",  kModulation32APSK  },
    { "8-psk",    kModulation8PSK    },
-   { "16-psk",   kModulation16PSK   },
+   { "16-psk",   kModulationDQPSK   },
+   { "dq-psk",   kModulationDQPSK   },
+   { "16psk",    kModulationDQPSK   },
    { NULL,       kModulationQAMAuto },
 };
 
@@ -286 +290 @@
     "auto",    ///< kModulationQAMAuto
     "8vsb",    ///< kModulation8VSB
     "16vsb",   ///< kModulation16VSB
-    "2vsb",    ///< kModulation2VSB
-    "4vsb",    ///< kModulation4VSB
-    "bpsk",    ///< kModulationBPSK
+    "8psk",    ///< kModulation8PSK
     "16apsk",  ///< kModulation16APSK
     "32apsk",  ///< kModulation32APSK
-    "8psk",    ///< kModulation8PSK
-    "16psk",   ///< kModulation16PSK
+    "dqpsk",   ///< kModulationDQPSK
 };
 
 const DTVParamHelperStruct DTVTransmitMode::confTable[] =
@@ -420 +421 @@
    "r", ///< kPolarityRight
    "l"  ///< kPolarityLeft
 };
+
+const DTVParamHelperStruct DTVModulationSystem::confTable[] =
+{
+   { "SYS_DVBS",  kModulationSystemDVBS  },
+   { "SYS_DVBS2", kModulationSystemDVBS2 },
+   { NULL,        kModulationSystemDVBS  },
+};
+
+const DTVParamHelperStruct DTVModulationSystem::vdrTable[] =
+{
+   { "0",  kModulationSystemDVBS  },
+   { "1",  kModulationSystemDVBS2 },
+   { NULL, kModulationSystemDVBS  },
+};
+
+const DTVParamHelperStruct DTVModulationSystem::parseTable[] =
+{
+   { "dvbs2", kModulationSystemDVBS2 },
+   { "dvbs",  kModulationSystemDVBS  },
+   { NULL,    kModulationSystemDVBS  },
+};
+
+const char *DTVModulationSystem::dbStr[DTVModulationSystem::kDBStrCnt] =
+{
+    "dvbs",  ///< kModulationSystemDVBS
+    "dvbs2", ///< kModulationSystemDVBS2
+};
+
+const DTVParamHelperStruct DTVRollOff::confTable[] =
+{
+   { "ROLLOFF_35",   kRollOff35   },
+   { "ROLLOFF_20",   kRollOff20   },
+   { "ROLLOFF_25",   kRollOff25   },
+   { "ROLLOFF_AUTO", kRollOffAuto },
+   { NULL,           kRollOffAuto },
+};
+
+const DTVParamHelperStruct DTVRollOff::vdrTable[] =
+{
+   { "35",   kRollOff35   },
+   { "20",   kRollOff20   },
+   { "25",   kRollOff25   },
+   { "0",    kRollOffAuto },
+   { NULL,   kRollOff35   },
+};
+
+const DTVParamHelperStruct DTVRollOff::parseTable[] =
+{
+   { "0.35",   kRollOff35   },
+   { "0.20",   kRollOff20   },
+   { "0.25",   kRollOff25   },
+   { "auto",   kRollOffAuto },
+   { NULL,     kRollOff35   },
+};
+
+const char *DTVRollOff::dbStr[DTVRollOff::kDBStrCnt] =
+{
+   "0.35",   ///< kRollOff35
+   "0.20",   ///< kRollOff20
+   "0.25",   ///< kRollOff25
+   "auto",   ///< kRollOffAuto
+};

mythtv/libs/libmythtv/dtvconfparserhelpers.h

@@ -191 +191 @@
     static const DTVParamHelperStruct confTable[];
     static const DTVParamHelperStruct vdrTable[];
     static const DTVParamHelperStruct parseTable[];
-    static const uint kDBStrCnt = 10;
+    static const uint kDBStrCnt = 12;
     static const char *dbStr[kDBStrCnt];
 
   public:
@@ -207 +207 @@
         kFEC_7_8,
         kFEC_8_9,
         kFECAuto,
+        kFEC_3_5,
+        kFEC_9_10,
     };
 
     DTVCodeRate(int _default = kFECAuto) : DTVParamHelper(_default) { }
@@ -236 +238 @@
   public:
     enum
     {
-        kModulationQPSK    = 0,
-        kModulationQAM16   = 1,
-        kModulationQAM32   = 2,
-        kModulationQAM64   = 3,
-        kModulationQAM128  = 4,
-        kModulationQAM256  = 5,
-        kModulationQAMAuto = 6,
-        kModulation8VSB    = 7,
-        kModulation16VSB   = 8,
-        kModulation2VSB    = 9,
-        kModulation4VSB    = 10,
-        kModulationBPSK    = 11,
-        kModulation16APSK  = 12,
-        kModulation32APSK  = 13,
-        kModulation8PSK    = 14,
-        kModulation16PSK   = 15,
-        kModulationAnalog  = 16, /* for analog channel scanner */
+        kModulationQPSK,
+        kModulationQAM16,
+        kModulationQAM32,
+        kModulationQAM64,
+        kModulationQAM128,
+        kModulationQAM256,
+        kModulationQAMAuto,
+        kModulation8VSB,
+        kModulation16VSB,
+        kModulation16APSK,
+        kModulation32APSK,
+        kModulation8PSK,
+        kModulationDQPSK,
+        kModulationAnalog = 99, /* for analog channel scanner */
     };
 
     DTVModulation(int _default = kModulationQAMAuto)
@@ -414 +413 @@
         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
 };
 
+class DTVModulationSystem : public DTVParamHelper
+{
+  protected:
+    static const DTVParamHelperStruct confTable[];
+    static const DTVParamHelperStruct vdrTable[];
+    static const DTVParamHelperStruct parseTable[];
+    static const uint kDBStrCnt = 2;
+    static const char *dbStr[kDBStrCnt];
+
+  public:
+    enum
+    {
+        kModulationSystemDVBS,
+        kModulationSystemDVBS2,
+    };
+
+    DTVModulationSystem(int _default = kModulationSystemDVBS)
+        : DTVParamHelper(_default) { }
+
+    bool ParseConf(const QString &_value)
+       { return ParseParam(_value, value, confTable); }
+    bool ParseVDR(const QString &_value)
+       { return ParseParam(_value, value, vdrTable); }
+    bool Parse(const QString &_value)
+       { return ParseParam(_value, value, parseTable); }
+
+    QString toString() const { return toString(value); }
+
+    static QString toString(int _value)
+        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
+};
+
+class DTVRollOff : public DTVParamHelper
+{
+  protected:
+    static const DTVParamHelperStruct confTable[];
+    static const DTVParamHelperStruct vdrTable[];
+    static const DTVParamHelperStruct parseTable[];
+    static const uint kDBStrCnt = 4;
+    static const char *dbStr[kDBStrCnt];
+
+  public:
+    enum
+    {
+        kRollOff35,
+        kRollOff20,
+        kRollOff25,
+        kRollOffAuto,
+    };
+
+    DTVRollOff(int _default = kRollOff35)
+        : DTVParamHelper(_default) { }
+
+    bool ParseConf(const QString &_value)
+       { return ParseParam(_value, value, confTable); }
+    bool ParseVDR(const QString &_value)
+       { return ParseParam(_value, value, vdrTable); }
+    bool Parse(const QString &_value)
+       { return ParseParam(_value, value, parseTable); }
+
+    QString toString() const { return toString(value); }
+
+    static QString toString(int _value)
+        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
+};
+
+class DTVPilot : public DTVParamHelper
+{
+  protected:
+    static const DTVParamHelperStruct confTable[];
+    static const DTVParamHelperStruct vdrTable[];
+    static const DTVParamHelperStruct parseTable[];
+    static const uint kDBStrCnt = 3;
+    static const char *dbStr[kDBStrCnt];
+
+  public:
+    enum
+    {
+        kPilotOn,
+        kPilotOff,
+        kPilotAuto,
+    };
+
+    DTVPilot(int _default = kPilotAuto)
+        : DTVParamHelper(_default) { }
+
+    bool ParseConf(const QString &_value)
+       { return ParseParam(_value, value, confTable); }
+
+    QString toString() const { return toString(value); }
+
+    static QString toString(int _value)
+        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
+};
+
 #endif // _DTVCONFPARSERHELPERS_H_

mythtv/libs/libmythtv/dtvmultiplex.cpp

@@ -24 +24 @@
     fec            = other.fec;
     mplex          = other.mplex;
     sistandard     = other.sistandard;
+    msystem        = other.msystem;
+    rolloff        = other.rolloff;
     sistandard.detach();
     return *this;
 }
@@ -40 +42 @@
             (guard_interval == m.guard_interval) &&
             (fec == m.fec) &&
             (polarity == m.polarity) &&
-            (hierarchy == m.hierarchy));
+            (hierarchy == m.hierarchy) &&
+            (msystem == m.msystem) &&
+            (rolloff == m.rolloff));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -48 +52 @@
 
 QString DTVMultiplex::toString() const
 {
-    QString ret = QString("%1 %2 %3 ")
-        .arg(frequency).arg(modulation.toString()).arg(inversion.toString());
+    QString ret = QString("f: %1 mod: %2 inv: %3 fec: %4")
+        .arg(frequency).arg(modulation.toString()).arg(inversion.toString()).arg(fec.toString());
 
-    ret += QString("%1 %2 %3 %4 %5 %6 %7")
+    ret += QString("hp: %1 lp: %2 bandw: %3 transmode: %4 guardi: %5 hier: %6 polar: %7 msys: %8 rolloff: %9")
         .arg(hp_code_rate.toString()).arg(lp_code_rate.toString())
         .arg(bandwidth.toString()).arg(trans_mode.toString())
         .arg(guard_interval.toString()).arg(hierarchy.toString())
-        .arg(polarity.toString());
+        .arg(polarity.toString())
+        .arg(msystem.toString()).arg(rolloff.toString());
 
     return ret;
 }
@@ -102 +107 @@
         return
             (inversion  == other.inversion)  &&
             (symbolrate == other.symbolrate) &&
-            (fec        == other.fec);
+            (fec        == other.fec)        &&
+            (msystem    == other.msystem)    &&
+            (rolloff    == other.rolloff);
     }
 
     return false;
@@ -182 +189 @@
     return ok;
 }
 
+bool DTVMultiplex::ParseDVB_S2(
+    const QString &_frequency,   const QString &_inversion,
+    const QString &_symbol_rate, const QString &_fec_inner,
+    const QString &_modulation,  const QString &_polarity,
+    const QString &_msystem,     const QString &_rolloff)
+{
+    bool ok = inversion.Parse(_inversion);
+    if (!ok)
+    {
+        VERBOSE(VB_GENERAL, LOC_WARN +
+                "Invalid inversion, falling back to 'auto'");
+
+        ok = true;
+    }
+
+    symbolrate = _symbol_rate.toInt();
+    if (!symbolrate)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid symbol rate " +
+                QString("parameter '%1', aborting.").arg(_symbol_rate));
+
+        return false;
+    }
+
+    ok &= fec.Parse(_fec_inner);
+    ok &= modulation.Parse(_modulation);
+
+    if (!_polarity.isEmpty())
+        ok &= polarity.Parse(_polarity.toLower());
+
+    ok &= msystem.Parse(_msystem);
+
+    if (!ok)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid S2 modulation system " +
+                QString("parameter '%1', aborting.").arg(_symbol_rate));
+        return false;
+    }
+
+    if (!_rolloff.isEmpty())
+        ok &= rolloff.Parse(_rolloff);
+
+    if (ok)
+        frequency = _frequency.toInt(&ok);
+
+    return ok;
+}
+
 bool DTVMultiplex::ParseTuningParams(
     DTVTunerType type,
     QString _frequency,    QString _inversion,      QString _symbolrate,
     QString _fec,          QString _polarity,
     QString _hp_code_rate, QString _lp_code_rate,   QString _ofdm_modulation,
     QString _trans_mode,   QString _guard_interval, QString _hierarchy,
-    QString _modulation,   QString _bandwidth)
+    QString _modulation,   QString _bandwidth,
+    QString _msystem,      QString _rolloff)
 {
     if (DTVTunerType::kTunerTypeOFDM == type)
     {
@@ -199 +255 @@
     }
 
     if ((DTVTunerType::kTunerTypeQPSK   == type) ||
-        (DTVTunerType::kTunerTypeDVB_S2 == type) ||
         (DTVTunerType::kTunerTypeQAM    == type))
     {
         return ParseDVB_S_and_C(
@@ -207 +262 @@
             _fec,             _modulation,    _polarity);
     }
 
+    if (DTVTunerType::kTunerTypeDVB_S2 == type)
+    {
+        return ParseDVB_S2(
+            _frequency,       _inversion,     _symbolrate,
+            _fec,             _modulation,    _polarity,
+            _msystem,         _rolloff);
+    }
+
     if (DTVTunerType::kTunerTypeATSC == type)
         return ParseATSC(_frequency, _modulation);
 
@@ -223 +286 @@
         "       fec,               polarity, "
         "       hp_code_rate,      lp_code_rate,   constellation, "
         "       transmission_mode, guard_interval, hierarchy, "
-        "       modulation,        bandwidth,      sistandard "
+        "       modulation,        bandwidth,      sistandard, "
+        "       msystem,           rolloff "
         "FROM dtv_multiplex "
         "WHERE dtv_multiplex.mplexid = :MPLEXID");
     query.bindValue(":MPLEXID", mplexid);
@@ -256 +320 @@
         query.value(6).toString(),  query.value(7).toString(),
         query.value(8).toString(),  query.value(9).toString(),
         query.value(10).toString(), query.value(11).toString(),
-        query.value(12).toString());
+        query.value(12).toString(), query.value(14).toString(),
+        query.value(15).toString());
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -318 +383 @@
         "    mplexid,            frequency,       inversion,  "
         "    symbolrate,         fec,             polarity,   "
         "    hp_code_rate,       lp_code_rate,    modulation, "
+        "    msystem,            rolloff,                     "
         "    transmission_mode,  guard_interval,  hierarchy,  "
         "    bandwidth,          sistandard,      tuner_type  "
         " ) "
@@ -326 +392 @@
         "   :MPLEXID,           :FREQUENCY,      :INVERSION,  "
         "   :SYMBOLRATE,        :FEC,            :POLARITY,   "
         "   :HP_CODE_RATE,      :LP_CODE_RATE,   :MODULATION, "
+        "   :MSYSTEM,           :ROLLOFF,                     "
         "   :TRANSMISSION_MODE, :GUARD_INTERVAL, :HIERARCHY,  "
         "   :BANDWIDTH,         :SISTANDARD,     :TUNER_TYPE  "
         " );");
@@ -340 +407 @@
     query.bindValue(":HP_CODE_RATE", hp_code_rate.toString());
     query.bindValue(":LP_CODE_RATE", lp_code_rate.toString());
     query.bindValue(":MODULATION", modulation.toString());
+    query.bindValue(":MSYSTEM", msystem.toString());
+    query.bindValue(":ROLLOFF", rolloff.toString());
     query.bindValue(":TRANSMISSION_MODE", trans_mode.toString());
     query.bindValue(":GUARD_INTERVAL", guard_interval.toString());
     query.bindValue(":HIERARCHY", hierarchy.toString());

mythtv/libs/libmythtv/dtvmultiplex.h

@@ -49 +49 @@
         const QString &symbol_rate,  const QString &fec_inner,
         const QString &modulation,   const QString &polarity);
 
+    bool ParseDVB_S2(
+        const QString &frequency,    const QString &inversion,
+        const QString &symbol_rate,  const QString &fec_inner,
+        const QString &modulation,   const QString &polarity,
+        const QString &msystem,      const QString &rolloff);
+
     bool ParseTuningParams(
         DTVTunerType type,
         QString frequency,    QString inversion,      QString symbolrate,
         QString fec,          QString polarity,
         QString hp_code_rate, QString lp_code_rate,   QString constellation,
         QString trans_mode,   QString guard_interval, QString hierarchy,
-        QString modulation,   QString bandwidth);
+        QString modulation,   QString bandwidth,
+        QString msystem,      QString rolloff);
 
     QString toString() const;
 
@@ -74 +81 @@
     DTVHierarchy     hierarchy;
     DTVPolarity      polarity;
     DTVCodeRate      fec; ///< Inner Forward Error Correction rate
+    DTVModulationSystem msystem;
+    DTVRollOff          rolloff;
 
     // Optional additional info
     uint             mplex;

mythtv/libs/libmythtv/dvbchannel.cpp

@@ -49 +49 @@
 
 static void drain_dvb_events(int fd);
 static bool wait_for_backend(int fd, int timeout_ms);
+
 static struct dvb_fe_params dtvmultiplex_to_dvbparams(
     DTVTunerType, const DTVMultiplex&);
 static DTVMultiplex dvbparams_to_dtvmultiplex(
     DTVTunerType, const dvb_fe_params&);
 
+static bool dtvmultiplex_to_dtvproperties(
+    DTVTunerType, const DTVMultiplex&, struct dtv_properties*, bool do_tune);
+
+static bool dtvmultiplex_to_dtvproperties(
+    DTVTunerType, const DTVMultiplex&, struct dtv_properties*);
+
+static DTVMultiplex dtvproperties_to_dtvmultiplex(
+    DTVTunerType, const dtv_properties&);
+
+
 #define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(device)
 #define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \
                  .arg(GetCardID()).arg(device)
@@ -167 +178 @@
         frontend_name       = master->frontend_name;
         card_type           = master->card_type;
         capabilities        = master->capabilities;
-        ext_modulations     = master->ext_modulations;
         frequency_minimum   = master->frequency_minimum;
         frequency_maximum   = master->frequency_maximum;
         symbol_rate_minimum = master->symbol_rate_minimum;
@@ -210 +220 @@
         return false;
     }
 
-#ifdef FE_GET_EXTENDED_INFO
-    if (info.caps & FE_HAS_EXTENDED_INFO)
-    {
-        bool ok = true;
-        dvb_fe_caps_extended extinfo;
-        bzero(&extinfo, sizeof(extinfo));
-        if (ioctl(fd_frontend, FE_GET_EXTENDED_INFO, &extinfo) < 0)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    "Failed to get frontend extended information." + ENO);
-
-            ok = false;
-        }
-
-        if (ok && (extinfo.modulations & MOD_8PSK))
-        {
-            if (ioctl(fd_frontend, FE_SET_STANDARD, FE_DVB_S2) < 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR +
-                        "Failed to set frontend standard to DVB-S2." + ENO);
-
-                ok = false;
-            }
-            else if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR +
-                        "Failed to get frontend information." + ENO);
-
-                ok = false;
-            }
-        }
-
-        if (!ok)
-        {
-            close(fd_frontend);
-            fd_frontend = -1;
-            return false;
-        }
-
-        ext_modulations   = extinfo.modulations;
-    }
-#endif
-
     frontend_name       = info.name;
-    card_type           = info.type;
+    //card_type           = info.type;
+    card_type.Parse(CardUtil::ProbeDVBType(device));
     capabilities        = info.caps;
     frequency_minimum   = info.frequency_min;
     frequency_maximum   = info.frequency_max;
@@ -309 +277 @@
 bool DVBChannel::TuneMultiplex(uint mplexid, QString inputname)
 {
     DTVMultiplex tuning;
-    if (!tuning.FillFromDB(card_type, mplexid))
+    bool ok = true;
+    //card_type.Parse(CardUtil::ProbeDVBType(inputname));
+    ok = tuning.FillFromDB(card_type, mplexid);
+    if (!ok)
         return false;
 
-    CheckOptions(tuning);
+    //CheckOptions(tuning);
 
     return Tune(tuning, inputname);
 }
@@ -365 +336 @@
 
     // Get the input data for the channel
     QString tvformat, modulation, freqtable, freqid, si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -375 +347 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff,
         mplexid, commfree))
     {
         VERBOSE(VB_IMPORTANT, loc_err +
@@ -596 +569 @@
     const DTVModulation m = modulation;
     const uint64_t      c = capabilities;
 
-#ifdef FE_GET_EXTENDED_INFO
-    if ((c & FE_HAS_EXTENDED_INFO)            &&
-        (DTVModulation::kModulation8PSK == m) &&
-        (ext_modulations & DTVModulation::kModulation8PSK))
-    {
-        return true;
-    }
-#endif // FE_GET_EXTENDED_INFO
-
     return
         ((DTVModulation::kModulationQPSK    == m) && (c & FE_CAN_QPSK))     ||
         ((DTVModulation::kModulationQAM16   == m) && (c & FE_CAN_QAM_16))   ||
@@ -680 +644 @@
     }
 
     bool reset = (force_reset || first_tune);
-    struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
+    //struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
+
+    struct dtv_properties cmds;
+
+    //clear card cache
+    dtv_property props[11];
+    memset(&props, 0, sizeof(props));
+    props[0].cmd = DTV_CLEAR;
+    cmds.num = 1;
+    cmds.props = props;
+    if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
+                "Clearing tuner cache failed." + ENO);
+        return false;
+    }
+
+    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds);
 
     bool is_dvbs = (DTVTunerType::kTunerTypeQPSK   == card_type ||
                     DTVTunerType::kTunerTypeDVB_S2 == card_type);
@@ -737 +718 @@
             // make sure we tune to frequency, if the lnb has changed
             reset = first_tune = true;
         }
-        
-        params.frequency = lnb->GetIntermediateFrequency(
-            diseqc_settings, tuning);
+
+        for (uint i = 0; i < cmds.num; i++)
+        {
+            if (cmds.props[i].cmd == DTV_FREQUENCY)
+            {
+                cmds.props[i].u.data = lnb->GetIntermediateFrequency(
+                    diseqc_settings, tuning);
+                break;
+            }
+        }
+        //params.frequency = lnb->GetIntermediateFrequency(
+        //    diseqc_settings, tuning);
 
         // if card can auto-FEC, use it -- sometimes NITs are inaccurate
-        if (capabilities & FE_CAN_FEC_AUTO)
-            params.u.qpsk.fec_inner = FEC_AUTO;
+        //if (capabilities & FE_CAN_FEC_AUTO)
+        //    params.u.qpsk.fec_inner = FEC_AUTO;
     }
 
     VERBOSE(VB_CHANNEL, LOC + "Old Params: " +
@@ -753 +743 @@
 
     // DVB-S is in kHz, other DVB is in Hz
     int     freq_mult = (is_dvbs) ? 1 : 1000;
-    QString suffix    = (is_dvbs) ? "kHz" : "Hz";
+    //QString suffix    = (is_dvbs) ? "kHz" : "Hz";
 
     if (reset || !prev_tuning.IsEqual(card_type, tuning, 500 * freq_mult))
     {
-        VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2")
-                .arg(params.frequency).arg(suffix));
-
-#ifdef FE_GET_EXTENDED_INFO
-        if (card_type == DTVTunerType::kTunerTypeDVB_S2)
+        //VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2")
+        //        .arg(params.frequency).arg(suffix));
+        VERBOSE(VB_CHANNEL, LOC + "Tune(): Tuning ...");
+        //if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
+        VERBOSE(VB_IMPORTANT, "ioctl");
+        if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
         {
-            if (ioctl(fd_frontend, FE_SET_FRONTEND2, &params) < 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
-                        "Setting Frontend(2) tuning parameters failed." + ENO);
-                return false;
-            }
-        }
-        else
-#endif // FE_GET_EXTENDED_INFO
-        {
-            if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
-                        "Setting Frontend tuning parameters failed." + ENO);
-                return false;
-            }
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
+                    "Setting Frontend tuning parameters failed." + ENO);
+            return false;
         }
 
         // Extra delay to add for broken DVB drivers
@@ -835 +813 @@
         return false;
     }
 
-    dvb_fe_params params;
-    return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
+    //dvb_fe_params params;
+    //return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
+    struct dtv_properties cmds;
+    cmds.num = 0;
+    return ioctl(fd_frontend, FE_GET_PROPERTY, &cmds) >= 0;
 }
 
 /** \fn DVBChannel::ProbeTuningParams(DTVMultiplex&) const
@@ -868 +849 @@
         return false;
     }
 
-    dvb_fe_params params;
-    if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0)
+    struct dtv_properties cmds;
+    dtv_property props[11];
+    memset(&props, 0, sizeof(props));
+    cmds.props = props;
+    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds, false);
+    if (ioctl(fd_frontend, FE_GET_PROPERTY, &cmds) < 0)
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR +
                 "Getting Frontend tuning parameters failed." + ENO);
@@ -880 +865 @@
     uint    mplex      = tuning.mplex;
     QString sistandard = tuning.sistandard; sistandard.detach();
 
-    tuning = dvbparams_to_dtvmultiplex(card_type, params);
+    tuning = dtvproperties_to_dtvmultiplex(card_type, cmds);
 
     tuning.mplex       = mplex;
     tuning.sistandard  = sistandard;
@@ -1094 +1079 @@
     return true;
 }
 
-static struct dvb_fe_params dtvmultiplex_to_dvbparams(
-    DTVTunerType tuner_type, const DTVMultiplex &tuning)
-{
-    dvb_fe_params params;
-    bzero(&params, sizeof(params));
-
-    params.frequency = tuning.frequency;
-    params.inversion = (fe_spectral_inversion_t) (int) tuning.inversion;
-
-    if (DTVTunerType::kTunerTypeQPSK == tuner_type)
-    {
-        params.u.qpsk.symbol_rate = tuning.symbolrate;
-        params.u.qpsk.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
-    }
-
-    if (DTVTunerType::kTunerTypeDVB_S2 == tuner_type)
-    {
-#ifdef FE_GET_EXTENDED_INFO
-        params.u.qpsk2.symbol_rate = tuning.symbolrate;
-        params.u.qpsk2.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
-        params.u.qpsk2.modulation  = (fe_modulation_t) (int) tuning.modulation;
-#else // if !FE_GET_EXTENDED_INFO
-        VERBOSE(VB_IMPORTANT, "DVBChan Error, MythTV was compiled without "
-                "DVB-S2 headers being present so DVB-S2 tuning will fail.");
-#endif // !FE_GET_EXTENDED_INFO
-    }
-
-    if (DTVTunerType::kTunerTypeQAM  == tuner_type)
-    {
-        params.u.qam.symbol_rate  = tuning.symbolrate;
-        params.u.qam.fec_inner    = (fe_code_rate_t) (int) tuning.fec;
-        params.u.qam.modulation   = (fe_modulation_t) (int) tuning.modulation;
-    }
 
-    if (DTVTunerType::kTunerTypeOFDM == tuner_type)
-    {
-        params.u.ofdm.bandwidth             =
-            (fe_bandwidth_t) (int) tuning.bandwidth;
-        params.u.ofdm.code_rate_HP          =
-            (fe_code_rate_t) (int) tuning.hp_code_rate;
-        params.u.ofdm.code_rate_LP          =
-            (fe_code_rate_t) (int) tuning.lp_code_rate;
-        params.u.ofdm.constellation         =
-            (fe_modulation_t) (int) tuning.modulation;
-        params.u.ofdm.transmission_mode     =
-            (fe_transmit_mode_t) (int) tuning.trans_mode;
-        params.u.ofdm.guard_interval        =
-            (fe_guard_interval_t) (int) tuning.guard_interval;
-        params.u.ofdm.hierarchy_information =
-            (fe_hierarchy_t) (int) tuning.hierarchy;
-    }
+static DTVMultiplex dtvproperties_to_dtvmultiplex(
+    DTVTunerType tuner_type, const dtv_properties &cmds)
+{
+    DTVMultiplex tuning;
 
-    if (DTVTunerType::kTunerTypeATSC == tuner_type)
+    for (uint i = 0; i < cmds.num; i++)
     {
+        switch (cmds.props[i].cmd)
+        {
+            case DTV_MODULATION:
+                tuning.modulation = cmds.props[i].u.data;
+                break;
+            case DTV_DELIVERY_SYSTEM:
+                switch (cmds.props[i].u.data)
+                {
+                    case SYS_DVBS:
+                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS;
+                        break;
+                    case SYS_DVBS2:
+                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS2;
+                        break;
+                    case SYS_DVBT:
+                    case SYS_DVBC_ANNEX_AC:
+                    case SYS_DVBC_ANNEX_B:
 #ifdef USE_ATSC
-        params.u.vsb.modulation   =
-            (fe_modulation_t) (int) tuning.modulation;
-#endif // USE_ATSC
+                    case SYS_ATSC:
+#endif
+                        break;
+                    default:
+                        VERBOSE(VB_IMPORTANT, "Unknown DVB delivery system." + ENO);
+                };
+                break;
+            case DTV_FREQUENCY:
+                if (tuning.modulation == DTVModulation::kModulationQPSK ||
+                    tuning.modulation == DTVModulation::kModulation8PSK)
+                    tuning.frequency = cmds.props[i].u.data / 1000UL;
+                else
+                    tuning.frequency = cmds.props[i].u.data;
+                break;
+            case DTV_SYMBOL_RATE:
+                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
+                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
+                    tuner_type == DTVTunerType::kTunerTypeQAM)
+                {
+                    if (tuning.modulation == DTVModulation::kModulationQPSK ||
+                        tuning.modulation == DTVModulation::kModulation8PSK)
+                        tuning.symbolrate = cmds.props[i].u.data / 1000UL;
+                    else
+                        tuning.symbolrate = cmds.props[i].u.data;
+                };
+                break;
+            case DTV_INNER_FEC:
+                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
+                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
+                    tuner_type == DTVTunerType::kTunerTypeQAM)
+                {
+                    tuning.symbolrate = cmds.props[i].u.data;
+                }
+                break;
+            case DTV_PILOT:
+                break;
+            case DTV_ROLLOFF:
+                if (tuner_type == DTVTunerType::kTunerTypeDVB_S2)
+                    tuning.rolloff = cmds.props[i].u.data;
+                break;
+            case DTV_INVERSION:
+                tuning.inversion = cmds.props[i].u.data;
+                break;
+            case DTV_BANDWIDTH_HZ:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.bandwidth = cmds.props[i].u.data;
+                break;
+            case DTV_CODE_RATE_HP:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.hp_code_rate = cmds.props[i].u.data;
+                break;
+            case DTV_CODE_RATE_LP:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.lp_code_rate = cmds.props[i].u.data;
+                break;
+            case DTV_TRANSMISSION_MODE:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.trans_mode = cmds.props[i].u.data;
+                break;
+            case DTV_GUARD_INTERVAL:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.guard_interval = cmds.props[i].u.data;
+                break;
+            case DTV_HIERARCHY:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.hierarchy = cmds.props[i].u.data;
+                break;
+            case DTV_TUNE:
+                break;
+            default:
+                VERBOSE(VB_IMPORTANT, "Unknown DTV command." + ENO);
+        }
     }
-
-    return params;
+    return tuning;
 }
 
-static DTVMultiplex dvbparams_to_dtvmultiplex(
-    DTVTunerType tuner_type, const dvb_fe_params &params)
+static bool dtvmultiplex_to_dtvproperties(
+    DTVTunerType tuner_type,
+    const DTVMultiplex &tuning,
+    struct dtv_properties *cmdseq)
 {
-    DTVMultiplex tuning;
-
-    tuning.frequency = params.frequency;
-    tuning.inversion = params.inversion;
+    return dtvmultiplex_to_dtvproperties(tuner_type, tuning, cmdseq, true);
+}
 
-    if ((DTVTunerType::kTunerTypeQPSK   == tuner_type) ||
-        (DTVTunerType::kTunerTypeDVB_S2 == tuner_type))
+static bool dtvmultiplex_to_dtvproperties(
+    DTVTunerType tuner_type,
+    const DTVMultiplex &tuning,
+    struct dtv_properties *cmdseq,
+    bool do_tune)
+{
+    VERBOSE(VB_IMPORTANT, tuner_type.toString());
+    if (tuner_type == DTVTunerType::kTunerTypeQPSK ||
+        (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
+         tuning.msystem == DTVModulationSystem::kModulationSystemDVBS))
     {
-        tuning.symbolrate     = params.u.qpsk.symbol_rate;
-        tuning.fec            = params.u.qpsk.fec_inner;
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = SYS_DVBS;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = QPSK;
+        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
+        cmdseq->props[3].u.data = tuning.symbolrate;
+        cmdseq->props[4].cmd    = DTV_INNER_FEC;
+        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
+        cmdseq->props[5].cmd    = DTV_INVERSION;
+        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
+        if (do_tune)
+        {
+            cmdseq->props[6].cmd    = DTV_TUNE;
+            cmdseq->num = 7;
+        }
+        else
+        {
+            cmdseq->num = 6;
+        }
     }
-
-    if (DTVTunerType::kTunerTypeQAM  == tuner_type)
+    else if (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
+             tuning.msystem == DTVModulationSystem::kModulationSystemDVBS2)
     {
-        tuning.symbolrate     = params.u.qam.symbol_rate;
-        tuning.fec            = params.u.qam.fec_inner;
-        tuning.modulation     = params.u.qam.modulation;
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = SYS_DVBS2;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
+        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
+        cmdseq->props[3].u.data = tuning.symbolrate;
+        cmdseq->props[4].cmd    = DTV_INNER_FEC;
+        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
+        cmdseq->props[5].cmd    = DTV_INVERSION;
+        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
+        cmdseq->props[6].cmd    = DTV_PILOT;
+        cmdseq->props[6].u.data = PILOT_AUTO;
+        cmdseq->props[7].cmd    = DTV_ROLLOFF;
+        cmdseq->props[7].u.data = (fe_rolloff_t) (int) tuning.rolloff;
+
+        if (do_tune)
+        {
+            cmdseq->props[8].cmd = DTV_TUNE;
+            cmdseq->num = 9;
+        }
+        else
+            cmdseq->num = 8;
     }
-
-    if (DTVTunerType::kTunerTypeOFDM == tuner_type)
+    else if (tuner_type == DTVTunerType::kTunerTypeQAM)
     {
-        tuning.bandwidth      = params.u.ofdm.bandwidth;
-        tuning.hp_code_rate   = params.u.ofdm.code_rate_HP;
-        tuning.lp_code_rate   = params.u.ofdm.code_rate_LP;
-        tuning.modulation     = params.u.ofdm.constellation;
-        tuning.trans_mode     = params.u.ofdm.transmission_mode;
-        tuning.guard_interval = params.u.ofdm.guard_interval;
-        tuning.hierarchy      = params.u.ofdm.hierarchy_information;
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = (fe_delivery_system_t) (int) tuning.msystem;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
+        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
+        cmdseq->props[3].u.data = tuning.symbolrate;
+        cmdseq->props[4].cmd    = DTV_INNER_FEC;
+        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
+        cmdseq->props[5].cmd    = DTV_INVERSION;
+        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
+        if (do_tune)
+        {
+            cmdseq->props[6].cmd    = DTV_TUNE;
+            cmdseq->num = 7;
+        }
+        else
+            cmdseq->num = 6;
     }
-
-    if (DTVTunerType::kTunerTypeATSC == tuner_type)
+    else if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     {
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = SYS_DVBC_ANNEX_AC;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
+        cmdseq->props[3].cmd    = DTV_INVERSION;
+        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
+        cmdseq->props[4].cmd    = DTV_BANDWIDTH_HZ;
+        cmdseq->props[4].u.data = (fe_bandwidth_t) (int) tuning.bandwidth;
+        cmdseq->props[5].cmd    = DTV_CODE_RATE_HP;
+        cmdseq->props[5].u.data = (fe_code_rate_t) (int) tuning.hp_code_rate;
+        cmdseq->props[6].cmd    = DTV_CODE_RATE_LP;
+        cmdseq->props[6].u.data = (fe_code_rate_t) (int) tuning.lp_code_rate;
+        cmdseq->props[7].cmd    = DTV_TRANSMISSION_MODE;
+        cmdseq->props[7].u.data = (fe_transmit_mode_t) (int) tuning.trans_mode;
+        cmdseq->props[8].cmd    = DTV_GUARD_INTERVAL;
+        cmdseq->props[8].u.data = (fe_guard_interval_t) (int) tuning.guard_interval;
+        cmdseq->props[9].cmd    = DTV_HIERARCHY;
+        cmdseq->props[9].u.data = (fe_hierarchy_t) (int) tuning.hierarchy;
+        if (do_tune)
+        {
+            cmdseq->props[10].cmd    = DTV_TUNE;
+            cmdseq->num = 11;
+        }
+        else
+            cmdseq->num = 10;
+    }
 #ifdef USE_ATSC
-        tuning.modulation     = params.u.vsb.modulation;
-#endif // USE_ATSC
+    else if (tuner_type == DTVTunerType::kTunerTypeATSC)
+    {
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = SYS_ATSC;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency * 1000UL;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;;
+        cmdseq->props[3].cmd    = DTV_INVERSION;
+        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
+        if (do_tune)
+        {
+            cmdseq->props[4].cmd    = DTV_TUNE;
+            cmdseq->num = 5;
+        }
+        else
+            cmdseq->num = 4;
     }
-
-    return tuning;
+#endif
+    else
+    {
+        VERBOSE(VB_IMPORTANT, "Unknown tuner type." + ENO);
+    }
+   return true;
 }
+

mythtv/libs/libmythtv/dvbchannel.h

@@ -117 +117 @@
     QString           frontend_name;
     DTVTunerType      card_type;
     uint64_t          capabilities;
-    uint64_t          ext_modulations;
     uint64_t          frequency_minimum;
     uint64_t          frequency_maximum;
     uint              symbol_rate_minimum;

mythtv/libs/libmythtv/dvbtypes.h

@@ -19 +19 @@
 #include <linux/dvb/frontend.h>
 #include <linux/dvb/dmx.h>
 
-#if (DVB_API_VERSION != 3)
-#    error "DVB driver includes with API version 3 not found!"
+#if (DVB_API_VERSION != 3 && DVB_API_VERSION != 5)
+#    error "DVB driver includes with correct API version not found!"
 #endif
 
 #ifndef DVB_API_VERSION_MINOR
 #    define DVB_API_VERSION_MINOR 0
 #endif
 
-#if (DVB_API_VERSION >= 3 && DVB_API_VERSION_MINOR >= 1)
+#if ((DVB_API_VERSION >= 3 && DVB_API_VERSION_MINOR >= 1) || (DVB_API_VERSION == 5 && DVB_API_VERSION_MINOR >= 0))
 #    define USE_ATSC
 #else
 #warning DVB API version < 3.1
@@ -39 +39 @@
 #    define VSB_16        (fe_modulation)(QAM_AUTO+2)
 #endif
 
-#ifdef FE_GET_EXTENDED_INFO
-  #define dvb_fe_params dvb_frontend_parameters_new
-#else
-  #define dvb_fe_params dvb_frontend_parameters
-#endif
+#define dvb_fe_params dvb_frontend_parameters
 
 class QString;
 QString toString(fe_status);

mythtv/libs/libmythtv/firewirechannel.cpp

@@ -60 +60 @@
 
     // Fetch tuning data from the database.
     QString tvformat, modulation, freqtable, freqid, dtv_si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -70 +71 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msyste, rolloff,
         mplexid, commfree))
     {
         VERBOSE(VB_IMPORTANT, loc + " " + QString(

mythtv/libs/libmythtv/frequencytables.cpp

@@ -68 +68 @@
         _tuning.lp_code_rate.toString(),     _tuning.modulation.toString(),
         _tuning.trans_mode.toString(),       _tuning.guard_interval.toString(),
         _tuning.hierarchy.toString(),        _tuning.modulation.toString(),
-        _tuning.bandwidth.toString());
+        _tuning.bandwidth.toString(),        _tuning.msystem.toString(),
+        _tuning.rolloff.toString());
 }
 
 TransportScanItem::TransportScanItem(uint sourceid,

mythtv/libs/libmythtv/hdhrchannel.cpp

@@ -291 +291 @@
 
     // Fetch tuning data from the database.
     QString tvformat, modulation, freqtable, freqid, si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -301 +302 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff,
         mplexid, commfree))
     {
         return false;
@@ -369 +371 @@
     uint64_t frequency;
     uint     transportid;
     uint     dvb_networkid;
+    QString  dvb_msystem;
+    QString  dvb_rolloff;
 
     if (!ChannelUtil::GetTuningParams(
             mplexid, modulation, frequency,
-            transportid, dvb_networkid, si_std))
+            transportid, dvb_networkid,
+            dvb_msystem, dvb_rolloff, si_std))
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR + "TuneMultiplex(): " +
                 QString("Could not find tuning parameters for multiplex %1.")

mythtv/libs/libmythtv/mpeg/dvbdescriptors.cpp

@@ -369 +369 @@
     QString str = QString("SatelliteDeliverySystemDescriptor: ");
 
     str.append(QString("Frequency: %1\n").arg(FrequencyHz()));
-    str.append(QString("      Mod=%1, SymbR=%2, FECInner=%3, Orbit=%4, Pol=%5")
+    str.append(QString("      ModSys=%1, Mod=%2, RollOff=%3. SymbR=%4, FECInner=%5, Orbit=%6, Pol=%7")
+        .arg(ModulationSystemString())
         .arg(ModulationString())
+        .arg(RollOffString())
         .arg(SymbolRateHz())
         .arg(FECInnerString())
         .arg(OrbitalPositionString())

mythtv/libs/libmythtv/mpeg/dvbdescriptors.h

@@ -745 +745 @@
     bool IsLinearPolarization()   const { return !((_data[8]>>6)&0x1); }
     bool IsHorizontalLeftPolarization() const { return (_data[8]>>5)&0x1; }
     bool IsVerticalRightPolarization() const { return !((_data[8]>>5)&0x1); }
-    // modulation               5   8.3
+    // rolloff                  2   8.3
+    uint RollOff() const { return (_data[8]>>3)&0x3; }
+    QString RollOffString()  const
+    {
+        static QString ps[] = { "0.35", "0.20", "0.25", "AUTO" };
+        return ps[Polarization()];
+    }
+    // modulation system        3   8.5
+    enum
+    {
+        kModulationSystemDVBS  = 0x0,
+        kModulationSystemDVBS2 = 0x1,
+    };
+    uint ModulationSystem() const { return _data[8]>>2&0x1; }
+    QString ModulationSystemString() const
+    {
+        static QString mss[] = { "dvbs", "dvbs2" };
+        return (mss[ModulationSystem()]);
+    }
+    // modulation               4   8.6
+
     enum
     {
         kModulationQPSK_NS = 0x0, // Non standard QPSK for Bell ExpressVu
@@ -753 +773 @@
         kModulation8PSK   = 0x2,
         kModulationQAM16  = 0x3,
     };
-    uint Modulation() const { return _data[8]&0x1f; }
+    uint Modulation() const { return _data[8]&0x7; }
     QString ModulationString() const
     {
         static QString ms[] = { "qpsk", "qpsk", "8psk", "qam_16" };
@@ -779 +799 @@
         kInnerFEC_5_6_ConvolutionCodeRate = 0x4,
         kInnerFEC_7_8_ConvolutionCodeRate = 0x5,
         kInnerFEC_8_9_ConvolutionCodeRate = 0x6,
+        kInnerFEC_3_5_ConvolutionCodeRate = 0x7,
+        kInnerFEC_4_5_ConvolutionCodeRate = 0x8,
+        kInnerFEC_9_10_ConvolutionCodeRate = 0x9,
+        kInnerFEC_Auto                    = 0xA,
         kInnerFEC_None                    = 0xF,
     };
     uint FECInner() const { return _data[12] & 0xf; }
@@ -1756 +1780 @@
 {
     switch (cr)
     {
-        case 0x0:  return "auto"; // not actually defined in spec
+        case 0x0:  return "none"; // not actually defined in spec
         case 0x1:  return "1/2";
         case 0x2:  return "2/3";
         case 0x3:  return "3/4";
         case 0x4:  return "5/6";
         case 0x5:  return "7/8";
-        case 0x8:  return "8/9";
+        case 0x6:  return "8/9";
+        case 0x7:  return "3/5";
+        case 0x8:  return "4/5";
+        case 0x9:  return "9/10";
         case 0xf:  return "none";
         default:   return "auto"; // not actually defined in spec
     }

mythtv/libs/libmythtv/scanwizard.cpp

@@ -98 +98 @@
         start_chan = configPane->GetStartChan();
         parse_type = DTVTunerType::kTunerTypeQPSK;
     }
+    else if (scantype == ScanTypeSetting::NITAddScan_DVBS2)
+    {
+        start_chan = configPane->GetStartChan();
+        parse_type = DTVTunerType::kTunerTypeDVB_S2;
+    }
     else if (scantype == ScanTypeSetting::NITAddScan_QAM)
     {
         start_chan = configPane->GetStartChan();
@@ -139 +144 @@
             start_chan["coderate_hp"],    start_chan["coderate_lp"],
             start_chan["constellation"],  start_chan["trans_mode"],
             start_chan["guard_interval"], start_chan["hierarchy"],
-            start_chan["modulation"],     start_chan["bandwidth"]))
+            start_chan["modulation"],     start_chan["bandwidth"],
+            start_chan["msystem"],        start_chan["rolloff"]))
     {
         MythPopupBox::showOkPopup(
             gContext->GetMainWindow(), tr("ScanWizard"),

mythtv/libs/libmythtv/scanwizardhelpers.cpp

@@ -455 +455 @@
         addSelection(tr("Import channels.conf"),
                      QString::number(DVBUtilsImport));
         break;
+    case CardUtil::DVBS2:
+        addSelection(tr("Full Scan (Tuned)"),
+                     QString::number(NITAddScan_DVBS2));
+        addSelection(tr("Import channels.conf"),
+                     QString::number(DVBUtilsImport));
+        break;
     case CardUtil::QAM:
         addSelection(tr("Full Scan (Tuned)"),
                      QString::number(NITAddScan_QAM));
@@ -574 +580 @@
               paneQAM);
     addTarget(QString::number(ScanTypeSetting::NITAddScan_QPSK),
               paneQPSK);
+    addTarget(QString::number(ScanTypeSetting::NITAddScan_DVBS2),
+              paneDVBS2);
     addTarget(QString::number(ScanTypeSetting::NITAddScan_OFDM),
               paneOFDM);
     addTarget(QString::number(ScanTypeSetting::FullScan_ATSC),
@@ -766 +774 @@
         startChan["modulation"] = "qpsk";
         startChan["polarity"]   = pane->polarity();
     }
+    else if (ScanTypeSetting::NITAddScan_DVBS2 == st)
+    {
+        const DVBS2Pane *pane = paneDVBS2;
+
+        startChan["std"]        = "dvb";
+        startChan["frequency"]  = pane->frequency();
+        startChan["inversion"]  = pane->inversion();
+        startChan["symbolrate"] = pane->symbolrate();
+        startChan["fec"]        = pane->fec();
+        startChan["msystem"]    = pane->msystem();
+        startChan["modulation"] = pane->modulation();
+        startChan["polarity"]   = pane->polarity();
+        startChan["rolloff"]    = pane->rolloff();
+    }
     else if (ScanTypeSetting::NITAddScan_QAM == st)
     {
         const QAMPane *pane = paneQAM;

mythtv/libs/libmythtv/scanwizardhelpers.h

@@ -243 +243 @@
         // seen in the Network Information Tables to the scan.
         NITAddScan_OFDM,
         NITAddScan_QPSK,
+        NITAddScan_DVBS2,
         NITAddScan_QAM,
         // Scan of all transports already in the database
         FullTransportScan,
@@ -274 +275 @@
     QString GetATSCFormat(const QString&)    const;
     QString GetFrequencyStandard(void)       const;
     QString GetModulation(void)              const;
+    QString GetRollOff(void)                 const;
     QString GetFrequencyTable(void)          const;
     bool    DoIgnoreSignalTimeout(void)      const;
     QString GetFilename(void)                const;
@@ -510 +512 @@
     {
         addSelection(QObject::tr("Auto"),"auto",true);
         addSelection("QPSK","qpsk");
-#ifdef FE_GET_EXTENDED_INFO
         addSelection("8PSK","8psk");
-#endif
         addSelection("QAM 16","qam_16");
         addSelection("QAM 32","qam_32");
         addSelection("QAM 64","qam_64");
@@ -531 +531 @@
     };
 };
 
+class ScanModulationSystemSetting: public ComboBoxSetting
+{
+  public:
+    ScanModulationSystemSetting(Storage *_storage) : ComboBoxSetting(_storage)
+    {
+        addSelection("DVB-S","dvbs",true);
+        addSelection("DVB-S2","dvbs2");
+    };
+};
+
+class ScanModulationSystem: public ScanModulationSystemSetting, public TransientStorage
+{
+  public:
+    ScanModulationSystem() : ScanModulationSystemSetting(this)
+    {
+        setLabel(QObject::tr("Modul. System"));
+        setHelpText(QObject::tr("Modulation System (Default: DVB-S)"));
+    };
+};
+
+class ScanRollOffSetting: public ComboBoxSetting
+{
+  public:
+    ScanRollOffSetting(Storage *_storage) : ComboBoxSetting(_storage)
+    {
+        addSelection(QObject::tr("Auto"),"auto");
+        addSelection("0.35","0.35",true);
+        addSelection("0.20","0.20");
+        addSelection("0.25","0.25");
+    };
+};
+
+class ScanRollOff: public ScanRollOffSetting, public TransientStorage
+{
+  public:
+    ScanRollOff() : ScanRollOffSetting(this)
+    {
+        setLabel(QObject::tr("RollOff"));
+        setHelpText(QObject::tr("RollOff (Default: 0.35)"));
+    };
+};
+
 class ScanConstellation: public ScanModulationSetting,
                          public TransientStorage
 {
@@ -552 +594 @@
         addSelection("1/2");
         addSelection("2/3");
         addSelection("3/4");
+        addSelection("3/5");
         addSelection("4/5");
         addSelection("5/6");
         addSelection("6/7");
         addSelection("7/8");
         addSelection("8/9");
+        addSelection("9/10");
     }
 };
 
@@ -692 +736 @@
         left->addChild( pfrequency  = new ScanFrequency());
         left->addChild( ppolarity   = new ScanPolarity());
         left->addChild( psymbolrate = new ScanSymbolRate());
-        right->addChild(pfec        = new ScanFec());
+        left->addChild(pfec         = new ScanFec());
+        right->addChild(pmsystem    = new ScanModulationSystem());
         right->addChild(pmodulation = new ScanModulation());
         right->addChild(pinversion  = new ScanInversion());
+        right->addChild(prolloff    = new ScanRollOff());
         addChild(left);
         addChild(right);
     }
@@ -704 +750 @@
     QString inversion(void)  const { return pinversion->getValue();  }
     QString fec(void)        const { return pfec->getValue();        }
     QString polarity(void)   const { return ppolarity->getValue();   }
+    QString msystem(void)    const { return pmsystem->getValue();    }
     QString modulation(void) const { return pmodulation->getValue(); }
+    QString rolloff(void)    const { return prolloff->getValue();    }
 
   protected:
     ScanFrequency  *pfrequency;
@@ -713 +761 @@
     ScanFec        *pfec;
     ScanPolarity   *ppolarity;
     ScanModulation *pmodulation;
+    ScanModulationSystem *pmsystem;
+    ScanRollOff          *prolloff;
 };
 
 class QPSKPane : public HorizontalConfigurationGroup

mythtv/libs/libmythtv/scanwizardscanner.cpp

@@ -364 +364 @@
     }
     else if ((ScanTypeSetting::NITAddScan_OFDM == scantype) ||
              (ScanTypeSetting::NITAddScan_QPSK == scantype) ||
+             (ScanTypeSetting::NITAddScan_DVBS2 == scantype) ||
              (ScanTypeSetting::NITAddScan_QAM  == scantype))
     {
         VERBOSE(VB_SIPARSER, LOC + "ScanTransports()");
@@ -490 +491 @@
         QString sub_type = CardUtil::ProbeDVBType(device).toUpper();
         bool need_nit = (("QAM"  == sub_type) ||
                          ("QPSK" == sub_type) ||
+                         ("DVB_S2" == sub_type) ||
                          ("OFDM" == sub_type));
 
         // Ugh, Some DVB drivers don't fully support signal monitoring...

mythtv/libs/libmythtv/siscan.cpp

@@ -903 +903 @@
     nextIt = transport_scan_items_it_t( scanTransports.end() );
 
     DTVMultiplex tuning;
-
+    DTVModulation modulation;
+    DTVModulationSystem msystem;
     DTVTunerType type;
 
     if (std == "dvb")
     {
-        ok = type.Parse(mod);
+        if (!modulation.Parse(*(startChan.find("modulation"))))
+        {
+            VERBOSE(VB_IMPORTANT, LOC + "Wrong modulation.");
+            return false;
+        }
+
+        if (modulation == DTVModulation::kModulationQPSK)
+        {
+            type = DTVTunerType::kTunerTypeQPSK;
+            ok = true;
+            if (startChan.find("msystem") != startChan.end())
+            {
+                if (!msystem.Parse(*(startChan.find("msystem"))))
+                {
+                    VERBOSE(VB_IMPORTANT, LOC + "Wrong modulation system.");
+                    return false;
+                }
+                if (msystem == DTVModulationSystem::kModulationSystemDVBS2)
+                    type = DTVTunerType::kTunerTypeDVB_S2;
+            }
+        }
+        else if (modulation == DTVModulation::kModulation8PSK)
+        {
+            type = DTVTunerType::kTunerTypeDVB_S2;
+            ok = true;
+        }
+        else
+            ok = type.Parse(mod);
     }
     else if (std == "atsc")
     {
@@ -926 +954 @@
             startChan["coderate_hp"],    startChan["coderate_lp"],
             startChan["constellation"],  startChan["trans_mode"],
             startChan["guard_interval"], startChan["hierarchy"],
-            startChan["modulation"],     startChan["bandwidth"]);
+            startChan["modulation"],     startChan["bandwidth"],
+            startChan["msystem"],        startChan["rolloff"]);
     }
 
     if (ok)
@@ -1566 +1595 @@
     const uint transportid, const uint networkid)
 {
     uint64_t    db_freq;
-    QString     tmp_modulation;
+    QString     tmp_modulation, tmp_msystem, tmp_rolloff;
     QString     tmp_si_std;
     uint        tmp_transportid, tmp_networkid;
     int         mplexid;
@@ -1580 +1609 @@
 
     if (!ChannelUtil::GetTuningParams(
             (uint)mplexid, tmp_modulation,
-            db_freq, tmp_transportid, tmp_networkid, tmp_si_std))
+            db_freq, tmp_transportid, tmp_networkid,
+            tmp_msystem, tmp_rolloff, tmp_si_std))
     {
         return tuning_freq;
     }

mythtv/libs/libmythtv/transporteditor.cpp

@@ -98 +98 @@
     MSqlQuery query(MSqlQuery::InitCon());
     query.prepare(
         "SELECT mplexid, modulation, frequency, "
-        "       symbolrate, networkid, transportid, constellation "
+        "       symbolrate, networkid, transportid, constellation, msystem "
         "FROM dtv_multiplex, videosource "
         "WHERE dtv_multiplex.sourceid = :SOURCEID AND "
         "      dtv_multiplex.sourceid = videosource.sourceid "
@@ -129 +129 @@
         QString tid = query.value(5).toUInt() ?
             QString("tid %1").arg(query.value(5).toUInt(), 5) : "";
 
-        QString hz = (CardUtil::QPSK == cardtype) ? "kHz" : "Hz";
+        QString hz = (CardUtil::QPSK == cardtype ||
+                      CardUtil::DVBS2 == cardtype) ? "kHz" : "Hz";
 
         QString type = "";
         if (CardUtil::OFDM == cardtype)
             type = "(DVB-T)";
         if (CardUtil::QPSK == cardtype)
             type = "(DVB-S)";
+        if (CardUtil::DVBS2 == cardtype)
+            type = (query.value(7).toString() == "dvbs2")?"(DVB-S2)":"DVB-S";
+
         if (CardUtil::QAM == cardtype)
             type = "(DVB-C)";
 
@@ -487 +491 @@
     };
 };
 
+class DVBS2ModulationSystem: public ComboBoxSetting, public MuxDBStorage
+{
+  public:
+    DVBS2ModulationSystem(const MultiplexID *id) :
+        ComboBoxSetting(this), MuxDBStorage(this, id, "msystem")
+    {
+        setLabel(QObject::tr("Modulation system"));
+        setHelpText(QObject::tr("Modulation system (Default: DVB-S)\n"
+                                "Standard selection: DVB-S/DVB-S2"));
+        addSelection(QObject::tr("DVB-S"), "dvbs");
+        addSelection(QObject::tr("DVB-S2"), "dvbs2");
+    };
+};
+
 class Modulation : public ComboBoxSetting, public MuxDBStorage
 {
   public:
@@ -506 +524 @@
         // no modulation options
         setVisible(false);
     }
+    if (CardUtil::QPSK == nType)
+    {
+        addSelection("QPSK", "qpsk");
+    }
+    if (CardUtil::DVBS2 == nType)
+    {
+        addSelection("QPSK", "qpsk");
+        addSelection("8PSK", "8psk");
+    }
     else if ((CardUtil::QAM == nType) || (CardUtil::OFDM == nType))
     {
         addSelection(QObject::tr("QAM Auto"), "auto");
@@ -576 +603 @@
         addSelection("1/2");
         addSelection("2/3");
         addSelection("3/4");
+        addSelection("3/5");
         addSelection("4/5");
         addSelection("5/6");
         addSelection("6/7");
         addSelection("7/8");
         addSelection("8/9");
+        addSelection("9/10");
     };
 };
 
@@ -597 +626 @@
     };
 };
 
+class DVBS2RollOff: public ComboBoxSetting, public MuxDBStorage
+{
+  public:
+    DVBS2RollOff(const MultiplexID *id) :
+        ComboBoxSetting(this), MuxDBStorage(this, id, "rolloff")
+    {
+        setLabel(QObject::tr("Roll-off"));
+        setHelpText(QObject::tr("Roll-off (Default: 0.35)"));
+        addSelection(QObject::tr("0.35"), "0.35");
+        addSelection(QObject::tr("0.20"), "0.20");
+        addSelection(QObject::tr("0.25"), "0.25");
+        addSelection(QObject::tr("Auto"), "auto");
+    };
+};
+
 class DVBTCoderateLP :
     public DVBForwardErrorCorrectionSelector, public MuxDBStorage
 {
@@ -715 +759 @@
         right->addChild(new DVBForwardErrorCorrection(id));
         right->addChild(new SignalPolarity(id));
     }
+    else if (CardUtil::DVBS2 == nType)
+    {
+        left->addChild(new DTVStandard(id, true, false));
+        left->addChild(new Frequency(id, true));
+        left->addChild(new DVBSymbolRate(id));
+        left->addChild(new DVBInversion(id));
+        left->addChild(new SignalPolarity(id));
+
+        right = new VerticalConfigurationGroup(false, true, false, false);
+        right->addChild(new DVBS2ModulationSystem(id));
+        right->addChild(new Modulation(id, nType));
+        right->addChild(new DVBForwardErrorCorrection(id));
+        right->addChild(new DVBS2RollOff(id));
+    }
     else if (CardUtil::QAM == nType)
     {
         left->addChild(new DTVStandard(id, true, false));

mythtv/libs/libmythtv/v4lchannel.cpp

@@ -453 +453 @@
 
     // Fetch tuning data from the database.
     QString tvformat, modulation, freqtable, freqid, dtv_si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -463 +464 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff,
         mplexid, commfree))
     {
         return false;
@@ -738 +740 @@
     uint64_t frequency;
     uint     transportid;
     uint     dvb_networkid;
+    QString  dvb_msystem;
+    QString  dvb_rolloff;
 
     if (!ChannelUtil::GetTuningParams(
             mplexid, modulation, frequency,
-            transportid, dvb_networkid, si_std))
+            transportid, dvb_networkid,
+            dvb_msystem, dvb_rolloff, si_std))
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR + "TuneMultiplex(): " +
                 QString("Could not find tuning parameters for multiplex %1.")

mythtv/libs/libmythtv/videosource.cpp

@@ -2929 +2929 @@
             signal_timeout->setValue(60000);
             channel_timeout->setValue(62500);
             break;
+        case CardUtil::DVBS2:
+            cardtype->setValue("DVB-S2");
+            cardname->setValue(frontend_name);
+            signal_timeout->setValue(60000);
+            channel_timeout->setValue(62500);
+            break;
         case CardUtil::QAM:
             cardtype->setValue("DVB-C");
             cardname->setValue(frontend_name);