code.vuplus.com Git - vuplus_openvuplus_3.0/blob - meta-bsp/recipes-vuplus/enigma2/enigma2/enigma2_vuplus_mis_pls.patch

   1 diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp
   2 index ca435464..b2d21f42 100755
   3 --- a/lib/dvb/db.cpp
   4 +++ b/lib/dvb/db.cpp
   5 @@ -378,11 +378,17 @@ void eDVBDB::loadServicelist(const char *file)
   6                                         system=eDVBFrontendParametersSatellite::System_DVB_S,
   7                                         modulation=eDVBFrontendParametersSatellite::Modulation_QPSK,
   8                                         rolloff=eDVBFrontendParametersSatellite::RollOff_alpha_0_35,
   9 -                                       pilot=eDVBFrontendParametersSatellite::Pilot_Unknown;
  10 +                                       pilot=eDVBFrontendParametersSatellite::Pilot_Unknown,
  11 +                                       is_id = NO_STREAM_ID_FILTER,
  12 +                                       pls_code = 0,
  13 +                                       pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;
  14                                 if (version == 3)
  15                                         sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &system, &modulation, &rolloff, &pilot);
  16                                 else
  17 -                                       sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &flags, &system, &modulation, &rolloff, &pilot);
  18 +                                       sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
  19 +                                               &frequency, &symbol_rate, &polarisation, &fec, &orbital_position,
  20 +                                               &inversion, &flags, &system, &modulation, &rolloff, &pilot,
  21 +                                               &is_id, &pls_code, &pls_mode);
  22                                 sat.frequency = frequency;
  23                                 sat.symbol_rate = symbol_rate;
  24                                 sat.polarisation = polarisation;
  25 @@ -394,6 +400,9 @@ void eDVBDB::loadServicelist(const char *file)
  26                                 sat.modulation = modulation;
  27                                 sat.rolloff = rolloff;
  28                                 sat.pilot = pilot;
  29 +                               sat.is_id = is_id;
  30 +                               sat.pls_mode = pls_mode & 3;
  31 +                               sat.pls_code = pls_code & 0x3FFFF;
  32                                 feparm->setDVBS(sat);
  33                                 feparm->setFlags(flags);
  34                         } else if (line[1]=='t')
  35 @@ -512,27 +521,23 @@ void eDVBDB::saveServicelist(const char *file)
  36                 ch.m_frontendParameters->getFlags(flags);
  37                 if (!ch.m_frontendParameters->getDVBS(sat))
  38                 {
  39 +                       fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d",
  40 +                               sat.frequency, sat.symbol_rate, sat.polarisation, sat.fec,
  41 +                               sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
  42 +                               sat.inversion, flags);
  43 +
  44                         if ((sat.system == eDVBFrontendParametersSatellite::System_DVB_S2) || (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2X))
  45                         {
  46 -                               fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n",
  47 -                                       sat.frequency, sat.symbol_rate,
  48 -                                       sat.polarisation, sat.fec,
  49 -                                       sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
  50 -                                       sat.inversion,
  51 -                                       flags,
  52 -                                       sat.system,
  53 -                                       sat.modulation,
  54 -                                       sat.rolloff,
  55 -                                       sat.pilot);
  56 -                       }
  57 -                       else
  58 -                       {
  59 -                               fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d\n",
  60 -                                       sat.frequency, sat.symbol_rate,
  61 -                                       sat.polarisation, sat.fec,
  62 -                                       sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
  63 -                                       sat.inversion, flags);
  64 +                               fprintf(f, ":%d:%d:%d:%d", sat.system, sat.modulation, sat.rolloff, sat.pilot);
  65 +
  66 +                               if (static_cast<unsigned int>(sat.is_id) != NO_STREAM_ID_FILTER ||
  67 +                                       (sat.pls_code & 0x3FFFF) != 0 ||
  68 +                                       (sat.pls_mode & 3) != eDVBFrontendParametersSatellite::PLS_Unknown)
  69 +                               {
  70 +                                       fprintf(f, ":%d:%d:%d", sat.is_id, sat.pls_code & 0x3FFFF, sat.pls_mode & 3);
  71 +                               }
  72                         }
  73 +                       fprintf(f, "\n");
  74                 }
  75                 else if (!ch.m_frontendParameters->getDVBT(ter))
  76                 {
  77 @@ -792,7 +797,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
  78                 return Py_False;
  79         }
  80         int tmp, *dest = NULL,
  81 -               modulation, system, freq, sr, pol, fec, inv, pilot, rolloff, tsid, onid;
  82 +               modulation, system, freq, sr, pol, fec, inv, pilot, rolloff, is_id, pls_code, pls_mode, tsid, onid;
  83         char *end_ptr;
  84         const Attribute *at;
  85         std::string name;
  86 @@ -857,6 +862,9 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
  87                                 inv = eDVBFrontendParametersSatellite::Inversion_Unknown;
  88                                 pilot = eDVBFrontendParametersSatellite::Pilot_Unknown;
  89                                 rolloff = eDVBFrontendParametersSatellite::RollOff_alpha_0_35;
  90 +                               is_id = NO_STREAM_ID_FILTER;
  91 +                               pls_code = 0;
  92 +                               pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;
  93                                 tsid = -1;
  94                                 onid = -1;
  95
  96 @@ -874,6 +882,9 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
  97                                         else if (name == "inversion") dest = &inv;
  98                                         else if (name == "rolloff") dest = &rolloff;
  99                                         else if (name == "pilot") dest = &pilot;
 100 +                                       else if (name == "is_id") dest = &is_id;
 101 +                                       else if (name == "pls_code") dest = &pls_code;
 102 +                                       else if (name == "pls_mode") dest = &pls_mode;
 103                                         else if (name == "tsid") dest = &tsid;
 104                                         else if (name == "onid") dest = &onid;
 105                                         else continue;
 106 @@ -887,7 +898,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
 107                                 }
 108                                 if (freq && sr && pol != -1)
 109                                 {
 110 -                                       tuple = PyTuple_New(12);
 111 +                                       tuple = PyTuple_New(15);
 112                                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0));
 113                                         PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(freq));
 114                                         PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(sr));
 115 @@ -898,8 +909,11 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
 116                                         PyTuple_SET_ITEM(tuple, 7, PyInt_FromLong(inv));
 117                                         PyTuple_SET_ITEM(tuple, 8, PyInt_FromLong(rolloff));
 118                                         PyTuple_SET_ITEM(tuple, 9, PyInt_FromLong(pilot));
 119 -                                       PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(tsid));
 120 -                                       PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(onid));
 121 +                                       PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(is_id));
 122 +                                       PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(pls_mode & 3));
 123 +                                       PyTuple_SET_ITEM(tuple, 12, PyInt_FromLong(pls_code & 0x3FFFF));
 124 +                                       PyTuple_SET_ITEM(tuple, 13, PyInt_FromLong(tsid));
 125 +                                       PyTuple_SET_ITEM(tuple, 14, PyInt_FromLong(onid));
 126                                         PyList_Append(tplist, tuple);
 127                                         Py_DECREF(tuple);
 128                                 }
 129 diff --git a/lib/dvb/dvb.cpp b/lib/dvb/dvb.cpp
 130 index 67c3aa98..5ebf10c2 100644
 131 --- a/lib/dvb/dvb.cpp
 132 +++ b/lib/dvb/dvb.cpp
 133 @@ -447,6 +447,18 @@ bool eDVBResourceManager::frontendIsCompatible(int index, const char *type)
 134         return false;
 135  }
 136
 137 +bool eDVBResourceManager::frontendIsMultistream(int index)
 138 +{
 139 +       for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
 140 +       {
 141 +               if (i->m_frontend->getSlotID() == index)
 142 +               {
 143 +                       return i->m_frontend->is_multistream();
 144 +               }
 145 +       }
 146 +       return false;
 147 +}
 148 +
 149  void eDVBResourceManager::setFrontendType(int index, const char *type)
 150  {
 151         eDebug("[eDVBResourceManager::setFrontendType] index : %d, type : %s", index, type);
 152 diff --git a/lib/dvb/dvb.h b/lib/dvb/dvb.h
 153 index 3e9fc7fd..f470fe13 100644
 154 --- a/lib/dvb/dvb.h
 155 +++ b/lib/dvb/dvb.h
 156 @@ -224,6 +224,7 @@ public:
 157         SWIG_VOID(RESULT) allocateRawChannel(eUsePtr<iDVBChannel> &SWIG_OUTPUT, int slot_index);
 158         PyObject *setFrontendSlotInformations(SWIG_PYOBJECT(ePyObject) list);
 159         bool frontendIsCompatible(int index, const char *type);
 160 +       bool frontendIsMultistream(int index);
 161         void setFrontendType(int index, const char *type);
 162  };
 163  SWIG_TEMPLATE_TYPEDEF(ePtr<eDVBResourceManager>, eDVBResourceManager);
 164 diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
 165 index a2eb0e82..bde90f8c 100755
 166 --- a/lib/dvb/frontend.cpp
 167 +++ b/lib/dvb/frontend.cpp
 168 @@ -129,12 +129,15 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto
 169                 orbital_position = 3600 - orbital_position;
 170         system = descriptor.getModulationSystem();
 171         modulation = descriptor.getModulation();
 172 -       if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation == eDVBFrontendParametersSatellite::Modulation_8PSK)
 173 +       if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation != eDVBFrontendParametersSatellite::Modulation_QPSK)
 174         {
 175                 eDebug("satellite_delivery_descriptor non valid modulation type.. force QPSK");
 176                 modulation=eDVBFrontendParametersSatellite::Modulation_QPSK;
 177         }
 178         rolloff = descriptor.getRollOff();
 179 +       is_id = NO_STREAM_ID_FILTER;
 180 +       pls_mode = eDVBFrontendParametersSatellite::PLS_Unknown;
 181 +       pls_code = 0;
 182         if (system == eDVBFrontendParametersSatellite::System_DVB_S)
 183         {
 184                 eDebug("SAT DVB-S freq %d, %s, pos %d, sr %d, fec %d",
 185 @@ -145,13 +148,16 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto
 186         }
 187         else // System_DVB_S2 or System_DVB_S2X
 188         {
 189 -               eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d",
 190 +               eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d, is_id %d, pls_mode %d, pls_code %d",
 191                         frequency,
 192                         polarisation ? "hor" : "vert",
 193                         orbital_position,
 194                         symbol_rate, fec,
 195                         modulation,
 196 -                       rolloff);
 197 +                       rolloff,
 198 +                       is_id,
 199 +                       pls_mode,
 200 +                       pls_code);
 201         }
 202  }
 203
 204 @@ -323,6 +329,12 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
 205                         diff = 1<<29;
 206                 else if (sat.polarisation != osat.polarisation)
 207                         diff = 1<<28;
 208 +               else if (sat.is_id != osat.is_id)
 209 +                       diff = 1<<27;
 210 +               else if (sat.pls_mode != osat.pls_mode)
 211 +                       diff = 1<<27;
 212 +               else if (sat.pls_code != osat.pls_code)
 213 +                       diff = 1<<27;
 214                 else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC_Auto && osat.fec != eDVBFrontendParametersSatellite::FEC_Auto)
 215                         diff = 1<<27;
 216                 else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto)
 217 @@ -494,7 +506,6 @@ int eDVBFrontend::openFrontend()
 218         m_state=stateIdle;
 219         m_tuning=0;
 220
 221 -       dvb_frontend_info fe_info;
 222         if (!m_simulate)
 223         {
 224                 eDebug("opening frontend %d", m_dvbid);
 225 @@ -512,6 +523,13 @@ int eDVBFrontend::openFrontend()
 226
 227                 if (m_delsys.empty())
 228                 {
 229 +                       if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
 230 +                       {
 231 +                               eWarning("ioctl FE_GET_INFO failed");
 232 +                               ::close(m_fd);
 233 +                               m_fd = -1;
 234 +                               return -1;
 235 +                       }
 236  #ifdef DTV_ENUM_DELSYS
 237                         struct dtv_property p[1];
 238                         p[0].cmd = DTV_ENUM_DELSYS;
 239 @@ -528,48 +546,46 @@ int eDVBFrontend::openFrontend()
 240                                         m_delsys[delsys] = true;
 241                                 }
 242                         }
 243 +                       else
 244  #else
 245 -                       if (::ioctl(m_fd, FE_GET_INFO, &fe_info) < 0)
 246 +                       /* no DTV_ENUM_DELSYS support */
 247 +                       if (1)
 248 +#endif
 249                         {
 250 -                               eWarning("ioctl FE_GET_INFO failed");
 251 -                               ::close(m_fd);
 252 -                               m_fd = -1;
 253 -                               return -1;
 254 -                       }
 255                         /* old DVB API, fill delsys map with some defaults */
 256 -                       switch (fe_info.type)
 257 -                       {
 258 -                               case FE_QPSK:
 259 +                               switch (fe_info.type)
 260                                 {
 261 -                                       m_delsys[SYS_DVBS] = true;
 262 +                                       case FE_QPSK:
 263 +                                       {
 264 +                                               m_delsys[SYS_DVBS] = true;
 265  #if DVB_API_VERSION >= 5
 266 -                                       if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBS2] = true;
 267 +                                               if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBS2] = true;
 268  #endif
 269 -                                       break;
 270 -                               }
 271 -                               case FE_QAM:
 272 -                               {
 273 +                                               break;
 274 +                                       }
 275 +                                       case FE_QAM:
 276 +                                       {
 277  #if defined SYS_DVBC_ANNEX_A
 278 -                                       m_delsys[SYS_DVBC_ANNEX_A] = true;
 279 +                                               m_delsys[SYS_DVBC_ANNEX_A] = true;
 280  #else
 281 -                                       m_delsys[SYS_DVBC_ANNEX_AC] = true;
 282 +                                               m_delsys[SYS_DVBC_ANNEX_AC] = true;
 283  #endif
 284 -                                       break;
 285 -                               }
 286 -                               case FE_OFDM:
 287 -                               {
 288 -                                       m_delsys[SYS_DVBT] = true;
 289 +                                               break;
 290 +                                       }
 291 +                                       case FE_OFDM:
 292 +                                       {
 293 +                                               m_delsys[SYS_DVBT] = true;
 294  #if DVB_API_VERSION > 5 || DVB_API_VERSION == 5 && DVB_API_VERSION_MINOR >= 3
 295 -                                       if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBT2] = true;
 296 +                                               if (fe_info.caps & FE_CAN_2G_MODULATION) m_delsys[SYS_DVBT2] = true;
 297  #endif
 298 -                                       break;
 299 -                               }
 300 -                               case FE_ATSC:   // placeholder to prevent warning
 301 -                               {
 302 -                                       break;
 303 +                                               break;
 304 +                                       }
 305 +                                       case FE_ATSC:   // placeholder to prevent warning
 306 +                                       {
 307 +                                               break;
 308 +                                       }
 309                                 }
 310                         }
 311 -#endif
 312                 }
 313
 314                 if (m_simulate_fe)
 315 @@ -580,6 +596,26 @@ int eDVBFrontend::openFrontend()
 316                 m_sn = eSocketNotifier::create(eApp, m_fd, eSocketNotifier::Read, false);
 317                 CONNECT(m_sn->activated, eDVBFrontend::feEvent);
 318         }
 319 +       else
 320 +       {
 321 +               fe_info.frequency_min = 900000;
 322 +               fe_info.frequency_max = 2200000;
 323 +
 324 +               eDebug("[eDVBFrontend] opening frontend %d", m_dvbid);
 325 +               int tmp_fd = ::open(m_filename, O_RDONLY | O_NONBLOCK);
 326 +               if (tmp_fd < 0)
 327 +               {
 328 +                       eWarning("[eDVBFrontend] opening %s failed: %m", m_filename);
 329 +               }
 330 +               else
 331 +               {
 332 +                       if (::ioctl(tmp_fd, FE_GET_INFO, &fe_info) < 0)
 333 +                       {
 334 +                               eWarning("[eDVBFrontend] ioctl FE_GET_INFO on frontend %s failed: %m", m_filename);
 335 +                       }
 336 +                       ::close(tmp_fd);
 337 +               }
 338 +       }
 339
 340         setTone(iDVBFrontend::toneOff);
 341         setVoltage(iDVBFrontend::voltageOff);
 342 @@ -1025,6 +1061,9 @@ void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &fe
 343         {
 344                 PutToDict(dict, "rolloff", feparm.rolloff);
 345                 PutToDict(dict, "pilot", feparm.pilot);
 346 +               PutToDict(dict, "is_id", feparm.is_id);
 347 +               PutToDict(dict, "pls_mode", feparm.pls_mode);
 348 +               PutToDict(dict, "pls_code", feparm.pls_code);
 349         }
 350         PutToDict(dict, "system", feparm.system);
 351  }
 352 @@ -1058,7 +1097,7 @@ void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm)
 353         PutToDict(dict, "fec_inner", feparm.fec_inner);
 354  }
 355
 356 -static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, long freq_offset, int orbital_position, int polarization)
 357 +static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, long freq_offset, eDVBFrontendParametersSatellite &feparm)
 358  {
 359         long tmp=0;
 360         int p_system = p[0].u.data;
 361 @@ -1069,12 +1108,13 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo
 362         int p_inner_fec = p[5].u.data;
 363         int p_rolloff = p[6].u.data;
 364         int p_pilot = p[7].u.data;
 365 +       int p_stream_id = p[8].u.data;
 366
 367         int frequency = p_frequency + freq_offset;
 368         PutToDict(dict, "frequency", frequency);
 369         PutToDict(dict, "symbol_rate", p_symbolrate);
 370 -       PutToDict(dict, "orbital_position", orbital_position);
 371 -       PutToDict(dict, "polarization", polarization);
 372 +       PutToDict(dict, "orbital_position", feparm.orbital_position);
 373 +       PutToDict(dict, "polarization", feparm.polarisation);
 374
 375         switch(p_inner_fec)
 376         {
 377 @@ -1121,6 +1161,10 @@ static void fillDictWithSatelliteData(ePyObject dict, struct dtv_property *p, lo
 378                 case PILOT_AUTO: tmp = eDVBFrontendParametersSatellite::Pilot_Unknown; break;
 379                 }
 380                 PutToDict(dict, "pilot", tmp);
 381 +
 382 +               PutToDict(dict, "is_id", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.is_id : (p_stream_id & 0xFF));
 383 +               PutToDict(dict, "pls_mode", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.pls_mode : ((p_stream_id >> 26) & 0x3));
 384 +               PutToDict(dict, "pls_code", ((unsigned int)p_stream_id == NO_STREAM_ID_FILTER) ? feparm.pls_code : ((p_stream_id >> 8) & 0x3FFFF));
 385         }
 386
 387         switch (p_modulation)
 388 @@ -1398,6 +1442,7 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original)
 389                         p[cmdseq.num++].cmd = DTV_INNER_FEC;
 390                         p[cmdseq.num++].cmd = DTV_ROLLOFF;
 391                         p[cmdseq.num++].cmd = DTV_PILOT;
 392 +                       p[cmdseq.num++].cmd = DTV_STREAM_ID;
 393                 }
 394                 else if(type == feCable)
 395                 {
 396 @@ -1457,13 +1502,12 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original)
 397                 }
 398                 else
 399                 {
 400 -                       FRONTENDPARAMETERS &parm = front;
 401                         switch(type)
 402                         {
 403                                 case feSatellite:
 404                                         eDVBFrontendParametersSatellite sparm;
 405                                         oparm.getDVBS(sparm);
 406 -                                       fillDictWithSatelliteData(dest, p, m_data[FREQ_OFFSET], sparm.orbital_position, sparm.polarisation);
 407 +                                       fillDictWithSatelliteData(dest, p, m_data[FREQ_OFFSET], sparm);
 408                                         break;
 409                                 case feCable:
 410                                         fillDictWithCableData(dest, p);
 411 @@ -2004,7 +2048,7 @@ void eDVBFrontend::setFrontend(bool recvEvents)
 412                         case eDVBFrontendParametersSatellite::RollOff_alpha_0_25: rolloff = ROLLOFF_25; break;
 413                         case eDVBFrontendParametersSatellite::RollOff_alpha_0_35: rolloff = ROLLOFF_35; break;
 414                         };
 415 -                       struct dtv_property p[10];
 416 +                       struct dtv_property p[11];
 417                         struct dtv_properties cmdseq;
 418                         cmdseq.props = p;
 419                         p[0].cmd = DTV_CLEAR;
 420 @@ -2018,8 +2062,9 @@ void eDVBFrontend::setFrontend(bool recvEvents)
 421                         {
 422                                 p[7].cmd = DTV_ROLLOFF,         p[7].u.data = rolloff;
 423                                 p[8].cmd = DTV_PILOT,           p[8].u.data = pilot;
 424 -                               p[9].cmd = DTV_TUNE;
 425 -                               cmdseq.num = 10;
 426 +                               p[9].cmd = DTV_STREAM_ID,       p[9].u.data = sparm.is_id | (sparm.pls_code << 8) | (sparm.pls_mode << 26);
 427 +                               p[10].cmd = DTV_TUNE;
 428 +                               cmdseq.num = 11;
 429                         }
 430                         else
 431                         {
 432 @@ -2128,7 +2173,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
 433         res = m_sec->prepare(*this, parm, feparm, 1 << m_slotid, tunetimeout);
 434         if (!res)
 435         {
 436 -               eDebugNoSimulate("prepare_sat Freq %d Pol %d SR %d INV %d FEC %d orbpos %d system %d modulation %d pilot %d, rolloff %d",
 437 +               eDebugNoSimulate("prepare_sat Freq %d Pol %d SR %d INV %d FEC %d orbpos %d system %d modulation %d pilot %d, rolloff %d, is_id %d, pls_mode %d, pls_code %d",
 438                         feparm.frequency,
 439                         feparm.polarisation,
 440                         feparm.symbol_rate,
 441 @@ -2138,7 +2183,10 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
 442                         feparm.system,
 443                         feparm.modulation,
 444                         feparm.pilot,
 445 -                       feparm.rolloff);
 446 +                       feparm.rolloff,
 447 +                       feparm.is_id,
 448 +                       feparm.pls_mode,
 449 +                       feparm.pls_code);
 450                 parm_u_qpsk_symbol_rate = feparm.symbol_rate;
 451                 switch (feparm.inversion)
 452                 {
 453 @@ -2861,12 +2909,23 @@ int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
 454                 {
 455                         return 0;
 456                 }
 457 +               bool multistream = (static_cast<unsigned int>(sat_parm.is_id) != NO_STREAM_ID_FILTER || (sat_parm.pls_code & 0x3FFFF) != 0 ||
 458 +                                       (sat_parm.pls_mode & 3) != eDVBFrontendParametersSatellite::PLS_Unknown);
 459 +               if (((sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2)||(sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2X)) && multistream && !is_multistream())
 460 +               {
 461 +                       return 0;
 462 +               }
 463                 score = m_sec ? m_sec->canTune(sat_parm, this, 1 << m_slotid) : 0;
 464                 if (score > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S && can_handle_dvbs2)
 465                 {
 466                         /* prefer to use a S tuner, try to keep S2 free for S2 transponders */
 467                         score--;
 468                 }
 469 +               if (score > 1 && is_multistream() && !multistream)
 470 +               {
 471 +                       /* prefer to use a non multistream tuner, try to keep multistream tuners free for multistream transponders */
 472 +                       score--;
 473 +               }
 474         }
 475
 476         else if (type == eDVBFrontend::feCable)
 477 @@ -3001,3 +3060,9 @@ arg_error:
 478                 "eDVBFrontend::setSlotInfo must get a tuple with first param slotid, second param slot description and third param enabled boolean");
 479         return false;
 480  }
 481 +
 482 +bool eDVBFrontend::is_multistream()
 483 +{
 484 +       return fe_info.caps & FE_CAN_MULTISTREAM;
 485 +}
 486 +
 487 diff --git a/lib/dvb/frontend.h b/lib/dvb/frontend.h
 488 index 6a8c39d6..39d125a9 100644
 489 --- a/lib/dvb/frontend.h
 490 +++ b/lib/dvb/frontend.h
 491 @@ -87,6 +87,7 @@ private:
 492         std::map<fe_delivery_system_t, bool> m_delsys, m_delsys_whitelist;
 493         char m_filename[128];
 494         char m_description[128];
 495 +       dvb_frontend_info fe_info;
 496         FRONTENDPARAMETERS parm;
 497         eDVBFrontendParameters oparm;
 498
 499 @@ -163,6 +164,7 @@ public:
 500         bool isLoopTimerActive() { return m_tuneTimer->isActive(); }
 501         bool isScheduledSendDiseqc();
 502         void setUSBTuner(bool yesno) { m_is_usbtuner = yesno; }
 503 +       bool is_multistream();
 504  };
 505
 506  #endif // SWIG
 507 diff --git a/lib/dvb/frontendparms.h b/lib/dvb/frontendparms.h
 508 index c941ca69..1d8f2eeb 100644
 509 --- a/lib/dvb/frontendparms.h
 510 +++ b/lib/dvb/frontendparms.h
 511 @@ -45,9 +45,13 @@ struct eDVBFrontendParametersSatellite
 512                 Pilot_Off, Pilot_On, Pilot_Unknown
 513         };
 514
 515 +       enum {
 516 +               PLS_Root, PLS_Gold, PLS_Combo, PLS_Unknown
 517 +       };
 518 +
 519         bool no_rotor_command_on_tune;
 520         unsigned int frequency, symbol_rate;
 521 -       int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot;
 522 +       int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot, is_id, pls_mode, pls_code;
 523  };
 524  SWIG_ALLOW_OUTPUT_SIMPLE(eDVBFrontendParametersSatellite);
 525
 526 diff --git a/lib/python/Components/NimManager.py b/lib/python/Components/NimManager.py
 527 index d726fece..2d524702 100755
 528 --- a/lib/python/Components/NimManager.py
 529 +++ b/lib/python/Components/NimManager.py
 530 @@ -603,7 +603,16 @@ class NIM(object):
 531         # empty tuners are supported!
 532         def isSupported(self):
 533                 return (self.frontend_id is not None) or self.__is_empty
 534 -
 535 +
 536 +       def isMultistream(self):
 537 +               multistream = self.frontend_id is not None and eDVBResourceManager.getInstance().frontendIsMultistream(self.frontend_id) or False
 538 +               # HACK due to poor support for VTUNER_SET_FE_INFO
 539 +               # When vtuner does not accept fe_info we have to fallback to detection using tuner name
 540 +               # More tuner names will be added when confirmed as multistream (FE_CAN_MULTISTREAM)
 541 +               if not multistream and "TBS" in self.description:
 542 +                       multistream = True
 543 +               return multistream
 544 +
 545         # returns dict {<slotid>: <type>}
 546         def getMultiTypeList(self):
 547                 return self.multi_type
 548 diff --git a/lib/python/Components/ServiceScan.py b/lib/python/Components/ServiceScan.py
 549 index 74123861..3a405f23 100644
 550 --- a/lib/python/Components/ServiceScan.py
 551 +++ b/lib/python/Components/ServiceScan.py
 552 @@ -71,6 +71,8 @@ class ServiceScan:
 553                                                                 tp.FEC_13_18 : "13/18", tp.FEC_26_45 : "26/45", tp.FEC_28_45 : "28/45", tp.FEC_7_9 : "7/9", tp.FEC_77_90 : "77/90",
 554                                                                 tp.FEC_32_45 : "32/45", tp.FEC_11_15 : "11/15", tp.FEC_1_2_L : "1/2-L", tp.FEC_8_15_L : "8/15-L", tp.FEC_3_5_L : "3/5-L",
 555                                                                 tp.FEC_2_3_L : "2/3-L", tp.FEC_5_9_L : "5/9-L", tp.FEC_26_45_L : "26/45-L"}.get(tp.fec, tp.FEC_Auto))
 556 +                                               if tp.is_id > -1 and tp.system in (tp.System_DVB_S2, tp.System_DVB_S2X):
 557 +                                                       tp_text = ("%s IS %d") % (tp_text, tp.is_id)
 558                                         elif tp_type == iDVBFrontend.feCable:
 559                                                 network = _("Cable")
 560                                                 tp = transponder.getDVBC()
 561 diff --git a/lib/python/Components/TuneTest.py b/lib/python/Components/TuneTest.py
 562 old mode 100644
 563 new mode 100755
 564 index 44b19091..9fb5143a
 565 --- a/lib/python/Components/TuneTest.py
 566 +++ b/lib/python/Components/TuneTest.py
 567 @@ -5,8 +5,7 @@ class Tuner:
 568                 self.frontend = frontend
 569                 self.ignore_rotor = ignore_rotor
 570
 571 -       # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, system, modulation, rolloff, pilot, tsid, onid)
 572 -       #                    0         1             2         3       4         5       6        7          8       9      10    11
 573 +       # transponder = (0:frequency 1:symbolrate 2:polarisation 3:fec 4:inversion 5:orbpos 6:system 7:modulation 8:rolloff 9:pilot 10:is_id 11:pls_mode 12:pls_code 13:tsid 14:onid)
 574         def tune(self, transponder):
 575                 if self.frontend:
 576                         print "tuning to transponder with data", transponder
 577 @@ -21,6 +20,14 @@ class Tuner:
 578                         parm.modulation = transponder[7]
 579                         parm.rolloff = transponder[8]
 580                         parm.pilot = transponder[9]
 581 +                       if len(transponder) > 12:
 582 +                               parm.is_id = transponder[10]
 583 +                               parm.pls_mode = transponder[11]
 584 +                               parm.pls_code = transponder[12]
 585 +                       else:
 586 +                               parm.is_id = -1
 587 +                               parm.pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
 588 +                               parm.pls_code = 0
 589                         feparm = eDVBFrontendParameters()
 590                         feparm.setDVBS(parm, self.ignore_rotor)
 591                         self.lastparm = feparm
 592 @@ -103,8 +110,8 @@ class TuneTest:
 593                                 pidsFailed = False
 594                                 if self.checkPIDs:
 595                                         if self.currTuned is not None:
 596 -                                               if self.tsid != self.currTuned[10] or self.onid != self.currTuned[11]:
 597 -                                                       self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[10], self.currTuned[11])}, dict])  # last parameter is the frontend status
 598 +                                               if self.tsid != self.currTuned[13] or self.onid != self.currTuned[14]:
 599 +                                                       self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[13], self.currTuned[14])}, dict])  # last parameter is the frontend status
 600                                                         pidsFailed = True
 601                                                 else:
 602                                                         self.successfullyTune.append([self.currTuned, self.oldTuned, dict])  # 3rd parameter is the frontend status
 603 @@ -141,7 +148,7 @@ class TuneTest:
 604                         # check for tsid != -1 and onid != -1
 605                         print "index:", index
 606                         print "len(self.transponderlist):", len(self.transponderlist)
 607 -                       while (index < len(self.transponderlist) and (self.transponderlist[index][10] == -1 or self.transponderlist[index][11] == -1)):
 608 +                       while (index < len(self.transponderlist) and (self.transponderlist[index][13] == -1 or self.transponderlist[index][14] == -1)):
 609                                 index += 1
 610                 print "FirstTransponder final index:", index
 611                 return index
 612 @@ -154,7 +161,7 @@ class TuneTest:
 613                         # check for tsid != -1 and onid != -1
 614                         print "index:", index
 615                         print "len(self.transponderlist):", len(self.transponderlist)
 616 -                       while (index < len(self.transponderlist) and (self.transponderlist[index][10] == -1 or self.transponderlist[index][11] == -1)):
 617 +                       while (index < len(self.transponderlist) and (self.transponderlist[index][13] == -1 or self.transponderlist[index][14] == -1)):
 618                                 index += 1
 619
 620                 print "next transponder index:", index
 621 @@ -204,8 +211,7 @@ class TuneTest:
 622                 self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_START, self.currTuned))
 623                 self.timer.start(100, True)
 624
 625 -       # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, <system>, <modulation>, <rolloff>, <pilot>, <tsid>, <onid>)
 626 -       #                    0         1             2         3       4         5       6        7              8         9        10       11
 627 +       # transponder = (0:frequency 1:symbolrate 2:polarisation 3:fec 4:inversion 5:orbpos 6:system 7:modulation 8:rolloff 9:pilot 10:is_id 11:pls_mode 12:pls_code 13:tsid 14:onid)
 628         def addTransponder(self, transponder):
 629                 self.transponderlist.append(transponder)
 630
 631 diff --git a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py
 632 old mode 100644
 633 new mode 100755
 634 index 5215a4b8..aa80aa2a
 635 --- a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py
 636 +++ b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py
 637 @@ -546,6 +546,9 @@ class Blindscan(ConfigListScreen, Screen):
 638                                                 parm.fec = fec[data[7]]
 639                                                 parm.modulation = qam[data[8]]
 640                                                 parm.rolloff = roll[data[9]]
 641 +                                               parm.is_id = -1
 642 +                                               parm.pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
 643 +                                               parm.pls_code = 0
 644                                                 self.tmp_tplist.append(parm)
 645                                         except: pass
 646                 self.blindscan_session.close(True)
 647 diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py
 648 index 4dcf6c6b..acb2a2da 100644
 649 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py
 650 +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py
 651 @@ -281,7 +281,7 @@ class DiseqcTester(Screen, TuneTest, ResultParser):
 652                 for sat in nimmanager.getSatListForNim(self.feid):
 653                         for transponder in nimmanager.getTransponders(sat[0]):
 654                                 #print transponder
 655 -                               mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11])
 656 +                               mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12], transponder[13], transponder[14])
 657                                 self.analyseTransponder(mytransponder)
 658
 659         def getIndexForTransponder(self, transponder):
 660 diff --git a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py
 661 old mode 100644
 662 new mode 100755
 663 index b94a8819..a9003503
 664 --- a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py
 665 +++ b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py
 666 @@ -10,11 +10,13 @@ from Plugins.Plugin import PluginDescriptor
 667  from Components.Label import Label
 668  from Components.ConfigList import ConfigList
 669  from Components.TunerInfo import TunerInfo
 670 -from Components.ActionMap import ActionMap
 671 +from Components.ActionMap import NumberActionMap, ActionMap
 672  from Components.NimManager import nimmanager
 673  from Components.MenuList import MenuList
 674  from Components.config import ConfigSatlist, ConfigNothing, ConfigSelection, ConfigSubsection, KEY_LEFT, KEY_RIGHT, getConfigListEntry
 675  from Components.TuneTest import Tuner
 676 +from Components.ConfigList import ConfigListScreen
 677 +from Components.config import config, ConfigSubsection, ConfigSelection, ConfigInteger, getConfigListEntry
 678  from Tools.Transponder import ConvertToHumanReadable
 679
 680  from time import sleep
 681 @@ -88,7 +90,10 @@ class PositionerSetup(Screen):
 682                         cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
 683                         cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
 684                         cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
 685 -                       cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))
 686 +                       cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown),
 687 +                       cur.get("is_id", -1),
 688 +                       cur.get("pls_mode", eDVBFrontendParametersSatellite.PLS_Unknown),
 689 +                       cur.get("pls_code", 0))
 690
 691                 self.tuner.tune(tp)
 692                 self.createConfig()
 693 @@ -406,9 +411,7 @@ class Diseqc:
 694                                 sleep(0.05)
 695                                 self.frontend.sendDiseqc(cmd) # send 2nd time
 696
 697 -tuning = None
 698 -
 699 -class TunerScreen(ScanSetup):
 700 +class TunerScreen(ConfigListScreen, Screen):
 701         skin = """
 702                 <screen position="90,100" size="520,400" title="Tune">
 703                         <widget name="config" position="20,10" size="460,350" scrollbarMode="showOnDemand" />
 704 @@ -418,29 +421,40 @@ class TunerScreen(ScanSetup):
 705         def __init__(self, session, feid, fe_data):
 706                 self.feid = feid
 707                 self.fe_data = fe_data
 708 -               ScanSetup.__init__(self, session)
 709 -               self["introduction"].setText("")
 710 +               Screen.__init__(self, session)
 711 +               ConfigListScreen.__init__(self, None)
 712 +               self.createConfig(fe_data)
 713 +               self.createSetup()
 714 +               self.tuning.sat.addNotifier(self.tuningSatChanged)
 715 +               self.tuning.type.addNotifier(self.tuningTypeChanged)
 716 +               self.scan_sat.system.addNotifier(self.systemChanged)
 717 +               self.scan_sat.system_dvbs2x.addNotifier(self.systemChanged)
 718 +               self.scan_sat.is_id_bool.addNotifier(self.isIdChanged, initial_call = False)
 719 +               self.scan_sat.pls_mode.addNotifier(self.plsModeChanged, initial_call = False)
 720 +
 721 +               self["actions"] = NumberActionMap(["SetupActions"],
 722 +               {
 723 +                       "ok": self.keyGo,
 724 +                       "cancel": self.keyCancel,
 725 +               }, -2)
 726 +
 727 +               self["introduction"] = Label(_(" "))
 728
 729         def createSetup(self):
 730 -               self.typeOfTuningEntry = None
 731 -               self.satEntry = None
 732                 self.list = []
 733 -               self.typeOfTuningEntry = getConfigListEntry(_('Tune'), tuning.type)
 734 -               self.list.append(self.typeOfTuningEntry)
 735 -               self.satEntry = getConfigListEntry(_('Satellite'), tuning.sat)
 736 -               self.list.append(self.satEntry)
 737 +               self.list.append(getConfigListEntry(_('Tune'), self.tuning.type) )
 738 +               self.list.append(getConfigListEntry(_('Satellite'), self.tuning.sat)    )
 739 +
 740 +               self.is_id_boolEntry = None
 741 +               self.plsModeEntry = None
 742                 nim = nimmanager.nim_slots[self.feid]
 743 -               self.systemEntry = None
 744 -
 745 -               if tuning.type.value == "manual_transponder":
 746 +               if self.tuning.type.value == "manual_transponder":
 747                         scan_sat_system_value = self.scan_sat.system.value
 748                         if nim.isCompatible("DVB-S2X"):
 749                                 scan_sat_system_value = self.scan_sat.system_dvbs2x.value
 750 -                               self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x)
 751 -                               self.list.append(self.systemEntry)
 752 +                               self.list.append(getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x))
 753                         elif nim.isCompatible("DVB-S2"):
 754 -                               self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
 755 -                               self.list.append(self.systemEntry)
 756 +                               self.list.append(getConfigListEntry(_('System'), self.scan_sat.system))
 757                         else:
 758                                 # downgrade to dvb-s, in case a -s2 config was active
 759                                 self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
 760 @@ -471,44 +485,218 @@ class TunerScreen(ScanSetup):
 761                                 self.list.append(self.modulationEntry)
 762                                 self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
 763                                 self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
 764 -               elif tuning.type.value == "predefined_transponder":
 765 -                       self.list.append(getConfigListEntry(_("Transponder"), tuning.transponder))
 766 +                       if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
 767 +                               if nim.isMultistream():
 768 +                                       self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
 769 +                                       self.list.append(self.is_id_boolEntry)
 770 +                                       if self.scan_sat.is_id_bool.value:
 771 +                                               self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
 772 +                                               self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
 773 +                                               self.list.append(self.plsModeEntry)
 774 +                                               if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
 775 +                                                       self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
 776 +               elif self.tuning.type.value == "predefined_transponder":
 777 +                       self.list.append(getConfigListEntry(_("Transponder"), self.tuning.transponder))
 778                 self["config"].list = self.list
 779                 self["config"].l.setList(self.list)
 780
 781 -       def newConfig(self):
 782 -               cur = self["config"].getCurrent()
 783 -               if cur in (self.typeOfTuningEntry, self.satEntry, self.systemEntry) or \
 784 -                       (self.modulationEntry and (cur == self.modulationEntry) and \
 785 -                       self.systemEntry and (self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2X)):
 786 -                       self.createSetup()
 787 -
 788 -       def createConfig(self, foo):
 789 -               global tuning
 790 -               if not tuning:
 791 -                       tuning = ConfigSubsection()
 792 -                       tuning.type = ConfigSelection(
 793 -                               default = "manual_transponder",
 794 -                               choices = { "manual_transponder" : _("Manual transponder"),
 795 -                                                       "predefined_transponder" : _("Predefined transponder") } )
 796 -                       tuning.sat = ConfigSatlist(list=nimmanager.getRotorSatListForNim(self.feid))
 797 -                       tuning.sat.addNotifier(self.tuningSatChanged)
 798 -                       self.updateTransponders()
 799 +       def createConfig(self, frontendData):
 800 +               satlist = nimmanager.getRotorSatListForNim(self.feid)
 801                 orb_pos = self.fe_data.get("orbital_position", None)
 802 +               self.tuning = ConfigSubsection()
 803 +               self.tuning.type = ConfigSelection(
 804 +                       default = "manual_transponder",
 805 +                       choices = { "manual_transponder" : _("Manual transponder"),
 806 +                                               "predefined_transponder" : _("Predefined transponder") } )
 807 +               self.tuning.sat = ConfigSatlist(list = satlist)
 808                 if orb_pos is not None:
 809 -                       for x in nimmanager.getRotorSatListForNim(self.feid):
 810 +                       for x in satlist:
 811                                 opos = str(orb_pos)
 812 -                               if x[0] == orb_pos and tuning.sat.value != opos:
 813 -                                       tuning.sat.value = opos
 814 +                               if x[0] == orb_pos and self.tuning.sat.value != opos:
 815 +                                       self.tuning.sat.value = opos
 816                         del self.fe_data["orbital_position"]
 817 -               ScanSetup.createConfig(self, self.fe_data)
 818 +
 819 +               self.updateTransponders()
 820 +
 821 +               defaultSat = {
 822 +                       "orbpos": 192,
 823 +                       "system": eDVBFrontendParametersSatellite.System_DVB_S,
 824 +                       "frequency": 11836,
 825 +                       "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
 826 +                       "symbolrate": 27500,
 827 +                       "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
 828 +                       "fec": eDVBFrontendParametersSatellite.FEC_Auto,
 829 +                       "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
 830 +                       "fec_s2x_qpsk": eDVBFrontendParametersSatellite.FEC_13_45,
 831 +                       "fec_s2x_8psk": eDVBFrontendParametersSatellite.FEC_23_36,
 832 +                       "fec_s2x_8apsk": eDVBFrontendParametersSatellite.FEC_5_9_L,
 833 +                       "fec_s2x_16apsk": eDVBFrontendParametersSatellite.FEC_1_2_L,
 834 +                       "fec_s2x_32apsk": eDVBFrontendParametersSatellite.FEC_2_3_L,
 835 +                       "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK,
 836 +                       "modulation_s2x": eDVBFrontendParametersSatellite.Modulation_QPSK,
 837 +                       "is_id": -1,
 838 +                       "pls_mode": eDVBFrontendParametersSatellite.PLS_Unknown,
 839 +                       "pls_code": 0 }
 840 +
 841 +               if frontendData is not None:
 842 +                       ttype = frontendData.get("tuner_type", "UNKNOWN")
 843 +                       defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
 844 +                       defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
 845 +                       defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
 846 +                       defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
 847 +                       defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
 848 +                       defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
 849 +
 850 +                       defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
 851 +                       defaultSat["modulation_s2x"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
 852 +
 853 +                       if defaultSat["modulation"] > eDVBFrontendParametersSatellite.Modulation_8PSK:
 854 +                               defaultSat["modulation"] = eDVBFrontendParametersSatellite.Modulation_8PSK
 855 +
 856 +                       if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
 857 +                               defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
 858 +                       elif defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2X:
 859 +                               if defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_QPSK:
 860 +                                       defaultSat["fec_s2x_qpsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_13_45)
 861 +                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8PSK:
 862 +                                       defaultSat["fec_s2x_8psk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_23_36)
 863 +                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8APSK:
 864 +                                       defaultSat["fec_s2x_8apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_5_9_L)
 865 +                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_16APSK:
 866 +                                       defaultSat["fec_s2x_16apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_1_2_L)
 867 +                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_32APSK:
 868 +                                       defaultSat["fec_s2x_32apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_2_3_L)
 869 +                       else:
 870 +                               defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
 871 +
 872 +                       if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
 873 +                               defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
 874 +                               defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
 875 +                               defaultSat["is_id"] = frontendData.get("is_id", defaultSat["is_id"])
 876 +                               defaultSat["pls_mode"] = frontendData.get("pls_mode", defaultSat["pls_mode"])
 877 +                               defaultSat["pls_code"] = frontendData.get("pls_code", defaultSat["pls_code"])
 878 +
 879 +               self.scan_sat = ConfigSubsection()
 880 +
 881 +               sat_choices = [
 882 +                               (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
 883 +                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]
 884 +
 885 +               sat_choices_dvbs2x = [
 886 +                       (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
 887 +                       (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2")),
 888 +                       (eDVBFrontendParametersSatellite.System_DVB_S2X, _("DVB-S2X"))]
 889 +
 890 +               self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = sat_choices)
 891 +               self.scan_sat.system_dvbs2x = ConfigSelection(default = defaultSat["system"], choices = sat_choices_dvbs2x)
 892 +               self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
 893 +               self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
 894 +                       (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
 895 +                       (eDVBFrontendParametersSatellite.Inversion_On, _("On")),
 896 +                       (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))])
 897 +               self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))
 898 +               self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
 899 +                       (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
 900 +                       (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
 901 +                       (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
 902 +                       (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
 903 +               self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [
 904 +                       (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")),
 905 +                       (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
 906 +                       (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
 907 +                       (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
 908 +                       (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
 909 +                       (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
 910 +                       (eDVBFrontendParametersSatellite.FEC_None, _("None"))])
 911 +               self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [
 912 +                       (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
 913 +                       (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
 914 +                       (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
 915 +                       (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
 916 +                       (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"),
 917 +                       (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
 918 +                       (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
 919 +                       (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
 920 +                       (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
 921 +               self.scan_sat.fec_s2x_qpsk = ConfigSelection(default = defaultSat["fec_s2x_qpsk"], choices = [
 922 +                       (eDVBFrontendParametersSatellite.FEC_13_45, "13/45"),
 923 +                       (eDVBFrontendParametersSatellite.FEC_9_20, "9/20"),
 924 +                       (eDVBFrontendParametersSatellite.FEC_11_20, "11/20")])
 925 +
 926 +               self.scan_sat.fec_s2x_8psk = ConfigSelection(default = defaultSat["fec_s2x_8psk"], choices = [
 927 +                       (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
 928 +                       (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
 929 +                       (eDVBFrontendParametersSatellite.FEC_13_18, "13/28")])
 930 +
 931 +               self.scan_sat.fec_s2x_8apsk = ConfigSelection(default = defaultSat["fec_s2x_8apsk"], choices = [
 932 +                       (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
 933 +                       (eDVBFrontendParametersSatellite.FEC_26_45_L, "26/45-L")])
 934 +
 935 +               self.scan_sat.fec_s2x_16apsk = ConfigSelection(default = defaultSat["fec_s2x_16apsk"], choices = [
 936 +                       (eDVBFrontendParametersSatellite.FEC_1_2_L, "1/2-L"),
 937 +                       (eDVBFrontendParametersSatellite.FEC_8_15_L, "8/15-L"),
 938 +                       (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
 939 +                       (eDVBFrontendParametersSatellite.FEC_26_45, "26/45"),
 940 +                       (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
 941 +                       (eDVBFrontendParametersSatellite.FEC_3_5_L, "3/5-L"),
 942 +                       (eDVBFrontendParametersSatellite.FEC_28_45, "28/45"),
 943 +                       (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
 944 +                       (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
 945 +                       (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
 946 +                       (eDVBFrontendParametersSatellite.FEC_13_18, "13/18"),
 947 +                       (eDVBFrontendParametersSatellite.FEC_7_9, "7/9"),
 948 +                       (eDVBFrontendParametersSatellite.FEC_77_90, "77/90")])
 949 +
 950 +               self.scan_sat.fec_s2x_32apsk = ConfigSelection(default = defaultSat["fec_s2x_32apsk"], choices = [
 951 +                       (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
 952 +                       (eDVBFrontendParametersSatellite.FEC_32_45, "32/45"),
 953 +                       (eDVBFrontendParametersSatellite.FEC_11_15, "11/15"),
 954 +                       (eDVBFrontendParametersSatellite.FEC_7_9, "7/9")])
 955 +               self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
 956 +                       (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
 957 +                       (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
 958 +               self.scan_sat.modulation_dvbs2x = ConfigSelection(default = defaultSat["modulation_s2x"], choices = [
 959 +                       (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
 960 +                       (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK"),
 961 +                       (eDVBFrontendParametersSatellite.Modulation_8APSK, "8APSK"),
 962 +                       (eDVBFrontendParametersSatellite.Modulation_16APSK, "16APSK"),
 963 +                       (eDVBFrontendParametersSatellite.Modulation_32APSK, "32APSK")])
 964 +               self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
 965 +                       (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
 966 +                       (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
 967 +                       (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20")])
 968 +               self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [
 969 +                       (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
 970 +                       (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
 971 +                       (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
 972 +               self.scan_sat.is_id = ConfigInteger(default = defaultSat["is_id"] if defaultSat["is_id"] != -1 else 0, limits = (0, 255))
 973 +               self.scan_sat.is_id_bool = ConfigSelection(default = defaultSat["is_id"] != -1, choices = [(True, _("Multistream")),(False, _("Ordinary"))])
 974 +               self.scan_sat.pls_mode = ConfigSelection(default = defaultSat["pls_mode"], choices = [
 975 +                               (eDVBFrontendParametersSatellite.PLS_Root, _("Root")),
 976 +                               (eDVBFrontendParametersSatellite.PLS_Gold, _("Gold")),
 977 +                               (eDVBFrontendParametersSatellite.PLS_Combo, _("Combo")),
 978 +                               (eDVBFrontendParametersSatellite.PLS_Unknown, _("Auto"))])
 979 +               self.scan_sat.pls_code = ConfigInteger(default = defaultSat["pls_code"], limits = (0, 262143))
 980
 981         def tuningSatChanged(self, *parm):
 982                 self.updateTransponders()
 983 +               self.createSetup()
 984 +
 985 +       def tuningTypeChanged(self, *parm):
 986 +               self.createSetup()
 987 +
 988 +       def systemChanged(self, *parm):
 989 +               self.createSetup()
 990 +
 991 +       def isIdChanged(self, *parm):
 992 +               self.createSetup()
 993 +
 994 +       def plsModeChanged(self, *parm):
 995 +               self.createSetup()
 996
 997         def updateTransponders(self):
 998 -               if len(tuning.sat.choices):
 999 -                       transponderlist = nimmanager.getTransponders(int(tuning.sat.value))
1000 +               if len(self.tuning.sat.choices):
1001 +                       transponderlist = nimmanager.getTransponders(int(self.tuning.sat.value))
1002                         tps = []
1003                         cnt=0
1004                         for x in transponderlist:
1005 @@ -534,13 +722,19 @@ class TunerScreen(ScanSetup):
1006                                 else:
1007                                         fec = fec_desc[x[4]]
1008                                 tps.append(str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec)
1009 -                       tuning.transponder = ConfigSelection(choices=tps)
1010 +                       self.tuning.transponder = ConfigSelection(choices=tps)
1011 +
1012 +       def keyLeft(self):
1013 +               ConfigListScreen.keyLeft(self)
1014 +
1015 +       def keyRight(self):
1016 +               ConfigListScreen.keyRight(self)
1017
1018         def keyGo(self):
1019 -               returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
1020 -               satpos = int(tuning.sat.value)
1021 +               returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 3, 0)
1022 +               satpos = int(self.tuning.sat.value)
1023                 nim = nimmanager.nim_slots[self.feid]
1024 -               if tuning.type.value == "manual_transponder":
1025 +               if self.tuning.type.value == "manual_transponder":
1026                         system = self.scan_sat.system.value
1027                         modulation = self.scan_sat.modulation.value
1028                         if nim.isCompatible("DVB-S2X"):
1029 @@ -563,7 +757,18 @@ class TunerScreen(ScanSetup):
1030                                 elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
1031                                         fec = self.scan_sat.fec_s2x_32apsk.value
1032                         else:
1033 -                               fec = self.scan_sat.fec_s2.value
1034 +                               fec = self.scan_sat.fec.value
1035 +
1036 +                       is_id = -1
1037 +                       pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
1038 +                       pls_code = 0
1039 +                       if self.scan_sat.is_id_bool.value:
1040 +                               is_id = self.scan_sat.is_id.value
1041 +                               pls_mode = self.scan_sat.pls_mode.value
1042 +                               if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
1043 +                                       pls_code = 0
1044 +                               else:
1045 +                                       pls_code = self.scan_sat.pls_code.value
1046
1047                         returnvalue = (
1048                                 self.scan_sat.frequency.value,
1049 @@ -575,11 +780,14 @@ class TunerScreen(ScanSetup):
1050                                 system,
1051                                 modulation,
1052                                 self.scan_sat.rolloff.value,
1053 -                               self.scan_sat.pilot.value)
1054 -               elif tuning.type.value == "predefined_transponder":
1055 -                       transponder = nimmanager.getTransponders(satpos)[tuning.transponder.index]
1056 +                               self.scan_sat.pilot.value,
1057 +                               is_id,
1058 +                               pls_mode,
1059 +                               pls_code)
1060 +               elif self.tuning.type.value == "predefined_transponder":
1061 +                       transponder = nimmanager.getTransponders(satpos)[self.tuning.transponder.index]
1062                         returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
1063 -                               transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
1064 +                               transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12])
1065                 self.close(returnvalue)
1066
1067         def keyCancel(self):
1068 diff --git a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py
1069 old mode 100644
1070 new mode 100755
1071 index a87ca26f..ad1c450b
1072 --- a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py
1073 +++ b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py
1074 @@ -59,17 +59,16 @@ class Satfinder(ScanSetup):
1075         def createSetup(self):
1076                 self.typeOfTuningEntry = None
1077                 self.satEntry = None
1078 -
1079 +               self.systemEntry = None
1080 +               self.is_id_boolEntry = None
1081 +               self.plsModeEntry = None
1082                 self.list = []
1083 -
1084                 self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
1085                 self.list.append(self.typeOfTuningEntry)
1086                 self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
1087                 self.list.append(self.satEntry)
1088
1089                 nim = nimmanager.nim_slots[self.feid]
1090 -
1091 -               self.systemEntry = None
1092                 if self.tuning_type.value == "manual_transponder":
1093                         scan_sat_system_value = self.scan_sat.system.value
1094                         if nim.isCompatible("DVB-S2X"):
1095 @@ -109,6 +108,16 @@ class Satfinder(ScanSetup):
1096                                 self.list.append(self.modulationEntry)
1097                                 self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
1098                                 self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
1099 +                       if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
1100 +                               if nim.isMultistream():
1101 +                                       self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
1102 +                                       self.list.append(self.is_id_boolEntry)
1103 +                                       if self.scan_sat.is_id_bool.value:
1104 +                                               self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
1105 +                                               self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
1106 +                                               self.list.append(self.plsModeEntry)
1107 +                                               if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
1108 +                                                       self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
1109                 elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
1110                         self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
1111                 self["config"].list = self.list
1112 @@ -116,7 +125,7 @@ class Satfinder(ScanSetup):
1113
1114         def newConfig(self):
1115                 cur = self["config"].getCurrent()
1116 -               if cur in (self.typeOfTuningEntry, self.systemEntry):
1117 +               if cur in (self.typeOfTuningEntry, self.systemEntry, self.is_id_boolEntry, self.plsModeEntry):
1118                         self.createSetup()
1119                 elif cur == self.satEntry:
1120                         self.updateSats()
1121 @@ -130,7 +139,7 @@ class Satfinder(ScanSetup):
1122                 self.retune(config_element)
1123
1124         def retune(self, configElement):
1125 -               returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
1126 +               returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 3, 0)
1127                 satpos = int(self.tuning_sat.value)
1128                 nim = nimmanager.nim_slots[self.feid]
1129                 if self.tuning_type.value == "manual_transponder":
1130 @@ -155,6 +164,18 @@ class Satfinder(ScanSetup):
1131                                         fec = self.scan_sat.fec_s2x_16apsk.value
1132                                 elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
1133                                         fec = self.scan_sat.fec_s2x_32apsk.value
1134 +
1135 +                       is_id = -1
1136 +                       pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
1137 +                       pls_code = 0
1138 +                       if self.scan_sat.is_id_bool.value:
1139 +                               is_id = self.scan_sat.is_id.value
1140 +                               pls_mode = self.scan_sat.pls_mode.value
1141 +                               if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
1142 +                                       pls_code = 0
1143 +                               else:
1144 +                                       pls_code = self.scan_sat.pls_code.value
1145 +
1146                         returnvalue = (
1147                                 self.scan_sat.frequency.value,
1148                                 self.scan_sat.symbolrate.value,
1149 @@ -165,7 +186,10 @@ class Satfinder(ScanSetup):
1150                                 system,
1151                                 modulation,
1152                                 self.scan_sat.rolloff.value,
1153 -                               self.scan_sat.pilot.value)
1154 +                               self.scan_sat.pilot.value,
1155 +                               is_id,
1156 +                               pls_mode,
1157 +                               pls_code)
1158                         self.tune(returnvalue)
1159                 elif self.tuning_type.value == "predefined_transponder":
1160                         tps = nimmanager.getTransponders(satpos)
1161 @@ -173,7 +197,7 @@ class Satfinder(ScanSetup):
1162                         if l > self.tuning_transponder.index:
1163                                 transponder = tps[self.tuning_transponder.index]
1164                                 returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
1165 -                                       transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
1166 +                                       transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12])
1167                                 self.tune(returnvalue)
1168
1169         def createConfig(self, foo):
1170 @@ -188,7 +212,8 @@ class Satfinder(ScanSetup):
1171                         self.scan_sat.inversion, self.scan_sat.symbolrate,
1172                         self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
1173                         self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
1174 -                       self.scan_sat.rolloff, self.scan_sat.system]
1175 +                       self.scan_sat.rolloff, self.scan_sat.system,
1176 +                       self.scan_sat.is_id_bool, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code]
1177
1178                 nim = nimmanager.nim_slots[self.feid]
1179                 if nim.isCompatible("DVB-S2X"):
1180 diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py
1181 old mode 100644
1182 new mode 100755
1183 index b7f57887..fa3126b0
1184 --- a/lib/python/Screens/ScanSetup.py
1185 +++ b/lib/python/Screens/ScanSetup.py
1186 @@ -49,6 +49,9 @@ def getInitialTransponderList(tlist, pos):
1187                         parm.modulation = x[6]
1188                         parm.rolloff = x[8]
1189                         parm.pilot = x[9]
1190 +                       parm.is_id = x[10]
1191 +                       parm.pls_mode = x[11]
1192 +                       parm.pls_code = x[12]
1193                         tlist.append(parm)
1194
1195  def getInitialCableTransponderList(tlist, nim):
1196 @@ -587,6 +590,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1197                 self.typeOfScanEntry = None
1198                 self.systemEntry = None
1199                 self.modulationEntry = None
1200 +               self.is_id_boolEntry = None
1201 +               self.plsModeEntry = None
1202                 nim = nimmanager.nim_slots[index_to_scan]
1203                 if nim.isCompatible("DVB-S"):
1204                         self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)
1205 @@ -647,6 +652,17 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1206                                         elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
1207                                                 self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
1208
1209 +                               if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
1210 +                                       if nim.isMultistream():
1211 +                                               self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
1212 +                                               self.list.append(self.is_id_boolEntry)
1213 +                                               if self.scan_sat.is_id_bool.value:
1214 +                                                       self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
1215 +                                                       self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
1216 +                                                       self.list.append(self.plsModeEntry)
1217 +                                                       if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
1218 +                                                               self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
1219 +
1220                         elif self.scan_type.value == "single_satellite":
1221                                 self.updateSatList()
1222                                 print self.scan_satselection[index_to_scan]
1223 @@ -721,7 +737,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1224                         cur == self.systemEntry or \
1225                         (self.modulationEntry and \
1226                         (self.systemEntry[1].value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X)) and \
1227 -                       cur == self.modulationEntry):
1228 +                       cur == self.modulationEntry) or \
1229 +                       cur == self.is_id_boolEntry or \
1230 +                       cur == self.plsModeEntry:
1231                         self.createSetup()
1232
1233         def createConfig(self, frontendData):
1234 @@ -740,7 +758,10 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1235                                 "fec_s2x_16apsk": eDVBFrontendParametersSatellite.FEC_1_2_L,
1236                                 "fec_s2x_32apsk": eDVBFrontendParametersSatellite.FEC_2_3_L,
1237                                 "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK,
1238 -                               "modulation_s2x": eDVBFrontendParametersSatellite.Modulation_QPSK}
1239 +                               "modulation_s2x": eDVBFrontendParametersSatellite.Modulation_QPSK,
1240 +                               "is_id": -1,
1241 +                               "pls_mode": eDVBFrontendParametersSatellite.PLS_Unknown,
1242 +                               "pls_code": 0 }
1243                         defaultCab = {
1244                                 "frequency": 466,
1245                                 "inversion": eDVBFrontendParametersCable.Inversion_Unknown,
1246 @@ -795,6 +816,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1247                                         if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
1248                                                 defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
1249                                                 defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
1250 +                                               defaultSat["is_id"] = frontendData.get("is_id", defaultSat["is_id"])
1251 +                                               defaultSat["pls_mode"] = frontendData.get("pls_mode", defaultSat["pls_mode"])
1252 +                                               defaultSat["pls_code"] = frontendData.get("pls_code", defaultSat["pls_code"])
1253
1254                                 elif ttype == "DVB-C":
1255                                         defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
1256 @@ -943,6 +967,14 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1257                                 (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
1258                                 (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
1259                                 (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
1260 +                       self.scan_sat.is_id = ConfigInteger(default = defaultSat["is_id"] if defaultSat["is_id"] != -1 else 0, limits = (0, 255))
1261 +                       self.scan_sat.is_id_bool = ConfigSelection(default = defaultSat["is_id"] != -1, choices = [(True, _("Multistream")),(False, _("Ordinary"))])
1262 +                       self.scan_sat.pls_mode = ConfigSelection(default = defaultSat["pls_mode"], choices = [
1263 +                               (eDVBFrontendParametersSatellite.PLS_Root, _("Root")),
1264 +                               (eDVBFrontendParametersSatellite.PLS_Gold, _("Gold")),
1265 +                               (eDVBFrontendParametersSatellite.PLS_Combo, _("Combo")),
1266 +                               (eDVBFrontendParametersSatellite.PLS_Unknown, _("Auto"))])
1267 +                       self.scan_sat.pls_code = ConfigInteger(default = defaultSat["pls_code"], limits = (0, 262143))
1268
1269                         # cable
1270                         self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
1271 @@ -1092,8 +1124,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1272         def updateStatus(self):
1273                 print "updatestatus"
1274
1275 -       def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot):
1276 -               print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot)
1277 +       def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot, is_id, pls_mode, pls_code):
1278 +               print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) + " is_id" + str(is_id) + " pls_mode" + str(pls_mode) + " pls_code" + str(pls_code)
1279                 print "orbpos: " + str(orbital_position)
1280                 parm = eDVBFrontendParametersSatellite()
1281                 parm.modulation = modulation
1282 @@ -1106,6 +1138,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1283                 parm.orbital_position = orbital_position
1284                 parm.rolloff = rolloff
1285                 parm.pilot = pilot
1286 +               parm.is_id = is_id
1287 +               parm.pls_mode = pls_mode
1288 +               parm.pls_code = pls_code
1289                 tlist.append(parm)
1290
1291         def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):
1292 @@ -1178,6 +1213,17 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1293                                         else:
1294                                                 fec = self.scan_sat.fec_s2.value
1295
1296 +                                       is_id = -1
1297 +                                       pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
1298 +                                       pls_code = 0
1299 +                                       if self.scan_sat.is_id_bool.value:
1300 +                                               is_id = self.scan_sat.is_id.value
1301 +                                               pls_mode = self.scan_sat.pls_mode.value
1302 +                                               if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
1303 +                                                       pls_code = 0
1304 +                                               else:
1305 +                                                       pls_code = self.scan_sat.pls_code.value
1306 +
1307                                         print "add sat transponder"
1308                                         self.addSatTransponder(tlist, self.scan_sat.frequency.value,
1309                                                                 self.scan_sat.symbolrate.value,
1310 @@ -1188,7 +1234,10 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
1311                                                                 system,
1312                                                                 modulation,
1313                                                                 self.scan_sat.rolloff.value,
1314 -                                                               self.scan_sat.pilot.value)
1315 +                                                               self.scan_sat.pilot.value,
1316 +                                                               is_id,
1317 +                                                               pls_mode,
1318 +                                                               pls_code)
1319                                 removeAll = False
1320                         elif self.scan_type.value == "single_satellite":
1321                                 sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
1322 diff --git a/lib/python/Screens/ServiceInfo.py b/lib/python/Screens/ServiceInfo.py
1323 index ffd288f3..5a52028c 100644
1324 --- a/lib/python/Screens/ServiceInfo.py
1325 +++ b/lib/python/Screens/ServiceInfo.py
1326 @@ -198,7 +198,10 @@ class ServiceInfo(Screen):
1327                                                 (_("Inversion"), frontendData["inversion"], TYPE_TEXT),
1328                                                 (_("FEC"), frontendData["fec_inner"], TYPE_TEXT),
1329                                                 (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT),
1330 -                                               (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT))
1331 +                                               (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT),
1332 +                                               (_("Input Stream ID"), frontendData.get("is_id", 0), TYPE_VALUE_DEC),
1333 +                                               (_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT),
1334 +                                               (_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC))
1335                         elif frontendDataOrg["tuner_type"] == "DVB-C":
1336                                 return ((_("NIM"), chr(ord('A')+int(frontendData["tuner_number"])), TYPE_TEXT),
1337                                                 (_("Type"), frontendData["tuner_type"], TYPE_TEXT),
1338 diff --git a/lib/python/Tools/Transponder.py b/lib/python/Tools/Transponder.py
1339 old mode 100644
1340 new mode 100755
1341 index 2b46d0e6..dffc3d26
1342 --- a/lib/python/Tools/Transponder.py
1343 +++ b/lib/python/Tools/Transponder.py
1344 @@ -69,6 +69,17 @@ def ConvertToHumanReadable(tp, type = None):
1345                                 eDVBFrontendParametersSatellite.Pilot_Unknown : _("Auto"),
1346                                 eDVBFrontendParametersSatellite.Pilot_On : _("On"),
1347                                 eDVBFrontendParametersSatellite.Pilot_Off : _("Off")}[tp["pilot"]]
1348 +                       ret["pls_mode"] = {
1349 +                               eDVBFrontendParametersSatellite.PLS_Root : _("Root"),
1350 +                               eDVBFrontendParametersSatellite.PLS_Gold : _("Gold"),
1351 +                               eDVBFrontendParametersSatellite.PLS_Combo : _("Combo"),
1352 +                               eDVBFrontendParametersSatellite.PLS_Unknown : _("Auto")}.get(tp.get("pls_mode"))
1353 +                       #ret["is_id"] = tp.get("is_id")
1354 +                       #ret["pls_code"] = tp.get("pls_code")
1355 +               else:
1356 +                       ret["pls_mode"] = None
1357 +                       ret["is_id"] = None
1358 +                       ret["pls_code"] = None
1359         elif type == "DVB-C":
1360                 ret["tuner_type"] = _("Cable")
1361                 ret["modulation"] = {