Ticket #5882: s2api.alan.r1.patch

File s2api.alan.r1.patch, 79.6 KB (added by alannisota@…, 11 years ago)

Rev1 of pathc by Alan

  • libs/libmythtv/dtvconfparserhelpers.h

    old new  
    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) { }
     
    245247        kModulationQAMAuto = 6,
    246248        kModulation8VSB    = 7,
    247249        kModulation16VSB   = 8,
    248         kModulation2VSB    = 9,
    249         kModulation4VSB    = 10,
    250         kModulationBPSK    = 11,
    251         kModulation16APSK  = 12,
    252         kModulation32APSK  = 13,
    253         kModulation8PSK    = 14,
    254         kModulation16PSK   = 15,
     250        kModulation8PSK    = 9,
     251        kModulation16APSK  = 10,
     252        kModulation32APSK  = 11,
     253        kModulationDQPSK   = 12,
     254        kModulation2VSB    = 13,
     255        kModulation4VSB    = 14,
     256        kModulationBPSK    = 15,
    255257        kModulationAnalog  = 16, /* for analog channel scanner */
     258        kModulation16PSK   = 17,
    256259    };
    257260
    258261    DTVModulation(int _default = kModulationQAMAuto)
     
    414417        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
    415418};
    416419
     420class DTVModulationSystem : public DTVParamHelper
     421{
     422  protected:
     423    static const DTVParamHelperStruct confTable[];
     424    static const DTVParamHelperStruct vdrTable[];
     425    static const DTVParamHelperStruct parseTable[];
     426    static const uint kDBStrCnt = 2;
     427    static const char *dbStr[kDBStrCnt];
     428
     429  public:
     430    enum
     431    {
     432        kModulationSystemDVBS,
     433        kModulationSystemDVBS2,
     434    };
     435
     436    DTVModulationSystem(int _default = kModulationSystemDVBS)
     437        : DTVParamHelper(_default) { }
     438
     439    bool ParseConf(const QString &_value)
     440       { return ParseParam(_value, value, confTable); }
     441    bool ParseVDR(const QString &_value)
     442       { return ParseParam(_value, value, vdrTable); }
     443    bool Parse(const QString &_value)
     444       { return ParseParam(_value, value, parseTable); }
     445
     446    QString toString() const { return toString(value); }
     447
     448    static QString toString(int _value)
     449        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     450};
     451
     452class DTVRollOff : public DTVParamHelper
     453{
     454  protected:
     455    static const DTVParamHelperStruct confTable[];
     456    static const DTVParamHelperStruct vdrTable[];
     457    static const DTVParamHelperStruct parseTable[];
     458    static const uint kDBStrCnt = 4;
     459    static const char *dbStr[kDBStrCnt];
     460
     461  public:
     462    enum
     463    {
     464        kRollOff35,
     465        kRollOff20,
     466        kRollOff25,
     467        kRollOffAuto,
     468    };
     469
     470    DTVRollOff(int _default = kRollOff35)
     471        : DTVParamHelper(_default) { }
     472
     473    bool ParseConf(const QString &_value)
     474       { return ParseParam(_value, value, confTable); }
     475    bool ParseVDR(const QString &_value)
     476       { return ParseParam(_value, value, vdrTable); }
     477    bool Parse(const QString &_value)
     478       { return ParseParam(_value, value, parseTable); }
     479
     480    QString toString() const { return toString(value); }
     481
     482    static QString toString(int _value)
     483        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     484};
     485
     486class DTVPilot : public DTVParamHelper
     487{
     488  protected:
     489    static const DTVParamHelperStruct confTable[];
     490    static const DTVParamHelperStruct vdrTable[];
     491    static const DTVParamHelperStruct parseTable[];
     492    static const uint kDBStrCnt = 3;
     493    static const char *dbStr[kDBStrCnt];
     494
     495  public:
     496    enum
     497    {
     498        kPilotOn,
     499        kPilotOff,
     500        kPilotAuto,
     501    };
     502
     503    DTVPilot(int _default = kPilotAuto)
     504        : DTVParamHelper(_default) { }
     505
     506    bool ParseConf(const QString &_value)
     507       { return ParseParam(_value, value, confTable); }
     508
     509    QString toString() const { return toString(value); }
     510
     511    static QString toString(int _value)
     512        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
     513};
     514
    417515#endif // _DTVCONFPARSERHELPERS_H_
  • libs/libmythtv/channelscan/scaninfo.cpp

    old new  
    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

    old new  
    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

    old new  
    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

    old new  
    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

    old new  
    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

    old new  
    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

    old new  
    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

    old new  
    154154    { "FEC_6_7",  kFEC_6_7  },
    155155    { "FEC_7_8",  kFEC_7_8  },
    156156    { "FEC_8_9",  kFEC_8_9  },
    157     { "FEC_NONE", kFECNone },
     157    { "FEC_3_5",  kFEC_3_5  },
     158    { "FEC_9_10", kFEC_9_10 },
     159    { "FEC_NONE", kFECNone  },
    158160    { NULL,       kFECAuto },
    159161};
    160162
     
    164166    { "12",  kFEC_1_2 },
    165167    { "23",  kFEC_2_3 },
    166168    { "34",  kFEC_3_4 },
     169    { "35",  kFEC_3_5 },
    167170    { "45",  kFEC_4_5 },
    168171    { "56",  kFEC_5_6 },
    169172    { "67",  kFEC_6_7 },
    170173    { "78",  kFEC_7_8 },
    171174    { "89",  kFEC_8_9 },
     175    { "910", kFEC_9_10},
    172176    { "0",   kFECNone },
    173177    { NULL,  kFECAuto }
    174178};
     
    184188    { "6/7",  kFEC_6_7 },
    185189    { "7/8",  kFEC_7_8 },
    186190    { "8/9",  kFEC_8_9 },
     191    { "3/5",  kFEC_3_5 },
     192    { "9/10", kFEC_9_10},
    187193    { "none", kFECNone },
    188194    { NULL,   kFECAuto }
    189195};
     
    199205     "6/7",  ///< kFEC_6_7
    200206     "7/8",  ///< kFEC_7_8
    201207     "8/9",  ///< kFEC_8_9
    202      "auto"  ///< kFECAuto
     208     "3/5",  ///< kFEC_3_5
     209     "9/10", ///< kFEC_9_10
     210     "auto", ///< kFECAuto
    203211};
    204212
    205213const DTVParamHelperStruct DTVModulation::confTable[] =
     
    220228   { "32APSK",   kModulation32APSK  },
    221229   { "8PSK",     kModulation8PSK    },
    222230   { "16PSK",    kModulation16PSK   },
     231   { "DQPSK",    kModulationDQPSK   },
    223232   { "analog",   kModulationAnalog  },
    224233   { NULL,       kModulationQAMAuto },
    225234};
     
    232241   { "64",  kModulationQAM64   },
    233242   { "128", kModulationQAM128  },
    234243   { "256", kModulationQAM256  },
     244   { "2",   kModulationQPSK    },
     245   { "10",  kModulation8VSB    },
     246   { "11",  kModulation16VSB   },
     247   { "6",   kModulation16APSK  },
     248   { "7",   kModulation32APSK  },
     249   { "5",   kModulation8PSK    },
    235250   { "0",   kModulationQPSK    },
    236251   { NULL,  kModulationQAMAuto },
    237252};
     
    254269   { "32apsk",   kModulation32APSK  },
    255270   { "8psk",     kModulation8PSK    },
    256271   { "16psk",    kModulation16PSK   },
     272   { "dqpsk",    kModulationDQPSK   },
    257273   // alternates
    258274   { "a",        kModulationQAMAuto },
    259275   { "qam_auto", kModulationQAMAuto },
     
    271287   { "16-apsk",  kModulation16APSK  },
    272288   { "32-apsk",  kModulation32APSK  },
    273289   { "8-psk",    kModulation8PSK    },
    274    { "16-psk",   kModulation16PSK   },
     290   { "16-psk",   kModulation16PSK  },
     291   { "dq-psk",   kModulationDQPSK   },
     292   { "16psk",    kModulation16PSK  },
    275293   { NULL,       kModulationQAMAuto },
    276294};
    277295
     
    293311    "32apsk",  ///< kModulation32APSK
    294312    "8psk",    ///< kModulation8PSK
    295313    "16psk",   ///< kModulation16PSK
     314    "dqpsk",   ///< kModulationDQPSK
    296315};
    297316
    298317const DTVParamHelperStruct DTVTransmitMode::confTable[] =
     
    420439   "r", ///< kPolarityRight
    421440   "l"  ///< kPolarityLeft
    422441};
     442
     443const DTVParamHelperStruct DTVModulationSystem::confTable[] =
     444{
     445   { "SYS_DVBS",  kModulationSystemDVBS  },
     446   { "SYS_DVBS2", kModulationSystemDVBS2 },
     447   { NULL,        kModulationSystemDVBS  },
     448};
     449
     450const DTVParamHelperStruct DTVModulationSystem::vdrTable[] =
     451{
     452   { "0",  kModulationSystemDVBS  },
     453   { "1",  kModulationSystemDVBS2 },
     454   { NULL, kModulationSystemDVBS  },
     455};
     456
     457const DTVParamHelperStruct DTVModulationSystem::parseTable[] =
     458{
     459   { "dvbs2", kModulationSystemDVBS2 },
     460   { "dvbs",  kModulationSystemDVBS  },
     461   { NULL,    kModulationSystemDVBS  },
     462};
     463
     464const char *DTVModulationSystem::dbStr[DTVModulationSystem::kDBStrCnt] =
     465{
     466    "dvbs",  ///< kModulationSystemDVBS
     467    "dvbs2", ///< kModulationSystemDVBS2
     468};
     469
     470const DTVParamHelperStruct DTVRollOff::confTable[] =
     471{
     472   { "ROLLOFF_35",   kRollOff35   },
     473   { "ROLLOFF_20",   kRollOff20   },
     474   { "ROLLOFF_25",   kRollOff25   },
     475   { "ROLLOFF_AUTO", kRollOffAuto },
     476   { NULL,           kRollOffAuto },
     477};
     478
     479const DTVParamHelperStruct DTVRollOff::vdrTable[] =
     480{
     481   { "35",   kRollOff35   },
     482   { "20",   kRollOff20   },
     483   { "25",   kRollOff25   },
     484   { "0",    kRollOffAuto },
     485   { NULL,   kRollOff35   },
     486};
     487
     488const DTVParamHelperStruct DTVRollOff::parseTable[] =
     489{
     490   { "0.35",   kRollOff35   },
     491   { "0.20",   kRollOff20   },
     492   { "0.25",   kRollOff25   },
     493   { "auto",   kRollOffAuto },
     494   { NULL,     kRollOff35   },
     495};
     496
     497const char *DTVRollOff::dbStr[DTVRollOff::kDBStrCnt] =
     498{
     499   "0.35",   ///< kRollOff35
     500   "0.20",   ///< kRollOff20
     501   "0.25",   ///< kRollOff25
     502   "auto",   ///< kRollOffAuto
     503};
  • libs/libmythtv/dtvconfparser.cpp

    old new  
    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);
     
    213213    PARSE_SKIP(unknown);
    214214    PARSE_SKIP(unknown);
    215215    PARSE_UINT(chan.serviceid);
     216    mux.modulation = DTVModulation::kModulationQPSK;
    216217
    217218    AddChannel(mux, chan);
    218219
     
    274275            case 'R':
    275276            case 'L':
    276277                mux.polarity.ParseVDR(ori);
     278            case 'S':
     279                mux.msystem.ParseVDR(params);
     280            case 'O':
     281                mux.rolloff.ParseVDR(params);
    277282                break;
    278283            default:
    279284                return false;
  • libs/libmythtv/dtvmultiplex.h

    old new  
    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

    old new  
    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);
  • libs/libmythtv/cardutil.h

    old new  
    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

    old new  
    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

    old new  
    1818#define MINIMUM_DBMS_VERSION 5,0,15
    1919
    2020/// This is the DB schema version expected by the running MythTV instance.
    21 const QString currentDatabaseVersion = "1227";
     21const QString currentDatabaseVersion = "1228";
    2222
    2323static bool UpdateDBVersionNumber(const QString &newnumber);
    2424static bool performActualUpdate(
     
    43854385            return false;
    43864386    }
    43874387
     4388    if (dbver == "1227")
     4389    {
     4390        const char *updates[] = {
     4391"ALTER TABLE dtv_multiplex ADD msystem VARCHAR(10) DEFAULT NULL AFTER polarity;",
     4392"ALTER TABLE dtv_multiplex ADD rolloff VARCHAR(10) DEFAULT NULL AFTER modulation;",
     4393NULL
     4394};
     4395        if (!performActualUpdate(updates, "1228", dbver))
     4396            return false;
     4397    }
     4398
    43884399    return true;
    43894400}
    43904401
  • libs/libmythtv/scanwizardscanner.cpp

    old new  
    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()");
     
    442443    DTVConfParser::cardtype_t type = DTVConfParser::UNKNOWN;
    443444    type = (CardUtil::OFDM == cardtype) ? DTVConfParser::OFDM : type;
    444445    type = (CardUtil::QPSK == cardtype) ? DTVConfParser::QPSK : type;
     446    type = (CardUtil::DVBS2 == cardtype) ? DTVConfParser::DVBS2 : type;
    445447    type = (CardUtil::QAM  == cardtype) ? DTVConfParser::QAM  : type;
    446448    type = ((CardUtil::ATSC == cardtype)||(CardUtil::HDHOMERUN == cardtype)) ?
    447449        DTVConfParser::ATSC : type;
     
    490492        QString sub_type = CardUtil::ProbeDVBType(device).toUpper();
    491493        bool need_nit = (("QAM"  == sub_type) ||
    492494                         ("QPSK" == sub_type) ||
     495                         ("DVB_S2" == sub_type) ||
    493496                         ("OFDM" == sub_type));
    494497
    495498        // Ugh, Some DVB drivers don't fully support signal monitoring...
  • libs/libmythtv/siscan.cpp

    old new  
    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)
  • libs/libmythtv/dtvconfparser.h

    old new  
    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/dvbchannel.h

    old new  
    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

    old new  
    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_sistd);
    298314        }
    299315
    300316        mux = ChannelUtil::CreateMultiplex(
     
    307323            cd.TransmissionModeString()[0].toAscii(),
    308324            QString(),                         cd.ConstellationString(),
    309325            cd.HierarchyString()[0].toAscii(), cd.CodeRateHPString(),
    310             cd.CodeRateLPString(),             cd.GuardIntervalString());
     326            cd.CodeRateLPString(),             cd.GuardIntervalString(),
     327            QString(),                         QString());
    311328
    312329        if (mux)
    313330            muxes.push_back(mux);
     
    334351            -1,
    335352            cd.FECInnerString(),  QString(),
    336353            -1,                   QString(),
    337             QString(),            QString());
     354            QString(),                   QString(),
     355            cd.ModulationSystemString(), cd.RollOffString());
    338356
    339357        if (mux)
    340358            muxes.push_back(mux);
     
    357375            -1,
    358376            cd.FECInnerString(),  QString::null,
    359377            -1,                   QString::null,
     378            QString::null,        QString::null,
    360379            QString::null,        QString::null);
    361380
    362381        if (mux)
     
    377396        -1,
    378397        QString::null,      QString::null,
    379398        -1,                 QString::null,
     399        QString::null,      QString::null,
    380400        QString::null,      QString::null);
    381401}
    382402
     
    390410    signed char trans_mode,
    391411    QString     inner_FEC,    QString     constellation,
    392412    signed char hierarchy,    QString     hp_code_rate,
    393     QString     lp_code_rate, QString     guard_interval)
     413    QString     lp_code_rate, QString     guard_interval,
     414    QString     msystem,      QString     rolloff)
    394415{
    395416    return insert_dtv_multiplex(
    396417        sourceid,           sistandard,
     
    402423        trans_mode,
    403424        inner_FEC,          constellation,
    404425        hierarchy,          hp_code_rate,
    405         lp_code_rate,       guard_interval);
     426        lp_code_rate,       guard_interval,
     427        msystem,            rolloff);
    406428}
    407429
    408430uint ChannelUtil::CreateMultiplex(uint sourceid, const DTVMultiplex &mux,
     
    418440        mux.trans_mode.toChar().toAscii(),
    419441        mux.fec.toString(),               mux.modulation.toString(),
    420442        mux.hierarchy.toChar().toAscii(), mux.hp_code_rate.toString(),
    421         mux.lp_code_rate.toString(),      mux.guard_interval.toString());
     443        mux.lp_code_rate.toString(),      mux.guard_interval.toString(),
     444        mux.msystem.toString(),           mux.rolloff.toString());
    422445}
    423446
    424447
     
    15351558        return true;
    15361559
    15371560    return GetTuningParams(mplexid, modulation, frequency,
    1538                            dvb_transportid, dvb_networkid, dtv_si_std);
     1561                           dvb_transportid, dvb_networkid,
     1562                           dtv_si_std);
    15391563}
    15401564
    15411565bool ChannelUtil::GetChannelSettings(int chanid, bool &useonairguide,
  • libs/libmythtv/mpeg/dvbdescriptors.h

    old new  
    685685    // FEC_inner                4  12.4
    686686    enum
    687687    {
    688         kInnerFEC_1_2_ConvolutionCodeRate = 0x1,
    689         kInnerFEC_2_3_ConvolutionCodeRate = 0x2,
    690         kInnerFEC_3_4_ConvolutionCodeRate = 0x3,
    691         kInnerFEC_5_6_ConvolutionCodeRate = 0x4,
    692         kInnerFEC_7_8_ConvolutionCodeRate = 0x5,
    693         kInnerFEC_8_9_ConvolutionCodeRate = 0x6,
    694         kInnerFEC_None                    = 0xF,
     688        kInnerFEC_1_2_ConvolutionCodeRate  = 0x1,
     689        kInnerFEC_2_3_ConvolutionCodeRate  = 0x2,
     690        kInnerFEC_3_4_ConvolutionCodeRate  = 0x3,
     691        kInnerFEC_5_6_ConvolutionCodeRate  = 0x4,
     692        kInnerFEC_7_8_ConvolutionCodeRate  = 0x5,
     693        kInnerFEC_8_9_ConvolutionCodeRate  = 0x6,
     694        kInnerFEC_3_5_ConvolutionCodeRate  = 0x7,
     695        kInnerFEC_4_5_ConvolutionCodeRate  = 0x8,
     696        kInnerFEC_9_10_ConvolutionCodeRate = 0x9,
     697        kInnerFEC_None                     = 0xF,
    695698    };
    696699    uint FECInner() const { return _data[12] & 0xf; }
    697700    QString FECInnerString() const { return coderate_inner(FECInner()); }
     
    745748    bool IsLinearPolarization()   const { return !((_data[8]>>6)&0x1); }
    746749    bool IsHorizontalLeftPolarization() const { return (_data[8]>>5)&0x1; }
    747750    bool IsVerticalRightPolarization() const { return !((_data[8]>>5)&0x1); }
    748     // modulation               5   8.3
     751    // rolloff                  2   8.3
     752    uint RollOff() const { return (_data[8]>>3)&0x3; }
     753    QString RollOffString()  const
     754    {
     755        static QString ps[] = { "0.35", "0.20", "0.25", "AUTO" };
     756        return ps[Polarization()];
     757    }
     758    // modulation system        3   8.5
     759    enum
     760    {
     761        kModulationSystemDVBS  = 0x0,
     762        kModulationSystemDVBS2 = 0x1,
     763    };
     764    uint ModulationSystem() const { return _data[8]>>2&0x1; }
     765    QString ModulationSystemString() const
     766    {
     767        static QString mss[] = { "dvbs", "dvbs2" };
     768        return (mss[ModulationSystem()]);
     769    }
     770    // modulation               4   8.6
     771
    749772    enum
    750773    {
    751774        kModulationQPSK_NS = 0x0, // Non standard QPSK for Bell ExpressVu
     
    753776        kModulation8PSK   = 0x2,
    754777        kModulationQAM16  = 0x3,
    755778    };
    756     uint Modulation() const { return _data[8]&0x1f; }
     779    uint Modulation() const { return _data[8]&0x3; }
    757780    QString ModulationString() const
    758781    {
    759782        static QString ms[] = { "qpsk", "qpsk", "8psk", "qam_16" };
     
    779802        kInnerFEC_5_6_ConvolutionCodeRate = 0x4,
    780803        kInnerFEC_7_8_ConvolutionCodeRate = 0x5,
    781804        kInnerFEC_8_9_ConvolutionCodeRate = 0x6,
     805        kInnerFEC_3_5_ConvolutionCodeRate = 0x7,
     806        kInnerFEC_4_5_ConvolutionCodeRate = 0x8,
     807        kInnerFEC_9_10_ConvolutionCodeRate = 0x9,
     808        kInnerFEC_Auto                    = 0xA,
    782809        kInnerFEC_None                    = 0xF,
    783810    };
    784811    uint FECInner() const { return _data[12] & 0xf; }
     
    17621789        case 0x3:  return "3/4";
    17631790        case 0x4:  return "5/6";
    17641791        case 0x5:  return "7/8";
    1765         case 0x8:  return "8/9";
     1792        case 0x6:  return "8/9";
     1793        case 0x7:  return "3/5";
     1794        case 0x8:  return "4/5";
     1795        case 0x9:  return "9/10";
    17661796        case 0xf:  return "none";
    17671797        default:   return "auto"; // not actually defined in spec
    17681798    }
  • libs/libmythtv/mpeg/dvbdescriptors.cpp

    old new  
    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/dvbtypes.h

    old new  
    2020#include <linux/dvb/dmx.h>
    2121
    2222#if (DVB_API_VERSION != 3 && DVB_API_VERSION != 5)
    23 #    error "DVB driver includes with API version 3 not found!"
     23#    error "DVB driver includes with API version 3 or 5 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 == 5)
     31#    define USE_DVB_V5
     32#endif
     33
    3034#if ((DVB_API_VERSION == 3 && DVB_API_VERSION_MINOR >= 1) || (DVB_API_VERSION > 3))
    3135#    define USE_ATSC
    3236#else
     
    3943#    define VSB_16        (fe_modulation)(QAM_AUTO+2)
    4044#endif
    4145
    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
     46#define dvb_fe_params dvb_frontend_parameters
    4747
    4848class QString;
    4949QString toString(fe_status);
  • libs/libmythtv/dvbchannel.cpp

    old new  
    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
     58#ifdef USE_DVB_V5
     59static bool dtvmultiplex_to_dtvproperties(
     60    DTVTunerType, const DTVMultiplex&, struct dtv_properties*, bool do_tune);
     61static bool dtvmultiplex_to_dtvproperties(
     62    DTVTunerType, const DTVMultiplex&, struct dtv_properties*);
     63static DTVMultiplex dtvproperties_to_dtvmultiplex(
     64    DTVTunerType, const dtv_properties&);
     65#endif
     66
    5767#define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(device)
    5868#define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \
    5969                 .arg(GetCardID()).arg(device)
     
    167177        frontend_name       = master->frontend_name;
    168178        card_type           = master->card_type;
    169179        capabilities        = master->capabilities;
    170         ext_modulations     = master->ext_modulations;
    171180        frequency_minimum   = master->frequency_minimum;
    172181        frequency_maximum   = master->frequency_maximum;
    173182        symbol_rate_minimum = master->symbol_rate_minimum;
     
    210219        return false;
    211220    }
    212221
    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         }
     222    frontend_name       = info.name;
     223    //card_type           = info.type;
     224    card_type.Parse(CardUtil::ProbeDVBType(device));
    251225
    252         ext_modulations   = extinfo.modulations;
    253     }
     226#ifdef USE_DVB_V5
     227    // FIXME: I think this will work ok, as v4l-dvb
     228    // should downgrade to QPSK automatically for
     229    // DVBS cards, but I'm not 100% sure of that
     230    if (card_type == DTVTunerType::kTunerTypeQPSK)
     231        card_type = DTVTunerType::kTunerTypeDVB_S2;
    254232#endif
    255233
    256     frontend_name       = info.name;
    257     card_type           = info.type;
    258234    capabilities        = info.caps;
    259235    frequency_minimum   = info.frequency_min;
    260236    frequency_maximum   = info.frequency_max;
     
    309285bool DVBChannel::TuneMultiplex(uint mplexid, QString inputname)
    310286{
    311287    DTVMultiplex tuning;
    312     if (!tuning.FillFromDB(card_type, mplexid))
     288    bool ok = true;
     289    ok = tuning.FillFromDB(card_type, mplexid);
     290    if (!ok)
    313291        return false;
    314292
    315293    CheckOptions(tuning);
     
    596574    const DTVModulation m = modulation;
    597575    const uint64_t      c = capabilities;
    598576
    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 
    608577    return
    609578        ((DTVModulation::kModulationQPSK    == m) && (c & FE_CAN_QPSK))     ||
    610579        ((DTVModulation::kModulationQAM16   == m) && (c & FE_CAN_QAM_16))   ||
     
    640609bool DVBChannel::Tune(const DTVMultiplex &tuning, QString inputname)
    641610{
    642611    int inputid = inputname.isEmpty() ? currentInputID : GetInputByName(inputname);
     612    QString device;
    643613    if (inputid < 0)
    644614    {
    645615        VERBOSE(VB_IMPORTANT, LOC_ERR + QString("Tune(): Invalid input '%1'.")
     
    671641                      bool same_input)
    672642{
    673643    QMutexLocker lock(&tune_lock);
     644    uint64_t frequency = tuning.frequency;
    674645
    675646    if (master)
    676647    {
     
    680651    }
    681652
    682653    bool reset = (force_reset || first_tune);
     654#ifdef USE_DVB_V5
     655
     656    struct dtv_properties cmds;
     657
     658    //clear card cache
     659    dtv_property props[11];
     660    memset(&props, 0, sizeof(props));
     661    props[0].cmd = DTV_CLEAR;
     662    cmds.num = 1;
     663    cmds.props = props;
     664    if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
     665    {
     666        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     667                "Clearing tuner cache failed." + ENO);
     668        return false;
     669    }
     670
     671    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds);
     672#else
    683673    struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
     674#endif
    684675
    685676    bool is_dvbs = (DTVTunerType::kTunerTypeQPSK   == card_type ||
    686677                    DTVTunerType::kTunerTypeDVB_S2 == card_type);
     
    737728            // make sure we tune to frequency, if the lnb has changed
    738729            reset = first_tune = true;
    739730        }
    740        
    741         params.frequency = lnb->GetIntermediateFrequency(
    742             diseqc_settings, tuning);
     731
     732        frequency = lnb->GetIntermediateFrequency( diseqc_settings, tuning);
     733
     734#ifdef USE_DVB_V5
     735        for (uint i = 0; i < cmds.num; i++)
     736        {
     737            if (cmds.props[i].cmd == DTV_FREQUENCY)
     738            {
     739                cmds.props[i].u.data = frequency;
     740                break;
     741            }
     742        }
     743#else
     744        params.frequency = frequency;
    743745
    744746        // if card can auto-FEC, use it -- sometimes NITs are inaccurate
    745747        if (capabilities & FE_CAN_FEC_AUTO)
    746748            params.u.qpsk.fec_inner = FEC_AUTO;
     749#endif
    747750    }
    748751
    749752    VERBOSE(VB_CHANNEL, LOC + "Old Params: " +
     
    758761    if (reset || !prev_tuning.IsEqual(card_type, tuning, 500 * freq_mult))
    759762    {
    760763        VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2")
    761                 .arg(params.frequency).arg(suffix));
     764                .arg(frequency).arg(suffix));
    762765
    763 #ifdef FE_GET_EXTENDED_INFO
    764         if (card_type == DTVTunerType::kTunerTypeDVB_S2)
     766#ifdef USE_DVB_V5
     767        if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
    765768        {
    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             }
     769            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     770                    "Setting Frontend tuning parameters failed." + ENO);
     771            return false;
    772772        }
    773         else
    774 #endif // FE_GET_EXTENDED_INFO
     773#else
     774        if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
    775775        {
    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             }
     776            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     777                    "Setting Frontend tuning parameters failed." + ENO);
     778            return false;
    782779        }
     780#endif
    783781
    784782        // Extra delay to add for broken DVB drivers
    785783        if (tuning_delay)
     
    835833        return false;
    836834    }
    837835
     836#ifdef USE_DVB_V5
     837    struct dtv_properties cmds;
     838    cmds.num = 0;
     839    return ioctl(fd_frontend, FE_GET_PROPERTY, &cmds) >= 0;
     840#else
    838841    dvb_fe_params params;
    839842    return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
     843#endif
    840844}
    841845
    842846/** \fn DVBChannel::ProbeTuningParams(DTVMultiplex&) const
     
    868872        return false;
    869873    }
    870874
     875    int fe_ok;
     876#ifdef USE_DVB_V5
     877    struct dtv_properties cmds;
     878    dtv_property props[11];
     879    memset(&props, 0, sizeof(props));
     880    cmds.props = props;
     881    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds, false);
     882    fe_ok = ioctl(fd_frontend, FE_GET_PROPERTY, &cmds);
     883#else
    871884    dvb_fe_params params;
    872     if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0)
     885    fe_ok = ioctl(fd_frontend, FE_GET_FRONTEND, &params);
     886#endif
     887    if (fe_ok < 0)
    873888    {
    874889        VERBOSE(VB_IMPORTANT, LOC_ERR +
    875890                "Getting Frontend tuning parameters failed." + ENO);
     
    880895    uint    mplex      = tuning.mplex;
    881896    QString sistandard = tuning.sistandard; sistandard.detach();
    882897
     898#ifdef USE_DVB_V5
     899    tuning = dtvproperties_to_dtvmultiplex(card_type, cmds);
     900#else
    883901    tuning = dvbparams_to_dtvmultiplex(card_type, params);
     902#endif
    884903
    885904    tuning.mplex       = mplex;
    886905    tuning.sistandard  = sistandard;
     
    11111130
    11121131    if (DTVTunerType::kTunerTypeDVB_S2 == tuner_type)
    11131132    {
    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
    11191133        VERBOSE(VB_IMPORTANT, "DVBChan Error, MythTV was compiled without "
    11201134                "DVB-S2 headers being present so DVB-S2 tuning will fail.");
    1121 #endif // !FE_GET_EXTENDED_INFO
    11221135    }
    11231136
    11241137    if (DTVTunerType::kTunerTypeQAM  == tuner_type)
     
    11991212
    12001213    return tuning;
    12011214}
     1215
     1216
     1217#ifdef USE_DVB_V5
     1218static DTVMultiplex dtvproperties_to_dtvmultiplex(
     1219    DTVTunerType tuner_type, const dtv_properties &cmds)
     1220{
     1221    DTVMultiplex tuning;
     1222
     1223    for (uint i = 0; i < cmds.num; i++)
     1224    {
     1225        switch (cmds.props[i].cmd)
     1226        {
     1227            case DTV_MODULATION:
     1228                tuning.modulation = cmds.props[i].u.data;
     1229                break;
     1230            case DTV_DELIVERY_SYSTEM:
     1231                switch (cmds.props[i].u.data)
     1232                {
     1233                    case SYS_DVBS:
     1234                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS;
     1235                        break;
     1236                    case SYS_DVBS2:
     1237                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS2;
     1238                        break;
     1239                    case SYS_DVBT:
     1240                    case SYS_DVBC_ANNEX_AC:
     1241                    case SYS_DVBC_ANNEX_B:
     1242#ifdef USE_ATSC
     1243                    case SYS_ATSC:
     1244#endif
     1245                        break;
     1246                    default:
     1247                        VERBOSE(VB_IMPORTANT, "Unknown DVB delivery system." + ENO);
     1248                };
     1249                break;
     1250            case DTV_FREQUENCY:
     1251                if (tuning.modulation == DTVModulation::kModulationQPSK ||
     1252                    tuning.modulation == DTVModulation::kModulation8PSK)
     1253                    tuning.frequency = cmds.props[i].u.data / 1000UL;
     1254                else
     1255                    tuning.frequency = cmds.props[i].u.data;
     1256                break;
     1257            case DTV_SYMBOL_RATE:
     1258                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
     1259                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
     1260                    tuner_type == DTVTunerType::kTunerTypeQAM)
     1261                {
     1262                    if (tuning.modulation == DTVModulation::kModulationQPSK ||
     1263                        tuning.modulation == DTVModulation::kModulation8PSK)
     1264                        tuning.symbolrate = cmds.props[i].u.data / 1000UL;
     1265                    else
     1266                        tuning.symbolrate = cmds.props[i].u.data;
     1267                };
     1268                break;
     1269            case DTV_INNER_FEC:
     1270                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
     1271                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
     1272                    tuner_type == DTVTunerType::kTunerTypeQAM)
     1273                {
     1274                    tuning.symbolrate = cmds.props[i].u.data;
     1275                }
     1276                break;
     1277            case DTV_PILOT:
     1278                break;
     1279            case DTV_ROLLOFF:
     1280                if (tuner_type == DTVTunerType::kTunerTypeDVB_S2)
     1281                    tuning.rolloff = cmds.props[i].u.data;
     1282                break;
     1283            case DTV_INVERSION:
     1284                tuning.inversion = cmds.props[i].u.data;
     1285                break;
     1286            case DTV_BANDWIDTH_HZ:
     1287                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1288                    tuning.bandwidth = cmds.props[i].u.data;
     1289                break;
     1290            case DTV_CODE_RATE_HP:
     1291                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1292                    tuning.hp_code_rate = cmds.props[i].u.data;
     1293                break;
     1294            case DTV_CODE_RATE_LP:
     1295                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1296                    tuning.lp_code_rate = cmds.props[i].u.data;
     1297                break;
     1298            case DTV_TRANSMISSION_MODE:
     1299                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1300                    tuning.trans_mode = cmds.props[i].u.data;
     1301                break;
     1302            case DTV_GUARD_INTERVAL:
     1303                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1304                    tuning.guard_interval = cmds.props[i].u.data;
     1305                break;
     1306            case DTV_HIERARCHY:
     1307                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1308                    tuning.hierarchy = cmds.props[i].u.data;
     1309                break;
     1310            case DTV_TUNE:
     1311                break;
     1312            default:
     1313                VERBOSE(VB_IMPORTANT, "Unknown DTV command." + ENO);
     1314        }
     1315    }
     1316    return tuning;
     1317}
     1318
     1319static bool dtvmultiplex_to_dtvproperties(
     1320    DTVTunerType tuner_type,
     1321    const DTVMultiplex &tuning,
     1322    struct dtv_properties *cmdseq)
     1323{
     1324    return dtvmultiplex_to_dtvproperties(tuner_type, tuning, cmdseq, true);
     1325}
     1326
     1327static bool dtvmultiplex_to_dtvproperties(
     1328    DTVTunerType tuner_type,
     1329    const DTVMultiplex &tuning,
     1330    struct dtv_properties *cmdseq,
     1331    bool do_tune)
     1332{
     1333    if (tuner_type == DTVTunerType::kTunerTypeQPSK ||
     1334        (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
     1335         tuning.modulation == DTVModulation::kModulationQPSK))
     1336    {
     1337        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1338        cmdseq->props[0].u.data = SYS_DVBS;
     1339        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1340        cmdseq->props[1].u.data = tuning.frequency;
     1341        cmdseq->props[2].cmd    = DTV_MODULATION;
     1342        cmdseq->props[2].u.data = tuning.modulation;
     1343        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1344        cmdseq->props[3].u.data = tuning.symbolrate;
     1345        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1346        cmdseq->props[4].u.data = tuning.fec;
     1347        cmdseq->props[5].cmd    = DTV_INVERSION;
     1348        cmdseq->props[5].u.data = tuning.inversion;
     1349        if (do_tune)
     1350        {
     1351            cmdseq->props[6].cmd    = DTV_TUNE;
     1352            cmdseq->num = 7;
     1353        }
     1354        else
     1355        {
     1356            cmdseq->num = 6;
     1357        }
     1358    }
     1359    else if (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
     1360             tuning.modulation == DTVModulation::kModulation8PSK)
     1361    {
     1362        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1363        cmdseq->props[0].u.data = SYS_DVBS2;
     1364        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1365        cmdseq->props[1].u.data = tuning.frequency;
     1366        cmdseq->props[2].cmd    = DTV_MODULATION;
     1367        cmdseq->props[2].u.data = tuning.modulation;
     1368        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1369        cmdseq->props[3].u.data = tuning.symbolrate;
     1370        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1371        cmdseq->props[4].u.data = tuning.fec;
     1372        cmdseq->props[5].cmd    = DTV_INVERSION;
     1373        cmdseq->props[5].u.data = tuning.inversion;
     1374        cmdseq->props[6].cmd    = DTV_PILOT;
     1375        cmdseq->props[6].u.data = PILOT_AUTO;
     1376        cmdseq->props[7].cmd    = DTV_ROLLOFF;
     1377        if (tuning.msystem == DTVModulationSystem::kModulationSystemDVBS2)
     1378            cmdseq->props[7].u.data = tuning.rolloff;
     1379        else
     1380            cmdseq->props[7].u.data = DTVRollOff::kRollOff35;
     1381        if (do_tune)
     1382        {
     1383            cmdseq->props[8].cmd = DTV_TUNE;
     1384            cmdseq->num = 9;
     1385        }
     1386        else
     1387            cmdseq->num = 8;
     1388    }
     1389    else if (tuner_type == DTVTunerType::kTunerTypeQAM)
     1390    {
     1391        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1392        cmdseq->props[0].u.data = (fe_delivery_system_t) (int) tuning.msystem;
     1393        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1394        cmdseq->props[1].u.data = tuning.frequency;
     1395        cmdseq->props[2].cmd    = DTV_MODULATION;
     1396        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
     1397        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
     1398        cmdseq->props[3].u.data = tuning.symbolrate;
     1399        cmdseq->props[4].cmd    = DTV_INNER_FEC;
     1400        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
     1401        cmdseq->props[5].cmd    = DTV_INVERSION;
     1402        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1403        if (do_tune)
     1404        {
     1405            cmdseq->props[6].cmd    = DTV_TUNE;
     1406            cmdseq->num = 7;
     1407        }
     1408        else
     1409            cmdseq->num = 6;
     1410    }
     1411    else if (tuner_type == DTVTunerType::kTunerTypeOFDM)
     1412    {
     1413        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1414        cmdseq->props[0].u.data = SYS_DVBC_ANNEX_AC;
     1415        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1416        cmdseq->props[1].u.data = tuning.frequency;
     1417        cmdseq->props[2].cmd    = DTV_MODULATION;
     1418        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
     1419        cmdseq->props[3].cmd    = DTV_INVERSION;
     1420        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1421        cmdseq->props[4].cmd    = DTV_BANDWIDTH_HZ;
     1422        cmdseq->props[4].u.data = (fe_bandwidth_t) (int) tuning.bandwidth;
     1423        cmdseq->props[5].cmd    = DTV_CODE_RATE_HP;
     1424        cmdseq->props[5].u.data = (fe_code_rate_t) (int) tuning.hp_code_rate;
     1425        cmdseq->props[6].cmd    = DTV_CODE_RATE_LP;
     1426        cmdseq->props[6].u.data = (fe_code_rate_t) (int) tuning.lp_code_rate;
     1427        cmdseq->props[7].cmd    = DTV_TRANSMISSION_MODE;
     1428        cmdseq->props[7].u.data = (fe_transmit_mode_t) (int) tuning.trans_mode;
     1429        cmdseq->props[8].cmd    = DTV_GUARD_INTERVAL;
     1430        cmdseq->props[8].u.data = (fe_guard_interval_t) (int) tuning.guard_interval;
     1431        cmdseq->props[9].cmd    = DTV_HIERARCHY;
     1432        cmdseq->props[9].u.data = (fe_hierarchy_t) (int) tuning.hierarchy;
     1433        if (do_tune)
     1434        {
     1435            cmdseq->props[10].cmd    = DTV_TUNE;
     1436            cmdseq->num = 11;
     1437        }
     1438        else
     1439            cmdseq->num = 10;
     1440    }
     1441#ifdef USE_ATSC
     1442    else if (tuner_type == DTVTunerType::kTunerTypeATSC)
     1443    {
     1444        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
     1445        cmdseq->props[0].u.data = SYS_ATSC;
     1446        cmdseq->props[1].cmd    = DTV_FREQUENCY;
     1447        cmdseq->props[1].u.data = tuning.frequency * 1000UL;
     1448        cmdseq->props[2].cmd    = DTV_MODULATION;
     1449        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;;
     1450        cmdseq->props[3].cmd    = DTV_INVERSION;
     1451        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
     1452        if (do_tune)
     1453        {
     1454            cmdseq->props[4].cmd    = DTV_TUNE;
     1455            cmdseq->num = 5;
     1456        }
     1457        else
     1458            cmdseq->num = 4;
     1459    }
     1460#endif
     1461    else
     1462    {
     1463        VERBOSE(VB_IMPORTANT, "Unknown tuner type." + ENO);
     1464    }
     1465   return true;
     1466}
     1467#endif
     1468
  • libs/libmythtv/cardutil.cpp

    old new  
    242242        VERBOSE(VB_IMPORTANT, "FE_GET_INFO ioctl failed (" + dvbdev + ").");
    243243        return ret;
    244244    }
     245    DTVTunerType type(info.type);
    245246    close(fd_frontend);
    246247
    247     DTVTunerType type(info.type);
    248248    ret = (type.toString() != "UNKNOWN") ? type.toString().toUpper() : ret;
    249249#endif // USING_DVB
    250250
     
    337337{
    338338    QString ct = card_type.toUpper();
    339339    return (ct == "DVB") || (ct == "QAM") || (ct == "QPSK") ||
    340         (ct == "OFDM") || (ct == "ATSC");
     340        (ct == "OFDM") || (ct == "ATSC") || (ct == "DVB_S2");
    341341}
    342342
    343343QString get_on_cardid(const QString &to_get, uint cardid)
  • libs/libmythtv/videosource.cpp

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

    old new  
    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

    old new  
    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

    old new  
    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

    old new  
    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

    old new  
    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    if (! fec.Parse(_fec_inner))
     218    {
     219        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid FEC " +
     220                QString("parameter '%1', aborting.").arg(_fec_inner));
     221        return false;
     222    }
     223
     224    if (! modulation.Parse(_modulation))
     225    {
     226        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid modulation " +
     227                QString("parameter '%1', aborting.").arg(_modulation));
     228        return false;
     229    }
     230
     231    if (!_polarity.isEmpty())
     232    {
     233        if (! polarity.Parse(_polarity.toLower()))
     234        {
     235            VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid polarity " +
     236                    QString("parameter '%1', aborting.").arg(_polarity));
     237            return false;
     238        }
     239    }
     240
     241    if (! _msystem.isEmpty())
     242    {
     243        if (! msystem.Parse(_msystem))
     244        {
     245            VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid modulation system " +
     246                    QString("parameter '%1', aborting.").arg(_msystem));
     247            return false;
     248        }
     249    }
     250
     251    if (!_rolloff.isEmpty())
     252    {
     253        if(! rolloff.Parse(_rolloff))
     254        {
     255            VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid rolloff " +
     256                    QString("parameter '%1', aborting.").arg(_rolloff));
     257            return false;
     258        }
     259    }
     260
     261    if (ok)
     262        frequency = _frequency.toInt(&ok);
     263
     264    return ok;
     265}
     266
    185267bool DTVMultiplex::ParseTuningParams(
    186268    DTVTunerType type,
    187269    QString _frequency,    QString _inversion,      QString _symbolrate,
    188270    QString _fec,          QString _polarity,
    189271    QString _hp_code_rate, QString _lp_code_rate,   QString _ofdm_modulation,
    190272    QString _trans_mode,   QString _guard_interval, QString _hierarchy,
    191     QString _modulation,   QString _bandwidth)
     273    QString _modulation,   QString _bandwidth,
     274    QString _msystem,      QString _rolloff)
    192275{
    193276    if (DTVTunerType::kTunerTypeOFDM == type)
    194277    {
     
    198281            _hierarchy);
    199282    }
    200283
    201     if ((DTVTunerType::kTunerTypeQPSK   == type) ||
    202         (DTVTunerType::kTunerTypeDVB_S2 == type) ||
    203         (DTVTunerType::kTunerTypeQAM    == type))
     284    if ((DTVTunerType::kTunerTypeQAM == type))
    204285    {
    205286        return ParseDVB_S_and_C(
    206287            _frequency,       _inversion,     _symbolrate,
    207288            _fec,             _modulation,    _polarity);
    208289    }
    209290
     291    if ((DTVTunerType::kTunerTypeQPSK   == type) ||
     292        (DTVTunerType::kTunerTypeDVB_S2 == type))
     293    {
     294        return ParseDVB_S2(
     295            _frequency,       _inversion,     _symbolrate,
     296            _fec,             _modulation,    _polarity,
     297            _msystem,         _rolloff);
     298    }
     299
    210300    if (DTVTunerType::kTunerTypeATSC == type)
    211301        return ParseATSC(_frequency, _modulation);
    212302
     
    223313        "       fec,               polarity, "
    224314        "       hp_code_rate,      lp_code_rate,   constellation, "
    225315        "       transmission_mode, guard_interval, hierarchy, "
    226         "       modulation,        bandwidth,      sistandard "
     316        "       modulation,        bandwidth,      sistandard, "
     317        "       msystem,           rolloff "
    227318        "FROM dtv_multiplex "
    228319        "WHERE dtv_multiplex.mplexid = :MPLEXID");
    229320    query.bindValue(":MPLEXID", mplexid);
     
    256347        query.value(6).toString(),  query.value(7).toString(),
    257348        query.value(8).toString(),  query.value(9).toString(),
    258349        query.value(10).toString(), query.value(11).toString(),
    259         query.value(12).toString());
     350        query.value(12).toString(), query.value(14).toString(),
     351        query.value(15).toString());
    260352}
    261353
    262354////////////////////////////////////////////////////////////////////////////
     
    318410        "    mplexid,            frequency,       inversion,  "
    319411        "    symbolrate,         fec,             polarity,   "
    320412        "    hp_code_rate,       lp_code_rate,    modulation, "
     413        "    msystem,            rolloff,                     "
    321414        "    transmission_mode,  guard_interval,  hierarchy,  "
    322415        "    bandwidth,          sistandard,      tuner_type  "
    323416        " ) "
     
    326419        "   :MPLEXID,           :FREQUENCY,      :INVERSION,  "
    327420        "   :SYMBOLRATE,        :FEC,            :POLARITY,   "
    328421        "   :HP_CODE_RATE,      :LP_CODE_RATE,   :MODULATION, "
     422        "   :MSYSTEM,           :ROLLOFF,                     "
    329423        "   :TRANSMISSION_MODE, :GUARD_INTERVAL, :HIERARCHY,  "
    330424        "   :BANDWIDTH,         :SISTANDARD,     :TUNER_TYPE  "
    331425        " );");
     
    340434    query.bindValue(":HP_CODE_RATE", hp_code_rate.toString());
    341435    query.bindValue(":LP_CODE_RATE", lp_code_rate.toString());
    342436    query.bindValue(":MODULATION", modulation.toString());
     437    query.bindValue(":MSYSTEM", msystem.toString());
     438    query.bindValue(":ROLLOFF", rolloff.toString());
    343439    query.bindValue(":TRANSMISSION_MODE", trans_mode.toString());
    344440    query.bindValue(":GUARD_INTERVAL", guard_interval.toString());
    345441    query.bindValue(":HIERARCHY", hierarchy.toString());