Ticket #5403: mythtv_multiproto.5.patch

File mythtv_multiproto.5.patch, 26.0 KB (added by wagabunda, 11 years ago)

corrected "Failed to get frontend parameters for DVB-S/S2 frontend" error, when adapter delivery is never set (after reboot)

  • libs/libmythtv/dtvconfparserhelpers.h

     
    3333#define _DTVCONFPARSERHELPERS_H_
    3434
    3535#include <qstring.h>
     36#include "dvbtypes.h"
    3637
    3738// The following are a set of helper classes to allow easy translation
    3839// between the different string representations of various tuning params.
     
    191192    static const DTVParamHelperStruct confTable[];
    192193    static const DTVParamHelperStruct vdrTable[];
    193194    static const DTVParamHelperStruct parseTable[];
     195#ifdef DVB_API_MULTIPROTO
     196    static const uint kDBStrCnt = 15;
     197#else
    194198    static const uint kDBStrCnt = 10;
     199#endif
    195200    static const char *dbStr[kDBStrCnt];
    196201
    197202  public:
    198203    enum
    199204    {
     205#ifdef DVB_API_MULTIPROTO
    200206        kFECNone,
     207        kFEC_1_4,
     208        kFEC_1_3,
     209        kFEC_2_5,
    201210        kFEC_1_2,
     211        kFEC_3_5,
    202212        kFEC_2_3,
    203213        kFEC_3_4,
    204214        kFEC_4_5,
     
    206216        kFEC_6_7,
    207217        kFEC_7_8,
    208218        kFEC_8_9,
     219        kFEC_9_10,
    209220        kFECAuto,
     221#else
     222        kFECNone,
     223        kFEC_1_2,
     224        kFEC_2_3,
     225        kFEC_3_4,
     226        kFEC_4_5,
     227        kFEC_5_6,
     228        kFEC_6_7,
     229        kFEC_7_8,
     230        kFEC_8_9,
     231        kFECAuto,
     232#endif
    210233    };
    211234
    212235    DTVCodeRate(int _default = kFECAuto) : DTVParamHelper(_default) { }
  • libs/libmythtv/dtvconfparserhelpers.cpp

     
    145145
    146146const DTVParamHelperStruct DTVCodeRate::confTable[] =
    147147{
     148#ifdef DVB_API_MULTIPROTO
     149    { "DVBFE_FEC_AUTO", kFECAuto  },
     150    { "DVBFE_FEC_1_4",  kFEC_1_4  },
     151    { "DVBFE_FEC_1_3",  kFEC_1_3  },
     152    { "DVBFE_FEC_2_5",  kFEC_2_5  },
     153    { "DVBFE_FEC_1_2",  kFEC_1_2  },
     154    { "DVBFE_FEC_3_5",  kFEC_3_5  },
     155    { "DVBFE_FEC_2_3",  kFEC_2_3  },
     156    { "DVBFE_FEC_3_4",  kFEC_3_4  },
     157    { "DVBFE_FEC_4_5",  kFEC_4_5  },   
     158    { "DVBFE_FEC_5_6",  kFEC_5_6  },
     159    { "DVBFE_FEC_6_7",  kFEC_6_7  },
     160    { "DVBFE_FEC_7_8",  kFEC_7_8  },
     161    { "DVBFE_FEC_8_9",  kFEC_8_9  },
     162    { "DVBFE_FEC_9_10", kFEC_9_10 },
     163    { "DVBFE_FEC_NONE", kFECNone  },
     164    { NULL,             kFECAuto  },
     165#else
    148166    { "FEC_AUTO", kFECAuto },
    149167    { "FEC_1_2",  kFEC_1_2  },
    150168    { "FEC_2_3",  kFEC_2_3  },
     
    156174    { "FEC_8_9",  kFEC_8_9  },
    157175    { "FEC_NONE", kFECNone },
    158176    { NULL,       kFECAuto },
     177#endif
    159178};
    160179
    161180const DTVParamHelperStruct DTVCodeRate::vdrTable[] =
    162181{
    163182    { "999", kFECAuto },
     183    { "14",  kFEC_1_4 },
     184    { "13",  kFEC_1_3 },
     185    { "25",  kFEC_2_5 },
    164186    { "12",  kFEC_1_2 },
     187    { "35",  kFEC_3_5 },
    165188    { "23",  kFEC_2_3 },
    166189    { "34",  kFEC_3_4 },
    167190    { "45",  kFEC_4_5 },
     
    169192    { "67",  kFEC_6_7 },
    170193    { "78",  kFEC_7_8 },
    171194    { "89",  kFEC_8_9 },
     195    { "910", kFEC_9_10 },
    172196    { "0",   kFECNone },
    173197    { NULL,  kFECAuto }
    174198};
     
    176200const DTVParamHelperStruct DTVCodeRate::parseTable[] =
    177201{
    178202    { "auto", kFECAuto },
     203    { "1/4",  kFEC_1_4 },
     204    { "1/3",  kFEC_1_3 },
     205    { "2/5",  kFEC_2_5 },
    179206    { "1/2",  kFEC_1_2 },
     207    { "3/5",  kFEC_3_5 },
    180208    { "2/3",  kFEC_2_3 },
    181209    { "3/4",  kFEC_3_4 },
    182210    { "4/5",  kFEC_4_5 },
     
    184212    { "6/7",  kFEC_6_7 },
    185213    { "7/8",  kFEC_7_8 },
    186214    { "8/9",  kFEC_8_9 },
     215    { "9/10", kFEC_9_10},
    187216    { "none", kFECNone },
    188217    { NULL,   kFECAuto }
    189218};
     
    191220const char *DTVCodeRate::dbStr[DTVCodeRate::kDBStrCnt] =
    192221{
    193222     "none", ///< kFECNone
     223         "1/4",  ///< kFEC_1_4
     224         "1/3",  ///< kFEC_1_3
     225         "2/5",  ///< kFEC_2_5
    194226     "1/2",  ///< kFEC_1_2
     227         "3/5",  ///< kFEC_3_5
    195228     "2/3",  ///< kFEC_2_3
    196229     "3/4",  ///< kFEC_3_4
    197230     "4/5",  ///< kFEC_4_5
     
    199232     "6/7",  ///< kFEC_6_7
    200233     "7/8",  ///< kFEC_7_8
    201234     "8/9",  ///< kFEC_8_9
    202      "auto"  ///< kFECAuto
     235         "9/10",  ///< kFEC_9_10
     236     "auto",  ///< kFECAuto
    203237};
    204238
    205239const DTVParamHelperStruct DTVModulation::confTable[] =
  • libs/libmythtv/dtvmultiplex.h

     
    1515
    1616// MythTV headers
    1717#include "dtvconfparserhelpers.h"
     18#include "dvbtypes.h"
    1819
    1920class DTVMultiplex
    2021{
  • libs/libmythtv/scanwizardhelpers.h

     
    536536        addSelection("6/7");
    537537        addSelection("7/8");
    538538        addSelection("8/9");
     539#ifdef DVB_API_MULTIPROTO
     540        addSelection("1/4");
     541        addSelection("1/3");
     542        addSelection("2/5");
     543        addSelection("3/5");
     544        addSelection("9/10");
     545#endif
    539546    }
    540547};
    541548
  • libs/libmythtv/dvbchannel.h

     
    100100    int  GetChanID(void) const;
    101101
    102102    void CheckOptions(DTVMultiplex &t) const;
     103#ifdef DVB_API_MULTIPROTO
     104    bool ReadTunerCapabilities(const DTVMultiplex &t);
     105#endif
    103106    bool CheckModulation(DTVModulation modulation) const;
    104107    bool CheckCodeRate(DTVCodeRate rate) const;
    105108
     
    117120    QString           frontend_name;
    118121    DTVTunerType      card_type;
    119122    uint64_t          capabilities;
    120     uint64_t          ext_modulations;
     123        uint64_t          delivery;
    121124    uint64_t          frequency_minimum;
    122125    uint64_t          frequency_maximum;
    123126    uint              symbol_rate_minimum;
  • libs/libmythtv/dvbtypes.h

     
    3939#    define VSB_16        (fe_modulation)(QAM_AUTO+2)
    4040#endif
    4141
    42 #ifdef FE_GET_EXTENDED_INFO
    43   #define dvb_fe_params dvb_frontend_parameters_new
    44 #else
    45   #define dvb_fe_params dvb_frontend_parameters
     42#if (DVB_API_VERSION >= 3 && DVB_API_VERSION_MINOR >= 3)
     43#    define DVB_API_MULTIPROTO
    4644#endif
    4745
    4846class QString;
  • libs/libmythtv/dvbchannel.cpp

     
    1 /*
     1/*   
    22 *  Class DVBChannel
    33 *
    44 * Copyright (C) Kenneth Aafloy 2003
     
    5050
    5151static void drain_dvb_events(int fd);
    5252static bool wait_for_backend(int fd, int timeout_ms);
    53 static struct dvb_fe_params dtvmultiplex_to_dvbparams(
     53static struct dvb_frontend_parameters dtvmultiplex_to_dvbparams(
    5454    DTVTunerType, const DTVMultiplex&);
    5555static DTVMultiplex dvbparams_to_dtvmultiplex(
    56     DTVTunerType, const dvb_fe_params&);
    57 
     56    DTVTunerType, const dvb_frontend_parameters&);
     57#ifdef DVB_API_MULTIPROTO
     58static DTVMultiplex dvbparams_to_dtvmultiplex(const dvbfe_params&);
     59#endif
    5860#define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(cardnum)
    5961#define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \
    6062                 .arg(GetCardID()).arg(cardnum)
    6163#define LOC_ERR QString("DVBChan(%1:%2) Error: ").arg(GetCardID()).arg(cardnum)
    6264
    6365/** \class DVBChannel
    64  *  \brief Provides interface to the tuning hardware when using DVB drivers
     66 *  \brief Provides interface to the tuning hardware when drivers
    6567 *
    6668 *  \bug Only supports single input cards.
    6769 */
     
    168170        frontend_name       = master->frontend_name;
    169171        card_type           = master->card_type;
    170172        capabilities        = master->capabilities;
    171         ext_modulations     = master->ext_modulations;
     173        delivery            = master->delivery;
    172174        frequency_minimum   = master->frequency_minimum;
    173175        frequency_maximum   = master->frequency_maximum;
    174176        symbol_rate_minimum = master->symbol_rate_minimum;
     
    198200        return false;
    199201    }
    200202
     203    VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.")
     204            .arg(cardnum).arg(frontend_name));
     205           
     206#ifdef DVB_API_MULTIPROTO
     207    if (ioctl(fd_frontend, DVBFE_GET_DELSYS, &delivery) < 0)
     208    {
     209        VERBOSE(VB_IMPORTANT, LOC_ERR +
     210                "Failed to get frontend delivery." + ENO);
     211
     212        close(fd_frontend);
     213        fd_frontend = -1;
     214        return false;
     215    }
     216    if (DVBFE_DELSYS_DVBS2 == (delivery & DVBFE_DELSYS_DVBS2)){
     217        card_type = DTVTunerType::kTunerTypeDVB_S2;
     218    } else if (DVBFE_DELSYS_DVBS == (delivery & DVBFE_DELSYS_DVBS)){
     219        card_type = DTVTunerType::kTunerTypeQPSK;
     220    } else {
     221        VERBOSE(VB_IMPORTANT, LOC_ERR +
     222                "Tuner does not support DVB-S/DVB-S2." + ENO);
     223        close(fd_frontend);
     224        fd_frontend = -1;
     225        return false;
     226    }
     227#else
    201228    dvb_frontend_info info;
    202229    bzero(&info, sizeof(info));
    203230    if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0)
     
    209236        fd_frontend = -1;
    210237        return false;
    211238    }
    212 
    213 #ifdef FE_GET_EXTENDED_INFO
    214     if (info.caps & FE_HAS_EXTENDED_INFO)
    215     {
    216         bool ok = true;
    217         dvb_fe_caps_extended extinfo;
    218         bzero(&extinfo, sizeof(extinfo));
    219         if (ioctl(fd_frontend, FE_GET_EXTENDED_INFO, &extinfo) < 0)
    220         {
    221             VERBOSE(VB_IMPORTANT, LOC_ERR +
    222                     "Failed to get frontend extended information." + ENO);
    223 
    224             ok = false;
    225         }
    226 
    227         if (ok && (extinfo.modulations & MOD_8PSK))
    228         {
    229             if (ioctl(fd_frontend, FE_SET_STANDARD, FE_DVB_S2) < 0)
    230             {
    231                 VERBOSE(VB_IMPORTANT, LOC_ERR +
    232                         "Failed to set frontend standard to DVB-S2." + ENO);
    233 
    234                 ok = false;
    235             }
    236             else if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0)
    237             {
    238                 VERBOSE(VB_IMPORTANT, LOC_ERR +
    239                         "Failed to get frontend information." + ENO);
    240 
    241                 ok = false;
    242             }
    243         }
    244 
    245         if (!ok)
    246         {
    247             close(fd_frontend);
    248             fd_frontend = -1;
    249             return false;
    250         }
    251 
    252         ext_modulations   = extinfo.modulations;
    253     }
    254 #endif
    255 
     239    card_type           = info.type;
     240    capabilities        = info.caps;   
    256241    frontend_name       = info.name;
    257     card_type           = info.type;
    258     capabilities        = info.caps;
    259242    frequency_minimum   = info.frequency_min;
    260243    frequency_maximum   = info.frequency_max;
    261244    symbol_rate_minimum = info.symbol_rate_min;
    262245    symbol_rate_maximum = info.symbol_rate_max;
     246#endif
    263247
    264     VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.")
    265             .arg(cardnum).arg(frontend_name));
    266 
    267248    // Turn on the power to the LNB
    268249    if (card_type == DTVTunerType::kTunerTypeQPSK ||
    269250        card_type == DTVTunerType::kTunerTypeDVB_S2)
     
    312293    if (!tuning.FillFromDB(card_type, mplexid))
    313294        return false;
    314295
     296#ifdef DVB_API_MULTIPROTO
     297    if (!ReadTunerCapabilities(tuning)){
     298      VERBOSE(VB_GENERAL, LOC_WARN +
     299                "Unable to read tuner capabilities.");
     300    }
     301#endif
    315302    CheckOptions(tuning);
    316303
    317304    return Tune(tuning, inputname);
     
    402389    SetDTVInfo(atsc_major, atsc_minor, netid, tsid, mpeg_prog_num);
    403390
    404391    // Try to fix any problems with the multiplex
     392#ifdef DVB_API_MULTIPROTO
     393    if (!ReadTunerCapabilities(tuning)){
     394      VERBOSE(VB_GENERAL, LOC_WARN +
     395                "Unable to read tuner capabilities.");
     396    }
     397#endif
    405398    CheckOptions(tuning);
    406399
    407400    if (!Tune(tuning, inputid))
     
    463456 */
    464457void DVBChannel::CheckOptions(DTVMultiplex &tuning) const
    465458{
     459
    466460    if ((tuning.inversion == DTVInversion::kInversionAuto) &&
    467461        !(capabilities & FE_CAN_INVERSION_AUTO))
    468462    {
     
    593587{
    594588    const DTVModulation m = modulation;
    595589    const uint64_t      c = capabilities;
    596 
    597 #ifdef FE_GET_EXTENDED_INFO
    598     if ((c & FE_HAS_EXTENDED_INFO)            &&
    599         (DTVModulation::kModulation8PSK == m) &&
    600         (ext_modulations & DTVModulation::kModulation8PSK))
    601     {
    602         return true;
    603     }
    604 #endif // FE_GET_EXTENDED_INFO
    605 
     590   
    606591    return
    607592        ((DTVModulation::kModulationQPSK    == m) && (c & FE_CAN_QPSK))     ||
    608593        ((DTVModulation::kModulationQAM16   == m) && (c & FE_CAN_QAM_16))   ||
     
    669654                      bool same_input)
    670655{
    671656    QMutexLocker lock(&tune_lock);
    672 
    673657    if (master)
    674658    {
    675659        VERBOSE(VB_CHANNEL, LOC + "tuning on slave channel");
     
    678662    }
    679663
    680664    bool reset = (force_reset || first_tune);
    681     struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
     665    struct dvb_frontend_parameters params = dtvmultiplex_to_dvbparams(card_type, tuning);
    682666
    683     bool is_dvbs = (DTVTunerType::kTunerTypeQPSK   == card_type ||
    684                     DTVTunerType::kTunerTypeDVB_S2 == card_type);
    685 
     667    bool is_dvbs = (DTVTunerType::kTunerTypeQPSK == card_type || DTVTunerType::kTunerTypeDVB_S2 == card_type);
     668   
    686669    bool has_diseqc = (diseqc_tree != NULL);
    687670    if (is_dvbs && !has_diseqc)
    688671    {
     
    701684
    702685        return false;
    703686    }
    704 
    705687    // Remove any events in queue before tuning.
    706688    drain_dvb_events(fd_frontend);
    707689
     
    711693        // configure for new input
    712694        if (!same_input)
    713695            diseqc_settings.Load(inputid);
    714 
    715696        // execute diseqc commands
    716697        if (!diseqc_tree->Execute(diseqc_settings, tuning))
    717698        {
     
    719700                    "Failed to setup DiSEqC devices");
    720701            return false;
    721702        }
    722 
    723703        // retrieve actual intermediate frequency
    724704        DiSEqCDevLNB *lnb = diseqc_tree->FindLNB(diseqc_settings);
    725705        if (!lnb)
     
    752732    // DVB-S is in kHz, other DVB is in Hz
    753733    int     freq_mult = (is_dvbs) ? 1 : 1000;
    754734    QString suffix    = (is_dvbs) ? "kHz" : "Hz";
    755 
     735       
    756736    if (reset || !prev_tuning.IsEqual(card_type, tuning, 500 * freq_mult))
    757737    {
    758738        VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2")
    759739                .arg(params.frequency).arg(suffix));
    760740
    761 #ifdef FE_GET_EXTENDED_INFO
    762         if (card_type == DTVTunerType::kTunerTypeDVB_S2)
    763         {
    764             if (ioctl(fd_frontend, FE_SET_FRONTEND2, &params) < 0)
    765             {
    766                 VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
    767                         "Setting Frontend(2) tuning parameters failed." + ENO);
    768                 return false;
    769             }
     741#ifdef DVB_API_MULTIPROTO
     742    if (card_type == DTVTunerType::kTunerTypeQPSK || card_type == DTVTunerType::kTunerTypeDVB_S2){
     743      struct dvbfe_params fe_params;
     744      struct dvbfe_params fe_cur_params;
     745   
     746      if (ioctl(fd_frontend, DVBFE_GET_PARAMS, &fe_cur_params) < 0)
     747      {
     748        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     749        "Getting frontend tuning parameters failed." + ENO);
     750        return false;
     751      }
     752     
     753      fe_params.frequency               = params.frequency;
     754      fe_params.inversion               = INVERSION_AUTO;
     755      if (tuning.modulation == DTVModulation::kModulation8PSK){
     756        fe_params.delsys.dvbs2.symbol_rate = tuning.symbolrate;
     757        fe_params.delsys.dvbs2.fec         = DVBFE_FEC_AUTO;
     758        fe_params.delsys.dvbs2.modulation  = DVBFE_MOD_8PSK;
     759        fe_params.delivery                 = DVBFE_DELSYS_DVBS2;
     760      } else{
     761        fe_params.delsys.dvbs.symbol_rate  = tuning.symbolrate;
     762        fe_params.delsys.dvbs.fec          = DVBFE_FEC_AUTO;
     763        fe_params.delsys.dvbs.modulation  = DVBFE_MOD_QPSK;
     764        fe_params.delivery                 = DVBFE_DELSYS_DVBS;
     765      }
     766     
     767      if (fe_cur_params.delivery != fe_params.delivery){
     768        if (ioctl(fd_frontend, DVBFE_SET_DELSYS, &fe_params.delivery) < 0){
     769            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     770              "Setting Frontend delivery failed." + ENO);
     771            return false;
    770772        }
    771         else
    772 #endif // FE_GET_EXTENDED_INFO
    773         {
     773      }
     774     
     775      if (ioctl(fd_frontend, DVBFE_SET_PARAMS, &fe_params) < 0){
     776        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     777              "Setting Frontend tuning parameters failed." + ENO);
     778        return false;
     779      }
     780     
     781    }
     782    else
     783#endif
    774784            if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
    775785            {
    776786                VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
    777787                        "Setting Frontend tuning parameters failed." + ENO);
    778788                return false;
    779789            }
    780         }
    781 
    782790        // Extra delay to add for broken DVB drivers
    783791        if (tuning_delay)
    784792            usleep(tuning_delay * 1000);
     
    831839        return false;
    832840    }
    833841
    834     dvb_fe_params params;
     842    dvb_frontend_parameters params;
    835843    return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
    836844}
    837845
     
    845853bool DVBChannel::ProbeTuningParams(DTVMultiplex &tuning) const
    846854{
    847855    QMutexLocker locker(&hw_lock);
     856    uint    mplex;
     857    QString sistandard;
    848858
    849859    if (fd_frontend < 0)
    850860    {
     
    864874        return false;
    865875    }
    866876
    867     dvb_fe_params params;
    868     if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0)
     877#ifdef DVB_API_MULTIPROTO
     878    if (card_type == DTVTunerType::kTunerTypeQPSK || card_type == DTVTunerType::kTunerTypeDVB_S2){
     879      struct dvbfe_params params;
     880      if (ioctl(fd_frontend, DVBFE_GET_PARAMS, &params) < 0){
     881        VERBOSE(VB_IMPORTANT, LOC_ERR +
     882                "Getting Frontend (multiproto) tuning parameters failed." + ENO);
     883
     884        return false;
     885      }
     886      mplex      = tuning.mplex;
     887      sistandard = QDeepCopy<QString>(tuning.sistandard);
     888      tuning     = dvbparams_to_dtvmultiplex(params);
     889    } 
     890    else
     891#endif
    869892    {
     893      struct dvb_frontend_parameters params;
     894      if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0){
    870895        VERBOSE(VB_IMPORTANT, LOC_ERR +
    871896                "Getting Frontend tuning parameters failed." + ENO);
    872897
    873898        return false;
     899      }
     900      mplex      = tuning.mplex;
     901      sistandard = QDeepCopy<QString>(tuning.sistandard);
     902      tuning     = dvbparams_to_dtvmultiplex(card_type, params);
    874903    }
    875 
    876     uint    mplex      = tuning.mplex;
    877     QString sistandard = QDeepCopy<QString>(tuning.sistandard);
    878 
    879     tuning = dvbparams_to_dtvmultiplex(card_type, params);
    880 
    881904    tuning.mplex       = mplex;
    882905    tuning.sistandard  = sistandard;
    883906
     
    10691092    if (ioctl(fd, FE_READ_STATUS, &status) < 0)
    10701093    {
    10711094        VERBOSE(VB_IMPORTANT, QString("dvbchannel.cpp:wait_for_backend: "
    1072                                       "Failed to get status, error: %1")
     1095                                      "Failed to , error: %1")
    10731096                .arg(strerror(errno)));
    10741097        return false;
    10751098    }
     
    10791102    return true;
    10801103}
    10811104
    1082 static struct dvb_fe_params dtvmultiplex_to_dvbparams(
     1105static struct dvb_frontend_parameters dtvmultiplex_to_dvbparams(
    10831106    DTVTunerType tuner_type, const DTVMultiplex &tuning)
    10841107{
    1085     dvb_fe_params params;
     1108    dvb_frontend_parameters params;
    10861109    bzero(&params, sizeof(params));
    10871110
    10881111    params.frequency = tuning.frequency;
    10891112    params.inversion = (fe_spectral_inversion_t) (int) tuning.inversion;
    10901113
    1091     if (DTVTunerType::kTunerTypeQPSK == tuner_type)
     1114    if (DTVTunerType::kTunerTypeQPSK == tuner_type || tuner_type == DTVTunerType::kTunerTypeDVB_S2)
    10921115    {
    10931116        params.u.qpsk.symbol_rate = tuning.symbolrate;
    10941117        params.u.qpsk.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
    10951118    }
    10961119
    1097     if (DTVTunerType::kTunerTypeDVB_S2 == tuner_type)
    1098     {
    1099 #ifdef FE_GET_EXTENDED_INFO
    1100         params.u.qpsk2.symbol_rate = tuning.symbolrate;
    1101         params.u.qpsk2.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
    1102         params.u.qpsk2.modulation  = (fe_modulation_t) (int) tuning.modulation;
    1103 #else // if !FE_GET_EXTENDED_INFO
    1104         VERBOSE(VB_IMPORTANT, "DVBChan Error, MythTV was compiled without "
    1105                 "DVB-S2 headers being present so DVB-S2 tuning will fail.");
    1106 #endif // !FE_GET_EXTENDED_INFO
    1107     }
    1108 
    11091120    if (DTVTunerType::kTunerTypeQAM  == tuner_type)
    11101121    {
    11111122        params.u.qam.symbol_rate  = tuning.symbolrate;
     
    11431154}
    11441155
    11451156static DTVMultiplex dvbparams_to_dtvmultiplex(
    1146     DTVTunerType tuner_type, const dvb_fe_params &params)
     1157    DTVTunerType tuner_type, const dvb_frontend_parameters &params)
    11471158{
    11481159    DTVMultiplex tuning;
    11491160
    11501161    tuning.frequency = params.frequency;
    11511162    tuning.inversion = params.inversion;
    11521163
    1153     if ((DTVTunerType::kTunerTypeQPSK   == tuner_type) ||
    1154         (DTVTunerType::kTunerTypeDVB_S2 == tuner_type))
     1164    if (DTVTunerType::kTunerTypeQPSK   == tuner_type)
    11551165    {
    11561166        tuning.symbolrate     = params.u.qpsk.symbol_rate;
    11571167        tuning.fec            = params.u.qpsk.fec_inner;
     
    11841194
    11851195    return tuning;
    11861196}
     1197
     1198#ifdef DVB_API_MULTIPROTO
     1199
     1200static DTVMultiplex dvbparams_to_dtvmultiplex(const dvbfe_params &params){
     1201   
     1202    DTVMultiplex tuning;
     1203
     1204    tuning.frequency = params.frequency;
     1205    tuning.inversion = params.inversion;
     1206   
     1207    switch(params.delivery){
     1208      case DVBFE_DELSYS_DVBS:
     1209      {
     1210        tuning.symbolrate     = params.delsys.dvbs.symbol_rate;
     1211        tuning.fec            = params.delsys.dvbs.fec;
     1212      } 
     1213        break;
     1214      case DVBFE_DELSYS_DVBS2:
     1215      {
     1216        tuning.symbolrate     = params.delsys.dvbs2.symbol_rate;
     1217        tuning.fec            = params.delsys.dvbs2.fec;
     1218      }
     1219        break; 
     1220    }
     1221    return tuning;
     1222}
     1223
     1224bool DVBChannel::ReadTunerCapabilities(const DTVMultiplex &tuning){
     1225
     1226    enum dvbfe_delsys d;
     1227    switch(tuning.modulation){
     1228      case DTVModulation::kModulation8PSK:
     1229        d = DVBFE_DELSYS_DVBS2;
     1230        break;
     1231      case DTVModulation::kModulationQPSK:
     1232        d = DVBFE_DELSYS_DVBS;
     1233        break;
     1234      default:
     1235        VERBOSE(VB_IMPORTANT, LOC_ERR +
     1236          "Failed to determine frontend delivery.");
     1237        return false;
     1238        break;
     1239    }
     1240   
     1241    struct dvbfe_params params;
     1242    if (ioctl(fd_frontend, DVBFE_GET_PARAMS, &params) < 0) {
     1243      if (ioctl(fd_frontend, DVBFE_SET_DELSYS, &d) < 0){
     1244          VERBOSE(VB_IMPORTANT, LOC_ERR +
     1245        "Failed to set frontend delivery." + ENO);
     1246        return false;
     1247      }
     1248      if (ioctl(fd_frontend, DVBFE_GET_PARAMS, &params) < 0) {
     1249          VERBOSE(VB_IMPORTANT, LOC_ERR +
     1250                QString("Failed to get frontend parameters for DVB-S/S2 frontend (%1)  .").arg(fd_frontend) + ENO);
     1251        return false;
     1252      }
     1253    }
     1254    if (params.delivery != d){
     1255      if (ioctl(fd_frontend, DVBFE_SET_DELSYS, &d) < 0){
     1256        VERBOSE(VB_IMPORTANT, LOC_ERR +
     1257                "Failed to set frontend delivery." + ENO);
     1258        return false;
     1259      }
     1260    }
     1261
     1262    struct dvbfe_info info;
     1263    if (ioctl(fd_frontend, DVBFE_GET_INFO, &info) < 0){
     1264        VERBOSE(VB_IMPORTANT, LOC_ERR +
     1265                "Failed to get frontend information for DVB-S frontend." + ENO);
     1266      return false;
     1267    }
     1268   
     1269    capabilities        = FEC_NONE;
     1270   
     1271    dvbfe_modulation m;
     1272    m = info.delsys.dvbs.modulation;
     1273    if (m & DVBFE_MOD_QPSK)    { capabilities |= FE_CAN_QPSK; }
     1274    if (m & DVBFE_MOD_QAM16)   { capabilities |= FE_CAN_QAM_16; }
     1275    if (m & DVBFE_MOD_QAM32)   { capabilities |= FE_CAN_QAM_32; }
     1276    if (m & DVBFE_MOD_QAM64)   { capabilities |= FE_CAN_QAM_64; }
     1277    if (m & DVBFE_MOD_QAM128)  { capabilities |= FE_CAN_QAM_128; }
     1278    if (m & DVBFE_MOD_QAM256)  { capabilities |= FE_CAN_QAM_256; }
     1279    if (m & DVBFE_MOD_QAMAUTO) { capabilities |= FE_CAN_QAM_AUTO; }
     1280   
     1281    dvbfe_fec f;
     1282    f = info.delsys.dvbs.fec;
     1283    if (f & DVBFE_FEC_1_2)  { capabilities |= FE_CAN_FEC_1_2; }
     1284    if (f & DVBFE_FEC_2_3)  { capabilities |= FE_CAN_FEC_2_3; }
     1285    if (f & DVBFE_FEC_3_4)  { capabilities |= FE_CAN_FEC_3_4; }
     1286    if (f & DVBFE_FEC_4_5)  { capabilities |= FE_CAN_FEC_4_5; }
     1287    if (f & DVBFE_FEC_5_6)  { capabilities |= FE_CAN_FEC_5_6; }
     1288    if (f & DVBFE_FEC_6_7)  { capabilities |= FE_CAN_FEC_6_7; }
     1289    if (f & DVBFE_FEC_7_8)  { capabilities |= FE_CAN_FEC_7_8; }
     1290    if (f & DVBFE_FEC_8_9)  { capabilities |= FE_CAN_FEC_8_9; }
     1291    if (f & DVBFE_FEC_AUTO) { capabilities |= FE_CAN_FEC_AUTO;}
     1292   
     1293    fe_spectral_inversion_t i;
     1294    i = info.inversion;
     1295    if ((i & INVERSION_AUTO) || i == 0) { capabilities |= FE_CAN_INVERSION_AUTO; }
     1296   
     1297    frontend_name       = info.name;
     1298    frequency_minimum   = info.frequency_min;
     1299    frequency_maximum   = info.frequency_max;
     1300    symbol_rate_minimum = info.symbol_rate_min;
     1301    symbol_rate_maximum = info.symbol_rate_max;
     1302   
     1303    return true;
     1304}
     1305#endif
  • libs/libmythtv/transporteditor.cpp

     
    3838#include "cardutil.h"
    3939#include "mythcontext.h"
    4040#include "mythdbcon.h"
     41#include "dvbtypes.h"
    4142
    4243#define LOC QString("DTVMux: ")
    4344#define LOC_ERR QString("DTVMux, Error: ")
     
    505506    if (CardUtil::QPSK == nType)
    506507    {
    507508        // no modulation options
    508         setVisible(false);
     509        //setVisible(false);
     510                addSelection("QPSK",   "qpsk");
     511                addSelection("8PSK",   "8psk");
    509512    }
    510513    else if ((CardUtil::QAM == nType) || (CardUtil::OFDM == nType))
    511514    {
     
    582585        addSelection("6/7");
    583586        addSelection("7/8");
    584587        addSelection("8/9");
     588#ifdef DVB_API_MULTIPROTO
     589        addSelection("1/4");
     590        addSelection("1/3");
     591        addSelection("2/5");
     592        addSelection("3/5");
     593        addSelection("9/10");
     594#endif
    585595    };
    586596};
    587597
     
    710720        left->addChild(new DTVStandard(id, true, false));
    711721        left->addChild(new Frequency(id, true));
    712722        left->addChild(new DVBSymbolRate(id));
     723                left->addChild(new Modulation(id, nType));
    713724
    714725        right = new VerticalConfigurationGroup(false, true, false, false);
    715726        right->addChild(new DVBInversion(id));
  • libs/libmythtv/dtvmultiplex.cpp

     
    180180
    181181    if (ok)
    182182        frequency = _frequency.toInt(&ok);
    183 
     183               
    184184    return ok;
    185185}
    186186