Ticket #5403: mythtv_multiproto.patch

File mythtv_multiproto.patch, 22.4 KB (added by wagabunda, 12 years ago)
  • 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

     
    117117    QString           frontend_name;
    118118    DTVTunerType      card_type;
    119119    uint64_t          capabilities;
    120     uint64_t          ext_modulations;
     120        uint64_t          delivery;
    121121    uint64_t          frequency_minimum;
    122122    uint64_t          frequency_maximum;
    123123    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;
     
    197199
    198200        return false;
    199201    }
     202   
     203#ifdef DVB_API_MULTIPROTO
     204    enum dvbfe_delsys d;
     205   
     206    if (ioctl(fd_frontend, DVBFE_GET_DELSYS, &d) < 0)
     207    {
     208        VERBOSE(VB_IMPORTANT, LOC_ERR +
     209                "Failed to get frontend delivery." + ENO);
    200210
     211        close(fd_frontend);
     212        fd_frontend = -1;
     213        return false;
     214    }
     215   
     216    if (d == (d & DVBFE_DELSYS_DVBS2)){
     217        d = DVBFE_DELSYS_DVBS2;
     218        card_type = DTVTunerType::kTunerTypeDVB_S2;
     219    } else if ( d == (d & DVBFE_DELSYS_DVBS)){
     220        d = DVBFE_DELSYS_DVBS;
     221        card_type = DTVTunerType::kTunerTypeQPSK;
     222    } else {
     223        VERBOSE(VB_IMPORTANT, LOC_ERR +
     224                "Tuner not support DVB-S/DVB-S2." + ENO);
     225        close(fd_frontend);
     226        fd_frontend = -1;
     227        return false;
     228    }
     229   
     230    if (ioctl(fd_frontend, DVBFE_SET_DELSYS, &d) < 0)
     231    {
     232        VERBOSE(VB_IMPORTANT, LOC_ERR +
     233                "Failed to set frontend delivery." + ENO);
     234        close(fd_frontend);
     235        fd_frontend = -1;
     236        return false;
     237    }
     238   
     239    dvbfe_info info;
     240    if (ioctl(fd_frontend, DVBFE_GET_INFO, &info) < 0)
     241    {
     242        VERBOSE(VB_IMPORTANT, LOC_ERR +
     243                "Failed to get frontend information for DVB-S frontend." + ENO);
     244        close(fd_frontend);
     245        fd_frontend = -1;
     246        return false;
     247    }
     248   
     249    capabilities        = FEC_NONE;
     250   
     251    dvbfe_modulation m;
     252    m = info.delsys.dvbs.modulation;
     253   
     254    if (m & DVBFE_MOD_QPSK)    { capabilities |= FE_CAN_QPSK; }
     255    if (m & DVBFE_MOD_QAM16)   { capabilities |= FE_CAN_QAM_16; }
     256    if (m & DVBFE_MOD_QAM32)   { capabilities |= FE_CAN_QAM_32; }
     257    if (m & DVBFE_MOD_QAM64)   { capabilities |= FE_CAN_QAM_64; }
     258    if (m & DVBFE_MOD_QAM128)  { capabilities |= FE_CAN_QAM_128; }
     259    if (m & DVBFE_MOD_QAM256)  { capabilities |= FE_CAN_QAM_256; }
     260    if (m & DVBFE_MOD_QAMAUTO) { capabilities |= FE_CAN_QAM_AUTO; }
     261   
     262    dvbfe_fec f;
     263    f = info.delsys.dvbs.fec;
     264
     265    if (f & DVBFE_FEC_1_2)  { capabilities |= FE_CAN_FEC_1_2; }
     266    if (f & DVBFE_FEC_2_3)  { capabilities |= FE_CAN_FEC_2_3; }
     267    if (f & DVBFE_FEC_3_4)  { capabilities |= FE_CAN_FEC_3_4; }
     268    if (f & DVBFE_FEC_4_5)  { capabilities |= FE_CAN_FEC_4_5; }
     269    if (f & DVBFE_FEC_5_6)  { capabilities |= FE_CAN_FEC_5_6; }
     270    if (f & DVBFE_FEC_6_7)  { capabilities |= FE_CAN_FEC_6_7; }
     271    if (f & DVBFE_FEC_7_8)  { capabilities |= FE_CAN_FEC_7_8; }
     272    if (f & DVBFE_FEC_8_9)  { capabilities |= FE_CAN_FEC_8_9; }
     273    if (f & DVBFE_FEC_AUTO) { capabilities |= FE_CAN_FEC_AUTO;}
     274   
     275    fe_spectral_inversion_t i;
     276    i = info.inversion;
     277    if (i & INVERSION_AUTO) { capabilities |= FE_CAN_INVERSION_AUTO; }
     278       
     279#else // DVB_API_MULTIPROTO
     280
    201281    dvb_frontend_info info;
    202282    bzero(&info, sizeof(info));
    203283    if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0)
     
    209289        fd_frontend = -1;
    210290        return false;
    211291    }
     292    card_type           = info.type;
     293    capabilities        = info.caps;   
    212294
    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     }
    254295#endif
    255296
    256297    frontend_name       = info.name;
    257     card_type           = info.type;
    258     capabilities        = info.caps;
    259298    frequency_minimum   = info.frequency_min;
    260299    frequency_maximum   = info.frequency_max;
    261300    symbol_rate_minimum = info.symbol_rate_min;
     
    593632{
    594633    const DTVModulation m = modulation;
    595634    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 
     635   
    606636    return
    607637        ((DTVModulation::kModulationQPSK    == m) && (c & FE_CAN_QPSK))     ||
    608638        ((DTVModulation::kModulationQAM16   == m) && (c & FE_CAN_QAM_16))   ||
     
    669699                      bool same_input)
    670700{
    671701    QMutexLocker lock(&tune_lock);
    672 
    673702    if (master)
    674703    {
    675704        VERBOSE(VB_CHANNEL, LOC + "tuning on slave channel");
     
    678707    }
    679708
    680709    bool reset = (force_reset || first_tune);
    681     struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
     710    struct dvb_frontend_parameters params = dtvmultiplex_to_dvbparams(card_type, tuning);
    682711
    683     bool is_dvbs = (DTVTunerType::kTunerTypeQPSK   == card_type ||
    684                     DTVTunerType::kTunerTypeDVB_S2 == card_type);
    685 
     712    bool is_dvbs = (DTVTunerType::kTunerTypeQPSK == card_type || DTVTunerType::kTunerTypeDVB_S2 == card_type);
     713   
    686714    bool has_diseqc = (diseqc_tree != NULL);
    687715    if (is_dvbs && !has_diseqc)
    688716    {
     
    701729
    702730        return false;
    703731    }
    704 
    705732    // Remove any events in queue before tuning.
    706733    drain_dvb_events(fd_frontend);
    707734
     
    711738        // configure for new input
    712739        if (!same_input)
    713740            diseqc_settings.Load(inputid);
    714 
    715741        // execute diseqc commands
    716742        if (!diseqc_tree->Execute(diseqc_settings, tuning))
    717743        {
     
    719745                    "Failed to setup DiSEqC devices");
    720746            return false;
    721747        }
    722 
    723748        // retrieve actual intermediate frequency
    724749        DiSEqCDevLNB *lnb = diseqc_tree->FindLNB(diseqc_settings);
    725750        if (!lnb)
     
    758783        VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2")
    759784                .arg(params.frequency).arg(suffix));
    760785
    761 #ifdef FE_GET_EXTENDED_INFO
    762         if (card_type == DTVTunerType::kTunerTypeDVB_S2)
    763         {
     786#ifdef DVB_API_MULTIPROTO
     787    VERBOSE(VB_GENERAL, LOC_ERR + QString("modulation: %1/%2").arg(tuning.modulation).arg(DTVModulation::kModulation8PSK));
     788           
     789    if (card_type == DTVTunerType::kTunerTypeQPSK || card_type == DTVTunerType::kTunerTypeDVB_S2){
     790      struct dvbfe_params fe_params;
     791      struct dvbfe_params fe_cur_params;
     792   
     793      if (ioctl(fd_frontend, DVBFE_GET_PARAMS, &fe_cur_params) < 0)
     794      {
     795        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     796        "Getting frontend tuning parameters failed." + ENO);
     797        return false;
     798      }
     799     VERBOSE(VB_GENERAL, LOC_ERR + QString("current parameters: frequency: %1, delivery: %2").arg(fe_cur_params.frequency).arg(fe_cur_params.delivery)); 
     800     
     801      fe_params.frequency               = params.frequency;
     802      fe_params.inversion               = INVERSION_AUTO;
     803      if (tuning.modulation == DTVModulation::kModulation8PSK){
     804        fe_params.delsys.dvbs2.symbol_rate = tuning.symbolrate;
     805        fe_params.delsys.dvbs2.fec         = DVBFE_FEC_AUTO;
     806        fe_params.delsys.dvbs2.modulation  = DVBFE_MOD_8PSK;
     807        fe_params.delivery                 = DVBFE_DELSYS_DVBS2;
     808      } else{
     809        fe_params.delsys.dvbs.symbol_rate  = tuning.symbolrate;
     810        fe_params.delsys.dvbs.fec          = DVBFE_FEC_AUTO;
     811        fe_params.delsys.dvbs.modulation  = DVBFE_MOD_QPSK;
     812        fe_params.delivery                 = DVBFE_DELSYS_DVBS;
     813      }
     814     
     815      if (fe_cur_params.delivery != fe_params.delivery){
     816        if (ioctl(fd_frontend, DVBFE_SET_DELSYS, &fe_params.delivery) < 0){
     817            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     818              "Setting Frontend delivery failed." + ENO);
     819            return false;
     820        }
     821      }
     822     
     823      if (ioctl(fd_frontend, DVBFE_SET_PARAMS, &fe_params) < 0){
     824        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
     825              "Setting Frontend tuning parameters failed." + ENO);
     826        return false;
     827      }
     828     
     829    }
     830    else
     831#endif
    764832            if (ioctl(fd_frontend, FE_SET_FRONTEND2, &params) < 0)
    765833            {
    766834                VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
    767835                        "Setting Frontend(2) tuning parameters failed." + ENO);
    768836                return false;
    769837            }
    770         }
    771         else
    772 #endif // FE_GET_EXTENDED_INFO
    773         {
    774             if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
    775             {
    776                 VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
    777                         "Setting Frontend tuning parameters failed." + ENO);
    778                 return false;
    779             }
    780         }
    781 
    782838        // Extra delay to add for broken DVB drivers
    783839        if (tuning_delay)
    784840            usleep(tuning_delay * 1000);
     
    831887        return false;
    832888    }
    833889
    834     dvb_fe_params params;
     890    dvb_frontend_parameters params;
    835891    return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
    836892}
    837893
     
    864920        return false;
    865921    }
    866922
    867     dvb_fe_params params;
    868     if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0)
     923#ifdef DVB_API_MULTIPROTO
     924
     925    uint    mplex;
     926    QString sistandard;
     927    if (card_type == DTVTunerType::kTunerTypeQPSK || card_type == DTVTunerType::kTunerTypeDVB_S2){
     928      struct dvbfe_params params;
     929      if (ioctl(fd_frontend, DVBFE_GET_PARAMS, &params) < 0){
     930        VERBOSE(VB_IMPORTANT, LOC_ERR +
     931                "Getting Frontend (multiproto) tuning parameters failed." + ENO);
     932
     933        return false;
     934      }
     935      mplex      = tuning.mplex;
     936      sistandard = QDeepCopy<QString>(tuning.sistandard);
     937      tuning     = dvbparams_to_dtvmultiplex(params);
     938    } 
     939    else
     940#endif
    869941    {
     942      struct dvb_frontend_parameters params;
     943      if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0){
    870944        VERBOSE(VB_IMPORTANT, LOC_ERR +
    871945                "Getting Frontend tuning parameters failed." + ENO);
    872946
    873947        return false;
     948      }
     949      mplex      = tuning.mplex;
     950      sistandard = QDeepCopy<QString>(tuning.sistandard);
     951      tuning     = dvbparams_to_dtvmultiplex(card_type, params);
    874952    }
    875 
    876     uint    mplex      = tuning.mplex;
    877     QString sistandard = QDeepCopy<QString>(tuning.sistandard);
    878 
    879     tuning = dvbparams_to_dtvmultiplex(card_type, params);
    880 
    881953    tuning.mplex       = mplex;
    882954    tuning.sistandard  = sistandard;
    883955
     
    10791151    return true;
    10801152}
    10811153
    1082 static struct dvb_fe_params dtvmultiplex_to_dvbparams(
     1154static struct dvb_frontend_parameters dtvmultiplex_to_dvbparams(
    10831155    DTVTunerType tuner_type, const DTVMultiplex &tuning)
    10841156{
    1085     dvb_fe_params params;
     1157    dvb_frontend_parameters params;
    10861158    bzero(&params, sizeof(params));
    10871159
    10881160    params.frequency = tuning.frequency;
    10891161    params.inversion = (fe_spectral_inversion_t) (int) tuning.inversion;
    10901162
    1091     if (DTVTunerType::kTunerTypeQPSK == tuner_type)
     1163    if (DTVTunerType::kTunerTypeQPSK == tuner_type || tuner_type == DTVTunerType::kTunerTypeDVB_S2)
    10921164    {
    10931165        params.u.qpsk.symbol_rate = tuning.symbolrate;
    10941166        params.u.qpsk.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
    10951167    }
    10961168
    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 
    11091169    if (DTVTunerType::kTunerTypeQAM  == tuner_type)
    11101170    {
    11111171        params.u.qam.symbol_rate  = tuning.symbolrate;
     
    11431203}
    11441204
    11451205static DTVMultiplex dvbparams_to_dtvmultiplex(
    1146     DTVTunerType tuner_type, const dvb_fe_params &params)
     1206    DTVTunerType tuner_type, const dvb_frontend_parameters &params)
    11471207{
    11481208    DTVMultiplex tuning;
    11491209
    11501210    tuning.frequency = params.frequency;
    11511211    tuning.inversion = params.inversion;
    11521212
    1153     if ((DTVTunerType::kTunerTypeQPSK   == tuner_type) ||
    1154         (DTVTunerType::kTunerTypeDVB_S2 == tuner_type))
     1213    if (DTVTunerType::kTunerTypeQPSK   == tuner_type)
    11551214    {
    11561215        tuning.symbolrate     = params.u.qpsk.symbol_rate;
    11571216        tuning.fec            = params.u.qpsk.fec_inner;
     
    11841243
    11851244    return tuning;
    11861245}
     1246
     1247#ifdef DVB_API_MULTIPROTO
     1248
     1249static DTVMultiplex dvbparams_to_dtvmultiplex(const dvbfe_params &params){
     1250   
     1251    DTVMultiplex tuning;
     1252
     1253    tuning.frequency = params.frequency;
     1254    tuning.inversion = params.inversion;
     1255   
     1256    switch(params.delivery){
     1257      case DVBFE_DELSYS_DVBS:
     1258      {
     1259        tuning.symbolrate     = params.delsys.dvbs.symbol_rate;
     1260        tuning.fec            = params.delsys.dvbs.fec;
     1261      } 
     1262        break;
     1263      case DVBFE_DELSYS_DVBS2:
     1264      {
     1265        tuning.symbolrate     = params.delsys.dvbs2.symbol_rate;
     1266        tuning.fec            = params.delsys.dvbs2.fec;
     1267      }
     1268        break; 
     1269    }
     1270    return tuning;
     1271}
     1272#endif
  • libs/libmythtv/transporteditor.cpp

     
    505505    if (CardUtil::QPSK == nType)
    506506    {
    507507        // no modulation options
    508         setVisible(false);
     508        //setVisible(false);
     509                addSelection("QPSK",   "qpsk");
     510                addSelection("8PSK",   "8psk");
    509511    }
    510512    else if ((CardUtil::QAM == nType) || (CardUtil::OFDM == nType))
    511513    {
     
    582584        addSelection("6/7");
    583585        addSelection("7/8");
    584586        addSelection("8/9");
     587#ifdef DVB_API_MULTIPROTO
     588                addSelection("1/4");
     589        addSelection("1/3");
     590        addSelection("2/5");
     591        addSelection("3/5");
     592                addSelection("9/10");
     593#endif
    585594    };
    586595};
    587596
     
    710719        left->addChild(new DTVStandard(id, true, false));
    711720        left->addChild(new Frequency(id, true));
    712721        left->addChild(new DVBSymbolRate(id));
     722                left->addChild(new Modulation(id, nType));
    713723
    714724        right = new VerticalConfigurationGroup(false, true, false, false);
    715725        right->addChild(new DVBInversion(id));