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()