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 SoftcamPanel(ConfigListScreen, Screen):
def __init__(self, session):
global emuDir
emuDir = "/etc/"
self.service = None
Screen.__init__(self, session)
self.skin = SOFTCAM_SKIN
self.onShown.append(self.setWindowTitle)
self.partyfeed = None
self.YellowAction = REFRESH
self.mlist = []
self["key_green"] = Label(_("Restart"))
self["key_red"] = Label(_("Stop"))
self["key_yellow"] = Label(_("Refresh"))
self.partyfeed = os.path.exists("/etc/opkg/3rdparty-feed.conf") or os.path.exists("/etc/opkg/3rd-party-feed.conf")
if self.partyfeed:
self["key_blue"]= Label(_("Install"))
else:
self["key_blue"]= Label(_("Exit"))
self["ecminfo"] = Label(_("No ECM info"))
self["actifcam"] = Label(_("no CAM 1 active"))
self["actifcam2"] = Label(_("no CAM 2 active"))
#// create listings
self.emuDirlist = []
self.emuList = []
self.emuBin = []
self.emuStart = []
self.emuStop = []
self.emuRgui = []
self.emuDirlist = os.listdir(emuDir)
self.ecmtel = 0
self.first = 0
global count
count = 0
#// check emu dir for config files
print "************ go in the emuloop ************"
for x in self.emuDirlist:
#// if file contains the string "emu" (then this is a emu config file)
if x.find("emu") > -1:
self.emuList.append(emuDir + x)
em = open(emuDir + x)
self.emuRgui.append(0)
#// read the emu config file
for line in em.readlines():
line1 = line
#// startcam
line = line1
if line.find("startcam") > -1:
line = line.split("=")
self.emuStart.append(line[1].strip())
#// stopcam
line = line1
if line.find("stopcam") > -1:
line = line.split("=")
self.emuStop.append(line[1].strip())
#// Restart GUI
line = line1
if line.find("restartgui") > -1:
self.emuRgui[count] = 1
#// binname
line = line1
if line.find("binname") > -1:
line = line.split("=")
self.emuBin.append(line[1].strip())
em.close()
count += 1
self.maxcount = count
self.onChangedEntry = [ ]
self.list = []
ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry)
self.ReadMenu()
self.createSetup()
self["ecminfo"].show()
self.read_shareinfo()
self.Timer = eTimer()
self.Timer.callback.append(self.layoutFinished)
self.Timer.start(2000, True)
#// get the remote buttons
self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ColorActions"],
{
"cancel": self.Exit,
"ok": self.ok,
"blue": self.Blue,
"red": self.Red,
"green": self.Green,
"yellow": self.Yellow,
}, -1)
#// update screen
self.onLayoutFinish.append(self.layoutFinished)
def setWindowTitle(self):
self.setTitle(_("Softcam Panel V2.0"))
def ReadMenu(self):
self.whichCam()
for x in self.emuDirlist:
#// if file contains the string "emu" (then this is a emu config file)
if x.find("emu") > -1:
self.emuList.append(emuDir + x)
em = open(emuDir + x)
self.emuRgui.append(0)
#// read the emu config file
for line in em.readlines():
line1 = line
#// emuname
line = line1
if line.find("emuname") > -1:
line = line.split("=")
self.mlist.append(line[1].strip())
name = line[1].strip()
em.close()
emusel = [_('no cam')]
for x in self.mlist:
emusel.append(x)
self.cam1sel = ConfigSelection(emusel)
self.cam2sel = ConfigSelection(emusel)
self.setYellowKey(self.curcam)
def whichCam(self):
#// check for active cam 1
cam = config.softcam.actCam.getValue()
self.curcam = None
self.curcamIndex = None
if cam in self.mlist:
index = self.mlist.index(cam)
x = self.emuBin[index]
if self.isCamrunning(x):
self.curcam = x
self.curcamIndex = index
#// check for active cam 2
cam = config.softcam.actCam2.getValue()
self.curcam2 = None
self.curcam2Index = None
if cam in self.mlist:
index = self.mlist.index(cam)
x = self.emuBin[index]
if self.isCamrunning(x):
self.curcam2 = x
self.curcam2Index = index
if not self.curcam and not self.curcam2 and self.mlist:
print "[SOFTCAMPANEL] try to find a running cam"
for cam in self.emuBin:
index = self.emuBin.index(cam)
if self.isCamrunning(cam):
self.curcam = cam
self.curcamIndex = index
camname = self.mlist[index]
print"[SOFTCAMPANEL] found %s running" % camname
self.Save_Settings(camname)
break
def createSetup(self):
self.editListEntry = None
self.list = []
self.list.append(getConfigListEntry(_("Select Cam 1"), self.cam1sel))
if len(self.emuStart) > 1:
self["actifcam2"].show()
if self.cam1sel.getValue() != _('no cam') or config.softcam.actCam.getValue() != _("no CAM 1 active"):
self.list.append(getConfigListEntry(_("Select Cam 2"), self.cam2sel))
if self.cam2sel.getValue() != _('no cam'):
self.list.append(getConfigListEntry(_("Wait time before start Cam 2"), config.softcam.waittime))
else:
self["actifcam2"].hide()
self.cam2sel.setValue(_('no cam'))
self["config"].list = self.list
self["config"].setList(self.list)
def setYellowKey(self, cam):
if cam == None or cam == _('no cam'):
self.YellowAction = REFRESH
self["key_yellow"].setText(_("Refresh"))
return
if cam.upper().startswith('CCCAM'):
self.YellowAction = CCCAMINFO
self["key_yellow"].setText(_("CCcamInfo"))
elif cam.upper().startswith('OSCAM'):
self.YellowAction = OSCAMINFO
self["key_yellow"].setText(_("OscamInfo"))
else:
self.YellowAction = REFRESH
self["key_yellow"].setText(_("Refresh"))
def selectionChanged(self):
#self["status"].setText(self["config"].getCurrent()[0])
pass
def changedEntry(self):
for x in self.onChangedEntry:
x()
self.selectionChanged()
self.createSetup()
def getCurrentEntry(self):
return self["config"].getCurrent()[0]
def getCurrentValue(self):
return str(self["config"].getCurrent()[1].getText())
def getCurrentDescription(self):
return self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2] or ""
def layoutFinished(self):
self.Timer.stop()
if not Check_Softcam():
self.Exit()
#// check for active cam
try:
self.whichCam()
global oldcamIndex, oldcam2Index
oldcamIndex = -1
oldcam2Index = -1
tel = 0
if self.curcam:
oldcamIndex = self.curcamIndex
actcam = self.mlist[oldcamIndex]
if self.first == 0:
self.cam1sel.setValue(actcam)
self["key_green"].setText(_("Restart"))
self["actifcam"].setText(_("active CAM 1: ") + actcam )
print '[SOFTCAM] set active cam 1 to: ' + actcam
else:
actcam = _("no CAM 1 active")
self["actifcam"].setText(actcam)
if self.curcam2:
oldcam2Index = self.curcam2Index
actcam = self.mlist[oldcam2Index]
if self.first == 0:
self.cam2sel.setValue(actcam)
self["actifcam2"].setText(_("active CAM 2: ") + actcam )
print '[SOFTCAM] set active cam 2 to: ' + actcam
else:
actcam2 = _("no CAM 2 active")
self["actifcam2"].setText(actcam2)
if self.first == 0: # Only update first time or when refresh button was pressed
self.createSetup()
self.first = 1
#// CAM IS NOT RUNNING
if not self.curcam and not self.curcam2:
self["key_green"].setText(_("Start"))
self.YellowAction = REFRESH
self["key_yellow"].setText(_("Refresh"))
if os.path.exists('/tmp/ecm.info') is True:
os.system("rm /tmp/ecm.info")
if os.path.exists('/tmp/ecm0.info') is True:
os.system("rm /tmp/ecm0.info")
except:
pass
if self["config"].getCurrent()[0] == _("Select Cam 1"):
self.setYellowKey(self.curcam)
else:
self.setYellowKey(self.curcam2)
#// read ecm.info
ecmi = ""
if os.path.exists('/tmp/ecm.info') is True:
ecmi = self.read_ecm('/tmp/ecm.info')
elif os.path.exists('/tmp/ecm1.info') is True:
ecmi = self.read_ecm('/tmp/ecm1.info')
else:
ecmi = _("No ECM info")
ecmold = self["ecminfo"].getText()
if ecmold == ecmi:
self.ecmtel += 1
if self.ecmtel > 5:
ecmi = _("No new ECM info")
else:
self.ecmtel = 0
self["ecminfo"].setText(ecmi)
self.Timer.start(2000, True) #reset timer
def read_shareinfo(self):
#// read share.info and put in list
self.shareinfo =[]
if os.path.exists('/tmp/share.info') is True:
s = open('/tmp/share.info')
for x in s.readlines():
self.shareinfo.append(x)
s.close()
def read_ecm(self, ecmpath):
#// read ecm.info and check for share.info
ecmi2 = ''
Caid = ''
Prov = ''
f = open(ecmpath)
for line in f.readlines():
line= line.replace('=', '')
line= line.replace(' ', '', 1)
#// search CaID
if line.find('ECM on CaID') > -1:
k = line.find('ECM on CaID') + 14
Caid = line[k:k+4]
#// search Boxid
if line.find('prov:') > -1:
tmpprov = line.split(':')
Prov = tmpprov[1].strip()
#// search peer in share.info only if share.info exists
if Caid <> '' and Prov <> '' and len(self.shareinfo) > 0 :
for x in self.shareinfo:
cel = x.split(' ')
#// search Boxid and Caid
if cel[5][0:4] == Caid and cel[9][3:7] == Prov:
line = 'Peer: ' + Prov + ' - ' + cel[3] + ' - ' + cel[8] + '\n'
break
ecmi2 = ecmi2 + line
f.close()
return ecmi2
def Red(self):
#// Stopping the CAM when pressing the RED button
self.Timer.stop()
self.Stopcam()
self.Timer.start(2000, True) #reset timer
def Yellow(self):
if self.YellowAction == CCCAMINFO:
self.Timer.stop()
self.session.openWithCallback(self.ShowSoftcamCallback, CCcamInfoMain)
elif self.YellowAction == OSCAMINFO:
self.Timer.stop()
self.session.openWithCallback(self.ShowSoftcamCallback, OscamInfoMenu)
else:
self.first = 0
self.layoutFinished()
def Green(self):
#// Start the CAM when pressing the GREEN button
self.Timer.stop()
self.Startcam()
self.Timer.start(2000, True) #reset timer
def Exit(self):
self.Timer.stop()
self.close()
def Blue(self):
if not self.partyfeed:
self.Exit()
else:
self.Timer.stop()
self.session.openWithCallback(self.ShowSoftcamCallback, ShowSoftcamPackages)
def ShowSoftcamCallback(self):
self.Timer.start(2000, True)
def ok(self):
#// Exit Softcam when pressing the OK button
self.Timer.stop()
self.Startcam()
if self.YellowAction == REFRESH:
self.Yellow()
self.Timer.start(2000, True) #reset timer
def Stopcam(self):
#// Stopping the CAM
global oldcamIndex, oldcam2Index
if oldcamIndex >= 0:
oldcam = self.emuBin[oldcamIndex]
else:
oldcam = None
if oldcam2Index >= 0:
oldcam2 = self.emuBin[oldcam2Index]
else:
oldcam2 = None
import time
self.container = eConsoleAppContainer()
if config.softcam.camstartMode.getValue() == "0" or not fileExists('/etc/init.d/softcam'):
if oldcam:
print '[SOFTCAM] Python stop cam 1: ' + oldcam
self.container.execute(self.emuStop[oldcamIndex])
time.sleep(1) # was 5sec
t = 0
while t < 5:
p = command('pidof %s |wc -w' % oldcam )
if not p.isdigit(): p=0
if int(p) > 0:
self.container = eConsoleAppContainer()
self.container.execute('killall -9 ' + oldcam)
t += 1
time.sleep(1)
else:
t = 5
if oldcam2:
print '[SOFTCAM] Python stop cam 2: ' + oldcam2
self.container.execute(self.emuStop[oldcam2Index])
time.sleep(1) # was 5sec
t = 0
while t < 5:
p = command('pidof %s |wc -w' % oldcam2 )
if not p.isdigit(): p=0
if int(p) > 0:
self.container = eConsoleAppContainer()
self.container.execute('killall -9 ' + oldcam2)
t += 1
time.sleep(1)
else:
t = 5
else:
self.container.execute('/etc/init.d/softcam.cam1 stop')
self.container.execute('/etc/init.d/softcam.cam2 stop')
if os.path.exists('/tmp/ecm.info') is True:
os.system("rm /tmp/ecm.info")
actcam = _("no CAM 1 active")
actcam2 = _("no CAM 2 active")
self["actifcam"].setText(actcam)
self["actifcam2"].setText(actcam2)
self["key_green"].setText(_("Start"))
self["ecminfo"].setText(_("No ECM info"))
self.Save_Settings(actcam)
self.Save_Settings2(actcam2)
def Startcam(self):
#// Starting the CAM
try:
if count > 0:
if self.cam1sel.getValue() == self.cam2sel.getValue():
self.session.openWithCallback(self.doNothing, MessageBox, _("No Cam started !!\n\nCam 1 must be different from Cam 2"), MessageBox.TYPE_ERROR, simple=True)
return
if config.softcam.camstartMode.getValue() == "0":
self.Stopcam()
self.camIndex = self.cam1sel.getIndex() -1
self.cam2Index = self.cam2sel.getIndex() - 1
if self.camIndex >= 0:
actcam = self.cam1sel.getValue()
self["actifcam"].setText(_("active CAM 1: ") + actcam)
self.Save_Settings(actcam)
start = self.emuStart[self.camIndex]
if self.checkBinName(self.emuBin[self.camIndex], start):
self.session.openWithCallback(self.startcam2, MessageBox, actcam + _(" Not Started !!\n\nCam binname must be in the start command line\nCheck your emu config file"), MessageBox.TYPE_ERROR, simple=True)
return
if config.softcam.camstartMode.getValue() == "0":
print '[SOFTCAM] Python start cam 1: ' + actcam
self.session.openWithCallback(self.waitTime, MessageBox, _("Starting Cam 1: ") + actcam, MessageBox.TYPE_WARNING, timeout=5, simple=True)
self.container = eConsoleAppContainer()
self.container.execute(start)
else:
# Create INIT.D start
self.session.openWithCallback(self.doNothing, MessageBox, _("Creating start scripts and starting the cam"), MessageBox.TYPE_WARNING, timeout=10, simple=True)
self.Save_Settings2(self.cam2sel.getValue())
camname1 = self.emuBin[self.camIndex]
camname2 = self.emuBin[self.cam2Index]
self.deleteInit()
camname = "/usr/bin/" + camname1
startcmd = self.emuStart[self.camIndex]
stopcmd = self.emuStop[self.camIndex]
self.createInitdscript("cam1", camname, startcmd, stopcmd)
if self.cam2Index >= 0:
camname = "/usr/bin/" + camname2
startcmd = self.emuStart[self.cam2Index]
stopcmd = self.emuStop[self.cam2Index]
self.createInitdscript("cam2", camname, startcmd, stopcmd, config.softcam.waittime.getValue())
self["key_green"].setText(_("Restart"))
except:
pass
def waitTime(self, ret):
if self.cam2Index >= 0:
if config.softcam.waittime.getValue() == '0':
self.startcam2(None)
else:
self.session.openWithCallback(self.startcam2, MessageBox, _("Waiting..."), MessageBox.TYPE_WARNING, timeout=int(config.softcam.waittime.getValue()), simple=True)
def doNothing(self, ret):
pass
def startcam2(self, ret):
camIndex = self.cam2Index
if camIndex >= 0:
actcam = self.cam2sel.getValue()
self["actifcam2"].setText(_("active CAM 2: ") + actcam)
self.Save_Settings2(actcam)
start = self.emuStart[camIndex]
if self.checkBinName(self.emuBin[self.cam2Index], start):
self.session.open(MessageBox, actcam + _(" Not Started !!\n\nCam binname must be in the start command line\nCheck your emu config file"), MessageBox.TYPE_ERROR, simple=True)
return
print '[SOFTCAM] Python start cam 2: ' + actcam
self.session.open(MessageBox, _("Starting Cam 2: ") + actcam, MessageBox.TYPE_WARNING, timeout=5, simple=True)
self.container = eConsoleAppContainer()
self.container.execute(start)
def Save_Settings(self, cam_name):
#// Save Came Name to Settings file
config.softcam.actCam.setValue(cam_name)
config.softcam.save()
configfile.save()
def Save_Settings2(self, cam_name):
#// Save Came Name to Settings file
config.softcam.actCam2.setValue(cam_name)
config.softcam.save()
configfile.save()
def isCamrunning(self, cam):
p = command('pidof ' + cam + ' |wc -w')
if not p.isdigit(): p=0
if int(p) > 0:
return True
else:
return False
def checkBinName(self, binname, start):
print "[CHECKBINNAME] bin=%s ,start=%s" %(binname,start)
if start.find(binname + ' ') > -1:
print "[CHECKBINNAME] OK"
return False
else:
if start[start.rfind('/')+1:] == binname:
print "[CHECKBINNAME] OK"
return False
else:
print "[CHECKBINNAME] ERROR"
return True
def createInitdscript(self, camname, emubin, start, stop, wait=None):
Adir = "/etc/init.d/softcam." + camname
softcamfile = []
softcamfile.append('#!/bin/sh')
softcamfile.append('DAEMON=%s' % emubin)
softcamfile.append('STARTCAM="%s"' % start)
softcamfile.append('STOPCAM="%s"' % stop)
softcamfile.append('DESC="Softcam"')
softcamfile.append('')
softcamfile.append('test -f $DAEMON || exit 0')
softcamfile.append('set -e')
softcamfile.append('')
softcamfile.append('case "$1" in')
softcamfile.append(' start)')
softcamfile.append(' echo -n "starting $DESC: $DAEMON... "')
if wait:
softcamfile.append(' sleep ' + wait)
softcamfile.append(' $STARTCAM')
softcamfile.append(' echo "done."')
softcamfile.append(' ;;')
softcamfile.append(' stop)')
softcamfile.append(' echo -n "stopping $DESC: $DAEMON... "')
softcamfile.append(' $STOPCAM')
softcamfile.append(' echo "done."')
softcamfile.append(' ;;')
softcamfile.append(' restart)')
softcamfile.append(' echo "restarting $DESC: $DAEMON... "')
softcamfile.append(' $0 stop')
softcamfile.append(' echo "wait..."')
softcamfile.append(' sleep 5')
softcamfile.append(' $0 start')
softcamfile.append(' echo "done."')
softcamfile.append(' ;;')
softcamfile.append(' *)')
softcamfile.append(' echo "Usage: $0 {start|stop|restart}"')
softcamfile.append(' exit 1')
softcamfile.append(' ;;')
softcamfile.append('esac')
softcamfile.append('')
softcamfile.append('exit 0')
f = open( Adir, "w" )
for x in softcamfile:
f.writelines(x + '\n')
f.close()
self.container = eConsoleAppContainer()
# Set execute rights
os.chmod(Adir,0755)
# Create symbolic link for startup
if not os.path.exists("/etc/rc2.d/S20softcam." + camname):
self.container.execute('update-rc.d -f softcam.' + camname + ' defaults')
# Wait a few seconds
import time
time.sleep (3)
# Start cam
if self.isCamrunning(emubin):
self.container.execute('/etc/init.d/softcam.' + camname + ' restart')
else:
self.container.execute('/etc/init.d/softcam.' + camname + ' start')
def deleteInit(self):
if os.path.exists("/etc/rc2.d/S20softcam.cam1"):
print "Delete Symbolink link"
self.container = eConsoleAppContainer()
self.container.execute('update-rc.d -f softcam.cam1 defaults')
if os.path.exists("/etc/init.d/softcam.cam1"):
print "Delete softcam init script cam1"
os.system("rm /etc/init.d/softcam.cam1")
if os.path.exists("/etc/rc2.d/S20softcam.cam2"):
print "Delete Symbolink link"
self.container = eConsoleAppContainer()
self.container.execute('update-rc.d -f softcam.cam2 defaults')
if os.path.exists("/etc/init.d/softcam.cam2"):
print "Delete softcam init script cam2"
os.system("rm /etc/init.d/softcam.cam2")
class KeymapSel(ConfigListScreen, Screen):
def __init__(self, session):
Screen.__init__(self, session)
self.session = session
self.skinName = ["SetupInfo", "Setup" ]
Screen.setTitle(self, _("Keymap Selection") + "...")
self.setup_title = _("Keymap Selection") + "..."
self["HelpWindow"] = Pixmap()
self["HelpWindow"].hide()
self["status"] = StaticText()
self['footnote'] = Label("")
self["description"] = Label("")
self["labelInfo"] = Label(_("Copy your keymap to\n/usr/share/enigma2/keymap.usr"))
usrkey = eEnv.resolve("${datadir}/enigma2/keymap.usr")
ntrkey = eEnv.resolve("${datadir}/enigma2/keymap.ntr")
u80key = eEnv.resolve("${datadir}/enigma2/keymap.u80")
self.actkeymap = self.getKeymap(config.usage.keymap.getValue())
keySel = [ ('keymap.xml',_("Default (keymap.xml)"))]
if os.path.isfile(usrkey):
keySel.append(('keymap.usr',_("User (keymap.usr)")))
if os.path.isfile(ntrkey):
keySel.append(('keymap.ntr',_("Neutrino (keymap.ntr)")))
if os.path.isfile(u80key):
keySel.append(('keymap.u80',_("UP80 (keymap.u80)")))
if self.actkeymap == usrkey and not os.path.isfile(usrkey):
setDefaultKeymap()
if self.actkeymap == ntrkey and not os.path.isfile(ntrkey):
setDefaultKeymap()
if self.actkeymap == u80key and not os.path.isfile(u80key):
setDefaultKeymap()
self.keyshow = ConfigSelection(keySel)
self.keyshow.setValue(self.actkeymap)
self.onChangedEntry = [ ]
self.list = []
ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry)
self.createSetup()
self["actions"] = ActionMap(["SetupActions", 'ColorActions'],
{
"ok": self.keySave,
"cancel": self.keyCancel,
"red": self.keyCancel,
"green": self.keySave,
"menu": self.keyCancel,
}, -2)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
if not self.selectionChanged in self["config"].onSelectionChanged:
self["config"].onSelectionChanged.append(self.selectionChanged)
self.selectionChanged()
def createSetup(self):
self.editListEntry = None
self.list = []
self.list.append(getConfigListEntry(_("Use Keymap"), self.keyshow))
self["config"].list = self.list
self["config"].setList(self.list)
if config.usage.sort_settings.getValue():
self["config"].list.sort()
def selectionChanged(self):
self["status"].setText(self["config"].getCurrent()[0])
def changedEntry(self):
for x in self.onChangedEntry:
x()
self.selectionChanged()
def getCurrentEntry(self):
return self["config"].getCurrent()[0]
def getCurrentValue(self):
return str(self["config"].getCurrent()[1].getText())
def getCurrentDescription(self):
return self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2] or ""
def createSummary(self):
from Screens.Setup import SetupSummary
return SetupSummary
def saveAll(self):
config.usage.keymap.setValue(eEnv.resolve("${datadir}/enigma2/" + self.keyshow.getValue()))
config.usage.keymap.save()
configfile.save()
if self.actkeymap != self.keyshow.getValue():
self.changedFinished()
def keySave(self):
self.saveAll()
self.close()
def cancelConfirm(self, result):
if not result:
return
for x in self["config"].list:
x[1].cancel()
self.close()
def keyCancel(self):
if self["config"].isChanged():
self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
else:
self.close()
def getKeymap(self, file):
return file[file.rfind('/') +1:]
def changedFinished(self):
self.session.openWithCallback(self.ExecuteRestart, MessageBox, _("Keymap changed, you need to restart the GUI") +"\n"+_("Do you want to restart now?"), MessageBox.TYPE_YESNO)
self.close()
def ExecuteRestart(self, result):
if result:
quitMainloop(3)
else:
self.close()
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 TranscodingSetup(ConfigListScreen, Screen):
skin = """
<screen position="center,center" size="500,114" title="Transcoding Setup">
<widget name="content" position="0,0" size="500,22" font="Regular;20" />
<widget name="config" position="4,26" font="Regular;20" size="492,60" />
<ePixmap pixmap="skin_default/buttons/red.png" position="0,76" size="140,40" alphatest="on" />
<ePixmap pixmap="skin_default/buttons/green.png" position="150,76" size="140,40" alphatest="on" />
<widget source="key_red" render="Label" position="0,76" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1"/>
<widget source="key_green" render="Label" position="150,76" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1"/>
</screen>
"""
def __init__(self, session):
bitrate_choices = [( 50, "50 kbps" ), ( 100, "100 kbps" ), ( 200, "200 kbps" ), ( 500, "500 kbps" ), ( 1000, "1 Mbps" ), ( 2000, "2 Mbps" )]
size_choices = [ "480p", "576p", "720p" ]
current_bitrate_value = ""
current_size = ""
Screen.__init__(self, session)
self.setTitle(_("Transcoding Setup"))
config_list = []
ConfigListScreen.__init__(self, config_list)
self.bitrate = ConfigSelection(choices = bitrate_choices)
self.size = ConfigSelection(choices = size_choices)
self.statusTimer = eTimer()
self.warningTimer = eTimer()
vumodel = None
boxtype = None
transcoding = None
port = None
try:
f = open("/proc/stb/info/vumodel", "r")
vumodel = f.readlines()
vumodel = [x.translate(None, ' \n\r') for x in vumodel]
vumodel = vumodel[0]
f.close()
except:
pass
try:
f = open("/proc/stb/info/boxtype", "r")
boxtype = f.readlines()
boxtype = [x.translate(None, ' \n\r') for x in boxtype]
boxtype = boxtype[0]
f.close()
except:
pass
if vumodel == "solo2" or vumodel == "duo2" or vumodel == "solose":
transcoding = "vuplus"
else:
if boxtype == "et10000" or boxtype == "hd2400":
transcoding = "enigma"
if transcoding == "vuplus":
port = 8002
elif transcoding == "enigma":
port = 8001
elif transcoding is None:
self.statusTimer.callback.append(self.setErrorMessage)
self.statusTimer.start(500, True)
return
config_list.append(getConfigListEntry(_("Bitrate"), self.bitrate))
config_list.append(getConfigListEntry(_("Video size"), self.size))
self["config"].list = config_list
if config.plugins.transcodingsetup.framerate.value is None:
config.plugins.transcodingsetup.framerate.value = 30000
if config.plugins.transcodingsetup.aspectratio.value is None:
config.plugins.transcodingsetup.aspectratio.value = 2
if config.plugins.transcodingsetup.interlaced.value is None:
config.plugins.transcodingsetup.interlaced.value = 0
if config.plugins.transcodingsetup.port.value is None:
config.plugins.transcodingsetup.port.value = port
rawcontent = []
try:
f = open(TRANSCODING_CONFIG, "r")
rawcontent = f.readlines()
rawcontent = [x.translate(None, ' \n\r') for x in rawcontent]
f.close()
except:
self.warningTimer.callback.append(self.setWarningMessage)
self.warningTimer.start(500, True)
self.content = []
for line in rawcontent:
if not line.startswith('#') and not line.startswith(';'):
tokens = line.split('=')
if(tokens[0] == "bitrate"):
for tuple in bitrate_choices:
if int(tokens[1]) <= int(tuple[0]):
self.bitrate.setValue(tuple[0])
break
if(tokens[0] == "size"):
self.size.setValue(tokens[1])
self.content += [ tokens ]
self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "ColorActions"],
{
"red": self.keyCancel,
"green": self.keyGo,
"ok": self.keyGo,
"cancel": self.keyCancel,
}, -2)
self["key_red"] = StaticText(_("Quit"))
self["key_green"] = StaticText(_("Set"))
self["content"] = Label(_("Default values for trancoding"))
def setWarningMessage(self):
self.session.open(MessageBox, _("Not found file '/etc/enigma2/streamproxy.conf' !"), MessageBox.TYPE_WARNING)
def setErrorMessage(self):
self.session.openWithCallback(self.closeCallback, MessageBox, _("It seems your receiver is not supported!"), MessageBox.TYPE_ERROR)
def closeCallback(self, answer):
self.close()
def keyLeft(self):
ConfigListScreen.keyLeft(self)
def keyRight(self):
ConfigListScreen.keyRight(self)
def keyCancel(self):
self.close()
def keyGo(self):
for token in self.content:
if(token[0] == "bitrate"):
token[1] = self.bitrate.value
if(token[0] == "size"):
token[1] = self.size.value
try:
f = open(TRANSCODING_CONFIG, "w")
for token in self.content:
f.write("%s = %s\n" % (token[0], token[1]))
f.close()
except:
pass
if self.size.value == "480p":
resx = 720
resy = 480
else:
if self.size.value == "576p":
resx = 720
resy = 576
else:
if self.size.value == "720p":
resx = 1280
resy = 720
resolution = "%dx%d" % (resx, resy)
config.plugins.transcodingsetup.port.save()
config.plugins.transcodingsetup.bitrate.value = self.bitrate.value * 1000
config.plugins.transcodingsetup.bitrate.save()
config.plugins.transcodingsetup.resolution.value = resolution
config.plugins.transcodingsetup.resolution.save()
config.plugins.transcodingsetup.framerate.save()
config.plugins.transcodingsetup.aspectratio.save()
config.plugins.transcodingsetup.interlaced.save()
configfile.save()
self.close()
def KeyNone(self):
None
def callbackNone(self, *retval):
None
class KeymapSel(ConfigListScreen, Screen):
def __init__(self, session):
Screen.__init__(self, session)
self.session = session
self.skinName = ["SetupInfo", "Setup"]
Screen.setTitle(self, _("Keymap Selection") + "...")
self.setup_title = _("Keymap Selection") + "..."
self["HelpWindow"] = Pixmap()
self["HelpWindow"].hide()
self["status"] = StaticText()
self['footnote'] = Label("")
self["description"] = Label("")
self["labelInfo"] = Label(
_("Copy your keymap to\n/usr/share/enigma2/keymap.usr"))
usrkey = eEnv.resolve("${datadir}/enigma2/keymap.usr")
ntrkey = eEnv.resolve("${datadir}/enigma2/keymap.ntr")
u80key = eEnv.resolve("${datadir}/enigma2/keymap.u80")
self.actkeymap = self.getKeymap(config.usage.keymap.getValue())
keySel = [('keymap.xml', _("Default (keymap.xml)"))]
if os.path.isfile(usrkey):
keySel.append(('keymap.usr', _("User (keymap.usr)")))
if os.path.isfile(ntrkey):
keySel.append(('keymap.ntr', _("Neut (keymap.ntr)")))
if os.path.isfile(u80key):
keySel.append(('keymap.u80', _("UP80 (keymap.u80)")))
if self.actkeymap == usrkey and not os.path.isfile(usrkey):
setDefaultKeymap()
if self.actkeymap == ntrkey and not os.path.isfile(ntrkey):
setDefaultKeymap()
if self.actkeymap == u80key and not os.path.isfile(u80key):
setDefaultKeymap()
self.keyshow = ConfigSelection(keySel)
self.keyshow.setValue(self.actkeymap)
self.onChangedEntry = []
self.list = []
ConfigListScreen.__init__(self,
self.list,
session=self.session,
on_change=self.changedEntry)
self.createSetup()
self["actions"] = ActionMap(
["SetupActions", 'ColorActions'], {
"ok": self.keySave,
"cancel": self.keyCancel,
"red": self.keyCancel,
"green": self.keySave,
"menu": self.keyCancel,
}, -2)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
if not self.selectionChanged in self["config"].onSelectionChanged:
self["config"].onSelectionChanged.append(self.selectionChanged)
self.selectionChanged()
def createSetup(self):
self.editListEntry = None
self.list = []
self.list.append(getConfigListEntry(_("Use Keymap"), self.keyshow))
self["config"].list = self.list
self["config"].setList(self.list)
if config.usage.sort_settings.getValue():
self["config"].list.sort()
def selectionChanged(self):
self["status"].setText(self["config"].getCurrent()[0])
def changedEntry(self):
for x in self.onChangedEntry:
x()
self.selectionChanged()
def getCurrentEntry(self):
return self["config"].getCurrent()[0]
def getCurrentValue(self):
return str(self["config"].getCurrent()[1].getText())
def getCurrentDescription(self):
return self["config"].getCurrent() and len(self["config"].getCurrent(
)) > 2 and self["config"].getCurrent()[2] or ""
def createSummary(self):
from Screens.Setup import SetupSummary
return SetupSummary
def saveAll(self):
config.usage.keymap.setValue(
eEnv.resolve("${datadir}/enigma2/" + self.keyshow.getValue()))
config.usage.keymap.save()
configfile.save()
if self.actkeymap != self.keyshow.getValue():
self.changedFinished()
def keySave(self):
self.saveAll()
self.close()
def cancelConfirm(self, result):
if not result:
return
for x in self["config"].list:
x[1].cancel()
self.close()
def keyCancel(self):
if self["config"].isChanged():
self.session.openWithCallback(
self.cancelConfirm, MessageBox,
_("Really close without saving settings?"))
else:
self.close()
def getKeymap(self, file):
return file[file.rfind('/') + 1:]
def changedFinished(self):
self.session.openWithCallback(
self.ExecuteRestart, MessageBox,
_("Keymap changed, you need to restart the GUI") + "\n" +
_("Do you want to restart now?"), MessageBox.TYPE_YESNO)
self.close()
def ExecuteRestart(self, result):
if result:
quitMainloop(3)
else:
self.close()
class KeymapSel(ConfigListScreen, Screen):
def __init__(self, session):
Screen.__init__(self, session)
self.session = session
self.skinName = ['SetupInfo', 'Setup']
Screen.setTitle(self, _('Keymap Selection') + '...')
self.setup_title = _('Keymap Selection') + '...'
self['HelpWindow'] = Pixmap()
self['HelpWindow'].hide()
self['status'] = StaticText()
self['footnote'] = Label('')
self['description'] = Label('')
self['labelInfo'] = Label(_('Copy your keymap to\n/usr/share/enigma2/keymap.usr'))
mqbkey = eEnv.resolve('${datadir}/enigma2/keymap.mqb')
usrkey = eEnv.resolve('${datadir}/enigma2/keymap.usr')
ntrkey = eEnv.resolve('${datadir}/enigma2/keymap.ntr')
u80key = eEnv.resolve('${datadir}/enigma2/keymap.u80')
self.actkeymap = self.getKeymap(config.usage.keymap.getValue())
keySel = [('keymap.xml', _('Default (keymap.xml)'))]
if os.path.isfile(mqbkey):
keySel.append(('keymap.mqb', _('ET-MultiQuickButton (keymap.mqb)')))
if os.path.isfile(usrkey):
keySel.append(('keymap.usr', _('User (keymap.usr)')))
if os.path.isfile(ntrkey):
keySel.append(('keymap.ntr', _('Neutrino (keymap.ntr)')))
if os.path.isfile(u80key):
keySel.append(('keymap.u80', _('UP80 (keymap.u80)')))
if self.actkeymap == usrkey and not os.path.isfile(usrkey):
setDefaultKeymap()
if self.actkeymap == ntrkey and not os.path.isfile(ntrkey):
setDefaultKeymap()
if self.actkeymap == u80key and not os.path.isfile(u80key):
setDefaultKeymap()
self.keyshow = ConfigSelection(keySel)
self.keyshow.setValue(self.actkeymap)
self.onChangedEntry = []
self.list = []
ConfigListScreen.__init__(self, self.list, session=self.session, on_change=self.changedEntry)
self.createSetup()
self['actions'] = ActionMap(['SetupActions', 'ColorActions'], {'ok': self.keySave,
'cancel': self.keyCancel,
'red': self.keyCancel,
'green': self.keySave,
'menu': self.keyCancel}, -2)
self['key_red'] = StaticText(_('Cancel'))
self['key_green'] = StaticText(_('OK'))
if self.selectionChanged not in self['config'].onSelectionChanged:
self['config'].onSelectionChanged.append(self.selectionChanged)
self.selectionChanged()
def createSetup(self):
self.editListEntry = None
self.list = []
self.list.append(getConfigListEntry(_('Use Keymap'), self.keyshow))
self['config'].list = self.list
self['config'].setList(self.list)
return
def selectionChanged(self):
self['status'].setText(self['config'].getCurrent()[0])
def changedEntry(self):
for x in self.onChangedEntry:
x()
self.selectionChanged()
def getCurrentEntry(self):
return self['config'].getCurrent()[0]
def getCurrentValue(self):
return str(self['config'].getCurrent()[1].getText())
def getCurrentDescription(self):
return self['config'].getCurrent() and len(self['config'].getCurrent()) > 2 and self['config'].getCurrent()[2] or ''
def createSummary(self):
from Screens.Setup import SetupSummary
return SetupSummary
def saveAll(self):
config.usage.keymap.setValue(eEnv.resolve('${datadir}/enigma2/' + self.keyshow.getValue()))
config.usage.keymap.save()
configfile.save()
if self.actkeymap != self.keyshow.getValue():
self.changedFinished()
def keySave(self):
self.saveAll()
self.close()
def cancelConfirm(self, result):
if not result:
return
for x in self['config'].list:
x[1].cancel()
self.close()
def keyCancel(self):
if self['config'].isChanged():
self.session.openWithCallback(self.cancelConfirm, MessageBox, _('Really close without saving settings?'))
else:
self.close()
def getKeymap(self, file):
return file[file.rfind('/') + 1:]
def changedFinished(self):
self.session.openWithCallback(self.ExecuteRestart, MessageBox, _('Keymap changed, you need to restart the GUI') + '\n' + _('Do you want to restart now?'), MessageBox.TYPE_YESNO)
self.close()
def ExecuteRestart(self, result):
if result:
quitMainloop(3)
else:
self.close()
class TranscodingSetup(ConfigListScreen, Screen):
skin = """
<screen position="center,center" size="500,114" title="Transcoding Setup">
<widget name="content" position="0,0" size="500,22" font="Regular;20" />
<widget name="config" position="4,26" font="Regular;20" size="492,60" />
<ePixmap pixmap="skin_default/buttons/red.png" position="0,76" size="140,40" alphatest="on" />
<ePixmap pixmap="skin_default/buttons/green.png" position="150,76" size="140,40" alphatest="on" />
<widget source="key_red" render="Label" position="0,76" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1"/>
<widget source="key_green" render="Label" position="150,76" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1"/>
</screen>
"""
def __init__(self, session):
bitrate_choices = [(50, "50 kbps"), (100, "100 kbps"),
(200, "200 kbps"), (500, "500 kbps"),
(1000, "1 Mbps"), (2000, "2 Mbps")]
size_choices = ["480p", "576p", "720p"]
current_bitrate_value = ""
current_size = ""
Screen.__init__(self, session)
self.setTitle(_("Transcoding Setup"))
config_list = []
ConfigListScreen.__init__(self, config_list)
self.bitrate = ConfigSelection(choices=bitrate_choices)
self.size = ConfigSelection(choices=size_choices)
self.statusTimer = eTimer()
self.warningTimer = eTimer()
vumodel = None
boxtype = None
transcoding = None
port = None
try:
f = open("/proc/stb/info/vumodel", "r")
vumodel = f.readlines()
vumodel = [x.translate(None, ' \n\r') for x in vumodel]
vumodel = vumodel[0]
f.close()
except:
pass
try:
f = open("/proc/stb/info/boxtype", "r")
boxtype = f.readlines()
boxtype = [x.translate(None, ' \n\r') for x in boxtype]
boxtype = boxtype[0]
f.close()
except:
pass
if vumodel == "solo2" or vumodel == "duo2" or vumodel == "solose":
transcoding = "vuplus"
else:
if boxtype == "et10000" or boxtype == "hd2400":
transcoding = "enigma"
if transcoding == "vuplus":
port = 8002
elif transcoding == "enigma":
port = 8001
elif transcoding is None:
self.statusTimer.callback.append(self.setErrorMessage)
self.statusTimer.start(500, True)
return
config_list.append(getConfigListEntry(_("Bitrate"), self.bitrate))
config_list.append(getConfigListEntry(_("Video size"), self.size))
self["config"].list = config_list
if config.plugins.transcodingsetup.framerate.value is None:
config.plugins.transcodingsetup.framerate.value = 30000
if config.plugins.transcodingsetup.aspectratio.value is None:
config.plugins.transcodingsetup.aspectratio.value = 2
if config.plugins.transcodingsetup.interlaced.value is None:
config.plugins.transcodingsetup.interlaced.value = 0
if config.plugins.transcodingsetup.port.value is None:
config.plugins.transcodingsetup.port.value = port
rawcontent = []
try:
f = open(TRANSCODING_CONFIG, "r")
rawcontent = f.readlines()
rawcontent = [x.translate(None, ' \n\r') for x in rawcontent]
f.close()
except:
self.warningTimer.callback.append(self.setWarningMessage)
self.warningTimer.start(500, True)
self.content = []
for line in rawcontent:
if not line.startswith('#') and not line.startswith(';'):
tokens = line.split('=')
if (tokens[0] == "bitrate"):
for tuple in bitrate_choices:
if int(tokens[1]) <= int(tuple[0]):
self.bitrate.setValue(tuple[0])
break
if (tokens[0] == "size"):
self.size.setValue(tokens[1])
self.content += [tokens]
self["actions"] = ActionMap(
["OkCancelActions", "ShortcutActions", "ColorActions"], {
"red": self.keyCancel,
"green": self.keyGo,
"ok": self.keyGo,
"cancel": self.keyCancel,
}, -2)
self["key_red"] = StaticText(_("Quit"))
self["key_green"] = StaticText(_("Set"))
self["content"] = Label(_("Default values for trancoding"))
def setWarningMessage(self):
self.session.open(
MessageBox, _("Not found file '/etc/enigma2/streamproxy.conf' !"),
MessageBox.TYPE_WARNING)
def setErrorMessage(self):
self.session.openWithCallback(
self.closeCallback, MessageBox,
_("It seems your receiver is not supported!"),
MessageBox.TYPE_ERROR)
def closeCallback(self, answer):
self.close()
def keyLeft(self):
ConfigListScreen.keyLeft(self)
def keyRight(self):
ConfigListScreen.keyRight(self)
def keyCancel(self):
self.close()
def keyGo(self):
for token in self.content:
if (token[0] == "bitrate"):
token[1] = self.bitrate.value
if (token[0] == "size"):
token[1] = self.size.value
try:
f = open(TRANSCODING_CONFIG, "w")
for token in self.content:
f.write("%s = %s\n" % (token[0], token[1]))
f.close()
except:
pass
if self.size.value == "480p":
resx = 720
resy = 480
else:
if self.size.value == "576p":
resx = 720
resy = 576
else:
if self.size.value == "720p":
resx = 1280
resy = 720
resolution = "%dx%d" % (resx, resy)
config.plugins.transcodingsetup.port.save()
config.plugins.transcodingsetup.bitrate.value = self.bitrate.value * 1000
config.plugins.transcodingsetup.bitrate.save()
config.plugins.transcodingsetup.resolution.value = resolution
config.plugins.transcodingsetup.resolution.save()
config.plugins.transcodingsetup.framerate.save()
config.plugins.transcodingsetup.aspectratio.save()
config.plugins.transcodingsetup.interlaced.save()
configfile.save()
self.close()
def KeyNone(self):
None
def callbackNone(self, *retval):
None
class SoftcamPanel(ConfigListScreen, Screen):
def __init__(self, session):
global count
global emuDir
emuDir = '/etc/'
self.service = None
Screen.__init__(self, session)
self.skin = SOFTCAM_SKIN
self.onShown.append(self.setWindowTitle)
self.partyfeed = None
self.YellowAction = REFRESH
self.mlist = []
self['key_green'] = Label(_('ReStart'))
self['key_red'] = Label(_('Stop'))
self['key_yellow'] = Label(_('Refresh'))
self.partyfeed = os.path.exists(
'/etc/opkg/3rdparty-feed.conf') or os.path.exists(
'/etc/opkg/3rd-party-feed.conf')
if self.partyfeed:
self['key_blue'] = Label(_('Install'))
else:
self['key_blue'] = Label(_('Exit'))
self['ecminfo'] = Label(_('No ECM info'))
self['actifcam'] = Label(_('no CAM 1 active'))
self['actifcam2'] = Label(_('no CAM 2 active'))
self.emuDirlist = []
self.emuList = []
self.emuBin = []
self.emuStart = []
self.emuStop = []
self.emuRgui = []
self.emuDirlist = os.listdir(emuDir)
self.ecmtel = 0
self.first = 0
count = 0
print '************ go in the emuloop ************'
for x in self.emuDirlist:
if x.find('emu') > -1:
self.emuList.append(emuDir + x)
em = open(emuDir + x)
self.emuRgui.append(0)
for line in em.readlines():
line1 = line
line = line1
if line.find('startcam') > -1:
line = line.split('=')
self.emuStart.append(line[1].strip())
line = line1
if line.find('stopcam') > -1:
line = line.split('=')
self.emuStop.append(line[1].strip())
line = line1
if line.find('restartgui') > -1:
self.emuRgui[count] = 1
line = line1
if line.find('binname') > -1:
line = line.split('=')
self.emuBin.append(line[1].strip())
em.close()
count += 1
self.maxcount = count
self.onChangedEntry = []
self.list = []
ConfigListScreen.__init__(self,
self.list,
session=self.session,
on_change=self.changedEntry)
self.ReadMenu()
self.createSetup()
self['ecminfo'].show()
self.read_shareinfo()
self.Timer = eTimer()
self.Timer.callback.append(self.layoutFinished)
self.Timer.start(2000, True)
self['actions'] = ActionMap(
['OkCancelActions', 'DirectionActions', 'ColorActions'], {
'cancel': self.Exit,
'ok': self.ok,
'blue': self.Blue,
'red': self.Red,
'green': self.Green,
'yellow': self.Yellow
}, -1)
self.onLayoutFinish.append(self.layoutFinished)
return
def setWindowTitle(self):
self.setTitle(_('Softcam Panel V2.0'))
def ReadMenu(self):
self.whichCam()
for x in self.emuDirlist:
if x.find('emu') > -1:
self.emuList.append(emuDir + x)
em = open(emuDir + x)
self.emuRgui.append(0)
for line in em.readlines():
line1 = line
line = line1
if line.find('emuname') > -1:
line = line.split('=')
self.mlist.append(line[1].strip())
name = line[1].strip()
em.close()
emusel = [_('no cam')]
for x in self.mlist:
emusel.append(x)
self.cam1sel = ConfigSelection(emusel)
self.cam2sel = ConfigSelection(emusel)
self.setYellowKey(self.curcam)
def whichCam(self):
cam = config.softcam.actCam.value
self.curcam = None
self.curcamIndex = None
if cam in self.mlist:
index = self.mlist.index(cam)
x = self.emuBin[index]
if self.isCamrunning(x):
self.curcam = x
self.curcamIndex = index
cam = config.softcam.actCam2.value
self.curcam2 = None
self.curcam2Index = None
if cam in self.mlist:
index = self.mlist.index(cam)
x = self.emuBin[index]
if self.isCamrunning(x):
self.curcam2 = x
self.curcam2Index = index
if not self.curcam and not self.curcam2 and self.mlist:
print '[SOFTCAMPANEL] try to find a running cam'
for cam in self.emuBin:
index = self.emuBin.index(cam)
if self.isCamrunning(cam):
self.curcam = cam
self.curcamIndex = index
camname = self.mlist[index]
print '[SOFTCAMPANEL] found %s running' % camname
self.Save_Settings(camname)
break
return
def createSetup(self):
self.editListEntry = None
self.list = []
self.list.append(getConfigListEntry(_('Select Cam 1'), self.cam1sel))
if len(self.emuStart) > 1:
self['actifcam2'].show()
if self.cam1sel.value != _(
'no cam') or config.softcam.actCam.value != _(
'no CAM 1 active'):
self.list.append(
getConfigListEntry(_('Select Cam 2'), self.cam2sel))
if self.cam2sel.value != _('no cam'):
self.list.append(
getConfigListEntry(_('Wait time before start Cam 2'),
config.softcam.waittime))
else:
self['actifcam2'].hide()
self.cam2sel.setValue(_('no cam'))
self['config'].list = self.list
self['config'].setList(self.list)
return
def setYellowKey(self, cam):
if cam == None or cam == _('no cam'):
self.YellowAction = REFRESH
self['key_yellow'].setText(_('Refresh'))
return
else:
if cam.upper().startswith('CCCAM'):
self.YellowAction = CCCAMINFO
self['key_yellow'].setText(_('CCcamInfo'))
elif cam.upper().startswith('OSCAM'):
self.YellowAction = OSCAMINFO
self['key_yellow'].setText(_('OscamInfo'))
else:
self.YellowAction = REFRESH
self['key_yellow'].setText(_('Refresh'))
return
def selectionChanged(self):
pass
def changedEntry(self):
for x in self.onChangedEntry:
x()
self.selectionChanged()
self.createSetup()
def getCurrentEntry(self):
return self['config'].getCurrent()[0]
def getCurrentValue(self):
return str(self['config'].getCurrent()[1].getText())
def getCurrentDescription(self):
return self['config'].getCurrent() and len(self['config'].getCurrent(
)) > 2 and self['config'].getCurrent()[2] or ''
def layoutFinished(self):
global oldcamIndex
global oldcam2Index
self.Timer.stop()
if not Check_Softcam():
self.Exit()
try:
self.whichCam()
oldcamIndex = -1
oldcam2Index = -1
tel = 0
if self.curcam:
oldcamIndex = self.curcamIndex
actcam = self.mlist[oldcamIndex]
if self.first == 0:
self.cam1sel.setValue(actcam)
self['key_green'].setText(_('ReStart'))
self['actifcam'].setText(_('active CAM 1: ') + actcam)
print '[SOFTCAM] set active cam 1 to: ' + actcam
else:
actcam = _('no CAM 1 active')
self['actifcam'].setText(actcam)
if self.curcam2:
oldcam2Index = self.curcam2Index
actcam = self.mlist[oldcam2Index]
if self.first == 0:
self.cam2sel.setValue(actcam)
self['actifcam2'].setText(_('active CAM 2: ') + actcam)
print '[SOFTCAM] set active cam 2 to: ' + actcam
else:
actcam2 = _('no CAM 2 active')
self['actifcam2'].setText(actcam2)
if self.first == 0:
self.createSetup()
self.first = 1
if not self.curcam and not self.curcam2:
self['key_green'].setText(_('Start'))
self.YellowAction = REFRESH
self['key_yellow'].setText(_('Refresh'))
if os.path.exists('/tmp/ecm.info') is True:
os.system('rm /tmp/ecm.info')
if os.path.exists('/tmp/ecm0.info') is True:
os.system('rm /tmp/ecm0.info')
except:
pass
if self['config'].getCurrent()[0] == _('Select Cam 1'):
self.setYellowKey(self.curcam)
else:
self.setYellowKey(self.curcam2)
ecmi = ''
if os.path.exists('/tmp/ecm.info') is True:
ecmi = self.read_ecm('/tmp/ecm.info')
elif os.path.exists('/tmp/ecm1.info') is True:
ecmi = self.read_ecm('/tmp/ecm1.info')
else:
ecmi = _('No ECM info')
ecmold = self['ecminfo'].getText()
if ecmold == ecmi:
self.ecmtel += 1
if self.ecmtel > 5:
ecmi = _('No new ECM info')
else:
self.ecmtel = 0
self['ecminfo'].setText(ecmi)
self.Timer.start(2000, True)
def read_shareinfo(self):
self.shareinfo = []
if os.path.exists('/tmp/share.info') is True:
s = open('/tmp/share.info')
for x in s.readlines():
self.shareinfo.append(x)
s.close()
def read_ecm(self, ecmpath):
ecmi2 = ''
Caid = ''
Prov = ''
f = open(ecmpath)
for line in f.readlines():
line = line.replace('=', '')
line = line.replace(' ', '', 1)
if line.find('ECM on CaID') > -1:
k = line.find('ECM on CaID') + 14
Caid = line[k:k + 4]
if line.find('prov:') > -1:
tmpprov = line.split(':')
Prov = tmpprov[1].strip()
if Caid != '' and Prov != '' and len(self.shareinfo) > 0:
for x in self.shareinfo:
cel = x.split(' ')
if cel[5][0:4] == Caid and cel[9][3:7] == Prov:
line = 'Peer: ' + Prov + ' - ' + cel[
3] + ' - ' + cel[8] + '\n'
break
ecmi2 = ecmi2 + line
f.close()
return ecmi2
def Red(self):
self.Timer.stop()
self.Stopcam()
self.Timer.start(2000, True)
def Yellow(self):
if self.YellowAction == CCCAMINFO:
self.Timer.stop()
self.session.openWithCallback(self.ShowSoftcamCallback,
CCcamInfoMain)
elif self.YellowAction == OSCAMINFO:
self.Timer.stop()
self.session.openWithCallback(self.ShowSoftcamCallback,
OscamInfoMenu)
else:
self.first = 0
self.layoutFinished()
def Green(self):
self.Timer.stop()
self.Startcam()
self.Timer.start(2000, True)
def Exit(self):
self.Timer.stop()
self.close()
def Blue(self):
if not self.partyfeed:
self.Exit()
else:
self.Timer.stop()
self.session.openWithCallback(self.ShowSoftcamCallback,
ShowSoftcamPackages)
def ShowSoftcamCallback(self):
self.Timer.start(2000, True)
def ok(self):
self.Timer.stop()
self.Startcam()
if self.YellowAction == REFRESH:
self.Yellow()
self.Timer.start(2000, True)
def Stopcam(self):
if oldcamIndex >= 0:
oldcam = self.emuBin[oldcamIndex]
else:
oldcam = None
if oldcam2Index >= 0:
oldcam2 = self.emuBin[oldcam2Index]
else:
oldcam2 = None
import time
self.container = eConsoleAppContainer()
if config.softcam.camstartMode.value == '0' or not fileExists(
'/etc/init.d/softcam'):
if oldcam:
print '[SOFTCAM] Python stop cam 1: ' + oldcam
self.container.execute(self.emuStop[oldcamIndex])
time.sleep(1)
t = 0
while t < 5:
p = command('pidof %s |wc -w' % oldcam)
if not p.isdigit():
p = 0
if int(p) > 0:
self.container = eConsoleAppContainer()
self.container.execute('killall -9 ' + oldcam)
t += 1
time.sleep(1)
else:
t = 5
if oldcam2:
print '[SOFTCAM] Python stop cam 2: ' + oldcam2
self.container.execute(self.emuStop[oldcam2Index])
time.sleep(1)
t = 0
while t < 5:
p = command('pidof %s |wc -w' % oldcam2)
if not p.isdigit():
p = 0
if int(p) > 0:
self.container = eConsoleAppContainer()
self.container.execute('killall -9 ' + oldcam2)
t += 1
time.sleep(1)
else:
t = 5
else:
self.container.execute('/etc/init.d/softcam.cam1 stop')
self.container.execute('/etc/init.d/softcam.cam2 stop')
if os.path.exists('/tmp/ecm.info') is True:
os.system('rm /tmp/ecm.info')
actcam = _('no CAM 1 active')
actcam2 = _('no CAM 2 active')
self['actifcam'].setText(actcam)
self['actifcam2'].setText(actcam2)
self['key_green'].setText(_('Start'))
self['ecminfo'].setText(_('No ECM info'))
self.Save_Settings(actcam)
self.Save_Settings2(actcam2)
return
def Startcam(self):
try:
if count > 0:
if self.cam1sel.value == self.cam2sel.value:
self.session.openWithCallback(
self.doNothing,
MessageBox,
_('No Cam started !!\n\nCam 1 must be different from Cam 2'
),
MessageBox.TYPE_ERROR,
simple=True)
return
if config.softcam.camstartMode.value == '0':
self.Stopcam()
self.camIndex = self.cam1sel.getIndex() - 1
self.cam2Index = self.cam2sel.getIndex() - 1
if self.camIndex >= 0:
actcam = self.cam1sel.value
self['actifcam'].setText(_('active CAM 1: ') + actcam)
self.Save_Settings(actcam)
start = self.emuStart[self.camIndex]
if self.checkBinName(self.emuBin[self.camIndex], start):
self.session.openWithCallback(
self.startcam2,
MessageBox,
actcam +
_(' Not Started !!\n\nCam binname must be in the start command line\nCheck your emu config file'
),
MessageBox.TYPE_ERROR,
simple=True)
return
if config.softcam.camstartMode.value == '0':
print '[SOFTCAM] Python start cam 1: ' + actcam
self.session.openWithCallback(self.waitTime,
MessageBox,
_('Starting Cam 1: ') +
actcam,
MessageBox.TYPE_WARNING,
timeout=5,
simple=True)
self.container = eConsoleAppContainer()
self.container.execute(start)
else:
self.session.openWithCallback(
self.doNothing,
MessageBox,
_('Creating start scripts and starting the cam'),
MessageBox.TYPE_WARNING,
timeout=10,
simple=True)
self.Save_Settings2(self.cam2sel.value)
camname1 = self.emuBin[self.camIndex]
camname2 = self.emuBin[self.cam2Index]
self.deleteInit()
camname = '/usr/bin/' + camname1
startcmd = self.emuStart[self.camIndex]
stopcmd = self.emuStop[self.camIndex]
self.createInitdscript('cam1', camname, startcmd,
stopcmd)
if self.cam2Index >= 0:
camname = '/usr/bin/' + camname2
startcmd = self.emuStart[self.cam2Index]
stopcmd = self.emuStop[self.cam2Index]
self.createInitdscript(
'cam2', camname, startcmd, stopcmd,
config.softcam.waittime.value)
self['key_green'].setText(_('ReStart'))
except:
pass
def waitTime(self, ret):
if self.cam2Index >= 0:
if config.softcam.waittime.value == '0':
self.startcam2(None)
else:
self.session.openWithCallback(
self.startcam2,
MessageBox,
_('Waiting...'),
MessageBox.TYPE_WARNING,
timeout=int(config.softcam.waittime.value),
simple=True)
return
def doNothing(self, ret):
pass
def startcam2(self, ret):
camIndex = self.cam2Index
if camIndex >= 0:
actcam = self.cam2sel.value
self['actifcam2'].setText(_('active CAM 2: ') + actcam)
self.Save_Settings2(actcam)
start = self.emuStart[camIndex]
if self.checkBinName(self.emuBin[self.cam2Index], start):
self.session.open(
MessageBox,
actcam +
_(' Not Started !!\n\nCam binname must be in the start command line\nCheck your emu config file'
),
MessageBox.TYPE_ERROR,
simple=True)
return
print '[SOFTCAM] Python start cam 2: ' + actcam
self.session.open(MessageBox,
_('Starting Cam 2: ') + actcam,
MessageBox.TYPE_WARNING,
timeout=5,
simple=True)
self.container = eConsoleAppContainer()
self.container.execute(start)
def Save_Settings(self, cam_name):
config.softcam.actCam.setValue(cam_name)
config.softcam.save()
configfile.save()
def Save_Settings2(self, cam_name):
config.softcam.actCam2.setValue(cam_name)
config.softcam.save()
configfile.save()
def isCamrunning(self, cam):
p = command('pidof ' + cam + ' |wc -w')
if not p.isdigit():
p = 0
if int(p) > 0:
return True
else:
return False
def checkBinName(self, binname, start):
print '[CHECKBINNAME] bin=%s ,start=%s' % (binname, start)
if start.find(binname + ' ') > -1:
print '[CHECKBINNAME] OK'
return False
elif start[start.rfind('/') + 1:] == binname:
print '[CHECKBINNAME] OK'
return False
else:
print '[CHECKBINNAME] ERROR'
return True
def createInitdscript(self, camname, emubin, start, stop, wait=None):
Adir = '/etc/init.d/softcam.' + camname
softcamfile = []
softcamfile.append('#!/bin/sh')
softcamfile.append('DAEMON=%s' % emubin)
softcamfile.append('STARTCAM="%s"' % start)
softcamfile.append('STOPCAM="%s"' % stop)
softcamfile.append('DESC="Softcam"')
softcamfile.append('')
softcamfile.append('test -f $DAEMON || exit 0')
softcamfile.append('set -e')
softcamfile.append('')
softcamfile.append('case "$1" in')
softcamfile.append('\tstart)')
softcamfile.append('\t\techo -n "starting $DESC: $DAEMON... "')
if wait:
softcamfile.append('\t\tsleep ' + wait)
softcamfile.append('\t\t$STARTCAM')
softcamfile.append('\t\techo "done."')
softcamfile.append('\t\t;;')
softcamfile.append('\tstop)')
softcamfile.append('\t\techo -n "stopping $DESC: $DAEMON... "')
softcamfile.append('\t\t$STOPCAM')
softcamfile.append('\t\techo "done."')
softcamfile.append('\t\t;;')
softcamfile.append('\trestart)')
softcamfile.append('\t\techo "restarting $DESC: $DAEMON... "')
softcamfile.append('\t\t$0 stop')
softcamfile.append('\t\techo "wait..."')
softcamfile.append('\t\tsleep 5')
softcamfile.append('\t\t$0 start')
softcamfile.append('\t\techo "done."')
softcamfile.append('\t\t;;')
softcamfile.append('\t*)')
softcamfile.append('\t\techo "Usage: $0 {start|stop|restart}"')
softcamfile.append('\t\texit 1')
softcamfile.append('\t\t;;')
softcamfile.append('esac')
softcamfile.append('')
softcamfile.append('exit 0')
f = open(Adir, 'w')
for x in softcamfile:
f.writelines(x + '\n')
f.close()
self.container = eConsoleAppContainer()
os.chmod(Adir, 493)
if not os.path.exists('/etc/rc2.d/S20softcam.' + camname):
self.container.execute('update-rc.d -f softcam.' + camname +
' defaults')
import time
time.sleep(3)
if self.isCamrunning(emubin):
self.container.execute('/etc/init.d/softcam.' + camname +
' restart')
else:
self.container.execute('/etc/init.d/softcam.' + camname + ' start')
def deleteInit(self):
if os.path.exists('/etc/rc2.d/S20softcam.cam1'):
print 'Delete Symbolink link'
self.container = eConsoleAppContainer()
self.container.execute('update-rc.d -f softcam.cam1 defaults')
if os.path.exists('/etc/init.d/softcam.cam1'):
print 'Delete softcam init script cam1'
os.system('rm /etc/init.d/softcam.cam1')
if os.path.exists('/etc/rc2.d/S20softcam.cam2'):
print 'Delete Symbolink link'
self.container = eConsoleAppContainer()
self.container.execute('update-rc.d -f softcam.cam2 defaults')
if os.path.exists('/etc/init.d/softcam.cam2'):
print 'Delete softcam init script cam2'
os.system('rm /etc/init.d/softcam.cam2')
class TranscodingSetup(ConfigListScreen, Screen):
skin = """
<screen position="center,center" size="500,114" title="TranscodingSetup">
<eLabel position="0,0" size="500,22" font="Regular;20" text="Default values for trancoding" />
<widget name="config" position="4,26" font="Regular;20" size="492,60" />
<ePixmap pixmap="skin_default/buttons/red.png" position="0,76" size="140,40" alphatest="on" />
<ePixmap pixmap="skin_default/buttons/green.png" position="150,76" size="140,40" alphatest="on" />
<widget source="key_red" render="Label" position="0,76" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1"/>
<widget source="key_green" render="Label" position="150,76" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1"/>
</screen>
"""
def KeyNone(self):
None
def callbackNone(self, *retval):
None
def __init__(self, session):
bitrate_choices = [( 50, "50 kbps" ), ( 100, "100 kbps" ), ( 200, "200 kbps" ), ( 500, "500 kbps" ), ( 1000, "1 Mbps" ), ( 2000, "2 Mbps" )]
size_choices = [ "480p", "576p", "720p" ]
current_bitrate_value = ""
current_size = ""
Screen.__init__(self, session)
config_list = []
ConfigListScreen.__init__(self, config_list)
self.bitrate = ConfigSelection(choices = bitrate_choices)
self.size = ConfigSelection(choices = size_choices)
config_list.append(getConfigListEntry(_("Bitrate"), self.bitrate));
config_list.append(getConfigListEntry(_("Video size"), self.size));
self["config"].list = config_list
rawcontent = []
with open("/etc/enigma2/streamproxy.conf", "r") as f:
rawcontent = f.readlines()
rawcontent = [x.translate(None, ' \n\r')for x in rawcontent]
f.close()
self.content = []
for line in rawcontent:
if not line.startswith('#') and not line.startswith(';'):
tokens = line.split('=')
if(tokens[0] == "bitrate"):
for tuple in bitrate_choices:
if int(tokens[1]) <= int(tuple[0]):
self.bitrate.setValue(tuple[0])
break
if(tokens[0] == "size"):
self.size.setValue(tokens[1])
self.content += [ tokens ]
self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "ColorActions" ],
{
"red": self.keyCancel,
"green": self.keyGo,
"ok": self.keyGo,
"cancel": self.keyCancel,
}, -2)
self["key_red"] = StaticText(_("Quit"))
self["key_green"] = StaticText(_("Set"))
def keyLeft(self):
ConfigListScreen.keyLeft(self)
def keyRight(self):
ConfigListScreen.keyRight(self)
def keyCancel(self):
self.close()
def keyGo(self):
for token in self.content:
if(token[0] == "bitrate"):
token[1] = self.bitrate.getValue()
if(token[0] == "size"):
token[1] = self.size.getValue()
with open("/etc/enigma2/streamproxy.conf", "w") as f:
for token in self.content:
f.write("%s = %s\n" % (token[0], token[1]))
f.close()
self.close()
class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
def __init__(self, session):
Screen.__init__(self, session)
Screen.setTitle(self, _("Manual Scan"))
self.finished_cb = None
self.updateSatList()
self.service = session.nav.getCurrentService()
self.feinfo = None
self.networkid = 0
frontendData = None
if self.service is not None:
self.feinfo = self.service.frontendInfo()
frontendData = self.feinfo and self.feinfo.getAll(True)
self.createConfig(frontendData)
del self.feinfo
del self.service
self.session.postScanService = session.nav.getCurrentlyPlayingServiceOrGroup()
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Scan"))
self["actions"] = NumberActionMap(["SetupActions", "MenuActions", "ColorActions"],
{
"ok": self.keyGo,
"save": self.keyGo,
"cancel": self.keyCancel,
"red": self.keyCancel,
"green": self.keyGo,
"menu": self.doCloseRecursive,
}, -2)
self.statusTimer = eTimer()
self.statusTimer.callback.append(self.updateStatus)
#self.statusTimer.start(5000, True)
self.list = []
ConfigListScreen.__init__(self, self.list)
self["header"] = Label(_("Manual Scan"))
if not self.scan_nims.getValue() == "":
self.createSetup()
self["introduction"] = Label(_("Press OK to start the scan"))
else:
self["introduction"] = Label(_("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."))
def runAsync(self, finished_cb):
self.finished_cb = finished_cb
self.keyGo()
def updateSatList(self):
self.satList = []
for slot in nimmanager.nim_slots:
if slot.isCompatible("DVB-S"):
self.satList.append(nimmanager.getSatListForNim(slot.slot))
else:
self.satList.append(None)
def createSetup(self):
self.list = []
self.multiscanlist = []
index_to_scan = int(self.scan_nims.getValue())
print "ID: ", index_to_scan
self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims)
self.list.append(self.tunerEntry)
if self.scan_nims == [ ]:
return
self.typeOfScanEntry = None
self.systemEntry = None
self.modulationEntry = None
self.preDefSatList = None
nim = nimmanager.nim_slots[index_to_scan]
if nim.isCompatible("DVB-S"):
self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)
self.list.append(self.typeOfScanEntry)
elif nim.isCompatible("DVB-C"):
self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typecable)
self.list.append(self.typeOfScanEntry)
elif nim.isCompatible("DVB-T"):
self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial)
self.list.append(self.typeOfScanEntry)
self.scan_networkScan.value = False
if nim.isCompatible("DVB-S"):
if self.scan_type.getValue() == "single_transponder":
self.updateSatList()
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(_('Satellite'), self.scan_satselection[index_to_scan]))
self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S:
self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
elif self.scan_sat.system.getValue() == 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.scan_type.getValue() == "predefined_transponder" and self.satList[index_to_scan]:
self.updateSatList()
self.preDefSatList = getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan])
self.list.append(self.preDefSatList)
sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
self.predefinedTranspondersList(sat[0])
self.list.append(getConfigListEntry(_('Transponder'), self.preDefTransponders))
elif self.scan_type.getValue() == "single_satellite":
self.updateSatList()
print self.scan_satselection[index_to_scan]
self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan]))
self.scan_networkScan.value = True
elif "multisat" in self.scan_type.value:
tlist = []
SatList = nimmanager.getSatListForNim(index_to_scan)
for x in SatList:
if self.Satexists(tlist, x[0]) == 0:
tlist.append(x[0])
sat = ConfigEnableDisable(default = "_yes" in self.scan_type.value and True or False)
configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat)
self.list.append(configEntry)
self.multiscanlist.append((x[0], sat))
self.scan_networkScan.value = True
elif nim.isCompatible("DVB-C"):
if self.scan_typecable.getValue() == "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))
if config.Nims[index_to_scan].cable.scan_networkid.getValue():
self.networkid = config.Nims[index_to_scan].cable.scan_networkid.getValue()
self.scan_networkScan.value = True
elif nim.isCompatible("DVB-T"):
if self.scan_typeterrestrial.getValue() == "single_transponder":
if nim.isCompatible("DVB-T2"):
self.systemEntry = getConfigListEntry(_('System'), self.scan_ter.system)
self.list.append(self.systemEntry)
else:
self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T
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))
self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
self.list.append(getConfigListEntry(_("Only free scan"), self.scan_onlyfree))
self["config"].list = self.list
self["config"].l.setList(self.list)
def Satexists(self, tlist, pos):
for x in tlist:
if x == pos:
return 1
return 0
def newConfig(self):
cur = self["config"].getCurrent()
print "cur is", cur
if cur == self.typeOfScanEntry or \
cur == self.tunerEntry or \
cur == self.systemEntry or \
cur == self.preDefSatList or \
(self.modulationEntry and self.systemEntry[1].getValue() == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
self.createSetup()
def createConfig(self, frontendData):
defaultSat = {
"orbpos": 192,
"system": eDVBFrontendParametersSatellite.System_DVB_S,
"frequency": 11836,
"inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
"symbolrate": 27500,
"polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
"fec": eDVBFrontendParametersSatellite.FEC_Auto,
"fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
"modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
defaultCab = {
"frequency": 466,
"inversion": eDVBFrontendParametersCable.Inversion_Unknown,
"modulation": eDVBFrontendParametersCable.Modulation_QAM64,
"fec": eDVBFrontendParametersCable.FEC_Auto,
"symbolrate": 6900,
"system": eDVBFrontendParametersCable.System_DVB_C_ANNEX_A }
defaultTer = {
"frequency" : 466000,
"inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown,
"bandwidth" : 7000000,
"fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto,
"feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto,
"modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto,
"transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto,
"guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto,
"hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto,
"system": eDVBFrontendParametersTerrestrial.System_DVB_T,
"plp_id": 0 }
if frontendData is not None:
ttype = frontendData.get("tuner_type", "UNKNOWN")
if ttype == "DVB-S":
defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
else:
defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
elif ttype == "DVB-C":
defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown)
defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto)
defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16)
defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersCable.System_DVB_C_ANNEX_A)
elif ttype == "DVB-T":
defaultTer["frequency"] = frontendData.get("frequency", 0)
defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown)
defaultTer["bandwidth"] = frontendData.get("bandwidth", 7000000)
defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto)
defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto)
defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto)
defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto)
defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto)
defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto)
defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersTerrestrial.System_DVB_T)
self.scan_sat = ConfigSubsection()
self.scan_cab = ConfigSubsection()
self.scan_ter = ConfigSubsection()
nim_list = []
# collect all nims which are *not* set to "nothing"
for n in nimmanager.nim_slots:
if n.config_mode == "nothing":
continue
if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
continue
if n.config_mode in ("loopthrough", "satposdepends"):
root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.getValue()))
if n.type == nimmanager.nim_slots[root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa
continue
nim_list.append((str(n.slot), n.friendly_full_description))
self.scan_nims = ConfigSelection(choices = nim_list)
if frontendData is not None and len(nim_list) > 0:
self.scan_nims.setValue(str(frontendData.get("tuner_number", nim_list[0][0])))
# status
self.scan_snr = ConfigSlider()
self.scan_snr.enabled = False
self.scan_agc = ConfigSlider()
self.scan_agc.enabled = False
self.scan_ber = ConfigSlider()
self.scan_ber.enabled = False
# sat
self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [
(eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
(eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])
self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
(eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
(eDVBFrontendParametersSatellite.Inversion_On, _("On")),
(eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))])
self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))
self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
(eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
(eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
(eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
(eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [
(eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")),
(eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
(eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
(eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
(eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
(eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
(eDVBFrontendParametersSatellite.FEC_None, _("None"))])
self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [
(eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
(eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
(eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
(eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
(eDVBFrontendParametersSatellite.FEC_4_5, "4/5"),
(eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
(eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
(eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
(eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
(eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
(eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
(eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
(eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
(eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20"),
(eDVBFrontendParametersSatellite.RollOff_auto, _("Auto"))])
self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [
(eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
(eDVBFrontendParametersSatellite.Pilot_On, _("On")),
(eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
# cable
self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [
(eDVBFrontendParametersCable.Inversion_Off, _("Off")),
(eDVBFrontendParametersCable.Inversion_On, _("On")),
(eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))])
self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [
(eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"),
(eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"),
(eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"),
(eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"),
(eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")])
self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [
(eDVBFrontendParametersCable.FEC_Auto, _("Auto")),
(eDVBFrontendParametersCable.FEC_1_2, "1/2"),
(eDVBFrontendParametersCable.FEC_2_3, "2/3"),
(eDVBFrontendParametersCable.FEC_3_4, "3/4"),
(eDVBFrontendParametersCable.FEC_5_6, "5/6"),
(eDVBFrontendParametersCable.FEC_6_7, "6/7"),
(eDVBFrontendParametersCable.FEC_7_8, "7/8"),
(eDVBFrontendParametersCable.FEC_8_9, "8/9"),
(eDVBFrontendParametersCable.FEC_None, _("None"))])
self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
self.scan_cab.system = ConfigSelection(default = defaultCab["system"], choices = [
(eDVBFrontendParametersCable.System_DVB_C_ANNEX_A, _("DVB-C")),
(eDVBFrontendParametersCable.System_DVB_C_ANNEX_C, _("DVB-C ANNEX C"))])
# terrestial
self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000))
self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [
(eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")),
(eDVBFrontendParametersTerrestrial.Inversion_On, _("On")),
(eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))])
# WORKAROUND: we can't use BW-auto
self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [
(10000000, "10MHz"),
(8000000, "8MHz"),
(7000000, "7MHz"),
(6000000, "6MHz"),
(5000000, "5MHz"),
(1712000, "1.712MHz")
])
#, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto"))))
self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [
(eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
(eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
(eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
(eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
(eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"),
(eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
(eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"),
(eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [
(eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
(eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
(eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
(eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
(eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"),
(eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
(eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"),
(eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [
(eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
(eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
(eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
(eDVBFrontendParametersTerrestrial.Modulation_QAM256, "QAM256"),
(eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
(eDVBFrontendParametersTerrestrial.TransmissionMode_1k, "1K"),
(eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
(eDVBFrontendParametersTerrestrial.TransmissionMode_4k, "4K"),
(eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
(eDVBFrontendParametersTerrestrial.TransmissionMode_16k, "16K"),
(eDVBFrontendParametersTerrestrial.TransmissionMode_32k, "32K"),
(eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [
(eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
(eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
(eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
(eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
(eDVBFrontendParametersTerrestrial.GuardInterval_1_128, "1/128"),
(eDVBFrontendParametersTerrestrial.GuardInterval_19_128, "19/128"),
(eDVBFrontendParametersTerrestrial.GuardInterval_19_256, "19/256"),
(eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [
(eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")),
(eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"),
(eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"),
(eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"),
(eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))])
self.scan_ter.system = ConfigSelection(default = defaultTer["system"], choices = [
(eDVBFrontendParametersTerrestrial.System_DVB_T, _("DVB-T")),
(eDVBFrontendParametersTerrestrial.System_DVB_T2, _("DVB-T2"))])
self.scan_ter.plp_id = ConfigInteger(default = defaultTer["plp_id"], limits = (0, 255))
if frontendData is not None and ttype == "DVB-S" and self.predefinedTranspondersList(defaultSat["orbpos"]) != None:
defaultSatSearchType = "predefined_transponder"
else:
defaultSatSearchType = "single_transponder"
self.scan_type = ConfigSelection(default = defaultSatSearchType, choices = [("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ("multisat_yes", _("Multisat"))])
self.scan_typecable = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
self.scan_typeterrestrial = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
self.scan_clearallservices = ConfigSelection(default = "no", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))])
self.scan_onlyfree = ConfigYesNo(default = False)
self.scan_networkScan = ConfigYesNo(default = False)
self.scan_scansat = {}
for sat in nimmanager.satList:
#print sat[1]
self.scan_scansat[sat[0]] = ConfigYesNo(default = False)
self.scan_satselection = []
for slot in nimmanager.nim_slots:
if slot.isCompatible("DVB-S"):
self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]))
else:
self.scan_satselection.append(None)
return True
def keyLeft(self):
ConfigListScreen.keyLeft(self)
self.newConfig()
def keyRight(self):
ConfigListScreen.keyRight(self)
self.newConfig()
def updateStatus(self):
print "updatestatus"
def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot):
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)
print "orbpos: " + str(orbital_position)
parm = eDVBFrontendParametersSatellite()
parm.modulation = modulation
parm.system = system
parm.frequency = frequency * 1000
parm.symbol_rate = symbol_rate * 1000
parm.polarisation = polarisation
parm.fec = fec
parm.inversion = inversion
parm.orbital_position = orbital_position
parm.rolloff = rolloff
parm.pilot = pilot
tlist.append(parm)
def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):
print "Add Cab: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(modulation) + " fec: " + str(fec) + " inversion: " + str(inversion)
parm = eDVBFrontendParametersCable()
parm.frequency = frequency * 1000
parm.symbol_rate = symbol_rate * 1000
parm.modulation = modulation
parm.fec = fec
parm.inversion = inversion
tlist.append(parm)
def addTerTransponder(self, tlist, *args, **kwargs):
tlist.append(buildTerTransponder(*args, **kwargs))
def keyGo(self):
infoBarInstance = InfoBar.instance
if infoBarInstance:
infoBarInstance.checkTimeshiftRunning(self.keyGoCheckTimeshiftCallback)
else:
self.keyGoCheckTimeshiftCallback(True)
def keyGoCheckTimeshiftCallback(self, answer):
if not answer or self.scan_nims.value == "":
return
tlist = []
flags = None
startScan = True
removeAll = True
index_to_scan = int(self.scan_nims.getValue())
if self.scan_nims == [ ]:
self.session.open(MessageBox, _("No tuner is enabled!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
return
nim = nimmanager.nim_slots[index_to_scan]
print "nim", nim.slot
if nim.isCompatible("DVB-S"):
print "is compatible with DVB-S"
if self.scan_type.getValue() == "single_transponder":
# these lists are generated for each tuner, so this has work.
assert len(self.satList) > index_to_scan
assert len(self.scan_satselection) > index_to_scan
nimsats = self.satList[index_to_scan]
selsatidx = self.scan_satselection[index_to_scan].index
# however, the satList itself could be empty. in that case, "index" is 0 (for "None").
if len(nimsats):
orbpos = nimsats[selsatidx][0]
if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S:
fec = self.scan_sat.fec.getValue()
else:
fec = self.scan_sat.fec_s2.getValue()
print "add sat transponder"
self.addSatTransponder(tlist, self.scan_sat.frequency.getValue(),
self.scan_sat.symbolrate.getValue(),
self.scan_sat.polarization.getValue(),
fec,
self.scan_sat.inversion.getValue(),
orbpos,
self.scan_sat.system.getValue(),
self.scan_sat.modulation.getValue(),
self.scan_sat.rolloff.getValue(),
self.scan_sat.pilot.getValue())
removeAll = False
elif self.scan_type.getValue() == "predefined_transponder":
nimsats = self.satList[index_to_scan]
selsatidx = self.scan_satselection[index_to_scan].index
if len(nimsats):
orbpos = nimsats[selsatidx][0]
tps = nimmanager.getTransponders(orbpos)
if len(tps) and len(tps) > self.preDefTransponders.index :
tp = tps[self.preDefTransponders.index]
self.addSatTransponder(tlist, tp[1] / 1000, tp[2] / 1000, tp[3], tp[4], tp[7], orbpos, tp[5], tp[6], tp[8], tp[9])
removeAll = False
elif self.scan_type.getValue() == "single_satellite":
sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
getInitialTransponderList(tlist, sat[0])
elif "multisat" in self.scan_type.value:
SatList = nimmanager.getSatListForNim(index_to_scan)
for x in self.multiscanlist:
if x[1].getValue():
print " " + str(x[0])
getInitialTransponderList(tlist, x[0])
elif nim.isCompatible("DVB-C"):
if self.scan_typecable.getValue() == "single_transponder":
self.addCabTransponder(tlist, self.scan_cab.frequency.getValue(),
self.scan_cab.symbolrate.getValue(),
self.scan_cab.modulation.getValue(),
self.scan_cab.fec.getValue(),
self.scan_cab.inversion.getValue())
removeAll = False
elif self.scan_typecable.getValue() == "complete":
if config.Nims[index_to_scan].cable.scan_type.getValue() == "provider":
getInitialCableTransponderList(tlist, index_to_scan)
else:
startScan = False
elif nim.isCompatible("DVB-T"):
if self.scan_typeterrestrial.getValue() == "single_transponder":
self.addTerTransponder(tlist,
self.scan_ter.frequency.getValue() * 1000,
inversion = self.scan_ter.inversion.getValue(),
bandwidth = self.scan_ter.bandwidth.getValue(),
fechigh = self.scan_ter.fechigh.getValue(),
feclow = self.scan_ter.feclow.getValue(),
modulation = self.scan_ter.modulation.getValue(),
transmission = self.scan_ter.transmission.getValue(),
guard = self.scan_ter.guard.getValue(),
hierarchy = self.scan_ter.hierarchy.getValue(),
system = self.scan_ter.system.getValue(),
plpid = self.scan_ter.plp_id.getValue())
removeAll = False
elif self.scan_typeterrestrial.getValue() == "complete":
getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan))
flags = self.scan_networkScan.getValue() and eComponentScan.scanNetworkSearch or 0
tmp = self.scan_clearallservices.getValue()
if tmp == "yes":
flags |= eComponentScan.scanRemoveServices
elif tmp == "yes_hold_feeds":
flags |= eComponentScan.scanRemoveServices
flags |= eComponentScan.scanDontRemoveFeeds
if tmp != "no" and not removeAll:
flags |= eComponentScan.scanDontRemoveUnscanned
if self.scan_onlyfree.getValue():
flags |= eComponentScan.scanOnlyFree
for x in self["config"].list:
x[1].save()
if startScan:
self.startScan(tlist, flags, index_to_scan, self.networkid)
else:
self.flags = flags
self.feid = index_to_scan
self.tlist = []
self.startCableTransponderSearch(self.feid)
def setCableTransponderSearchResult(self, tlist):
self.tlist = tlist
def cableTransponderSearchFinished(self):
if self.tlist is None:
self.tlist = []
else:
self.startScan(self.tlist, self.flags, self.feid)
def predefinedTranspondersList(self, orbpos):
default = None
if orbpos is not None:
list = []
if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S2:
fec = self.scan_sat.fec_s2.getValue()
else:
fec = self.scan_sat.fec.getValue()
compare = self.humanReadableTransponder([0, self.scan_sat.frequency.getValue(), self.scan_sat.symbolrate.getValue(), self.scan_sat.polarization.getValue(), fec])
i = 0
tps = nimmanager.getTransponders(orbpos)
for tp in tps:
if tp[0] == 0:
params = self.humanReadableTransponder(tp, 1000)
if default is None and params == compare:
default = str(i)
list.append((str(i), params))
i += 1
self.preDefTransponders = ConfigSelection(choices = list, default = default)
return default
def humanReadableTransponder(self, tp, div = 1):
pol_list = ['H','V','L','R']
fec_list = ['Auto','1/2','2/3','3/4','5/6','7/8','8/9','3/5','4/5','9/10','None']
return str(tp[1]/div) + " " + pol_list[tp[3]] + " " + str(tp[2]/div) + " " + fec_list[tp[4]]
def startScan(self, tlist, flags, feid, networkid = 0):
if len(tlist):
# flags |= eComponentScan.scanSearchBAT
if self.finished_cb:
self.session.openWithCallback(self.finished_cb, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}])
else:
self.session.openWithCallback(self.startScanCallback, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}])
else:
if self.finished_cb:
self.session.openWithCallback(self.finished_cb, MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
else:
self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
def startScanCallback(self, answer):
if answer:
self.doCloseRecursive()
def keyCancel(self):
self.session.nav.playService(self.session.postScanService)
for x in self["config"].list:
x[1].cancel()
self.close()
def doCloseRecursive(self):
self.session.nav.playService(self.session.postScanService)
self.closeRecursive()
