class Satfinder(ScanSetup, ServiceScan):
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.typeOfTuningEntry = None
self.systemEntry = None
self.satfinderTunerEntry = None
self.satEntry = None
self.typeOfInputEntry = None
ScanSetup.__init__(self, session)
self.setTitle(_("Satfinder"))
self["introduction"].setText(_("Press OK to scan"))
self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
def openFrontend(self):
res_mgr = eDVBResourceManager.getInstance()
if res_mgr:
self.raw_channel = res_mgr.allocateRawChannel(self.feid)
if self.raw_channel:
self.frontend = self.raw_channel.getFrontend()
if self.frontend:
return True
return False
def prepareFrontend(self):
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
self.retune(None)
def __onClose(self):
self.session.nav.playService(self.session.postScanService)
def newConfig(self):
cur = self["config"].getCurrent()
if cur in (self.typeOfTuningEntry, self.systemEntry, self.typeOfInputEntry):
self.createSetup()
elif cur == self.satfinderTunerEntry:
self.feid = int(self.satfinder_scan_nims.value)
self.createSetup()
self.prepareFrontend()
if self.frontend == None:
msg = _("Tuner not available.")
if self.session.nav.RecordTimer.isRecording():
msg += _("\nRecording in progress.")
self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR)
elif cur == self.satEntry:
self.createSetup()
else:
self.retune(None)
def createSetup(self):
self.list = []
self.satfinderTunerEntry = getConfigListEntry(_("Tuner"), self.satfinder_scan_nims)
self.list.append(self.satfinderTunerEntry)
if nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-S"):
self.tuning_sat = self.scan_satselection[self.getSelectedSatIndex(self.feid)]
self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
self.list.append(self.satEntry)
self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
if len(nimmanager.getTransponders(int(self.tuning_sat.value))) < 1: # Only offer 'predefined transponder' if some transponders exist
self.tuning_type.value = "single_transponder"
else:
self.list.append(self.typeOfTuningEntry)
nim = nimmanager.nim_slots[self.feid]
if self.tuning_type.value == "single_transponder":
if nim.isCompatible("DVB-S2"):
self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
self.list.append(self.systemEntry)
else:
# downgrade to dvb-s, in case a -s2 config was active
self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
self.list.append(self.modulationEntry)
self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
self.list.append(getConfigListEntry(_("PLS Mode"), self.scan_sat.pls_mode))
self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
elif self.tuning_type.value == "predefined_transponder":
self.updatePreDefTransponders()
self.list.append(getConfigListEntry(_("Transponder"), self.preDefTransponders))
elif nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-C"):
self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
if config.Nims[self.feid].cable.scan_type.value != "provider" or len(nimmanager.getTranspondersCable(int(self.satfinder_scan_nims.value))) < 1: # only show 'predefined transponder' if in provider mode and transponders exist
self.tuning_type.value = "single_transponder"
else:
self.list.append(self.typeOfTuningEntry)
if self.tuning_type.value == "single_transponder":
self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency))
self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion))
self.list.append(getConfigListEntry(_("Symbol rate"), self.scan_cab.symbolrate))
self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation))
self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))
elif self.tuning_type.value == "predefined_transponder":
self.scan_nims.value = self.satfinder_scan_nims.value
self.predefinedCabTranspondersList()
self.list.append(getConfigListEntry(_('Transponder'), self.CableTransponders))
elif nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-T"):
self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
region = nimmanager.getTerrestrialDescription(int(self.satfinder_scan_nims.value))
if len(nimmanager.getTranspondersTerrestrial(region)) < 1: # Only offer 'predefined transponder' if some transponders exist
self.tuning_type.value = "single_transponder"
else:
self.list.append(self.typeOfTuningEntry)
if self.tuning_type.value == "single_transponder":
if nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-T2"):
self.systemEntryTerr = getConfigListEntry(_('System'), self.scan_ter.system)
self.list.append(self.systemEntryTerr)
else:
self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T
self.typeOfInputEntry = getConfigListEntry(_("Use frequency or channel"), self.scan_input_as)
if self.ter_channel_input:
self.list.append(self.typeOfInputEntry)
else:
self.scan_input_as.value = self.scan_input_as.choices[0]
if self.ter_channel_input and self.scan_input_as.value == "channel":
channel = getChannelNumber(self.scan_ter.frequency.value*1000, self.ter_tnumber)
if channel:
self.scan_ter.channel.value = int(channel.replace("+","").replace("-",""))
self.list.append(getConfigListEntry(_("Channel"), self.scan_ter.channel))
else:
prev_val = self.scan_ter.frequency.value
self.scan_ter.frequency.value = channel2frequency(self.scan_ter.channel.value, self.ter_tnumber)/1000
if self.scan_ter.frequency.value == 474000:
self.scan_ter.frequency.value = prev_val
self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth))
self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh))
self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow))
self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation))
self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard))
self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T2:
self.list.append(getConfigListEntry(_('PLP ID'), self.scan_ter.plp_id))
elif self.tuning_type.value == "predefined_transponder":
self.scan_nims.value = self.satfinder_scan_nims.value
self.predefinedTerrTranspondersList()
self.list.append(getConfigListEntry(_('Transponder'), self.TerrestrialTransponders))
self.retune(None)
self["config"].list = self.list
self["config"].l.setList(self.list)
def createConfig(self, foo):
self.tuning_type = ConfigSelection(default = "predefined_transponder", choices = [("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))])
self.orbital_position = 192
if self.frontendData and self.frontendData.has_key('orbital_position'):
self.orbital_position = self.frontendData['orbital_position']
ScanSetup.createConfig(self, self.frontendData)
for x in (self.scan_sat.frequency,
self.scan_sat.inversion, self.scan_sat.symbolrate,
self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
self.scan_sat.rolloff, self.scan_sat.system, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code,
self.scan_ter.channel, self.scan_ter.frequency, self.scan_ter.inversion,
self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow,
self.scan_ter.modulation, self.scan_ter.transmission,
self.scan_ter.guard, self.scan_ter.hierarchy, self.scan_ter.plp_id,
self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate,
self.scan_cab.modulation, self.scan_cab.fec):
x.addNotifier(self.retune, initial_call = False)
satfinder_nim_list = []
for n in nimmanager.nim_slots:
if not (n.isCompatible("DVB-S") or n.isCompatible("DVB-T") or n.isCompatible("DVB-C")):
continue
if n.config_mode in ("loopthrough", "satposdepends", "nothing"):
continue
if n.isCompatible("DVB-S") and n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
continue
satfinder_nim_list.append((str(n.slot), n.friendly_full_description))
self.satfinder_scan_nims = ConfigSelection(choices = satfinder_nim_list)
if self.frontendData is not None and len(satfinder_nim_list) > 0: # open the plugin with the currently active NIM as default
self.satfinder_scan_nims.setValue(str(self.frontendData.get("tuner_number", satfinder_nim_list[0][0])))
self.feid = int(self.satfinder_scan_nims.value)
self.satList = []
self.scan_satselection = []
for slot in nimmanager.nim_slots:
if slot.isCompatible("DVB-S"):
self.satList.append(nimmanager.getSatListForNim(slot.slot))
self.scan_satselection.append(getConfigSatlist(self.orbital_position, self.satList[slot.slot]))
else:
self.satList.append(None)
if self.frontendData:
ttype = self.frontendData.get("tuner_type", "UNKNOWN")
if ttype == "DVB-S" and self.predefinedTranspondersList(self.getSelectedSatIndex(self.feid)) is None and len(nimmanager.getTransponders(self.getSelectedSatIndex(self.feid))) > 0:
self.tuning_type.value = "single_transponder"
elif ttype == "DVB-T" and self.predefinedTerrTranspondersList() is None and len(nimmanager.getTranspondersTerrestrial(nimmanager.getTerrestrialDescription(self.feid))) > 0:
self.tuning_type.value = "single_transponder"
elif ttype == "DVB-C" and self.predefinedCabTranspondersList() is None and len(nimmanager.getTranspondersCable(self.feid)) > 0:
self.tuning_type.value = "single_transponder"
def getSelectedSatIndex(self, v):
index = 0
none_cnt = 0
for n in self.satList:
if self.satList[index] is None:
none_cnt += 1
if index == int(v):
return index-none_cnt
index += 1
return -1
def updatePreDefTransponders(self):
ScanSetup.predefinedTranspondersList(self, self.tuning_sat.orbital_position)
def retuneCab(self, configElement):
if not nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-C"):
return
if self.initcomplete:
if self.tuning_type.value == "single_transponder":
transponder = (
self.scan_cab.frequency.value*1000,
self.scan_cab.symbolrate.value*1000,
self.scan_cab.modulation.value,
self.scan_cab.fec.value,
self.scan_cab.inversion.value
)
if self.initcomplete:
self.tuner.tuneCab(transponder)
self.transponder = transponder
elif self.tuning_type.value == "predefined_transponder":
tps = nimmanager.getTranspondersCable(int(self.satfinder_scan_nims.value))
if len(tps) > self.CableTransponders.index :
tp = tps[self.CableTransponders.index]
# tp = 0 transponder type, 1 freq, 2 sym, 3 mod, 4 fec, 5 inv, 6 sys
transponder = (tp[1], tp[2], tp[3], tp[4], tp[5])
if self.initcomplete:
self.tuner.tuneCab(transponder)
self.transponder = transponder
def retuneTerr(self, configElement):
if not nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-T"):
return self.retuneCab(configElement)
if self.initcomplete:
if self.scan_input_as.value == "channel":
frequency = channel2frequency(self.scan_ter.channel.value, self.ter_tnumber)
else:
frequency = self.scan_ter.frequency.value * 1000
if self.tuning_type.value == "single_transponder":
transponder = [
2, #TERRESTRIAL
frequency,
self.scan_ter.bandwidth.value,
self.scan_ter.modulation.value,
self.scan_ter.fechigh.value,
self.scan_ter.feclow.value,
self.scan_ter.guard.value,
self.scan_ter.transmission.value,
self.scan_ter.hierarchy.value,
self.scan_ter.inversion.value,
self.scan_ter.system.value,
self.scan_ter.plp_id.value]
if self.initcomplete:
self.tuner.tuneTerr(transponder[1], transponder[9], transponder[2], transponder[4], transponder[5], transponder[3], transponder[7], transponder[6], transponder[8], transponder[10], transponder[11])
self.transponder = transponder
elif self.tuning_type.value == "predefined_transponder":
region = nimmanager.getTerrestrialDescription(int(self.satfinder_scan_nims.value))
tps = nimmanager.getTranspondersTerrestrial(region)
if len(tps) > self.TerrestrialTransponders.index :
transponder = tps[self.TerrestrialTransponders.index]
# frequency 1, inversion 9, bandwidth 2, fechigh 4, feclow 5, modulation 3, transmission 7, guard 6, hierarchy 8, system 10, plp_id 11
if self.initcomplete:
self.tuner.tuneTerr(transponder[1], transponder[9], transponder[2], transponder[4], transponder[5], transponder[3], transponder[7], transponder[6], transponder[8], transponder[10], transponder[11])
self.transponder = transponder
def retune(self, configElement): # satellite
if not nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-S"):
return self.retuneTerr(configElement)
if not self.tuning_sat.value:
return
satpos = int(self.tuning_sat.value)
if self.tuning_type.value == "single_transponder":
if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
fec = self.scan_sat.fec_s2.value
else:
fec = self.scan_sat.fec.value
transponder = (
self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
self.scan_sat.polarization.value,
fec,
self.scan_sat.inversion.value,
satpos,
self.scan_sat.system.value,
self.scan_sat.modulation.value,
self.scan_sat.rolloff.value,
self.scan_sat.pilot.value,
self.scan_sat.is_id.value,
self.scan_sat.pls_mode.value,
self.scan_sat.pls_code.value)
if self.initcomplete:
self.tuner.tune(transponder)
self.transponder = transponder
elif self.tuning_type.value == "predefined_transponder":
tps = nimmanager.getTransponders(satpos)
if len(tps) > self.preDefTransponders.index:
tp = tps[self.preDefTransponders.index]
transponder = (tp[1] / 1000, tp[2] / 1000,
tp[3], tp[4], 2, satpos, tp[5], tp[6], tp[8], tp[9], tp[10], tp[11], tp[12])
if self.initcomplete:
self.tuner.tune(transponder)
self.transponder = transponder
def keyGoScan(self):
self.frontend = None
if self.raw_channel:
del(self.raw_channel)
tlist = []
if nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-S"):
self.addSatTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # sr
self.transponder[2], # pol
self.transponder[3], # fec
self.transponder[4], # inversion
self.tuning_sat.orbital_position,
self.transponder[6], # system
self.transponder[7], # modulation
self.transponder[8], # rolloff
self.transponder[9], # pilot
self.transponder[10],# input stream id
self.transponder[11],# pls mode
self.transponder[12] # pls mode
)
elif nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-T"):
parm = buildTerTransponder(
self.transponder[1], # frequency
self.transponder[9], # inversion
self.transponder[2], # bandwidth
self.transponder[4], # fechigh
self.transponder[5], # feclow
self.transponder[3], # modulation
self.transponder[7], # transmission
self.transponder[6], # guard
self.transponder[8], # hierarchy
self.transponder[10], # system
self.transponder[11] # plp_id
)
tlist.append(parm)
else: # DVB-C
self.addCabTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # sr
self.transponder[2], # modulation
self.transponder[3], # fec_inner
self.transponder[4] # inversion
)
self.startScan(tlist, self.feid)
def startScan(self, tlist, feid):
flags = 0
networkid = 0
self.session.openWithCallback(self.startScanCallback, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}])
def startScanCallback(self, answer=None):
if answer:
self.doCloseRecursive()
def keyCancel(self):
if self.session.postScanService and self.frontend:
self.frontend = None
del self.raw_channel
self.close(False)
def doCloseRecursive(self):
if self.session.postScanService and self.frontend:
self.frontend = None
del self.raw_channel
self.close(True)
class Satfinder(ScanSetup, ServiceScan):
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.typeOfTuningEntry = None
self.systemEntry = None
self.satfinderTunerEntry = None
self.satEntry = None
self.typeOfInputEntry = None
ScanSetup.__init__(self, session)
self.setTitle(_("Satfinder"))
self["introduction"].setText(_("Press OK to scan"))
self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
def openFrontend(self):
res_mgr = eDVBResourceManager.getInstance()
if res_mgr:
self.raw_channel = res_mgr.allocateRawChannel(self.feid)
if self.raw_channel:
self.frontend = self.raw_channel.getFrontend()
if self.frontend:
return True
return False
def prepareFrontend(self):
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
self.retune(None)
def __onClose(self):
self.session.nav.playService(self.session.postScanService)
def newConfig(self):
cur = self["config"].getCurrent()
if cur in (self.typeOfTuningEntry, self.systemEntry, self.typeOfInputEntry):
self.createSetup()
elif cur == self.satfinderTunerEntry:
self.feid = int(self.satfinder_scan_nims.value)
self.createSetup()
self.prepareFrontend()
if self.frontend == None:
msg = _("Tuner not available.")
if self.session.nav.RecordTimer.isRecording():
msg += _("\nRecording in progress.")
self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR)
elif cur == self.satEntry:
self.createSetup()
else:
self.retune(None)
def createSetup(self):
self.list = []
self.satfinderTunerEntry = getConfigListEntry(_("Tuner"), self.satfinder_scan_nims)
self.list.append(self.satfinderTunerEntry)
if nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-S"):
self.tuning_sat = self.scan_satselection[self.getSelectedSatIndex(self.feid)]
self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
self.list.append(self.satEntry)
self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
if len(nimmanager.getTransponders(int(self.tuning_sat.value))) < 1: # Only offer 'predefined transponder' if some transponders exist
self.tuning_type.value = "single_transponder"
else:
self.list.append(self.typeOfTuningEntry)
nim = nimmanager.nim_slots[self.feid]
if self.tuning_type.value == "single_transponder":
if nim.isCompatible("DVB-S2"):
self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
self.list.append(self.systemEntry)
else:
# downgrade to dvb-s, in case a -s2 config was active
self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
self.list.append(self.modulationEntry)
self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
elif self.tuning_type.value == "predefined_transponder":
self.updatePreDefTransponders()
self.list.append(getConfigListEntry(_("Transponder"), self.preDefTransponders))
elif nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-C"):
self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
if config.Nims[self.feid].cable.scan_type.value != "provider" or len(nimmanager.getTranspondersCable(int(self.satfinder_scan_nims.value))) < 1: # only show 'predefined transponder' if in provider mode and transponders exist
self.tuning_type.value = "single_transponder"
else:
self.list.append(self.typeOfTuningEntry)
if self.tuning_type.value == "single_transponder":
self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency))
self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion))
self.list.append(getConfigListEntry(_("Symbol rate"), self.scan_cab.symbolrate))
self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation))
self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))
elif self.tuning_type.value == "predefined_transponder":
self.scan_nims.value = self.satfinder_scan_nims.value
self.predefinedCabTranspondersList()
self.list.append(getConfigListEntry(_('Transponder'), self.CableTransponders))
elif nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-T"):
self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
region = nimmanager.getTerrestrialDescription(int(self.satfinder_scan_nims.value))
if len(nimmanager.getTranspondersTerrestrial(region)) < 1: # Only offer 'predefined transponder' if some transponders exist
self.tuning_type.value = "single_transponder"
else:
self.list.append(self.typeOfTuningEntry)
if self.tuning_type.value == "single_transponder":
if nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-T2"):
self.systemEntryTerr = getConfigListEntry(_('System'), self.scan_ter.system)
self.list.append(self.systemEntryTerr)
else:
self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T
self.typeOfInputEntry = getConfigListEntry(_("Use frequency or channel"), self.scan_input_as)
if self.ter_channel_input:
self.list.append(self.typeOfInputEntry)
else:
self.scan_input_as.value = self.scan_input_as.choices[0]
if self.ter_channel_input and self.scan_input_as.value == "channel":
channel = getChannelNumber(self.scan_ter.frequency.value*1000, self.ter_tnumber)
if channel:
self.scan_ter.channel.value = int(channel.replace("+","").replace("-",""))
self.list.append(getConfigListEntry(_("Channel"), self.scan_ter.channel))
else:
prev_val = self.scan_ter.frequency.value
self.scan_ter.frequency.value = channel2frequency(self.scan_ter.channel.value, self.ter_tnumber)/1000
if self.scan_ter.frequency.value == 474000:
self.scan_ter.frequency.value = prev_val
self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth))
self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh))
self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow))
self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation))
self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard))
self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T2:
self.list.append(getConfigListEntry(_('PLP ID'), self.scan_ter.plp_id))
elif self.tuning_type.value == "predefined_transponder":
self.scan_nims.value = self.satfinder_scan_nims.value
self.predefinedTerrTranspondersList()
self.list.append(getConfigListEntry(_('Transponder'), self.TerrestrialTransponders))
self.retune(None)
self["config"].list = self.list
self["config"].l.setList(self.list)
def createConfig(self, foo):
self.tuning_type = ConfigSelection(default = "predefined_transponder", choices = [("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))])
self.orbital_position = 192
if self.frontendData and self.frontendData.has_key('orbital_position'):
self.orbital_position = self.frontendData['orbital_position']
ScanSetup.createConfig(self, self.frontendData)
for x in (self.scan_sat.frequency,
self.scan_sat.inversion, self.scan_sat.symbolrate,
self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
self.scan_sat.rolloff, self.scan_sat.system,
self.scan_ter.channel, self.scan_ter.frequency, self.scan_ter.inversion,
self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow,
self.scan_ter.modulation, self.scan_ter.transmission,
self.scan_ter.guard, self.scan_ter.hierarchy, self.scan_ter.plp_id,
self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate,
self.scan_cab.modulation, self.scan_cab.fec):
x.addNotifier(self.retune, initial_call = False)
satfinder_nim_list = []
for n in nimmanager.nim_slots:
if not (n.isCompatible("DVB-S") or n.isCompatible("DVB-T") or n.isCompatible("DVB-C")):
continue
if n.config_mode in ("loopthrough", "satposdepends", "nothing"):
continue
if n.isCompatible("DVB-S") and n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
continue
satfinder_nim_list.append((str(n.slot), n.friendly_full_description))
self.satfinder_scan_nims = ConfigSelection(choices = satfinder_nim_list)
if self.frontendData is not None and len(satfinder_nim_list) > 0: # open the plugin with the currently active NIM as default
self.satfinder_scan_nims.setValue(str(self.frontendData.get("tuner_number", satfinder_nim_list[0][0])))
self.feid = int(self.satfinder_scan_nims.value)
self.satList = []
self.scan_satselection = []
for slot in nimmanager.nim_slots:
if slot.isCompatible("DVB-S"):
self.satList.append(nimmanager.getSatListForNim(slot.slot))
self.scan_satselection.append(getConfigSatlist(self.orbital_position, self.satList[slot.slot]))
else:
self.satList.append(None)
if self.frontendData:
ttype = self.frontendData.get("tuner_type", "UNKNOWN")
if ttype == "DVB-S" and self.predefinedTranspondersList(self.getSelectedSatIndex(self.feid)) is None and len(nimmanager.getTransponders(self.getSelectedSatIndex(self.feid))) > 0:
self.tuning_type.value = "single_transponder"
elif ttype == "DVB-T" and self.predefinedTerrTranspondersList() is None and len(nimmanager.getTranspondersTerrestrial(nimmanager.getTerrestrialDescription(self.feid))) > 0:
self.tuning_type.value = "single_transponder"
elif ttype == "DVB-C" and self.predefinedCabTranspondersList() is None and len(nimmanager.getTranspondersCable(self.feid)) > 0:
self.tuning_type.value = "single_transponder"
def getSelectedSatIndex(self, v):
index = 0
none_cnt = 0
for n in self.satList:
if self.satList[index] is None:
none_cnt += 1
if index == int(v):
return index-none_cnt
index += 1
return -1
def updatePreDefTransponders(self):
ScanSetup.predefinedTranspondersList(self, self.tuning_sat.orbital_position)
def retuneCab(self, configElement):
if not nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-C"):
return
if self.initcomplete:
if self.tuning_type.value == "single_transponder":
transponder = (
self.scan_cab.frequency.value*1000,
self.scan_cab.symbolrate.value*1000,
self.scan_cab.modulation.value,
self.scan_cab.fec.value,
self.scan_cab.inversion.value
)
if self.initcomplete:
self.tuner.tuneCab(transponder)
self.transponder = transponder
elif self.tuning_type.value == "predefined_transponder":
tps = nimmanager.getTranspondersCable(int(self.satfinder_scan_nims.value))
if len(tps) > self.CableTransponders.index :
tp = tps[self.CableTransponders.index]
# tp = 0 transponder type, 1 freq, 2 sym, 3 mod, 4 fec, 5 inv, 6 sys
transponder = (tp[1], tp[2], tp[3], tp[4], tp[5])
if self.initcomplete:
self.tuner.tuneCab(transponder)
self.transponder = transponder
def retuneTerr(self, configElement):
if not nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-T"):
return self.retuneCab(configElement)
if self.initcomplete:
if self.scan_input_as.value == "channel":
frequency = channel2frequency(self.scan_ter.channel.value, self.ter_tnumber)
else:
frequency = self.scan_ter.frequency.value * 1000
if self.tuning_type.value == "single_transponder":
transponder = [
2, #TERRESTRIAL
frequency,
self.scan_ter.bandwidth.value,
self.scan_ter.modulation.value,
self.scan_ter.fechigh.value,
self.scan_ter.feclow.value,
self.scan_ter.guard.value,
self.scan_ter.transmission.value,
self.scan_ter.hierarchy.value,
self.scan_ter.inversion.value,
self.scan_ter.system.value,
self.scan_ter.plp_id.value]
if self.initcomplete:
self.tuner.tuneTerr(transponder[1], transponder[9], transponder[2], transponder[4], transponder[5], transponder[3], transponder[7], transponder[6], transponder[8], transponder[10], transponder[11])
self.transponder = transponder
elif self.tuning_type.value == "predefined_transponder":
region = nimmanager.getTerrestrialDescription(int(self.satfinder_scan_nims.value))
tps = nimmanager.getTranspondersTerrestrial(region)
if len(tps) > self.TerrestrialTransponders.index :
transponder = tps[self.TerrestrialTransponders.index]
# frequency 1, inversion 9, bandwidth 2, fechigh 4, feclow 5, modulation 3, transmission 7, guard 6, hierarchy 8, system 10, plp_id 11
if self.initcomplete:
self.tuner.tuneTerr(transponder[1], transponder[9], transponder[2], transponder[4], transponder[5], transponder[3], transponder[7], transponder[6], transponder[8], transponder[10], transponder[11])
self.transponder = transponder
def retune(self, configElement): # satellite
if not nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-S"):
return self.retuneTerr(configElement)
if not self.tuning_sat.value:
return
satpos = int(self.tuning_sat.value)
if self.tuning_type.value == "single_transponder":
if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
fec = self.scan_sat.fec_s2.value
else:
fec = self.scan_sat.fec.value
transponder = (
self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
self.scan_sat.polarization.value,
fec,
self.scan_sat.inversion.value,
satpos,
self.scan_sat.system.value,
self.scan_sat.modulation.value,
self.scan_sat.rolloff.value,
self.scan_sat.pilot.value)
if self.initcomplete:
self.tuner.tune(transponder)
self.transponder = transponder
elif self.tuning_type.value == "predefined_transponder":
tps = nimmanager.getTransponders(satpos)
if len(tps) > self.preDefTransponders.index:
tp = tps[self.preDefTransponders.index]
transponder = (tp[1] / 1000, tp[2] / 1000,
tp[3], tp[4], 2, satpos, tp[5], tp[6], tp[8], tp[9])
if self.initcomplete:
self.tuner.tune(transponder)
self.transponder = transponder
def keyGoScan(self):
self.frontend = None
if self.raw_channel:
del(self.raw_channel)
tlist = []
if nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-S"):
self.addSatTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # sr
self.transponder[2], # pol
self.transponder[3], # fec
self.transponder[4], # inversion
self.tuning_sat.orbital_position,
self.transponder[6], # system
self.transponder[7], # modulation
self.transponder[8], # rolloff
self.transponder[9] # pilot
)
elif nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-T"):
parm = buildTerTransponder(
self.transponder[1], # frequency
self.transponder[9], # inversion
self.transponder[2], # bandwidth
self.transponder[4], # fechigh
self.transponder[5], # feclow
self.transponder[3], # modulation
self.transponder[7], # transmission
self.transponder[6], # guard
self.transponder[8], # hierarchy
self.transponder[10], # system
self.transponder[11] # plp_id
)
tlist.append(parm)
else: # DVB-C
self.addCabTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # sr
self.transponder[2], # modulation
self.transponder[3], # fec_inner
self.transponder[4] # inversion
)
self.startScan(tlist, self.feid)
def startScan(self, tlist, feid):
flags = 0
networkid = 0
self.session.openWithCallback(self.startScanCallback, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}])
def startScanCallback(self, answer=None):
if answer:
self.doCloseRecursive()
def keyCancel(self):
if self.session.postScanService and self.frontend:
self.frontend = None
del self.raw_channel
self.close(False)
def doCloseRecursive(self):
if self.session.postScanService and self.frontend:
self.frontend = None
del self.raw_channel
self.close(True)
class Satfinder(ScanSetup, ServiceScan):
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.systemEntry = None
self.systemEntryATSC = None
self.satfinderTunerEntry = None
self.satEntry = None
self.frequencyEntry = None
self.polarizationEntry = None
self.symbolrateEntry = None
self.inversionEntry = None
self.rolloffEntry = None
self.pilotEntry = None
self.fecEntry = None
self.transponder = None
ScanSetup.__init__(self, session)
self.setTitle(_("Signal Finder"))
self["introduction"].setText(_("Press OK to scan"))
self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
def openFrontend(self):
res_mgr = eDVBResourceManager.getInstance()
if res_mgr:
fe_id = int(self.scan_nims.value)
self.raw_channel = res_mgr.allocateRawChannel(fe_id)
if self.raw_channel:
self.frontend = self.raw_channel.getFrontend()
if self.frontend:
return True
return False
def prepareFrontend(self):
self.frontend = None
try:
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
self.createSetup()
self.retune()
except:
pass
def __onClose(self):
self.session.nav.playService(self.session.postScanService)
def newConfig(self):
# self.transponder = None
cur = self["config"].getCurrent()
print"cur ", cur
if cur == self.tunerEntry:
self.feid = int(self.scan_nims.value)
self.prepareFrontend()
if self.frontend == None and self.session.nav.RecordTimer.isRecording():
slot = nimmanager.nim_slots[self.feid]
msg = _("%s not available.") % slot.getSlotName()
msg += _("\nRecording in progress.")
self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR)
else:
ScanSetup.newConfig(self)
if cur[1].value == "single_transponder":
self.retune()
def createSetup(self):
ScanSetup.createSetup(self)
#manipulate "config", remove "self.scan_networkScan", "self.scan_clearallservices" and "self.scan_onlyfree"
tlist = self["config"].getList()
for x in (self.scan_networkScan, self.scan_clearallservices, self.scan_onlyfree):
for y in tlist:
if x == y[1]:
tlist.remove(y)
self["config"].list = tlist
self["config"].l.setList(tlist)
#manipulate choices, we need only "single_transponder","predefined_transponder"
for scan_type in (self.scan_type, self.scan_typecable, self.scan_typeterrestrial, self.scan_typeatsc):
slist = scan_type.choices.choices
dlist = []
for x in slist:
if x[0] in ("single_transponder","predefined_transponder"):
dlist.append(x)
scan_type.choices.choices = dlist
def TunerTypeChanged(self):
fe_id = int(self.scan_nims.value)
multiType = config.Nims[fe_id].multiType
system = multiType.getText()
if (system in ('DVB-S','DVB-S2') and config.Nims[fe_id].dvbs.configMode.value == "nothing") or \
(system in ('DVB-T','DVB-T2') and config.Nims[fe_id].dvbt.configMode.value == "nothing") or \
(system in ('DVB-C') and config.Nims[fe_id].dvbc.configMode.value == "nothing") or \
(system in ('ATSC') and config.Nims[fe_id].atsc.configMode.value == "nothing") :
return
slot = nimmanager.nim_slots[fe_id]
print "dvb_api_version ",iDVBFrontend.dvb_api_version
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
if slot.isMultiType():
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, "dummy", False) #to force a clear of m_delsys_whitelist
types = slot.getMultiTypeList()
for FeType in types.itervalues():
if FeType in ("DVB-S", "DVB-S2", "DVB-S2X") and config.Nims[slot.slot].dvbs.configMode.value == "nothing":
continue
elif FeType in ("DVB-T", "DVB-T2") and config.Nims[slot.slot].dvbt.configMode.value == "nothing":
continue
elif FeType in ("DVB-C", "DVB-C2") and config.Nims[slot.slot].dvbc.configMode.value == "nothing":
continue
elif FeType in ("ATSC") and config.Nims[slot.slot].atsc.configMode.value == "nothing":
continue
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, FeType, True)
else:
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, slot.getType())
# if not path.exists("/proc/stb/frontend/%d/mode" % fe_id) and iDVBFrontend.dvb_api_version >= 5:
print "api >=5 and new style tuner driver"
if self.frontend:
if system == 'DVB-C':
ret = self.frontend.changeType(iDVBFrontend.feCable)
elif system in ('DVB-T','DVB-T2'):
ret = self.frontend.changeType(iDVBFrontend.feTerrestrial)
elif system in ('DVB-S','DVB-S2'):
ret = self.frontend.changeType(iDVBFrontend.feSatellite)
elif system == 'ATSC':
ret = self.frontend.changeType(iDVBFrontend.feATSC)
else:
ret = False
if not ret:
print "%d: tunerTypeChange to '%s' failed" %(fe_id, system)
else:
print "new system ",system
else:
print "%d: tunerTypeChange to '%s' failed (BUSY)" %(fe_id, multiType.getText())
self.retune()
def createConfig(self):
ScanSetup.createConfig(self)
for x in (
self.scan_sat.frequency,
self.scan_satselection[int(self.scan_nims.value)],
self.scan_sat.symbolrate,
self.scan_sat.is_id,
self.scan_sat.pls_mode,
self.scan_sat.pls_code,
self.scan_ter.channel,
self.scan_ter.frequency,
self.scan_ter.inversion,
self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow,
self.scan_ter.modulation, self.scan_ter.transmission,
self.scan_ter.guard, self.scan_ter.hierarchy,
self.scan_ter.plp_id,
self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate,
self.scan_cab.modulation, self.scan_cab.fec,
self.scan_ats.frequency, self.scan_ats.modulation, self.scan_ats.inversion,
self.scan_ats.system,
):
if x is not None:
x.clearNotifiers()
x.addNotifier(self.TriggeredByConfigElement, initial_call = False)
def TriggeredByConfigElement(self, configElement):
self.retune()
def retune(self):
nim = nimmanager.nim_slots[int(self.scan_nims.value)]
if nim.isCompatible("DVB-S") and nim.config.dvbs.configMode.value != "nothing":
return self.retuneSat()
if nim.isCompatible("DVB-T") and nim.config.dvbt.configMode.value != "nothing":
return self.retuneTerr()
if nim.isCompatible("DVB-C") and nim.config.dvbc.configMode.value != "nothing":
return self.retuneCab()
if nim.isCompatible("ATSC") and nim.config.atsc.configMode.value != "nothing":
return self.retuneATSC()
self.frontend = None
self.raw_channel = None
print "error: tuner not enabled/supported", nim.getType()
def retuneCab(self):
if self.initcomplete:
if self.scan_typecable.value == "single_transponder":
transponder = (
self.scan_cab.frequency.value*1000,
self.scan_cab.symbolrate.value*1000,
self.scan_cab.modulation.value,
self.scan_cab.fec.value,
self.scan_cab.inversion.value
)
self.tuner.tuneCab(transponder)
self.transponder = transponder
elif self.scan_typecable.value == "predefined_transponder":
if self.CableTransponders is not None:
tps = nimmanager.getTranspondersCable(int(self.scan_nims.value))
if len(tps) > self.CableTransponders.index :
tp = tps[self.CableTransponders.index]
# tp = 0 transponder type, 1 freq, 2 sym, 3 mod, 4 fec, 5 inv, 6 sys
transponder = (tp[1], tp[2], tp[3], tp[4], tp[5])
self.tuner.tuneCab(transponder)
self.transponder = transponder
def retuneTerr(self):
if self.initcomplete:
if self.scan_input_as.value == "channel":
frequency = channel2frequency(self.scan_ter.channel.value, self.ter_tnumber)
else:
frequency = self.scan_ter.frequency.value * 1000
if self.scan_typeterrestrial.value == "single_transponder":
transponder = [
2, #TERRESTRIAL
frequency,
self.scan_ter.bandwidth.value,
self.scan_ter.modulation.value,
self.scan_ter.fechigh.value,
self.scan_ter.feclow.value,
self.scan_ter.guard.value,
self.scan_ter.transmission.value,
self.scan_ter.hierarchy.value,
self.scan_ter.inversion.value,
self.scan_ter.system.value,
self.scan_ter.plp_id.value]
self.tuner.tuneTerr(transponder[1], transponder[9], transponder[2], transponder[4], transponder[5], transponder[3], transponder[7], transponder[6], transponder[8], transponder[10], transponder[11])
self.transponder = transponder
elif self.scan_typeterrestrial.value == "predefined_transponder":
if self.TerrestrialTransponders is not None:
region = nimmanager.getTerrestrialDescription(int(self.scan_nims.value))
tps = nimmanager.getTranspondersTerrestrial(region)
if len(tps) > self.TerrestrialTransponders.index :
transponder = tps[self.TerrestrialTransponders.index]
# frequency 1, inversion 9, bandwidth 2, fechigh 4, feclow 5, modulation 3, transmission 7, guard 6, hierarchy 8, system 10, plp_id 11
self.tuner.tuneTerr(transponder[1], transponder[9], transponder[2], transponder[4], transponder[5], transponder[3], transponder[7], transponder[6], transponder[8], transponder[10], transponder[11])
self.transponder = transponder
def retuneSat(self):
fe_id = int(self.scan_nims.value)
nimsats = self.satList[fe_id]
selsatidx = self.scan_satselection[fe_id].index
if len(nimsats):
orbpos = nimsats[selsatidx][0]
if self.initcomplete:
if self.scan_type.value == "single_transponder":
if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
fec = self.scan_sat.fec_s2.value
else:
fec = self.scan_sat.fec.value
transponder = (
self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
self.scan_sat.polarization.value,
fec,
self.scan_sat.inversion.value,
orbpos,
self.scan_sat.system.value,
self.scan_sat.modulation.value,
self.scan_sat.rolloff.value,
self.scan_sat.pilot.value,
self.scan_sat.is_id.value,
self.scan_sat.pls_mode.value,
self.scan_sat.pls_code.value)
self.tuner.tune(transponder)
self.transponder = transponder
elif self.scan_type.value == "predefined_transponder":
tps = nimmanager.getTransponders(orbpos)
if len(tps) > self.preDefTransponders.index:
tp = tps[self.preDefTransponders.index]
transponder = (tp[1] / 1000, tp[2] / 1000,
tp[3], tp[4], 2, orbpos, tp[5], tp[6], tp[8], tp[9], tp[10], tp[11], tp[12])
self.tuner.tune(transponder)
self.transponder = transponder
def retuneATSC(self):
if self.initcomplete:
if self.scan_typeatsc.value == "single_transponder":
transponder = (
self.scan_ats.frequency.value*1000,
self.scan_ats.modulation.value,
self.scan_ats.inversion.value,
self.scan_ats.system.value,
)
if self.initcomplete:
self.tuner.tuneATSC(transponder)
self.transponder = transponder
elif self.scan_typeatsc.value == "predefined_transponder":
tps = nimmanager.getTranspondersATSC(int(self.scan_nims.value))
if tps and len(tps) > self.ATSCTransponders.index:
tp = tps[self.ATSCTransponders.index]
transponder = (tp[1], tp[2], tp[3], tp[4])
if self.initcomplete:
self.tuner.tuneATSC(transponder)
self.transponder = transponder
def keyGoScan(self):
if self.transponder is None:
print "error: no transponder data"
return
fe_id = int(self.scan_nims.value)
nim = nimmanager.nim_slots[fe_id]
self.frontend = None
if self.raw_channel:
self.raw_channel = None
tlist = []
if nim.isCompatible("DVB-S"):
nimsats = self.satList[fe_id]
selsatidx = self.scan_satselection[fe_id].index
if len(nimsats):
orbpos = nimsats[selsatidx][0]
self.addSatTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # sr
self.transponder[2], # pol
self.transponder[3], # fec
self.transponder[4], # inversion
orbpos,
self.transponder[6], # system
self.transponder[7], # modulation
self.transponder[8], # rolloff
self.transponder[9], # pilot
self.transponder[10],# input stream id
self.transponder[11],# pls mode
self.transponder[12] # pls code
)
elif nim.isCompatible("DVB-T"):
parm = buildTerTransponder(
self.transponder[1], # frequency
self.transponder[9], # inversion
self.transponder[2], # bandwidth
self.transponder[4], # fechigh
self.transponder[5], # feclow
self.transponder[3], # modulation
self.transponder[7], # transmission
self.transponder[6], # guard
self.transponder[8], # hierarchy
self.transponder[10], # system
self.transponder[11] # plp_id
)
tlist.append(parm)
elif nim.isCompatible("DVB-C"):
self.addCabTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # sr
self.transponder[2], # modulation
self.transponder[3], # fec_inner
self.transponder[4] # inversion
)
elif nim.isCompatible("ATSC"):
self.addATSCTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # modulation
self.transponder[2], # inversion
self.transponder[3] # system
)
else:
print "error: tuner not enabled/supported", nim.getType()
self.startScan(tlist, fe_id)
def startScan(self, tlist, feid):
flags = 0
networkid = 0
self.session.openWithCallback(self.startScanCallback, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}])
def startScanCallback(self, answer=None):
if answer:
self.doCloseRecursive()
def keyCancel(self):
if self.session.postScanService and self.frontend:
self.frontend = None
self.raw_channel = None
self.close(False)
def doCloseRecursive(self):
if self.session.postScanService and self.frontend:
self.frontend = None
self.raw_channel = None
self.close(True)
class Satfinder(ScanSetup, ServiceScan):
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.systemEntry = None
self.systemEntryATSC = None
self.satfinderTunerEntry = None
self.satEntry = None
self.frequencyEntry = None
self.polarizationEntry = None
self.symbolrateEntry = None
self.inversionEntry = None
self.rolloffEntry = None
self.pilotEntry = None
self.fecEntry = None
self.transponder = None
self.is_id_boolEntry = None
self.t2mi_plp_id_boolEntry = None
ScanSetup.__init__(self, session)
self.setTitle(_("Signal Finder"))
self["introduction"].setText(_("Press OK to scan"))
self["Frontend"] = FrontendStatus(frontend_source=lambda: self.frontend, update_interval=100)
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
def openFrontend(self):
res_mgr = eDVBResourceManager.getInstance()
if res_mgr:
fe_id = int(self.scan_nims.value)
self.raw_channel = res_mgr.allocateRawChannel(fe_id)
if self.raw_channel:
self.frontend = self.raw_channel.getFrontend()
if self.frontend:
return True
return False
def prepareFrontend(self):
self.frontend = None
try:
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
self.createSetup()
self.retune()
except:
pass
def __onClose(self):
self.session.nav.playService(self.session.postScanService)
def newConfig(self):
# self.transponder = None
cur = self["config"].getCurrent()
print("cur ", cur)
if cur == self.tunerEntry:
self.feid = int(self.scan_nims.value)
self.prepareFrontend()
if self.frontend == None and self.session.nav.RecordTimer.isRecording():
slot = nimmanager.nim_slots[self.feid]
msg = _("%s not available.") % slot.getSlotName()
msg += _("\nRecording in progress.")
self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR)
elif cur == self.is_id_boolEntry:
if self.is_id_boolEntry[1].value:
self.scan_sat.is_id.value = 0 if self.is_id_memory < 0 else self.is_id_memory
self.scan_sat.pls_mode.value = self.pls_mode_memory
self.scan_sat.pls_code.value = self.pls_code_memory
else:
self.is_id_memory = self.scan_sat.is_id.value
self.pls_mode_memory = self.scan_sat.pls_mode.value
self.pls_code_memory = self.scan_sat.pls_code.value
self.scan_sat.is_id.value = eDVBFrontendParametersSatellite.No_Stream_Id_Filter
self.scan_sat.pls_mode.value = eDVBFrontendParametersSatellite.PLS_Gold
self.scan_sat.pls_code.value = eDVBFrontendParametersSatellite.PLS_Default_Gold_Code
self.createSetup()
self.retune()
elif cur == self.t2mi_plp_id_boolEntry:
if self.t2mi_plp_id_boolEntry[1].value:
self.scan_sat.t2mi_plp_id.value = 0 if self.t2mi_plp_id_memory < 0 else self.t2mi_plp_id_memory
self.scan_sat.t2mi_pid.value = self.t2mi_pid_memory
else:
self.t2mi_plp_id_memory = self.scan_sat.t2mi_plp_id.value
self.t2mi_pid_memory = self.scan_sat.t2mi_pid.value
self.scan_sat.t2mi_plp_id.value = eDVBFrontendParametersSatellite.No_T2MI_PLP_Id
self.scan_sat.t2mi_pid.value = eDVBFrontendParametersSatellite.T2MI_Default_Pid
self.createSetup()
self.retune()
else:
ScanSetup.newConfig(self)
if cur[1].value == "single_transponder":
self.retune()
def createSetup(self):
ScanSetup.createSetup(self)
#manipulate "config", remove "self.scan_networkScan", "self.scan_clearallservices" and "self.scan_onlyfree"
tlist = self["config"].getList()
for x in (self.scan_networkScan, self.scan_clearallservices, self.scan_onlyfree):
for y in tlist:
if x == y[1]:
tlist.remove(y)
self["config"].list = tlist
self["config"].l.setList(tlist)
#manipulate choices, we need only "single_transponder","predefined_transponder"
for scan_type in (self.scan_type, self.scan_typecable, self.scan_typeterrestrial, self.scan_typeatsc):
slist = scan_type.choices.choices
dlist = []
for x in slist:
if x[0] in ("single_transponder", "predefined_transponder"):
dlist.append(x)
scan_type.choices.choices = dlist
def TunerTypeChanged(self):
fe_id = int(self.scan_nims.value)
multiType = config.Nims[fe_id].multiType
system = multiType.getText()
if (system in ('DVB-S', 'DVB-S2') and config.Nims[fe_id].dvbs.configMode.value == "nothing") or \
(system in ('DVB-T', 'DVB-T2') and config.Nims[fe_id].dvbt.configMode.value == "nothing") or \
(system in ('DVB-C') and config.Nims[fe_id].dvbc.configMode.value == "nothing") or \
(system in ('ATSC') and config.Nims[fe_id].atsc.configMode.value == "nothing"):
return
slot = nimmanager.nim_slots[fe_id]
print("dvb_api_version ", iDVBFrontend.dvb_api_version)
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
if slot.isMultiType():
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, "dummy", False) #to force a clear of m_delsys_whitelist
types = slot.getMultiTypeList()
import six
for FeType in six.itervalues(types):
if FeType in ("DVB-S", "DVB-S2", "DVB-S2X") and config.Nims[slot.slot].dvbs.configMode.value == "nothing":
continue
elif FeType in ("DVB-T", "DVB-T2") and config.Nims[slot.slot].dvbt.configMode.value == "nothing":
continue
elif FeType in ("DVB-C", "DVB-C2") and config.Nims[slot.slot].dvbc.configMode.value == "nothing":
continue
elif FeType in ("ATSC") and config.Nims[slot.slot].atsc.configMode.value == "nothing":
continue
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, FeType, True)
else:
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, slot.getType())
# if not path.exists("/proc/stb/frontend/%d/mode" % fe_id) and iDVBFrontend.dvb_api_version >= 5:
print("api >=5 and new style tuner driver")
if self.frontend:
if system == 'DVB-C':
ret = self.frontend.changeType(iDVBFrontend.feCable)
elif system in ('DVB-T', 'DVB-T2'):
ret = self.frontend.changeType(iDVBFrontend.feTerrestrial)
elif system in ('DVB-S', 'DVB-S2'):
ret = self.frontend.changeType(iDVBFrontend.feSatellite)
elif system == 'ATSC':
ret = self.frontend.changeType(iDVBFrontend.feATSC)
else:
ret = False
if not ret:
print("%d: tunerTypeChange to '%s' failed" % (fe_id, system))
else:
print("new system ", system)
else:
print("%d: tunerTypeChange to '%s' failed (BUSY)" % (fe_id, multiType.getText()))
self.retune()
def createConfig(self):
ScanSetup.createConfig(self)
for x in (
self.scan_sat.frequency,
self.scan_satselection[int(self.scan_nims.value)],
self.scan_sat.symbolrate,
self.scan_sat.is_id,
self.scan_sat.pls_mode,
self.scan_sat.pls_code,
self.scan_sat.t2mi_plp_id,
self.scan_sat.t2mi_pid,
self.scan_ter.channel,
self.scan_ter.frequency,
self.scan_ter.inversion,
self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow,
self.scan_ter.modulation, self.scan_ter.transmission,
self.scan_ter.guard, self.scan_ter.hierarchy,
self.scan_ter.plp_id,
self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate,
self.scan_cab.modulation, self.scan_cab.fec,
self.scan_ats.frequency, self.scan_ats.modulation, self.scan_ats.inversion,
self.scan_ats.system,
):
if x is not None:
x.clearNotifiers()
x.addNotifier(self.TriggeredByConfigElement, initial_call=False)
def TriggeredByConfigElement(self, configElement):
self.retune()
def retune(self):
nim = nimmanager.nim_slots[int(self.scan_nims.value)]
if nim.isCompatible("DVB-S") and nim.config.dvbs.configMode.value != "nothing":
return self.retuneSat()
if nim.isCompatible("DVB-T") and nim.config.dvbt.configMode.value != "nothing":
return self.retuneTerr()
if nim.isCompatible("DVB-C") and nim.config.dvbc.configMode.value != "nothing":
return self.retuneCab()
if nim.isCompatible("ATSC") and nim.config.atsc.configMode.value != "nothing":
return self.retuneATSC()
self.frontend = None
self.raw_channel = None
print("error: tuner not enabled/supported", nim.getType())
def retuneCab(self):
if self.initcomplete:
if self.scan_typecable.value == "single_transponder":
transponder = (
self.scan_cab.frequency.value[0] * 1000 + self.scan_cab.frequency.value[1],
self.scan_cab.symbolrate.value * 1000,
self.scan_cab.modulation.value,
self.scan_cab.fec.value,
self.scan_cab.inversion.value
)
self.tuner.tuneCab(transponder)
self.transponder = transponder
elif self.scan_typecable.value == "predefined_transponder":
if self.CableTransponders is not None:
tps = nimmanager.getTranspondersCable(int(self.scan_nims.value))
if len(tps) > self.CableTransponders.index:
tp = tps[self.CableTransponders.index]
# tp = 0 transponder type, 1 freq, 2 sym, 3 mod, 4 fec, 5 inv, 6 sys
transponder = (tp[1], tp[2], tp[3], tp[4], tp[5])
self.tuner.tuneCab(transponder)
self.transponder = transponder
def retuneTerr(self):
if self.initcomplete:
if self.scan_input_as.value == "channel":
frequency = channel2frequency(self.scan_ter.channel.value, self.ter_tnumber)
if frequency:
frequency = int(frequency)
else: # FIXME channel2frequency return None because of channel not found
print("[Satfinder] retuneTerr DVB-T channel '%s' out of scope" % str(self.scan_ter.channel.value))
return
else:
frequency = self.scan_ter.frequency.floatint * 1000
if self.scan_typeterrestrial.value == "single_transponder":
transponder = [
2, #TERRESTRIAL
frequency,
self.scan_ter.bandwidth.value,
self.scan_ter.modulation.value,
self.scan_ter.fechigh.value,
self.scan_ter.feclow.value,
self.scan_ter.guard.value,
self.scan_ter.transmission.value,
self.scan_ter.hierarchy.value,
self.scan_ter.inversion.value,
self.scan_ter.system.value,
self.scan_ter.plp_id.value]
self.tuner.tuneTerr(transponder[1], transponder[9], transponder[2], transponder[4], transponder[5], transponder[3], transponder[7], transponder[6], transponder[8], transponder[10], transponder[11])
self.transponder = transponder
elif self.scan_typeterrestrial.value == "predefined_transponder":
if self.TerrestrialTransponders is not None:
region = nimmanager.getTerrestrialDescription(int(self.scan_nims.value))
tps = nimmanager.getTranspondersTerrestrial(region)
if len(tps) > self.TerrestrialTransponders.index:
transponder = tps[self.TerrestrialTransponders.index]
# frequency 1, inversion 9, bandwidth 2, fechigh 4, feclow 5, modulation 3, transmission 7, guard 6, hierarchy 8, system 10, plp_id 11
self.tuner.tuneTerr(transponder[1], transponder[9], transponder[2], transponder[4], transponder[5], transponder[3], transponder[7], transponder[6], transponder[8], transponder[10], transponder[11])
self.transponder = transponder
def retuneSat(self):
fe_id = int(self.scan_nims.value)
nimsats = self.satList[fe_id]
selsatidx = self.scan_satselection[fe_id].index
if len(nimsats):
orbpos = nimsats[selsatidx][0]
if self.initcomplete:
if self.scan_type.value == "single_transponder":
if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
fec = self.scan_sat.fec_s2.value
else:
fec = self.scan_sat.fec.value
transponder = (
self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
self.scan_sat.polarization.value,
fec,
self.scan_sat.inversion.value,
orbpos,
self.scan_sat.system.value,
self.scan_sat.modulation.value,
self.scan_sat.rolloff.value,
self.scan_sat.pilot.value,
self.scan_sat.is_id.value,
self.scan_sat.pls_mode.value,
self.scan_sat.pls_code.value,
self.scan_sat.t2mi_plp_id.value,
self.scan_sat.t2mi_pid.value)
self.tuner.tune(transponder)
self.transponder = transponder
elif self.scan_type.value == "predefined_transponder":
tps = nimmanager.getTransponders(orbpos)
if len(tps) > self.preDefTransponders.index:
tp = tps[self.preDefTransponders.index]
transponder = (tp[1] // 1000, tp[2] // 1000,
tp[3], tp[4], 2, orbpos, tp[5], tp[6], tp[8], tp[9], tp[10], tp[11], tp[12], tp[13], tp[14])
self.tuner.tune(transponder)
self.transponder = transponder
def retuneATSC(self):
if self.initcomplete:
if self.scan_typeatsc.value == "single_transponder":
transponder = (
self.scan_ats.frequency.floatint * 1000,
self.scan_ats.modulation.value,
self.scan_ats.inversion.value,
self.scan_ats.system.value,
)
if self.initcomplete:
self.tuner.tuneATSC(transponder)
self.transponder = transponder
elif self.scan_typeatsc.value == "predefined_transponder":
tps = nimmanager.getTranspondersATSC(int(self.scan_nims.value))
if tps and len(tps) > self.ATSCTransponders.index:
tp = tps[self.ATSCTransponders.index]
transponder = (tp[1], tp[2], tp[3], tp[4])
if self.initcomplete:
self.tuner.tuneATSC(transponder)
self.transponder = transponder
def keyGoScan(self):
if self.transponder is None:
print("error: no transponder data")
return
fe_id = int(self.scan_nims.value)
nim = nimmanager.nim_slots[fe_id]
self.frontend = None
if self.raw_channel:
self.raw_channel = None
tlist = []
if nim.isCompatible("DVB-S"):
nimsats = self.satList[fe_id]
selsatidx = self.scan_satselection[fe_id].index
if len(nimsats):
orbpos = nimsats[selsatidx][0]
self.addSatTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # sr
self.transponder[2], # pol
self.transponder[3], # fec
self.transponder[4], # inversion
orbpos,
self.transponder[6], # system
self.transponder[7], # modulation
self.transponder[8], # rolloff
self.transponder[9], # pilot
self.transponder[10],# input stream id
self.transponder[11],# pls mode
self.transponder[12], # pls code
self.transponder[13], # t2mi_plp_id
self.transponder[14] # t2mi_pid
)
elif nim.isCompatible("DVB-T"):
parm = buildTerTransponder(
self.transponder[1], # frequency
self.transponder[9], # inversion
self.transponder[2], # bandwidth
self.transponder[4], # fechigh
self.transponder[5], # feclow
self.transponder[3], # modulation
self.transponder[7], # transmission
self.transponder[6], # guard
self.transponder[8], # hierarchy
self.transponder[10], # system
self.transponder[11] # plp_id
)
tlist.append(parm)
elif nim.isCompatible("DVB-C"):
self.addCabTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # sr
self.transponder[2], # modulation
self.transponder[3], # fec_inner
self.transponder[4] # inversion
)
elif nim.isCompatible("ATSC"):
self.addATSCTransponder(tlist,
self.transponder[0], # frequency
self.transponder[1], # modulation
self.transponder[2], # inversion
self.transponder[3] # system
)
else:
print("error: tuner not enabled/supported", nim.getType())
self.startScan(tlist, fe_id)
def startScan(self, tlist, feid):
flags = 0
networkid = 0
self.session.openWithCallback(self.startScanCallback, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}])
def startScanCallback(self, answer=None):
if answer:
self.doCloseRecursive()
def keyCancel(self):
if self.session.postScanService and self.frontend:
self.frontend = None
self.raw_channel = None
self.close(False)
def doCloseRecursive(self):
if self.session.postScanService and self.frontend:
self.frontend = None
self.raw_channel = None
self.close(True)
class Satfinder(ScanSetup, ServiceScan):
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.preDefTransponders = None
self.CableTransponders = None
self.ATSCTransponders = None
self.typeOfTuningEntry = None
self.systemEntry = None
self.systemEntryATSC = None
self.satfinderTunerEntry = None
self.satEntry = None
self.frequencyEntry = None
self.polarizationEntry = None
self.symbolrateEntry = None
self.inversionEntry = None
self.rolloffEntry = None
self.pilotEntry = None
self.fecEntry = None
self.transponder = None
ScanSetup.__init__(self, session)
self.setTitle(_('Signal Finder'))
self['introduction'].setText(_('Press OK to scan'))
self['Frontend'] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self['actions'] = ActionMap(['SetupActions', 'ColorActions'], {
'save': self.keyGoScan,
'ok': self.keyGoScan,
'cancel': self.keyCancel
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
return
def openFrontend(self):
res_mgr = eDVBResourceManager.getInstance()
if res_mgr:
fe_id = int(self.scan_nims.value)
self.raw_channel = res_mgr.allocateRawChannel(fe_id)
if self.raw_channel:
self.frontend = self.raw_channel.getFrontend()
if self.frontend:
return True
return False
def prepareFrontend(self):
self.frontend = None
try:
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(
InfoBar.instance,
'showPiP') and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None
self.tuner = Tuner(self.frontend)
self.createSetup()
self.retune()
except:
pass
return
def __onClose(self):
self.session.nav.playService(self.session.postScanService)
def newConfig(self):
self.transponder = None
ScanSetup.newConfig(self)
cur = self['config'].getCurrent()
print 'cur ', cur
if cur == self.tunerEntry:
self.feid = int(self.scan_nims.value)
self.prepareFrontend()
if self.frontend == None and self.session.nav.RecordTimer.isRecording(
):
slot = nimmanager.nim_slots[self.feid]
msg = _('%s not available.') % slot.getSlotName()
msg += _('\nRecording in progress.')
self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR)
return
def createSetup(self):
ScanSetup.createSetup(self)
tlist = self['config'].getList()
for x in (self.scan_networkScan, self.scan_clearallservices,
self.scan_onlyfree):
for y in tlist:
if x == y[1]:
tlist.remove(y)
self['config'].list = tlist
self['config'].l.setList(tlist)
for scan_type in (self.scan_type, self.scan_typecable,
self.scan_typeterrestrial):
slist = scan_type.choices.choices
dlist = []
for x in slist:
if x[0] in ('single_transponder', 'predefined_transponder'):
dlist.append(x)
scan_type.choices.choices = dlist
def TunerTypeChanged(self):
fe_id = int(self.scan_nims.value)
multiType = config.Nims[fe_id].multiType
system = multiType.getText()
if system in (
'DVB-S', 'DVB-S2'
) and config.Nims[fe_id].dvbs.configMode.value == 'nothing' or system in (
'DVB-T', 'DVB-T2'
) and config.Nims[
fe_id].dvbt.configMode.value == 'nothing' or system in 'DVB-C' and config.Nims[
fe_id].dvbc.configMode.value == 'nothing' or system in 'ATSC' and config.Nims[
fe_id].atsc.configMode.value == 'nothing':
return
else:
slot = nimmanager.nim_slots[fe_id]
print 'dvb_api_version ', iDVBFrontend.dvb_api_version
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(
InfoBar.instance,
'showPiP') and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None
self.tuner = Tuner(self.frontend)
if slot.isMultiType():
eDVBResourceManager.getInstance().setFrontendType(
slot.frontend_id, 'dummy', False)
types = slot.getMultiTypeList()
for FeType in types.itervalues():
if FeType in (
'DVB-S', 'DVB-S2', 'DVB-S2X') and config.Nims[
slot.slot].dvbs.configMode.value == 'nothing':
continue
elif FeType in ('DVB-T', 'DVB-T2') and config.Nims[
slot.slot].dvbt.configMode.value == 'nothing':
continue
elif FeType in ('DVB-C', 'DVB-C2') and config.Nims[
slot.slot].dvbc.configMode.value == 'nothing':
continue
elif FeType in 'ATSC' and config.Nims[
slot.slot].atsc.configMode.value == 'nothing':
continue
eDVBResourceManager.getInstance().setFrontendType(
slot.frontend_id, FeType, True)
else:
eDVBResourceManager.getInstance().setFrontendType(
slot.frontend_id, slot.getType())
print 'api >=5 and new style tuner driver'
if self.frontend:
if system == 'DVB-C':
ret = self.frontend.changeType(iDVBFrontend.feCable)
elif system in ('DVB-T', 'DVB-T2'):
ret = self.frontend.changeType(iDVBFrontend.feTerrestrial)
elif system in ('DVB-S', 'DVB-S2'):
ret = self.frontend.changeType(iDVBFrontend.feSatellite)
elif system == 'ATSC':
ret = self.frontend.changeType(iDVBFrontend.feATSC)
else:
ret = False
if not ret:
print "%d: tunerTypeChange to '%s' failed" % (fe_id,
system)
else:
print 'new system ', system
else:
print "%d: tunerTypeChange to '%s' failed (BUSY)" % (
fe_id, multiType.getText())
return
def createConfig(self):
ScanSetup.createConfig(self)
for x in (self.scan_sat.frequency, self.scan_sat.inversion,
self.scan_sat.symbolrate, self.scan_sat.polarization,
self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2,
self.scan_sat.fec, self.scan_sat.modulation,
self.scan_sat.rolloff, self.scan_sat.system,
self.scan_sat.is_id, self.scan_sat.pls_mode,
self.scan_sat.pls_code, self.scan_ter.channel,
self.scan_ter.frequency, self.scan_ter.inversion,
self.scan_ter.bandwidth, self.scan_ter.fechigh,
self.scan_ter.feclow, self.scan_ter.modulation,
self.scan_ter.transmission, self.scan_ter.guard,
self.scan_ter.hierarchy, self.scan_ter.plp_id,
self.scan_cab.frequency, self.scan_cab.inversion,
self.scan_cab.symbolrate, self.scan_cab.modulation,
self.scan_cab.fec, self.scan_ats.frequency,
self.scan_ats.modulation, self.scan_ats.inversion,
self.scan_ats.system, self.preDefTransponders,
self.CableTransponders, self.TerrestrialTransponders,
self.ATSCTransponders):
if x is not None:
x.clearNotifiers()
x.addNotifier(self.TriggeredByConfigElement,
initial_call=False)
return
def TriggeredByConfigElement(self, configElement):
self.scan_ter.channel.removeNotifier(self.TriggeredByConfigElement)
self.scan_ter.frequency.removeNotifier(self.TriggeredByConfigElement)
self.createSetup()
self.scan_ter.channel.addNotifier(self.TriggeredByConfigElement,
initial_call=False)
self.scan_ter.frequency.addNotifier(self.TriggeredByConfigElement,
initial_call=False)
self.retune()
def retune(self):
nim = nimmanager.nim_slots[int(self.scan_nims.value)]
if nim.isCompatible(
'DVB-S') and nim.config.dvbs.configMode.value != 'nothing':
return self.retuneSat()
elif nim.isCompatible(
'DVB-T') and nim.config.dvbt.configMode.value != 'nothing':
return self.retuneTerr()
elif nim.isCompatible(
'DVB-C') and nim.config.dvbc.configMode.value != 'nothing':
return self.retuneCab()
elif nim.isCompatible(
'ATSC') and nim.config.atsc.configMode.value != 'nothing':
return self.retuneATSC()
else:
self.frontend = None
self.raw_channel = None
print 'error: tuner not enabled/supported', nim.getType()
return
def retuneCab(self):
if self.initcomplete:
if self.scan_typecable.value == 'single_transponder':
transponder = (self.scan_cab.frequency.value * 1000,
self.scan_cab.symbolrate.value * 1000,
self.scan_cab.modulation.value,
self.scan_cab.fec.value,
self.scan_cab.inversion.value)
self.tuner.tuneCab(transponder)
self.transponder = transponder
elif self.scan_typecable.value == 'predefined_transponder':
if self.CableTransponders is not None:
tps = nimmanager.getTranspondersCable(
int(self.scan_nims.value))
if len(tps) > self.CableTransponders.index:
tp = tps[self.CableTransponders.index]
transponder = (tp[1], tp[2], tp[3], tp[4], tp[5])
self.tuner.tuneCab(transponder)
self.transponder = transponder
return
def retuneTerr(self):
if self.initcomplete:
if self.scan_input_as.value == 'channel':
frequency = channel2frequency(self.scan_ter.channel.value,
self.ter_tnumber)
else:
frequency = self.scan_ter.frequency.value * 1000
if self.scan_typeterrestrial.value == 'single_transponder':
transponder = [
2, frequency, self.scan_ter.bandwidth.value,
self.scan_ter.modulation.value,
self.scan_ter.fechigh.value, self.scan_ter.feclow.value,
self.scan_ter.guard.value,
self.scan_ter.transmission.value,
self.scan_ter.hierarchy.value,
self.scan_ter.inversion.value, self.scan_ter.system.value,
self.scan_ter.plp_id.value
]
self.tuner.tuneTerr(transponder[1], transponder[9],
transponder[2], transponder[4],
transponder[5], transponder[3],
transponder[7], transponder[6],
transponder[8], transponder[10],
transponder[11])
self.transponder = transponder
elif self.scan_typeterrestrial.value == 'predefined_transponder':
if self.TerrestrialTransponders is not None:
region = nimmanager.getTerrestrialDescription(
int(self.scan_nims.value))
tps = nimmanager.getTranspondersTerrestrial(region)
if len(tps) > self.TerrestrialTransponders.index:
transponder = tps[self.TerrestrialTransponders.index]
self.tuner.tuneTerr(transponder[1], transponder[9],
transponder[2], transponder[4],
transponder[5], transponder[3],
transponder[7], transponder[6],
transponder[8], transponder[10],
transponder[11])
self.transponder = transponder
return
def retuneSat(self):
fe_id = int(self.scan_nims.value)
nimsats = self.satList[fe_id]
selsatidx = self.scan_satselection[fe_id].index
if len(nimsats):
orbpos = nimsats[selsatidx][0]
if self.initcomplete:
if self.scan_type.value == 'single_transponder':
if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
fec = self.scan_sat.fec_s2.value
else:
fec = self.scan_sat.fec.value
transponder = (self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
self.scan_sat.polarization.value, fec,
self.scan_sat.inversion.value, orbpos,
self.scan_sat.system.value,
self.scan_sat.modulation.value,
self.scan_sat.rolloff.value,
self.scan_sat.pilot.value,
self.scan_sat.is_id.value,
self.scan_sat.pls_mode.value,
self.scan_sat.pls_code.value)
self.tuner.tune(transponder)
self.transponder = transponder
elif self.scan_type.value == 'predefined_transponder':
tps = nimmanager.getTransponders(orbpos)
if len(tps) > self.preDefTransponders.index:
tp = tps[self.preDefTransponders.index]
transponder = (tp[1] / 1000, tp[2] / 1000, tp[3],
tp[4], 2, orbpos, tp[5], tp[6], tp[8],
tp[9], tp[10], tp[11], tp[12])
self.tuner.tune(transponder)
self.transponder = transponder
def retuneATSC(self):
if self.initcomplete:
if self.tuning_type.value == 'single_transponder':
transponder = (self.scan_ats.frequency.value * 1000,
self.scan_ats.modulation.value,
self.scan_ats.inversion.value,
self.scan_ats.system.value)
if self.initcomplete:
self.tuner.tuneATSC(transponder)
self.transponder = transponder
elif self.tuning_type.value == 'predefined_transponder':
tps = nimmanager.getTranspondersATSC(
int(self.satfinder_scan_nims.value))
if tps and len(tps) > self.ATSCTransponders.index:
tp = tps[self.ATSCTransponders.index]
transponder = (tp[1], tp[2], tp[3], tp[4])
if self.initcomplete:
self.tuner.tuneATSC(transponder)
self.transponder = transponder
def keyGoScan(self):
if self.transponder is None:
print 'error: no transponder data'
return
else:
fe_id = int(self.scan_nims.value)
nim = nimmanager.nim_slots[fe_id]
self.frontend = None
if self.raw_channel:
self.raw_channel = None
tlist = []
if nim.isCompatible('DVB-S'):
nimsats = self.satList[fe_id]
selsatidx = self.scan_satselection[fe_id].index
if len(nimsats):
orbpos = nimsats[selsatidx][0]
self.addSatTransponder(
tlist, self.transponder[0], self.transponder[1],
self.transponder[2], self.transponder[3],
self.transponder[4], orbpos, self.transponder[6],
self.transponder[7], self.transponder[8],
self.transponder[9], self.transponder[10],
self.transponder[11], self.transponder[12])
elif nim.isCompatible('DVB-T'):
parm = buildTerTransponder(
self.transponder[1], self.transponder[9],
self.transponder[2], self.transponder[4],
self.transponder[5], self.transponder[3],
self.transponder[7], self.transponder[6],
self.transponder[8], self.transponder[10],
self.transponder[11])
tlist.append(parm)
elif nim.isCompatible('DVB-C'):
self.addCabTransponder(tlist, self.transponder[0],
self.transponder[1],
self.transponder[2],
self.transponder[3],
self.transponder[4])
elif nim.isCompatible('ATSC'):
self.addATSCTransponder(tlist, self.transponder[0],
self.transponder[1],
self.transponder[2],
self.transponder[3])
else:
print 'error: tuner not enabled/supported', nim.getType()
self.startScan(tlist, fe_id)
return
def startScan(self, tlist, feid):
flags = 0
networkid = 0
self.session.openWithCallback(self.startScanCallback, ServiceScan,
[{
'transponders': tlist,
'feid': feid,
'flags': flags,
'networkid': networkid
}])
def startScanCallback(self, answer=None):
if answer:
self.doCloseRecursive()
def keyCancel(self):
if self.session.postScanService and self.frontend:
self.frontend = None
self.raw_channel = None
self.close(False)
return
def doCloseRecursive(self):
if self.session.postScanService and self.frontend:
self.frontend = None
self.raw_channel = None
self.close(True)
return
