Ticket #1330: 8psk.2.patch

File 8psk.2.patch, 19.2 KB (added by anonymous, 20 years ago)

  • libs/libmythtv/scanwizardhelpers.h

     
    418418    {
    419419        addSelection(QObject::tr("Auto"),"auto",true);
    420420        addSelection("QPSK","qpsk");
     421#ifdef FE_GET_EXTENDED_INFO
     422        addSelection("8PSK","8psk");
     423#endif
    421424        addSelection("QAM 16","qam_16");
    422425        addSelection("QAM 32","qam_32");
    423426        addSelection("QAM 64","qam_64");
    … …  
    591594    ScanGuardInterval    *pguard_interval;
    592595    ScanHierarchy        *phierarchy;
    593596};
     597#ifdef FE_GET_EXTENDED_INFO
     598class DVBS2Pane : public HorizontalConfigurationGroup
     599{
     600  public:
     601    DVBS2Pane() : HorizontalConfigurationGroup(false,false,true,false)
     602    {
     603        setUseFrame(false);
     604        VerticalConfigurationGroup *left =
     605            new VerticalConfigurationGroup(false,true);
     606        VerticalConfigurationGroup *right =
     607            new VerticalConfigurationGroup(false,true);
     608        left->addChild(pfrequency  = new ScanFrequency());
     609        left->addChild(ppolarity   = new ScanPolarity());
     610        left->addChild(psymbolrate = new ScanSymbolRate());
     611        right->addChild(pfec       = new ScanFec());
     612        right->addChild(pmodulation= new ScanModulation());
     613        right->addChild(pinversion = new ScanInversion());
     614        addChild(left);
     615        addChild(right);     
     616    }
    594617
     618    QString frequency()  { return pfrequency->getValue(); }
     619    QString symbolrate() { return psymbolrate->getValue(); }
     620    QString inversion()  { return pinversion->getValue(); }
     621    QString fec()        { return pfec->getValue(); }
     622    QString polarity()   { return ppolarity->getValue(); }
     623    QString modulation() { return pmodulation->getValue(); }
     624
     625  protected:
     626    ScanFrequency  *pfrequency;
     627    ScanSymbolRate *psymbolrate;
     628    ScanInversion  *pinversion;
     629    ScanFec        *pfec;
     630    ScanPolarity   *ppolarity;
     631    ScanModulation *pmodulation;
     632};
     633#endif
     634
    595635class QPSKPane : public HorizontalConfigurationGroup
    596636{
    597637  public:

  • libs/libmythtv/dvbtypes.cpp

     
    156156   {"QAM_128",QAM_128},
    157157   {"QAM_256",QAM_256},
    158158   {"QPSK",QPSK},
     159#ifdef FE_GET_EXTENDED_INFO
     160   {"8PSK", MOD_8PSK},
     161#endif
    159162   {NULL,QAM_AUTO},
    160163};
    161164
    … …  
    182185   {"qpsk",QPSK},
    183186   {"8vsb",VSB_8},
    184187   {"16vsb",VSB_16},
     188#ifdef FE_GET_EXTENDED_INFO
     189   {"8psk", MOD_8PSK},
     190#endif
    185191   {NULL,QAM_AUTO},
    186192};
    187193
    … …  
    195201    "qam_256", //QAM_256,
    196202    "auto",    //QAM_AUTO,
    197203    "8vsb",    //VSB_8,
    198     "16vsb"    //VSB_16
     204    "16vsb",    //VSB_16
     205#ifdef FE_GET_EXTENDED_INFO
     206    "8psk",
     207#endif
    199208};
    200209
    201210DVBParamHelper<fe_transmit_mode_t>::Table DVBTransmitMode::confTable[] =
    … …  
    307316    "a"  //HIERARCHY_AUTO
    308317};
    309318
    310 bool equal_qpsk(const struct dvb_frontend_parameters &p,
    311                 const struct dvb_frontend_parameters &op, uint range)
     319bool equal_qpsk(const struct dvb_fe_params &p,
     320                const struct dvb_fe_params &op, uint range)
    312321{
    313322    return
    314323        p.frequency + range  >= op.frequency           &&
    … …  
    318327        p.u.qpsk.fec_inner   == op.u.qpsk.fec_inner;
    319328}
    320329
    321 bool equal_atsc(const struct dvb_frontend_parameters &p,
    322                 const struct dvb_frontend_parameters &op, uint range)
     330#ifdef FE_GET_EXTENDED_INFO
     331bool equal_dvbs2(const struct dvb_frontend_parameters_new &p,
     332                const struct dvb_frontend_parameters_new &op, uint range)
    323333{
     334    return
     335        p.frequency + range  >= op.frequency           &&
     336        p.frequency          <= op.frequency + range   &&
     337        p.inversion          == op.inversion           &&
     338        p.u.qpsk.symbol_rate == op.u.qpsk.symbol_rate  &&
     339        p.u.qpsk.fec_inner   == op.u.qpsk.fec_inner;
     340}
     341#endif
     342
     343bool equal_atsc(const struct dvb_fe_params &p,
     344                const struct dvb_fe_params &op, uint range)
     345{
    324346    bool ok =
    325347        p.frequency + range  >= op.frequency           &&
    326348        p.frequency          <= op.frequency + range;
    … …  
    330352    return ok;
    331353}
    332354
    333 bool equal_qam(const struct dvb_frontend_parameters &p,
    334                const struct dvb_frontend_parameters &op, uint range)
     355bool equal_qam(const struct dvb_fe_params &p,
     356               const struct dvb_fe_params &op, uint range)
    335357{
    336358    return
    337359        p.frequency + range  >= op.frequency            &&
    … …  
    342364        p.u.qam.modulation   == op.u.qam.modulation;
    343365}
    344366
    345 bool equal_ofdm(const struct dvb_frontend_parameters &p,
    346                 const struct dvb_frontend_parameters &op,
     367bool equal_ofdm(const struct dvb_fe_params &p,
     368                const struct dvb_fe_params &op,
    347369                uint range)
    348370{
    349371    return
    … …  
    359381        p.u.ofdm.hierarchy_information == op.u.ofdm.hierarchy_information;
    360382}
    361383
    362 bool equal_type(const struct dvb_frontend_parameters &p,
    363                 const struct dvb_frontend_parameters &op,
     384bool equal_type(const struct dvb_fe_params &p,
     385                const struct dvb_fe_params &op,
    364386                fe_type_t type, uint freq_range)
    365387{
    366388    if (FE_QAM == type)
    … …  
    371393        return equal_qpsk(p, op, freq_range);
    372394    if (FE_ATSC == type)
    373395        return equal_atsc(p, op, freq_range);
     396#ifdef FE_GET_EXTENDED_INFO
     397    if (FE_DVB_S2 == type)
     398        return equal_dvbs2(p, op, freq_range);
     399#endif
    374400    return false;
    375401}
    376402
    … …  
    659685    return true;
    660686}
    661687
     688#ifdef FE_GET_EXTENDED_INFO
     689bool DVBTuning::parseDVBS2(const QString& frequency,   const QString& inversion,
     690                          const QString& symbol_rate, const QString& fec_inner,
     691                          const QString& pol,         const QString& _diseqc_type,
     692                          const QString& _diseqc_port,
     693                          const QString& _diseqc_pos,
     694                          const QString& _lnb_lof_switch,
     695                          const QString& _lnb_lof_hi,
     696                          const QString& _lnb_lof_lo,
     697                          const QString &modulation)
     698{
     699    bool ok = true;
     700
     701    dvb_dvbs2_parameters& p = params.u.qpsk2;
     702    params.frequency = frequency.toInt();
     703
     704    params.inversion = parseInversion(inversion, ok);
     705    if (!ok)
     706        VERBOSE(VB_GENERAL, LOC_WARN +
     707                "Invalid inversion, aborting, falling back to 'auto'");
     708
     709    p.symbol_rate = symbol_rate.toInt();
     710    if (!p.symbol_rate)
     711    {
     712        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid symbol rate " +
     713                QString("parameter '%1', aborting.").arg(symbol_rate));
     714        return false;
     715    }
     716
     717    voltage = parsePolarity(pol, ok);
     718    if (SEC_VOLTAGE_OFF == voltage)
     719    {
     720        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid polarization, aborting.");
     721        return false;
     722    }
     723
     724    p.fec_inner = parseCodeRate(fec_inner, ok);
     725
     726    p.modulation = parseModulation(modulation, ok);
     727    diseqc_type = _diseqc_type.toInt();
     728    diseqc_port = _diseqc_port.toInt();
     729    diseqc_pos  = _diseqc_pos.toFloat();
     730    lnb_lof_switch = _lnb_lof_switch.toInt();
     731    lnb_lof_hi  = _lnb_lof_hi.toInt();
     732    lnb_lof_lo  = _lnb_lof_lo.toInt();
     733    return true;
     734}
     735#endif
     736
    662737// TODO: Add in DiseqcPos when diseqc class supports it
    663738bool DVBTuning::parseQPSK(const QString& frequency,   const QString& inversion,
    664739                          const QString& symbol_rate, const QString& fec_inner,
    … …  
    902977    else if (modulation ==  "qam-16") return QAM_16;
    903978    else if (modulation ==   "8-vsb") return VSB_8;
    904979    else if (modulation ==  "16-vsb") return VSB_16;
    905 
     980#ifdef FE_GET_EXTENDED_INFO
     981    else if (modulation ==    "8psk") return MOD_8PSK;
     982#endif
    906983    ok = false;
    907984
    908985    VERBOSE(VB_GENERAL, LOC_WARN +
    … …  
    9421019            hierarchy);
    9431020    else if (FE_ATSC == type)
    9441021        ok = tuning.parseATSC(frequency, modulation);
     1022#ifdef FE_GET_EXTENDED_INFO
     1023    else if (FE_DVB_S2 == type)
     1024        ok = tuning.parseDVBS2(
     1025            frequency,       inversion,     symbolrate,   fec,   polarity,
     1026            dvb_diseqc_type, diseqc_port,   diseqc_pos,
     1027            lnb_lof_switch,  lnb_lof_hi,    lnb_lof_lo, modulation);
     1028#endif
    9451029       
    9461030    sistandard = _sistandard;
    9471031    input_id   = _input_id.toInt();
    … …  
    9631047        case QAM_16:   return  "QAM-16";
    9641048        case VSB_8:    return   "8-VSB";
    9651049        case VSB_16:   return  "16-VSB";
     1050#ifdef FE_GET_EXTENDED_INFO
     1051        case MOD_8PSK: return    "8PSK";
     1052#endif
    9661053        default:      return "auto";
    9671054    }
    9681055    return "Unknown";
    … …  
    9811068        case QAM_256:  return "qam_256";
    9821069        case VSB_8:    return "8vsb";
    9831070        case VSB_16:   return "16vsb";
     1071#ifdef FE_GET_EXTENDED_INFO
     1072        case MOD_8PSK: return "8psk";
     1073#endif
    9841074        default:       return "auto";
    9851075    }
    9861076}
    … …  
    10151105    return "Unknown";
    10161106}
    10171107
    1018 QString toString(const struct dvb_frontend_parameters &params,
     1108QString toString(const struct dvb_fe_params &params,
    10191109                 const fe_type_t type)
    10201110{
    10211111    return QString("freq(%1) type(%2)")
    … …  
    10381128QString toString(const struct dvb_frontend_event &event,
    10391129                 const fe_type_t type)
    10401130{
     1131    const struct dvb_fe_params *params;
     1132    params  = (const struct dvb_fe_params *)(&event.parameters);
    10411133    return QString("Event status(%1) %2")
    1042         .arg(toString(event.status)).arg(toString(event.parameters, type));
     1134        .arg(toString(event.status))
     1135        .arg(toString(*params, type));
    10431136}

  • libs/libmythtv/dvbchannel.h

     
    101101    dvb_frontend_info info;        ///< Contains info on tuning hardware
    102102    dvb_channel_t     chan_opts;   ///< Tuning options sent to tuning hardware
    103103    DVBTuning         prev_tuning; ///< Last tuning options sent to hardware
     104#ifdef FE_GET_EXTENDED_INFO
     105    dvb_fe_caps_extended extinfo;  ///<Additional info on tuning hardware
     106#endif
    104107
    105108    volatile int      fd_frontend; ///< File descriptor for tuning hardware
    106109    int               cardnum;     ///< DVB Card number

  • libs/libmythtv/dvbtypes.h

     
    5151#define MAX_SECTION_SIZE 4096
    5252#define DMX_DONT_FILTER 0x2000
    5353
     54#ifdef FE_GET_EXTENDED_INFO
     55  #define dvb_fe_params dvb_frontend_parameters_new
     56#else
     57  #define dvb_fe_params dvb_frontend_parameters
     58#endif
     59
    5460QString toString(const fe_type_t);
    55 QString toString(const struct dvb_frontend_parameters&, const fe_type_t);
     61QString toString(const struct dvb_fe_params&, const fe_type_t);
    5662QString toString(fe_status);
    5763QString toString(const struct dvb_frontend_event&, const fe_type_t);
    5864
    … …  
    282288typedef vector<uint16_t> dvb_caid_t;
    283289
    284290extern bool equal_qpsk(
    285     const struct dvb_frontend_parameters &p,
    286     const struct dvb_frontend_parameters &op, uint range);
     291    const struct dvb_fe_params &p,
     292    const struct dvb_fe_params &op, uint range);
     293#ifdef FE_GET_EXTENDED_INFO
     294extern bool equal_dvbs2(
     295    const struct dvb_fe_params &p,
     296    const struct dvb_fe_params &op, uint range);
     297#endif
    287298extern bool equal_atsc(
    288     const struct dvb_frontend_parameters &p,
    289     const struct dvb_frontend_parameters &op, uint range);
     299    const struct dvb_fe_params &p,
     300    const struct dvb_fe_params &op, uint range);
    290301extern bool equal_qam(
    291     const struct dvb_frontend_parameters &p,
    292     const struct dvb_frontend_parameters &op, uint range);
     302    const struct dvb_fe_params &p,
     303    const struct dvb_fe_params &op, uint range);
    293304extern bool equal_ofdm(
    294     const struct dvb_frontend_parameters &p,
    295     const struct dvb_frontend_parameters &op, uint range);
     305    const struct dvb_fe_params &p,
     306    const struct dvb_fe_params &op, uint range);
    296307extern bool equal_type(
    297     const struct dvb_frontend_parameters &p,
    298     const struct dvb_frontend_parameters &op,
     308    const struct dvb_fe_params &p,
     309    const struct dvb_fe_params &op,
    299310    fe_type_t type, uint freq_range);
    300311
    301312class DVBTuning
    … …  
    306317        diseqc_type(0), diseqc_port(0), diseqc_pos(0.0f),
    307318        lnb_lof_switch(0), lnb_lof_hi(0), lnb_lof_lo(0)
    308319    {
    309         bzero(&params, sizeof(dvb_frontend_parameters));
     320        bzero(&params, sizeof(dvb_fe_params));
    310321    }
    311322
    312     struct dvb_frontend_parameters params;
     323    struct dvb_fe_params params;
    313324    fe_sec_voltage_t    voltage;
    314325    fe_sec_tone_mode_t  tone;
    315326    unsigned int        diseqc_type;
    … …  
    386397    bool parseQAM(const QString& frequency,       const QString& inversion,
    387398                  const QString& symbol_rate,     const QString& fec_inner,
    388399                  const QString& modulation);
     400
     401#ifdef FE_GET_EXTENDED_INFO
     402    bool equalDVBS2(const DVBTuning& other, uint range = 0) const
     403        { return equal_dvbs2(params, other.params, range);  }
     404    uint DVBS2SymbolRate() const { return params.u.qpsk2.symbol_rate; }
     405    bool parseDVBS2(const QString& frequency,      const QString& inversion,
     406                   const QString& symbol_rate,    const QString& fec_inner,
     407                   const QString& pol,            const QString& diseqc_type,
     408                   const QString& diseqc_port,    const QString& diseqc_pos,
     409                   const QString& lnb_lof_switch, const QString& lnb_lof_hi,
     410                   const QString& lnb_lof_lo,     const QString& modulation);
     411#endif
    389412};
    390413
    391414class dvb_channel_t

  • libs/libmythtv/dvbchannel.cpp

     
    147147        return false;
    148148    }
    149149
     150#ifdef FE_GET_EXTENDED_INFO
     151    if (info.caps & FE_HAS_EXTENDED_INFO)
     152    {
     153        if (ioctl(fd_frontend, FE_GET_EXTENDED_INFO, &extinfo) < 0)
     154        {
     155            VERBOSE(VB_IMPORTANT, LOC_ERR +
     156                    "Failed to get frontend extended information." + ENO);
     157            close(fd_frontend);
     158            fd_frontend = -1;
     159            return false;
     160        }
     161        if (extinfo.modulations & MOD_8PSK)
     162        {
     163            if (ioctl(fd_frontend, FE_SET_STANDARD, FE_DVB_S2) < 0)
     164            {
     165                VERBOSE(VB_IMPORTANT, LOC_ERR +
     166                        "Failed to get extended frontend information." + ENO);
     167                close(fd_frontend);
     168                fd_frontend = -1;
     169                return false;
     170            }
     171            if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0)
     172            {
     173                VERBOSE(VB_IMPORTANT, LOC_ERR +
     174                        "Failed to get frontend information." + ENO);
     175                close(fd_frontend);
     176                fd_frontend = -1;
     177                return false;
     178            }
     179        }
     180    }
     181#endif
     182
    150183    VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.")
    151184            .arg(cardnum).arg(info.name));
    152185
    153186    // Turn on the power to the LNB
     187#ifdef FE_GET_EXTENDED_INFO
     188    if (info.type == FE_QPSK || info.type == FE_DVB_S2)
     189#else
    154190    if (info.type == FE_QPSK)
     191#endif
    155192    {
    156193        if (ioctl(fd_frontend, FE_SET_TONE, SEC_TONE_OFF) < 0)
    157194        {
    … …  
    473510            }
    474511            break;
    475512
     513#ifdef FE_GET_EXTENDED_INFO
     514        case FE_DVB_S2:
     515            symbol_rate = t.DVBS2SymbolRate();
     516
     517            if (!CheckModulation(t.params.u.qpsk2.modulation))
     518                VERBOSE(VB_GENERAL, LOC_WARN +
     519                        "Unsupported modulation parameter.");
     520
     521            if (!CheckCodeRate(t.params.u.qpsk2.fec_inner))
     522                VERBOSE(VB_GENERAL, LOC_WARN +
     523                        "Unsupported fec_inner parameter.");
     524            break;
     525#endif
     526
    476527        case FE_QAM:
    477528            symbol_rate = t.QAMSymbolRate();
    478529
    … …  
    541592       case FE_ATSC:
    542593            // ATSC doesn't need any validation
    543594            break;
     595       default:
     596            break;
    544597    }
    545598
    546599    if (info.type != FE_OFDM &&
    … …  
    572625        case FEC_8_9:  if (info.caps & FE_CAN_FEC_8_9)  return true;
    573626        case FEC_AUTO: if (info.caps & FE_CAN_FEC_AUTO) return true;
    574627        case FEC_NONE: return true;
     628        default: return false;
    575629    }
    576630    return false;
    577631}
    … …  
    592646        case QAM_AUTO: if (info.caps & FE_CAN_QAM_AUTO) return true;
    593647        case VSB_8:    if (info.caps & FE_CAN_8VSB)     return true;
    594648        case VSB_16:   if (info.caps & FE_CAN_16VSB)    return true;
     649#ifdef FE_GET_EXTENDED_INFO
     650        case MOD_8PSK: if (info.caps & FE_HAS_EXTENDED_INFO &&
     651                           extinfo.modulations & MOD_8PSK) return true;
     652#endif
     653        default: return false;
    595654    }
    596655    return false;
    597656}
    … …  
    644703bool DVBChannel::Tune(const dvb_channel_t& channel, bool force_reset)
    645704{
    646705    bool reset = (force_reset || first_tune);
     706#ifdef FE_GET_EXTENDED_INFO
     707    bool has_diseq = (FE_QPSK == info.type || FE_DVB_S2 == info.type) && diseqc;
     708#else
    647709    bool has_diseq = (FE_QPSK == info.type) && diseqc;
    648     struct dvb_frontend_parameters params = channel.tuning.params;
     710#endif
     711    struct dvb_fe_params params = channel.tuning.params;
    649712
    650713    retune_tuning = channel.tuning;
    651714
    … …  
    683746
    684747        params.frequency = params.frequency + (retune_adj = -retune_adj);
    685748
     749#ifdef FE_GET_EXTENDED_INFO
     750        if (info.type == FE_DVB_S2)
     751        {
     752            if (ioctl(fd_frontend, FE_SET_FRONTEND2, &params) < 0)
     753            {
     754                VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     755                        "Setting Frontend(2) tuning parameters failed." + ENO);
     756                return false;
     757            }
     758        } else {
     759            if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
     760            {
     761                VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     762                        "Setting Frontend tuning parameters failed." + ENO);
     763                return false;
     764            }
     765        }
     766#else
    686767        if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
    687768        {
    688769            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
    … …  
    690771
    691772            return false;
    692773        }
     774#endif
    693775
    694776        // Extra delay to add for broken DVB drivers
    695777        if (tuning_delay)
    … …  
    806888static uint tuned_frequency(const DVBTuning &tuning, fe_type_t type,
    807889                            fe_sec_tone_mode_t *p_tone)
    808890{
     891#ifdef FE_GET_EXTENDED_INFO
     892    if (FE_QPSK != type && FE_DVB_S2 != type)
     893        return tuning.Frequency();
     894#else
    809895    if (FE_QPSK != type)
    810896        return tuning.Frequency();
     897#endif
    811898
    812899    uint freq   = tuning.Frequency();
    813900    bool tone   = freq >= tuning.lnb_lof_switch;

  • libs/libmythtv/scanwizard.cpp

     
    3939    : paneOFDM(new OFDMPane()),     paneQPSK(new QPSKPane()),
    4040      paneATSC(new ATSCPane()),     paneQAM(new QAMPane()),
    4141      paneSingle(new STPane()),
     42#ifdef FE_GET_EXTENDED_INFO
     43      paneDVBS2(new DVBS2Pane()),
     44#endif
    4245      nVideoDev(-1),                nCardType(CardUtil::ERROR_PROBE),
    4346      nCaptureCard(-1),
    4447      configPane(new ScanWizardScanType(this, sourceid)),