Index: libs/libmythtv/dtvconfparserhelpers.h =================================================================== --- libs/libmythtv/dtvconfparserhelpers.h (revision 17447) +++ libs/libmythtv/dtvconfparserhelpers.h (working copy) @@ -33,6 +33,7 @@ #define _DTVCONFPARSERHELPERS_H_ #include +#include "dvbtypes.h" // The following are a set of helper classes to allow easy translation // between the different string representations of various tuning params. @@ -191,14 +192,23 @@ static const DTVParamHelperStruct confTable[]; static const DTVParamHelperStruct vdrTable[]; static const DTVParamHelperStruct parseTable[]; +#ifdef DVB_API_MULTIPROTO + static const uint kDBStrCnt = 15; +#else static const uint kDBStrCnt = 10; +#endif static const char *dbStr[kDBStrCnt]; public: enum { +#ifdef DVB_API_MULTIPROTO kFECNone, + kFEC_1_4, + kFEC_1_3, + kFEC_2_5, kFEC_1_2, + kFEC_3_5, kFEC_2_3, kFEC_3_4, kFEC_4_5, @@ -206,7 +216,20 @@ kFEC_6_7, kFEC_7_8, kFEC_8_9, + kFEC_9_10, kFECAuto, +#else + kFECNone, + kFEC_1_2, + kFEC_2_3, + kFEC_3_4, + kFEC_4_5, + kFEC_5_6, + kFEC_6_7, + kFEC_7_8, + kFEC_8_9, + kFECAuto, +#endif }; DTVCodeRate(int _default = kFECAuto) : DTVParamHelper(_default) { } Index: libs/libmythtv/dtvconfparserhelpers.cpp =================================================================== --- libs/libmythtv/dtvconfparserhelpers.cpp (revision 17447) +++ libs/libmythtv/dtvconfparserhelpers.cpp (working copy) @@ -145,6 +145,24 @@ const DTVParamHelperStruct DTVCodeRate::confTable[] = { +#ifdef DVB_API_MULTIPROTO + { "DVBFE_FEC_AUTO", kFECAuto }, + { "DVBFE_FEC_1_4", kFEC_1_4 }, + { "DVBFE_FEC_1_3", kFEC_1_3 }, + { "DVBFE_FEC_2_5", kFEC_2_5 }, + { "DVBFE_FEC_1_2", kFEC_1_2 }, + { "DVBFE_FEC_3_5", kFEC_3_5 }, + { "DVBFE_FEC_2_3", kFEC_2_3 }, + { "DVBFE_FEC_3_4", kFEC_3_4 }, + { "DVBFE_FEC_4_5", kFEC_4_5 }, + { "DVBFE_FEC_5_6", kFEC_5_6 }, + { "DVBFE_FEC_6_7", kFEC_6_7 }, + { "DVBFE_FEC_7_8", kFEC_7_8 }, + { "DVBFE_FEC_8_9", kFEC_8_9 }, + { "DVBFE_FEC_9_10", kFEC_9_10 }, + { "DVBFE_FEC_NONE", kFECNone }, + { NULL, kFECAuto }, +#else { "FEC_AUTO", kFECAuto }, { "FEC_1_2", kFEC_1_2 }, { "FEC_2_3", kFEC_2_3 }, @@ -156,12 +174,17 @@ { "FEC_8_9", kFEC_8_9 }, { "FEC_NONE", kFECNone }, { NULL, kFECAuto }, +#endif }; const DTVParamHelperStruct DTVCodeRate::vdrTable[] = { { "999", kFECAuto }, + { "14", kFEC_1_4 }, + { "13", kFEC_1_3 }, + { "25", kFEC_2_5 }, { "12", kFEC_1_2 }, + { "35", kFEC_3_5 }, { "23", kFEC_2_3 }, { "34", kFEC_3_4 }, { "45", kFEC_4_5 }, @@ -169,6 +192,7 @@ { "67", kFEC_6_7 }, { "78", kFEC_7_8 }, { "89", kFEC_8_9 }, + { "910", kFEC_9_10 }, { "0", kFECNone }, { NULL, kFECAuto } }; @@ -176,7 +200,11 @@ const DTVParamHelperStruct DTVCodeRate::parseTable[] = { { "auto", kFECAuto }, + { "1/4", kFEC_1_4 }, + { "1/3", kFEC_1_3 }, + { "2/5", kFEC_2_5 }, { "1/2", kFEC_1_2 }, + { "3/5", kFEC_3_5 }, { "2/3", kFEC_2_3 }, { "3/4", kFEC_3_4 }, { "4/5", kFEC_4_5 }, @@ -184,6 +212,7 @@ { "6/7", kFEC_6_7 }, { "7/8", kFEC_7_8 }, { "8/9", kFEC_8_9 }, + { "9/10", kFEC_9_10}, { "none", kFECNone }, { NULL, kFECAuto } }; @@ -191,7 +220,11 @@ const char *DTVCodeRate::dbStr[DTVCodeRate::kDBStrCnt] = { "none", ///< kFECNone + "1/4", ///< kFEC_1_4 + "1/3", ///< kFEC_1_3 + "2/5", ///< kFEC_2_5 "1/2", ///< kFEC_1_2 + "3/5", ///< kFEC_3_5 "2/3", ///< kFEC_2_3 "3/4", ///< kFEC_3_4 "4/5", ///< kFEC_4_5 @@ -199,7 +232,8 @@ "6/7", ///< kFEC_6_7 "7/8", ///< kFEC_7_8 "8/9", ///< kFEC_8_9 - "auto" ///< kFECAuto + "9/10", ///< kFEC_9_10 + "auto", ///< kFECAuto }; const DTVParamHelperStruct DTVModulation::confTable[] = Index: libs/libmythtv/dtvmultiplex.h =================================================================== --- libs/libmythtv/dtvmultiplex.h (revision 17447) +++ libs/libmythtv/dtvmultiplex.h (working copy) @@ -15,6 +15,7 @@ // MythTV headers #include "dtvconfparserhelpers.h" +#include "dvbtypes.h" class DTVMultiplex { Index: libs/libmythtv/scanwizardhelpers.h =================================================================== --- libs/libmythtv/scanwizardhelpers.h (revision 17447) +++ libs/libmythtv/scanwizardhelpers.h (working copy) @@ -536,6 +536,13 @@ addSelection("6/7"); addSelection("7/8"); addSelection("8/9"); +#ifdef DVB_API_MULTIPROTO + addSelection("1/4"); + addSelection("1/3"); + addSelection("2/5"); + addSelection("3/5"); + addSelection("9/10"); +#endif } }; Index: libs/libmythtv/dvbchannel.h =================================================================== --- libs/libmythtv/dvbchannel.h (revision 17447) +++ libs/libmythtv/dvbchannel.h (working copy) @@ -100,6 +100,9 @@ int GetChanID(void) const; void CheckOptions(DTVMultiplex &t) const; +#ifdef DVB_API_MULTIPROTO + bool ReadTunerCapabilities(const DTVMultiplex &t); +#endif bool CheckModulation(DTVModulation modulation) const; bool CheckCodeRate(DTVCodeRate rate) const; @@ -117,7 +120,7 @@ QString frontend_name; DTVTunerType card_type; uint64_t capabilities; - uint64_t ext_modulations; + uint64_t delivery; uint64_t frequency_minimum; uint64_t frequency_maximum; uint symbol_rate_minimum; Index: libs/libmythtv/dvbtypes.h =================================================================== --- libs/libmythtv/dvbtypes.h (revision 17447) +++ libs/libmythtv/dvbtypes.h (working copy) @@ -39,10 +39,8 @@ # define VSB_16 (fe_modulation)(QAM_AUTO+2) #endif -#ifdef FE_GET_EXTENDED_INFO - #define dvb_fe_params dvb_frontend_parameters_new -#else - #define dvb_fe_params dvb_frontend_parameters +#if (DVB_API_VERSION >= 3 && DVB_API_VERSION_MINOR >= 3) +# define DVB_API_MULTIPROTO #endif class QString; Index: libs/libmythtv/dvbchannel.cpp =================================================================== --- libs/libmythtv/dvbchannel.cpp (revision 17447) +++ libs/libmythtv/dvbchannel.cpp (working copy) @@ -1,4 +1,4 @@ -/* +/* * Class DVBChannel * * Copyright (C) Kenneth Aafloy 2003 @@ -50,18 +50,20 @@ static void drain_dvb_events(int fd); static bool wait_for_backend(int fd, int timeout_ms); -static struct dvb_fe_params dtvmultiplex_to_dvbparams( +static struct dvb_frontend_parameters dtvmultiplex_to_dvbparams( DTVTunerType, const DTVMultiplex&); static DTVMultiplex dvbparams_to_dtvmultiplex( - DTVTunerType, const dvb_fe_params&); - + DTVTunerType, const dvb_frontend_parameters&); +#ifdef DVB_API_MULTIPROTO +static DTVMultiplex dvbparams_to_dtvmultiplex(const dvbfe_params&); +#endif #define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(cardnum) #define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \ .arg(GetCardID()).arg(cardnum) #define LOC_ERR QString("DVBChan(%1:%2) Error: ").arg(GetCardID()).arg(cardnum) /** \class DVBChannel - * \brief Provides interface to the tuning hardware when using DVB drivers + * \brief Provides interface to the tuning hardware when drivers * * \bug Only supports single input cards. */ @@ -168,7 +170,7 @@ frontend_name = master->frontend_name; card_type = master->card_type; capabilities = master->capabilities; - ext_modulations = master->ext_modulations; + delivery = master->delivery; frequency_minimum = master->frequency_minimum; frequency_maximum = master->frequency_maximum; symbol_rate_minimum = master->symbol_rate_minimum; @@ -198,6 +200,31 @@ return false; } + VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.") + .arg(cardnum).arg(frontend_name)); + +#ifdef DVB_API_MULTIPROTO + if (ioctl(fd_frontend, DVBFE_GET_DELSYS, &delivery) < 0) + { + VERBOSE(VB_IMPORTANT, LOC_ERR + + "Failed to get frontend delivery." + ENO); + + close(fd_frontend); + fd_frontend = -1; + return false; + } + if (DVBFE_DELSYS_DVBS2 == (delivery & DVBFE_DELSYS_DVBS2)){ + card_type = DTVTunerType::kTunerTypeDVB_S2; + } else if (DVBFE_DELSYS_DVBS == (delivery & DVBFE_DELSYS_DVBS)){ + card_type = DTVTunerType::kTunerTypeQPSK; + } else { + VERBOSE(VB_IMPORTANT, LOC_ERR + + "Tuner does not support DVB-S/DVB-S2." + ENO); + close(fd_frontend); + fd_frontend = -1; + return false; + } +#else dvb_frontend_info info; bzero(&info, sizeof(info)); if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0) @@ -209,61 +236,15 @@ fd_frontend = -1; return false; } - -#ifdef FE_GET_EXTENDED_INFO - if (info.caps & FE_HAS_EXTENDED_INFO) - { - bool ok = true; - dvb_fe_caps_extended extinfo; - bzero(&extinfo, sizeof(extinfo)); - if (ioctl(fd_frontend, FE_GET_EXTENDED_INFO, &extinfo) < 0) - { - VERBOSE(VB_IMPORTANT, LOC_ERR + - "Failed to get frontend extended information." + ENO); - - ok = false; - } - - if (ok && (extinfo.modulations & MOD_8PSK)) - { - if (ioctl(fd_frontend, FE_SET_STANDARD, FE_DVB_S2) < 0) - { - VERBOSE(VB_IMPORTANT, LOC_ERR + - "Failed to set frontend standard to DVB-S2." + ENO); - - ok = false; - } - else if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0) - { - VERBOSE(VB_IMPORTANT, LOC_ERR + - "Failed to get frontend information." + ENO); - - ok = false; - } - } - - if (!ok) - { - close(fd_frontend); - fd_frontend = -1; - return false; - } - - ext_modulations = extinfo.modulations; - } -#endif - + card_type = info.type; + capabilities = info.caps; frontend_name = info.name; - card_type = info.type; - capabilities = info.caps; frequency_minimum = info.frequency_min; frequency_maximum = info.frequency_max; symbol_rate_minimum = info.symbol_rate_min; symbol_rate_maximum = info.symbol_rate_max; +#endif - VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.") - .arg(cardnum).arg(frontend_name)); - // Turn on the power to the LNB if (card_type == DTVTunerType::kTunerTypeQPSK || card_type == DTVTunerType::kTunerTypeDVB_S2) @@ -312,6 +293,12 @@ if (!tuning.FillFromDB(card_type, mplexid)) return false; +#ifdef DVB_API_MULTIPROTO + if (!ReadTunerCapabilities(tuning)){ + VERBOSE(VB_GENERAL, LOC_WARN + + "Unable to read tuner capabilities."); + } +#endif CheckOptions(tuning); return Tune(tuning, inputname); @@ -402,6 +389,12 @@ SetDTVInfo(atsc_major, atsc_minor, netid, tsid, mpeg_prog_num); // Try to fix any problems with the multiplex +#ifdef DVB_API_MULTIPROTO + if (!ReadTunerCapabilities(tuning)){ + VERBOSE(VB_GENERAL, LOC_WARN + + "Unable to read tuner capabilities."); + } +#endif CheckOptions(tuning); if (!Tune(tuning, inputid)) @@ -463,6 +456,7 @@ */ void DVBChannel::CheckOptions(DTVMultiplex &tuning) const { + if ((tuning.inversion == DTVInversion::kInversionAuto) && !(capabilities & FE_CAN_INVERSION_AUTO)) { @@ -593,16 +587,7 @@ { const DTVModulation m = modulation; const uint64_t c = capabilities; - -#ifdef FE_GET_EXTENDED_INFO - if ((c & FE_HAS_EXTENDED_INFO) && - (DTVModulation::kModulation8PSK == m) && - (ext_modulations & DTVModulation::kModulation8PSK)) - { - return true; - } -#endif // FE_GET_EXTENDED_INFO - + return ((DTVModulation::kModulationQPSK == m) && (c & FE_CAN_QPSK)) || ((DTVModulation::kModulationQAM16 == m) && (c & FE_CAN_QAM_16)) || @@ -669,7 +654,6 @@ bool same_input) { QMutexLocker lock(&tune_lock); - if (master) { VERBOSE(VB_CHANNEL, LOC + "tuning on slave channel"); @@ -678,11 +662,10 @@ } bool reset = (force_reset || first_tune); - struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning); + struct dvb_frontend_parameters params = dtvmultiplex_to_dvbparams(card_type, tuning); - bool is_dvbs = (DTVTunerType::kTunerTypeQPSK == card_type || - DTVTunerType::kTunerTypeDVB_S2 == card_type); - + bool is_dvbs = (DTVTunerType::kTunerTypeQPSK == card_type || DTVTunerType::kTunerTypeDVB_S2 == card_type); + bool has_diseqc = (diseqc_tree != NULL); if (is_dvbs && !has_diseqc) { @@ -701,7 +684,6 @@ return false; } - // Remove any events in queue before tuning. drain_dvb_events(fd_frontend); @@ -711,7 +693,6 @@ // configure for new input if (!same_input) diseqc_settings.Load(inputid); - // execute diseqc commands if (!diseqc_tree->Execute(diseqc_settings, tuning)) { @@ -719,7 +700,6 @@ "Failed to setup DiSEqC devices"); return false; } - // retrieve actual intermediate frequency DiSEqCDevLNB *lnb = diseqc_tree->FindLNB(diseqc_settings); if (!lnb) @@ -752,33 +732,61 @@ // DVB-S is in kHz, other DVB is in Hz int freq_mult = (is_dvbs) ? 1 : 1000; QString suffix = (is_dvbs) ? "kHz" : "Hz"; - + if (reset || !prev_tuning.IsEqual(card_type, tuning, 500 * freq_mult)) { VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2") .arg(params.frequency).arg(suffix)); -#ifdef FE_GET_EXTENDED_INFO - if (card_type == DTVTunerType::kTunerTypeDVB_S2) - { - if (ioctl(fd_frontend, FE_SET_FRONTEND2, ¶ms) < 0) - { - VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " + - "Setting Frontend(2) tuning parameters failed." + ENO); - return false; - } +#ifdef DVB_API_MULTIPROTO + if (card_type == DTVTunerType::kTunerTypeQPSK || card_type == DTVTunerType::kTunerTypeDVB_S2){ + struct dvbfe_params fe_params; + struct dvbfe_params fe_cur_params; + + if (ioctl(fd_frontend, DVBFE_GET_PARAMS, &fe_cur_params) < 0) + { + VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " + + "Getting frontend tuning parameters failed." + ENO); + return false; + } + + fe_params.frequency = params.frequency; + fe_params.inversion = INVERSION_AUTO; + if (tuning.modulation == DTVModulation::kModulation8PSK){ + fe_params.delsys.dvbs2.symbol_rate = tuning.symbolrate; + fe_params.delsys.dvbs2.fec = DVBFE_FEC_AUTO; + fe_params.delsys.dvbs2.modulation = DVBFE_MOD_8PSK; + fe_params.delivery = DVBFE_DELSYS_DVBS2; + } else{ + fe_params.delsys.dvbs.symbol_rate = tuning.symbolrate; + fe_params.delsys.dvbs.fec = DVBFE_FEC_AUTO; + fe_params.delsys.dvbs.modulation = DVBFE_MOD_QPSK; + fe_params.delivery = DVBFE_DELSYS_DVBS; + } + + if (fe_cur_params.delivery != fe_params.delivery){ + if (ioctl(fd_frontend, DVBFE_SET_DELSYS, &fe_params.delivery) < 0){ + VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " + + "Setting Frontend delivery failed." + ENO); + return false; } - else -#endif // FE_GET_EXTENDED_INFO - { + } + + if (ioctl(fd_frontend, DVBFE_SET_PARAMS, &fe_params) < 0){ + VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " + + "Setting Frontend tuning parameters failed." + ENO); + return false; + } + + } + else +#endif if (ioctl(fd_frontend, FE_SET_FRONTEND, ¶ms) < 0) { VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " + "Setting Frontend tuning parameters failed." + ENO); return false; } - } - // Extra delay to add for broken DVB drivers if (tuning_delay) usleep(tuning_delay * 1000); @@ -831,7 +839,7 @@ return false; } - dvb_fe_params params; + dvb_frontend_parameters params; return ioctl(fd_frontend, FE_GET_FRONTEND, ¶ms) >= 0; } @@ -845,6 +853,8 @@ bool DVBChannel::ProbeTuningParams(DTVMultiplex &tuning) const { QMutexLocker locker(&hw_lock); + uint mplex; + QString sistandard; if (fd_frontend < 0) { @@ -864,20 +874,33 @@ return false; } - dvb_fe_params params; - if (ioctl(fd_frontend, FE_GET_FRONTEND, ¶ms) < 0) +#ifdef DVB_API_MULTIPROTO + if (card_type == DTVTunerType::kTunerTypeQPSK || card_type == DTVTunerType::kTunerTypeDVB_S2){ + struct dvbfe_params params; + if (ioctl(fd_frontend, DVBFE_GET_PARAMS, ¶ms) < 0){ + VERBOSE(VB_IMPORTANT, LOC_ERR + + "Getting Frontend (multiproto) tuning parameters failed." + ENO); + + return false; + } + mplex = tuning.mplex; + sistandard = QDeepCopy(tuning.sistandard); + tuning = dvbparams_to_dtvmultiplex(params); + } + else +#endif { + struct dvb_frontend_parameters params; + if (ioctl(fd_frontend, FE_GET_FRONTEND, ¶ms) < 0){ VERBOSE(VB_IMPORTANT, LOC_ERR + "Getting Frontend tuning parameters failed." + ENO); return false; + } + mplex = tuning.mplex; + sistandard = QDeepCopy(tuning.sistandard); + tuning = dvbparams_to_dtvmultiplex(card_type, params); } - - uint mplex = tuning.mplex; - QString sistandard = QDeepCopy(tuning.sistandard); - - tuning = dvbparams_to_dtvmultiplex(card_type, params); - tuning.mplex = mplex; tuning.sistandard = sistandard; @@ -1069,7 +1092,7 @@ if (ioctl(fd, FE_READ_STATUS, &status) < 0) { VERBOSE(VB_IMPORTANT, QString("dvbchannel.cpp:wait_for_backend: " - "Failed to get status, error: %1") + "Failed to , error: %1") .arg(strerror(errno))); return false; } @@ -1079,33 +1102,21 @@ return true; } -static struct dvb_fe_params dtvmultiplex_to_dvbparams( +static struct dvb_frontend_parameters dtvmultiplex_to_dvbparams( DTVTunerType tuner_type, const DTVMultiplex &tuning) { - dvb_fe_params params; + dvb_frontend_parameters params; bzero(¶ms, sizeof(params)); params.frequency = tuning.frequency; params.inversion = (fe_spectral_inversion_t) (int) tuning.inversion; - if (DTVTunerType::kTunerTypeQPSK == tuner_type) + if (DTVTunerType::kTunerTypeQPSK == tuner_type || tuner_type == DTVTunerType::kTunerTypeDVB_S2) { params.u.qpsk.symbol_rate = tuning.symbolrate; params.u.qpsk.fec_inner = (fe_code_rate_t) (int) tuning.fec; } - if (DTVTunerType::kTunerTypeDVB_S2 == tuner_type) - { -#ifdef FE_GET_EXTENDED_INFO - params.u.qpsk2.symbol_rate = tuning.symbolrate; - params.u.qpsk2.fec_inner = (fe_code_rate_t) (int) tuning.fec; - params.u.qpsk2.modulation = (fe_modulation_t) (int) tuning.modulation; -#else // if !FE_GET_EXTENDED_INFO - VERBOSE(VB_IMPORTANT, "DVBChan Error, MythTV was compiled without " - "DVB-S2 headers being present so DVB-S2 tuning will fail."); -#endif // !FE_GET_EXTENDED_INFO - } - if (DTVTunerType::kTunerTypeQAM == tuner_type) { params.u.qam.symbol_rate = tuning.symbolrate; @@ -1143,15 +1154,14 @@ } static DTVMultiplex dvbparams_to_dtvmultiplex( - DTVTunerType tuner_type, const dvb_fe_params ¶ms) + DTVTunerType tuner_type, const dvb_frontend_parameters ¶ms) { DTVMultiplex tuning; tuning.frequency = params.frequency; tuning.inversion = params.inversion; - if ((DTVTunerType::kTunerTypeQPSK == tuner_type) || - (DTVTunerType::kTunerTypeDVB_S2 == tuner_type)) + if (DTVTunerType::kTunerTypeQPSK == tuner_type) { tuning.symbolrate = params.u.qpsk.symbol_rate; tuning.fec = params.u.qpsk.fec_inner; @@ -1184,3 +1194,112 @@ return tuning; } + +#ifdef DVB_API_MULTIPROTO + +static DTVMultiplex dvbparams_to_dtvmultiplex(const dvbfe_params ¶ms){ + + DTVMultiplex tuning; + + tuning.frequency = params.frequency; + tuning.inversion = params.inversion; + + switch(params.delivery){ + case DVBFE_DELSYS_DVBS: + { + tuning.symbolrate = params.delsys.dvbs.symbol_rate; + tuning.fec = params.delsys.dvbs.fec; + } + break; + case DVBFE_DELSYS_DVBS2: + { + tuning.symbolrate = params.delsys.dvbs2.symbol_rate; + tuning.fec = params.delsys.dvbs2.fec; + } + break; + } + return tuning; +} + +bool DVBChannel::ReadTunerCapabilities(const DTVMultiplex &tuning){ + + enum dvbfe_delsys d; + switch(tuning.modulation){ + case DTVModulation::kModulation8PSK: + d = DVBFE_DELSYS_DVBS2; + break; + case DTVModulation::kModulationQPSK: + d = DVBFE_DELSYS_DVBS; + break; + default: + VERBOSE(VB_IMPORTANT, LOC_ERR + + "Failed to determine frontend delivery."); + return false; + break; + } + + struct dvbfe_params params; + if (ioctl(fd_frontend, DVBFE_GET_PARAMS, ¶ms) < 0) { + if (ioctl(fd_frontend, DVBFE_SET_DELSYS, &d) < 0){ + VERBOSE(VB_IMPORTANT, LOC_ERR + + "Failed to set frontend delivery." + ENO); + return false; + } + if (ioctl(fd_frontend, DVBFE_GET_PARAMS, ¶ms) < 0) { + VERBOSE(VB_IMPORTANT, LOC_ERR + + QString("Failed to get frontend parameters for DVB-S/S2 frontend (%1) .").arg(fd_frontend) + ENO); + return false; + } + } + if (params.delivery != d){ + if (ioctl(fd_frontend, DVBFE_SET_DELSYS, &d) < 0){ + VERBOSE(VB_IMPORTANT, LOC_ERR + + "Failed to set frontend delivery." + ENO); + return false; + } + } + + struct dvbfe_info info; + if (ioctl(fd_frontend, DVBFE_GET_INFO, &info) < 0){ + VERBOSE(VB_IMPORTANT, LOC_ERR + + "Failed to get frontend information for DVB-S frontend." + ENO); + return false; + } + + capabilities = FEC_NONE; + + dvbfe_modulation m; + m = info.delsys.dvbs.modulation; + if (m & DVBFE_MOD_QPSK) { capabilities |= FE_CAN_QPSK; } + if (m & DVBFE_MOD_QAM16) { capabilities |= FE_CAN_QAM_16; } + if (m & DVBFE_MOD_QAM32) { capabilities |= FE_CAN_QAM_32; } + if (m & DVBFE_MOD_QAM64) { capabilities |= FE_CAN_QAM_64; } + if (m & DVBFE_MOD_QAM128) { capabilities |= FE_CAN_QAM_128; } + if (m & DVBFE_MOD_QAM256) { capabilities |= FE_CAN_QAM_256; } + if (m & DVBFE_MOD_QAMAUTO) { capabilities |= FE_CAN_QAM_AUTO; } + + dvbfe_fec f; + f = info.delsys.dvbs.fec; + if (f & DVBFE_FEC_1_2) { capabilities |= FE_CAN_FEC_1_2; } + if (f & DVBFE_FEC_2_3) { capabilities |= FE_CAN_FEC_2_3; } + if (f & DVBFE_FEC_3_4) { capabilities |= FE_CAN_FEC_3_4; } + if (f & DVBFE_FEC_4_5) { capabilities |= FE_CAN_FEC_4_5; } + if (f & DVBFE_FEC_5_6) { capabilities |= FE_CAN_FEC_5_6; } + if (f & DVBFE_FEC_6_7) { capabilities |= FE_CAN_FEC_6_7; } + if (f & DVBFE_FEC_7_8) { capabilities |= FE_CAN_FEC_7_8; } + if (f & DVBFE_FEC_8_9) { capabilities |= FE_CAN_FEC_8_9; } + if (f & DVBFE_FEC_AUTO) { capabilities |= FE_CAN_FEC_AUTO;} + + fe_spectral_inversion_t i; + i = info.inversion; + if ((i & INVERSION_AUTO) || i == 0) { capabilities |= FE_CAN_INVERSION_AUTO; } + + frontend_name = info.name; + frequency_minimum = info.frequency_min; + frequency_maximum = info.frequency_max; + symbol_rate_minimum = info.symbol_rate_min; + symbol_rate_maximum = info.symbol_rate_max; + + return true; +} +#endif Index: libs/libmythtv/transporteditor.cpp =================================================================== --- libs/libmythtv/transporteditor.cpp (revision 17447) +++ libs/libmythtv/transporteditor.cpp (working copy) @@ -38,6 +38,7 @@ #include "cardutil.h" #include "mythcontext.h" #include "mythdbcon.h" +#include "dvbtypes.h" #define LOC QString("DTVMux: ") #define LOC_ERR QString("DTVMux, Error: ") @@ -505,7 +506,9 @@ if (CardUtil::QPSK == nType) { // no modulation options - setVisible(false); + //setVisible(false); + addSelection("QPSK", "qpsk"); + addSelection("8PSK", "8psk"); } else if ((CardUtil::QAM == nType) || (CardUtil::OFDM == nType)) { @@ -582,6 +585,13 @@ addSelection("6/7"); addSelection("7/8"); addSelection("8/9"); +#ifdef DVB_API_MULTIPROTO + addSelection("1/4"); + addSelection("1/3"); + addSelection("2/5"); + addSelection("3/5"); + addSelection("9/10"); +#endif }; }; @@ -710,6 +720,7 @@ left->addChild(new DTVStandard(id, true, false)); left->addChild(new Frequency(id, true)); left->addChild(new DVBSymbolRate(id)); + left->addChild(new Modulation(id, nType)); right = new VerticalConfigurationGroup(false, true, false, false); right->addChild(new DVBInversion(id)); Index: libs/libmythtv/dtvmultiplex.cpp =================================================================== --- libs/libmythtv/dtvmultiplex.cpp (revision 17447) +++ libs/libmythtv/dtvmultiplex.cpp (working copy) @@ -180,7 +180,7 @@ if (ok) frequency = _frequency.toInt(&ok); - + return ok; }