def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if self.transponder_info: tuner = (_("Type"), frontendData["tuner_type"], TYPE_TEXT) else: tuner = (_("NIM & Type"), chr(ord('A') + frontendData["tuner_number"]) + " - " + frontendData["tuner_type"], TYPE_TEXT) if frontendDataOrg["tuner_type"] == "DVB-S": return (tuner, (_("System & Modulation"), frontendData["system"] + " " + frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency & Polarization"), "%s MHz" % (frontendData["frequency"] / 1000) + " - " + frontendData["polarization"], TYPE_TEXT), (_("Symbol rate & FEC"), "%s KSymb/s" % (frontendData["symbol_rate"] / 1000) + " - " + frontendData["fec_inner"], TYPE_TEXT), (_("Inversion, Pilot & Roll-off"), frontendData["inversion"] + " - " + str(frontendData.get("pilot", None)) + " - " + str(frontendData.get("rolloff", None)), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return (tuner, (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT), (_("Symbol rate & FEC"), "%s KSymb/s" % (frontendData["symbol_rate"] / 1000) + " - " + frontendData["fec_inner"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": return (tuner, (_("Frequency & Channel"), "%.3f MHz" % ((frontendData["frequency"] / 1000) / 1000.0) + " - Ch. " + getChannelNumber(frontendData["frequency"], frontendData["tuner_number"]), TYPE_TEXT), (_("Inversion & Bandwidth"), frontendData["inversion"] + " - " + str(frontendData["bandwidth"]), TYPE_TEXT), (_("Code R. LP-HP & Guard Int."), frontendData["code_rate_lp"] + " - " + frontendData["code_rate_hp"] + " - " + frontendData["guard_interval"], TYPE_TEXT), (_("Constellation & FFT mode"), frontendData["constellation"] + " - " + frontendData["transmission_mode"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "ATSC": return (tuner, (_("System & Modulation"), frontendData["system"] + " " + frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"] / 1000, TYPE_VALUE_FREQ_FLOAT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) return []
def getText(self): service = self.source.service info = service and service.info() if not info: return "" if self.type == self.XRES: return self.getServiceInfoString(info, iServiceInformation.sVideoWidth) elif self.type == self.YRES: return self.getServiceInfoString(info, iServiceInformation.sVideoHeight) elif self.type == self.APID: return self.getServiceInfoString(info, iServiceInformation.sAudioPID) elif self.type == self.VPID: return self.getServiceInfoString(info, iServiceInformation.sVideoPID) elif self.type == self.PCRPID: return self.getServiceInfoString(info, iServiceInformation.sPCRPID) elif self.type == self.PMTPID: return self.getServiceInfoString(info, iServiceInformation.sPMTPID) elif self.type == self.TXTPID: return self.getServiceInfoString(info, iServiceInformation.sTXTPID) elif self.type == self.TSID: return self.getServiceInfoString(info, iServiceInformation.sTSID) elif self.type == self.ONID: return self.getServiceInfoString(info, iServiceInformation.sONID) elif self.type == self.SID: return self.getServiceInfoString(info, iServiceInformation.sSID) elif self.type == self.FRAMERATE: return self.getServiceInfoString(info, iServiceInformation.sFrameRate, lambda x: "%d fps" % ((x+500)/1000)) elif self.type == self.TRANSFERBPS: return self.getServiceInfoString(info, iServiceInformation.sTransferBPS, lambda x: "%d kB/s" % (x/1024)) elif self.type == self.HAS_HBBTV: return info.getInfoString(iServiceInformation.sHBBTVUrl) elif self.type == self.FREQ_INFO: feinfo = service.frontendInfo() if feinfo is None: return "" feraw = feinfo.getAll(False) if feraw is None: return "" fedata = ConvertToHumanReadable(feraw) if fedata is None: return "" frequency = fedata.get("frequency") if frequency: frequency = str(frequency / 1000) sr_txt = "Sr:" polarization = fedata.get("polarization_abbreviation") if polarization is None: polarization = "" symbolrate = str(int(fedata.get("symbol_rate", 0) / 1000)) if symbolrate == "0": sr_txt = "" symbolrate = "" fec = fedata.get("fec_inner") if fec is None: fec = "" out = "Freq: %s %s %s %s %s" % (frequency, polarization, sr_txt, symbolrate, fec) return out return ""
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceReference(): name = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference()).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference().toString() else: name = _("N/A") refstr = _("N/A") aspect = self.getServiceInfoValue(iServiceInformation.sAspect) if aspect in ( 1, 2, 5, 6, 9, 0xA, 0xD, 0xE ): aspect = _("4:3") else: aspect = _("16:9") width = self.info and self.info.getInfo(iServiceInformation.sVideoWidth) or -1 height = self.info and self.info.getInfo(iServiceInformation.sVideoHeight) or -1 if width != -1 and height != -1: Labels = ( (_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Aspect ratio"), aspect, TYPE_TEXT), (_("Resolution"), "%dx%d" %(width, height), TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) else: Labels = ( (_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Aspect ratio"), aspect, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type" : _("Type"), "system" : _("System"), "modulation" : _("Modulation"), "orbital_position" : _("Orbital position"), "frequency" : _("Frequency"), "symbol_rate" : _("Symbol rate"), "bandwidth" : _("Bandwidth"), "polarization" : _("Polarization"), "inversion" : _("Inversion"), "pilot" : _("Pilot"), "rolloff" : _("Roll-off"), "fec_inner" : _("FEC"), "code_rate_lp" : _("Code rate LP"), "code_rate_hp" : _("Code rate HP"), "constellation" : _("Constellation"), "transmission_mode" : _("Transmission mode"), "guard_interval" : _("Guard interval"), "hierarchy_information" : _("Hierarchy info"), "plp_id" : _("Stream Id"), "is_id" : _("Stream Id"), "pls_mode" : _("PLS Mode"), "pls_code" : _("PLS Code")} Labels = [(conv[i], tp_info[i], TYPE_VALUE_DEC) for i in tp_info.keys()] self.fillList(Labels)
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": data = ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) if frontendData["system"] == "DVB-S2": data += ((_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT), (_("Input Stream ID"), frontendData["is_id"], TYPE_VALUE_DEC), (_("PLS Mode"), frontendData["pls_mode"], TYPE_TEXT), (_("PLS Code"), frontendData["pls_code"], TYPE_VALUE_DEC)) return data elif frontendDataOrg["tuner_type"] == "DVB-C": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T" and frontendData["system"] == "DVB-T2": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["constellation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"]/1000, TYPE_VALUE_DEC), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("FEC"), frontendData["code_rate_hp"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("PLP ID"), frontendData["plp_id"], TYPE_VALUE_DEC)) elif frontendDataOrg["tuner_type"] == "DVB-T" and frontendData["system"] == "DVB-T": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["constellation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"]/1000, TYPE_VALUE_DEC), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("FEC HP"), frontendData["code_rate_hp"], TYPE_TEXT), (_("FEC LP"), frontendData["code_rate_lp"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) return [ ]
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": if frontendData["frequency"] > 11699999 : band = "High" else: band = "Low" return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Band"), band, TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT), (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Channel"), getChannelNumber(frontendData["frequency"], frontendData["tuner_number"]), TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("Code rate LP"), frontendData["code_rate_lp"], TYPE_TEXT), (_("Code rate HP"), frontendData["code_rate_hp"], TYPE_TEXT), (_("Constellation"), frontendData["constellation"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "ATSC": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) return [ ]
def information(self): if self.type is TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference()).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference().toString() else: name = _("N/A") refstr = _("N/A") aspect = "-" videocodec = "-" resolution = "-" if self.info: videocodec = ("MPEG2", "MPEG4", "MPEG1", "MPEG4-II", "VC1", "VC1-SM", "-" )[self.info and self.info.getInfo(iServiceInformation.sVideoType)] width = self.info.getInfo(iServiceInformation.sVideoWidth) height = self.info.getInfo(iServiceInformation.sVideoHeight) if width > 0 and height > 0: resolution = "%dx%d " % (width,height) resolution += str((self.info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) aspect = self.getServiceInfoValue(iServiceInformation.sAspect) if aspect in ( 1, 2, 5, 6, 9, 0xA, 0xD, 0xE ): aspect = "4:3" else: aspect = "16:9" Labels = ( (_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Videoformat"), aspect, TYPE_TEXT), (_("Videosize"), resolution, TYPE_TEXT), (_("Videocodec"), videocodec, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type" : _("Transponder type"), "system" : _("System"), "modulation" : _("Modulation"), "orbital_position" : _("Orbital position"), "frequency" : _("Frequency"), "symbol_rate" : _("Symbol rate"), "bandwidth" : _("Bandwidth"), "polarization" : _("Polarization"), "inversion" : _("Inversion"), "pilot" : _("Pilot"), "rolloff" : _("Roll-off"), "is_id" : _("Input Stream ID"), "pls_mode" : _("PLS Mode"), "pls_code" : _("PLS Code"), "fec_inner" : _("FEC"), "code_rate_lp" : _("Coderate LP"), "code_rate_hp" : _("Coderate HP"), "constellation" : _("Constellation"), "transmission_mode" : _("Transmission mode"), "guard_interval" : _("Guard interval"), "hierarchy_information": _("Hierarchy information"), "plp_id" : _("PLP ID") } Labels = [(conv[i], tp_info[i], i == "orbital_position" and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv] self.fillList(Labels)
def tuningChangedTo(self, tp): def setLowRateAdapterCount(symbolrate): # change the measurement time and update interval in case of low symbol rate, # since more time is needed for the front end in that case. # It is an heuristic determination without any pretence. For symbol rates # of 5000 the interval is multiplied by 3 until 15000 which is seen # as a high symbol rate. Linear interpolation elsewhere. return max(int(round((3 - 1) * (symbolrate - 15000) / (5000 - 15000) + 1)), 1) self.symbolrate = tp[1] self.polarisation = tp[2] self.MAX_LOW_RATE_ADAPTER_COUNT = setLowRateAdapterCount(self.symbolrate) transponderdata = ConvertToHumanReadable(self.tuner.getTransponderData(), "DVB-S") self["frequency_value"].setText(str(transponderdata.get("frequency"))) self["symbolrate_value"].setText(str(transponderdata.get("symbol_rate"))) self["fec_value"].setText(str(transponderdata.get("fec_inner"))) self["polarisation"].setText(str(transponderdata.get("polarization")))
def updateStatus(self): if self.frontend: self.frontend.getFrontendStatus(self.frontendStatus) self["snr_db"].update() self["snr_percentage"].update() self["ber_value"].update() self["snr_bar"].update() self["ber_bar"].update() self["lock_state"].update() transponderdata = ConvertToHumanReadable(self.tuner.getTransponderData(), "DVB-S") self["frequency_value"].setText(str(transponderdata.get("frequency"))) self["symbolrate_value"].setText(str(transponderdata.get("symbol_rate"))) self["fec_value"].setText(str(transponderdata.get("fec_inner"))) if self.frontendStatus.get("tuner_locked", 0) == 1 and self.isMoving and self.stopOnLock: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False self.updateColors(self.getCurrentConfigPath()) self.statusTimer.start(50, True)
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": t2mi = lambda x: None if x == -1 else str(x) return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT), (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT), (_("Input Stream ID"), frontendData.get("is_id", 0), TYPE_VALUE_DEC), (_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT), (_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC), (_("T2MI PLP ID"), t2mi(frontendData.get("t2mi_plp_id", -1)), TYPE_TEXT), (_("T2MI PID"), None if frontendData.get("t2mi_plp_id", -1) == -1 else str(frontendData.get("t2mi_pid", eDVBFrontendParametersSatellite.T2MI_Default_Pid)), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": channel = channelnumbers.getChannelNumber(frontendDataOrg["frequency"], frontendDataOrg["tuner_number"]) if channelnumbers.supportedChannels(frontendDataOrg["tuner_number"]) else None return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Channel"), channel, TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("Code rate LP"), frontendData["code_rate_lp"], TYPE_TEXT), (_("Code rate HP"), frontendData["code_rate_hp"], TYPE_TEXT), (_("Constellation"), frontendData["constellation"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "ATSC": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) return [ ]
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": return ((_("NIM"), ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')[frontendData["tuner_number"]], TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT), (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return ((_("NIM"), ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')[frontendData["tuner_number"]], TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": data = ((_("NIM"), ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')[frontendData["tuner_number"]], TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("Code rate LP"), frontendData["code_rate_lp"], TYPE_TEXT), (_("Code rate HP"), frontendData["code_rate_hp"], TYPE_TEXT), (_("Constellation"), frontendData["constellation"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) if frontendData.has_key("plp_id"): data += ((_("PLP ID"), frontendData["plp_id"], TYPE_VALUE_DEC), ) return data return [ ]
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) tunerType = frontendDataOrg["tuner_type"] inputName = nimmanager.getNimSlotInputName(frontendData["slot_number"]) if tunerType == feSatellite: return ((_("NIM"), inputName, TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT), (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT), (_("Stream Id"), frontendData.get("is_id", None), TYPE_VALUE_DEC), (_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT), (_("PLS Code"), frontendData.get("pls_code", None), TYPE_VALUE_DEC)) elif tunerType == feCable: return ((_("NIM"), inputName, TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif tunerType == feTerrestrial: return ((_("NIM"), inputName, TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("Code rate LP"), frontendData.get("code_rate_lp", None), TYPE_TEXT), (_("Code rate HP"), frontendData.get("code_rate_hp", None), TYPE_TEXT), (_("Hierarchy info"), frontendData.get("hierarchy_information", None), TYPE_TEXT), (_("FEC"), frontendData.get("fec_inner", None), TYPE_TEXT), (_("PLP ID"), frontendData.get("plp_id", None), TYPE_VALUE_DEC), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("Constellation"), frontendData["constellation"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT)) return [ ]
def updateStatus(self): self.statusTimer.start(self.UPDATE_INTERVAL, True) if self.frontend: self.frontend.getFrontendStatus(self.frontendStatus) self["snr_db"].update() self["snr_percentage"].update() self["ber_value"].update() self["snr_bar"].update() self["ber_bar"].update() self["lock_state"].update() transponderdata = ConvertToHumanReadable(self.tuner.getTransponderData(), "DVB-S") self["frequency_value"].setText(str(transponderdata.get("frequency") / 1000)) self["symbolrate_value"].setText(str(transponderdata.get("symbol_rate") / 1000)) self["fec_value"].setText(str(transponderdata.get("fec_inner"))) self["polarisation"].setText(str(transponderdata.get("polarization"))) if self.statusMsgBlinking: self.statusMsgBlinkCount += 1 if self.statusMsgBlinkCount == self.statusMsgBlinkRate: self.statusMsgBlinkCount = 0 self["status_bar"].visible = not self["status_bar"].visible if self.statusMsgTimeoutTicks > 0: self.statusMsgTimeoutTicks -= 1 if self.statusMsgTimeoutTicks == 0: self["status_bar"].setText("") self.statusMsgBlinking = False self["status_bar"].visible = True if self.isLocked() and self.isMoving and self.stopOnLock: self.stopMoving() self.updateColors(self.getCurrentConfigPath()) if self.collectingStatistics: self.snr_percentage += self["snr_percentage"].getValue(TunerInfo.SNR) self.lock_count += self["lock_state"].getValue(TunerInfo.LOCK) self.stat_count += 1 if self.stat_count == self.max_count: self.collectingStatistics = False count = float(self.stat_count) self.lock_count /= count self.snr_percentage *= 100.0 / 0x10000 / count self.dataAvailable.set()
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg['tuner_type'] == 'DVB-S': return ((_('NIM'), chr(ord('A') + frontendData['tuner_number']), TYPE_TEXT), (_('Type'), frontendData['tuner_type'], TYPE_TEXT), (_('System'), frontendData['system'], TYPE_TEXT), (_('Modulation'), frontendData['modulation'], TYPE_TEXT), (_('Orbital position'), frontendData['orbital_position'], TYPE_VALUE_DEC), (_('Frequency'), frontendData['frequency'], TYPE_VALUE_DEC), (_('Symbol rate'), frontendData['symbol_rate'], TYPE_VALUE_DEC), (_('Polarization'), frontendData['polarization'], TYPE_TEXT), (_('Inversion'), frontendData['inversion'], TYPE_TEXT), (_('FEC'), frontendData['fec_inner'], TYPE_TEXT), (_('Pilot'), frontendData.get('pilot', None), TYPE_TEXT), (_('Roll-off'), frontendData.get('rolloff', None), TYPE_TEXT)) if frontendDataOrg['tuner_type'] == 'DVB-C': return ((_('NIM'), chr(ord('A') + frontendData['tuner_number']), TYPE_TEXT), (_('Type'), frontendData['tuner_type'], TYPE_TEXT), (_('Modulation'), frontendData['modulation'], TYPE_TEXT), (_('Frequency'), frontendData['frequency'], TYPE_VALUE_DEC), (_('Symbol rate'), frontendData['symbol_rate'], TYPE_VALUE_DEC), (_('Inversion'), frontendData['inversion'], TYPE_TEXT), (_('FEC'), frontendData['fec_inner'], TYPE_TEXT)) if frontendDataOrg['tuner_type'] == 'DVB-T': channel = getChannelNumber(frontendDataOrg['frequency'], frontendDataOrg['tuner_number']) if supportedChannels(frontendDataOrg['tuner_number']) else None return ((_('NIM'), chr(ord('A') + frontendData['tuner_number']), TYPE_TEXT), (_('Type'), frontendData['tuner_type'], TYPE_TEXT), (_('Frequency'), frontendData['frequency'], TYPE_VALUE_DEC), (_('Channel'), getChannelNumber(frontendData['frequency'], frontendData['tuner_number']), TYPE_VALUE_DEC), (_('Inversion'), frontendData['inversion'], TYPE_TEXT), (_('Bandwidth'), frontendData['bandwidth'], TYPE_VALUE_DEC), (_('Code rate LP'), frontendData['code_rate_lp'], TYPE_TEXT), (_('Code rate HP'), frontendData['code_rate_hp'], TYPE_TEXT), (_('Constellation'), frontendData['constellation'], TYPE_TEXT), (_('Transmission mode'), frontendData['transmission_mode'], TYPE_TEXT), (_('Guard interval'), frontendData['guard_interval'], TYPE_TEXT), (_('Hierarchy info'), frontendData['hierarchy_information'], TYPE_TEXT)) return []
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": return (("NIM", ('A', 'B', 'C', 'D')[frontendData["tuner_number"]], TYPE_TEXT), ("Type", frontendData["system"], TYPE_TEXT), ("Modulation", frontendData["modulation"], TYPE_TEXT), ("Orbital position", frontendData["orbital_position"], TYPE_VALUE_DEC), ("Frequency", frontendData["frequency"], TYPE_VALUE_DEC), ("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC), ("Polarization", frontendData["polarization"], TYPE_TEXT), ("Inversion", frontendData["inversion"], TYPE_TEXT), ("FEC inner", frontendData["fec_inner"], TYPE_TEXT), ("Pilot", frontendData.get("pilot", None), TYPE_TEXT), ("Rolloff", frontendData.get("rolloff", None), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return (("NIM", ('A', 'B', 'C', 'D')[frontendData["tuner_number"]], TYPE_TEXT), ("Type", frontendData["tuner_type"], TYPE_TEXT), ("Frequency", frontendData["frequency"], TYPE_VALUE_DEC), ("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC), ("Modulation", frontendData["modulation"], TYPE_TEXT), ("Inversion", frontendData["inversion"], TYPE_TEXT), ("FEC inner", frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": return (("NIM", ('A', 'B', 'C', 'D')[frontendData["tuner_number"]], TYPE_TEXT), ("Type", frontendData["tuner_type"], TYPE_TEXT), ("Frequency", frontendData["frequency"], TYPE_VALUE_DEC), ("Inversion", frontendData["inversion"], TYPE_TEXT), ("Bandwidth", frontendData["bandwidth"], TYPE_VALUE_DEC), ("CodeRateLP", frontendData["code_rate_lp"], TYPE_TEXT), ("CodeRateHP", frontendData["code_rate_hp"], TYPE_TEXT), ("Constellation", frontendData["constellation"], TYPE_TEXT), ("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT), ("Guard Interval", frontendData["guard_interval"], TYPE_TEXT), ("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT)) return [ ]
def getTunerInfo(self, service): tunerinfo = "" info = (service and service.info()) Ret_Text = "" xresol = info.getInfo(iServiceInformation.sVideoWidth) yresol = info.getInfo(iServiceInformation.sVideoHeight) if info: try: Ret_Text = str(xresol) + "x" + str(yresol) transponderData = ConvertToHumanReadable(info.getInfoObject(iServiceInformation.sTransponderData)) tunerType = transponderData.get("tuner_type") symbolRate = transponderData.get("symbol_rate", "") frequency = transponderData.get("frequency", "") polarization = transponderData.get("polarization", "").replace(_("Horizontal"), "H").replace(_("Vertical"), "V").replace(_("Circular left"), "CL").replace(_("Circular right"), "CR") fec = transponderData.get("fec_inner", "") if (tunerType == _("Satellite")): frequency = (str((int(frequency) / 1000)) + " MHz") symbolRate = (str((int(symbolRate) / 1000))) tunerinfo = (((((((Ret_Text + " ") + frequency + " ") + polarization) + " ") + fec) + " ") + symbolRate) return tunerinfo except: return ""
def getText(self): service = self.source.service try: info = service and service.info() except: try: info = eServiceCenter.getInstance().info(service) except: pass if not info: return '' else: Ret_Text = '' Sec_Text = '' Res_Text = '' showCryptoInfo = False if self.type == self.SMART_INFO_H or self.type == self.SERVICE_INFO or self.type == self.CRYPTO_INFO or self.type == self.FREQUENCY_INFO: sep = ' ' sep2 = ' - ' elif self.type == self.SMART_INFO_V: sep = '\n' sep2 = '\n' else: return '' if self.type == self.FREQUENCY_INFO: try: feinfo = service and service.frontendInfo() prvd = info.getInfoString(iServiceInformation.sProvider) Ret_Text = self.short(prvd) frontendDataOrg = feinfo and feinfo.getAll(True) except: try: frontendDataOrg = info.getInfoObject(service, iServiceInformation.sTransponderData) prvd = info.getInfoString(service, iServiceInformation.sProvider) except: pass if frontendDataOrg is not None: frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg.get('tuner_type') == 'DVB-S' or frontendDataOrg.get('tuner_type') == 'DVB-C': frequency = str(frontendData.get('frequency') / 1000) + ' MHz' symbolrate = str(frontendData.get('symbol_rate') / 1000) fec_inner = frontendData.get('fec_inner') if frontendDataOrg.get('tuner_type') == 'DVB-S': Ret_Text += sep + frontendData.get('system') orbital_pos = int(frontendDataOrg['orbital_position']) if orbital_pos > 1800: if orbital_pos == 3590: orb_pos = 'Thor/Intelsat' elif orbital_pos == 3560: orb_pos = 'Amos (4' elif orbital_pos == 3550: orb_pos = 'Atlantic Bird' elif orbital_pos == 3530: orb_pos = 'Nilesat/Atlantic Bird' elif orbital_pos == 3520: orb_pos = 'Atlantic Bird' elif orbital_pos == 3475: orb_pos = 'Atlantic Bird' elif orbital_pos == 3460: orb_pos = 'Express' elif orbital_pos == 3450: orb_pos = 'Telstar' elif orbital_pos == 3420: orb_pos = 'Intelsat' elif orbital_pos == 3380: orb_pos = 'Nss' elif orbital_pos == 3355: orb_pos = 'Intelsat' elif orbital_pos == 3325: orb_pos = 'Intelsat' elif orbital_pos == 3300: orb_pos = 'Hispasat' elif orbital_pos == 3285: orb_pos = 'Intelsat' elif orbital_pos == 3170: orb_pos = 'Intelsat' elif orbital_pos == 3150: orb_pos = 'Intelsat' elif orbital_pos == 3070: orb_pos = 'Intelsat' elif orbital_pos == 3045: orb_pos = 'Intelsat' elif orbital_pos == 3020: orb_pos = 'Intelsat 9' elif orbital_pos == 2990: orb_pos = 'Amazonas' elif orbital_pos == 2900: orb_pos = 'Star One' elif orbital_pos == 2880: orb_pos = 'AMC 6 (72' elif orbital_pos == 2875: orb_pos = 'Echostar 6' elif orbital_pos == 2860: orb_pos = 'Horizons' elif orbital_pos == 2810: orb_pos = 'AMC5' elif orbital_pos == 2780: orb_pos = 'NIMIQ 4' elif orbital_pos == 2690: orb_pos = 'NIMIQ 1' elif orbital_pos == 3592: orb_pos = 'Thor/Intelsat' elif orbital_pos == 2985: orb_pos = 'Echostar 3,12' elif orbital_pos == 2830: orb_pos = 'Echostar 8' elif orbital_pos == 2630: orb_pos = 'Galaxy 19' elif orbital_pos == 2500: orb_pos = 'Echostar 10,11' elif orbital_pos == 2502: orb_pos = 'DirectTV 5' elif orbital_pos == 2410: orb_pos = 'Echostar 7 Anik F3' elif orbital_pos == 2391: orb_pos = 'Galaxy 23' elif orbital_pos == 2390: orb_pos = 'Echostar 9' elif orbital_pos == 2412: orb_pos = 'DirectTV 7S' elif orbital_pos == 2310: orb_pos = 'Galaxy 27' elif orbital_pos == 2311: orb_pos = 'Ciel 2' elif orbital_pos == 2120: orb_pos = 'Echostar 2' else: orb_pos = str(float(3600 - orbital_pos) / 10.0) + 'W' elif orbital_pos > 0: if orbital_pos == 192: orb_pos = 'Astra 1F' elif orbital_pos == 130: orb_pos = 'Hot Bird 6,7A,8' elif orbital_pos == 235: orb_pos = 'Astra 1E' elif orbital_pos == 1100: orb_pos = 'BSat 1A,2A' elif orbital_pos == 1101: orb_pos = 'N-Sat 110' elif orbital_pos == 1131: orb_pos = 'KoreaSat 5' elif orbital_pos == 1440: orb_pos = 'SuperBird 7,C2' elif orbital_pos == 1006: orb_pos = 'AsiaSat 2' elif orbital_pos == 1030: orb_pos = 'Express A2' elif orbital_pos == 1056: orb_pos = 'Asiasat 3S' elif orbital_pos == 1082: orb_pos = 'NSS 11' elif orbital_pos == 881: orb_pos = 'ST1' elif orbital_pos == 900: orb_pos = 'Yamal 201' elif orbital_pos == 917: orb_pos = 'Mesat' elif orbital_pos == 950: orb_pos = 'Insat 4B' elif orbital_pos == 951: orb_pos = 'NSS 6' elif orbital_pos == 765: orb_pos = 'Telestar' elif orbital_pos == 785: orb_pos = 'ThaiCom 5' elif orbital_pos == 800: orb_pos = 'Express' elif orbital_pos == 830: orb_pos = 'Insat 4A' elif orbital_pos == 850: orb_pos = 'Intelsat 709' elif orbital_pos == 750: orb_pos = 'Abs' elif orbital_pos == 720: orb_pos = 'Intelsat' elif orbital_pos == 705: orb_pos = 'Eutelsat W5' elif orbital_pos == 685: orb_pos = 'Intelsat' elif orbital_pos == 620: orb_pos = 'Intelsat 902' elif orbital_pos == 600: orb_pos = 'Intelsat 904' elif orbital_pos == 570: orb_pos = 'Nss' elif orbital_pos == 530: orb_pos = 'Express AM22' elif orbital_pos == 480: orb_pos = 'Eutelsat 2F2' elif orbital_pos == 450: orb_pos = 'Intelsat' elif orbital_pos == 420: orb_pos = 'Turksat 2A' elif orbital_pos == 400: orb_pos = 'Express AM1' elif orbital_pos == 390: orb_pos = 'Hellas Sat 2' elif orbital_pos == 380: orb_pos = 'Paksat 1' elif orbital_pos == 360: orb_pos = 'Eutelsat Sesat' elif orbital_pos == 335: orb_pos = 'Astra 1M' elif orbital_pos == 330: orb_pos = 'Eurobird 3' elif orbital_pos == 328: orb_pos = 'Galaxy 11' elif orbital_pos == 315: orb_pos = 'Astra 5A' elif orbital_pos == 310: orb_pos = 'Turksat' elif orbital_pos == 305: orb_pos = 'Arabsat' elif orbital_pos == 285: orb_pos = 'Eurobird 1' elif orbital_pos == 284: orb_pos = 'Eurobird/Astra' elif orbital_pos == 282: orb_pos = 'Eurobird/Astra' elif orbital_pos == 1220: orb_pos = 'AsiaSat' elif orbital_pos == 1380: orb_pos = 'Telstar 18' elif orbital_pos == 260: orb_pos = 'Badr 3/4' elif orbital_pos == 255: orb_pos = 'Eurobird 2' elif orbital_pos == 215: orb_pos = 'Eutelsat' elif orbital_pos == 216: orb_pos = 'Eutelsat W6' elif orbital_pos == 210: orb_pos = 'AfriStar 1' elif orbital_pos == 160: orb_pos = 'Eutelsat W2' elif orbital_pos == 100: orb_pos = 'Eutelsat W1' elif orbital_pos == 90: orb_pos = 'Eurobird 9' elif orbital_pos == 70: orb_pos = 'Eutelsat W3A' elif orbital_pos == 50: orb_pos = 'Sirius 4' elif orbital_pos == 48: orb_pos = 'Sirius 4' elif orbital_pos == 30: orb_pos = 'Telecom 2' else: orb_pos = str(float(orbital_pos) / 10.0) + 'E' Ret_Text += sep + orb_pos + '\n' Ret_Text += frequency + sep + frontendData.get('polarization_abbreviation') Ret_Text += sep + symbolrate Ret_Text += sep + frontendData.get('modulation') + '-' + fec_inner else: Ret_Text += sep + 'DVB-C ' + frequency + ' MHz' + sep + fec_inner + sep + symbolrate elif frontendData.get('tuner_type') == 'DVB-T': frequency = str(frontendData.get('frequency') / 1000) + ' MHz' Ret_Text = 'Frequency: ' + frequency if self.type == self.SMART_INFO_H or self.type == self.SMART_INFO_V or self.type == self.SERVICE_INFO: xresol = info.getInfo(iServiceInformation.sVideoWidth) yresol = info.getInfo(iServiceInformation.sVideoHeight) feinfo = service and service.frontendInfo() prvd = info.getInfoString(iServiceInformation.sProvider) Ret_Text = self.short(prvd) frontendDataOrg = feinfo and feinfo.getAll(True) if frontendDataOrg is not None: frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg.get('tuner_type') == 'DVB-S' or frontendDataOrg.get('tuner_type') == 'DVB-C': frequency = str(frontendData.get('frequency') / 1000) symbolrate = str(frontendData.get('symbol_rate') / 1000) fec_inner = frontendData.get('fec_inner') if frontendDataOrg.get('tuner_type') == 'DVB-S': Ret_Text += sep + frontendData.get('system') Ret_Text += sep + frequency + frontendData.get('polarization_abbreviation') Ret_Text += sep + symbolrate Ret_Text += sep + fec_inner + ' ' + frontendData.get('modulation') orbital_pos = int(frontendDataOrg['orbital_position']) if orbital_pos > 1800: orb_pos = str(float(3600 - orbital_pos) / 10.0) + 'W' elif orbital_pos > 0: orb_pos = str(float(orbital_pos) / 10.0) + 'E' Ret_Text += sep + orb_pos else: Ret_Text += sep + 'DVB-C ' + frequency + ' MHz' + sep + fec_inner + sep + symbolrate elif frontendDataOrg.get('tuner_type') == 'DVB-T': frequency = str(frontendData.get('frequency') / 1000) Ret_Text += sep + 'DVB-T' + sep + 'Frequency:' + sep + frequency + ' MHz' if feinfo is not None and xresol > 0: Res_Text += ('MPEG2 ', 'MPEG4 ', 'MPEG1 ', 'MPEG4-II ', 'VC1 ', 'VC1-SM ', '')[info.getInfo(iServiceInformation.sVideoType)] Res_Text += str(xresol) + 'x' + str(yresol) Res_Text += ('i', 'p', '')[info.getInfo(iServiceInformation.sProgressive)] Res_Text += str((info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) if self.type == self.SMART_INFO_H or self.type == self.SMART_INFO_V or self.type == self.CRYPTO_INFO: decCI = '0' Sec_Text = '' if info.getInfo(iServiceInformation.sIsCrypted) == 1: data = self.ecmdata.getEcmData() if not config.usage.show_cryptoinfo.value: showCryptoInfo = True Sec_Text = data[0] + '\n' decCI = data[1] provid = data[2] pid = data[3] if decCI != '0': decCIfull = '%04x' % int(decCI, 16) for idline in self.idnames: if int(decCI, 16) >= int(idline[0], 16) and int(decCI, 16) <= int(idline[1], 16): decCIfull = idline[2] + ':' + decCIfull break Sec_Text += decCIfull if provid != '0': Sec_Text += ':%04x' % int(provid, 16) else: Sec_Text += ':' if pid != '0': Sec_Text += ':%04x:%04x' % (info.getInfo(iServiceInformation.sSID), int(pid, 16)) elif not config.usage.show_cryptoinfo.value: showCryptoInfo = True Sec_Text = 'FTA' res = '' searchIDs = info.getInfoObject(iServiceInformation.sCAIDs) for idline in self.idnames: if int(decCI, 16) >= int(idline[0], 16) and int(decCI, 16) <= int(idline[1], 16): color = '\\c0000??00' else: color = '\\c007?7?7?' try: for oneID in searchIDs: if oneID >= int(idline[0], 16) and oneID <= int(idline[1], 16): color = '\\c00????00' except: pass res += color + idline[3] + ' ' if self.type != self.CRYPTO_INFO: Ret_Text += '\n' Ret_Text += res + '\\c00?????? ' + Sec_Text if Res_Text != '': if showCryptoInfo: Ret_Text += sep + Res_Text else: Ret_Text += '\n' + Res_Text return Ret_Text
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference()).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference().toString() else: name = _('N/A') refstr = _('N/A') aspect = '-' videocodec = '-' videomode = '-' resolution = '-' if self.info: videocodec = ('MPEG2', 'MPEG4', 'MPEG1', 'MPEG4-II', 'VC1', 'VC1-SM', '-')[self.info and self.info.getInfo(iServiceInformation.sVideoType)] video_height = 0 video_width = 0 video_pol = ' ' video_rate = 0 if path.exists('/proc/stb/vmpeg/0/yres'): f = open('/proc/stb/vmpeg/0/yres', 'r') try: video_height = int(f.read(), 16) except: pass f.close() if path.exists('/proc/stb/vmpeg/0/xres'): f = open('/proc/stb/vmpeg/0/xres', 'r') try: video_width = int(f.read(), 16) except: pass f.close() if path.exists('/proc/stb/vmpeg/0/progressive'): f = open('/proc/stb/vmpeg/0/progressive', 'r') try: video_pol = 'p' if int(f.read(), 16) else 'i' except: pass f.close() if path.exists('/proc/stb/vmpeg/0/framerate'): f = open('/proc/stb/vmpeg/0/framerate', 'r') try: video_rate = int(f.read()) except: pass f.close() fps = str((video_rate + 500) / 1000) resolution = str(video_width) + 'x' + str(video_height) + video_pol + fps aspect = self.getServiceInfoValue(iServiceInformation.sAspect) if aspect in (1, 2, 5, 6, 9, 10, 13, 14): aspect = '4:3' else: aspect = '16:9' f = open('/proc/stb/video/videomode') videomode = f.read()[:-1].replace('\n', '') f.close() Labels = ((_('Name'), name, TYPE_TEXT), (_('Provider'), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_('Videoformat'), aspect, TYPE_TEXT), (_('Videomode'), videomode, TYPE_TEXT), (_('Videosize'), resolution, TYPE_TEXT), (_('Videocodec'), videocodec, TYPE_TEXT), (_('Namespace'), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_('Service reference'), refstr, TYPE_TEXT)) self.fillList(Labels) elif self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = {'tuner_type': _('Transponder type'), 'system': _('System'), 'modulation': _('Modulation'), 'orbital_position': _('Orbital position'), 'frequency': _('Frequency'), 'symbol_rate': _('Symbol rate'), 'bandwidth': _('Bandwidth'), 'polarization': _('Polarization'), 'inversion': _('Inversion'), 'pilot': _('Pilot'), 'rolloff': _('Roll-off'), 'fec_inner': _('FEC'), 'code_rate_lp': _('Coderate LP'), 'code_rate_hp': _('Coderate HP'), 'constellation': _('Constellation'), 'transmission_mode': _('Transmission mode'), 'guard_interval': _('Guard interval'), 'hierarchy_information': _('Hierarchy information')} Labels = [ (conv[i], tp_info[i], i == 'orbital_position' and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv ] self.fillList(Labels)
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference()).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference().toString() else: name = _("N/A") refstr = _("N/A") aspect = "-" videocodec = "-" videomode = "-" resolution = "-" if self.info: videocodec = ("MPEG2", "MPEG4", "MPEG1", "MPEG4-VC", "VC1", "VC1-SM", "HEVC", "-")[self.info.getInfo(iServiceInformation.sVideoType)] width = self.info.getInfo(iServiceInformation.sVideoWidth) height = self.info.getInfo(iServiceInformation.sVideoHeight) if width > 0 and height > 0: resolution = "%dx%d" % (width,height) resolution += ("i", "p", "")[self.info.getInfo(iServiceInformation.sProgressive)] resolution += str((self.info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) aspect = self.getServiceInfoValue(iServiceInformation.sAspect) if aspect in ( 1, 2, 5, 6, 9, 0xA, 0xD, 0xE ): aspect = "4:3" else: aspect = "16:9" f = open("/proc/stb/video/videomode") videomode = f.read()[:-1].replace('\n','') f.close() codenumbers = subprocess.check_output(['timeout -t 2 -s kill dvbsnoop -n 1 -nph 1 | grep CA_system_ID | awk -F "=" "{print $2}" | awk -F "]" "{print $1}" | wc -l'], shell=True) codesystem = subprocess.check_output(["timeout -t 2 -s kill dvbsnoop -n 1 -nph 1 | grep CA_system_ID | awk -F '=' '{print $2}' | awk -F ']' '{print $1}'"], shell=True) caidssyst = subprocess.check_output(["timeout -t 2 -s kill dvbsnoop -n 1 -nph 1 | grep CA_system_ID | awk -F '(' '{print $2}' | awk -F ')' '{print $1}'"], shell=True) Labels = ( (_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Videoformat"), aspect, TYPE_TEXT), (_("Videomode"), videomode, TYPE_TEXT), (_("Videosize"), resolution, TYPE_TEXT), (_("Videocodec"), videocodec, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT), (_("Coding Systems"), codenumbers, TYPE_TEXT)) if codenumbers > 0: i = 0 caidssyst1 = caidssyst.splitlines() codesystem1 = codesystem.splitlines() while i < int(codenumbers): caidsystem = caidssyst1[i] + " " + codesystem1[i] i += 1 newlabel = ( (_("%s " %i), caidsystem, TYPE_TEXT)) Labels = Labels + (newlabel,) self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type" : _("Transponder type"), "system" : _("System"), "modulation" : _("Modulation"), "orbital_position" : _("Orbital position"), "frequency" : _("Frequency"), "symbol_rate" : _("Symbol rate"), "bandwidth" : _("Bandwidth"), "polarization" : _("Polarization"), "inversion" : _("Inversion"), "pilot" : _("Pilot"), "rolloff" : _("Roll-off"), "is_id" : _("Input Stream ID"), "pls_mode" : _("PLS Mode"), "pls_code" : _("PLS Code"), "fec_inner" : _("FEC"), "code_rate_lp" : _("Coderate LP"), "code_rate_hp" : _("Coderate HP"), "constellation" : _("Constellation"), "transmission_mode": _("Transmission mode"), "guard_interval" : _("Guard interval"), "hierarchy_information": _("Hierarchy information")} Labels = [(conv[i], tp_info[i], i == "orbital_position" and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv] self.fillList(Labels)
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference( self.session.nav.getCurrentlyPlayingServiceReference( )).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference( ).toString() else: name = _("N/A") refstr = _("N/A") aspect = "-" videocodec = "-" videomode = "-" resolution = "-" if self.info: videocodec = ("MPEG2", "MPEG4 H.264", "MPEG1", "MPEG4-VC", "VC1", "VC1-SM", "HEVC H.265", "-")[self.info.getInfo( iServiceInformation.sVideoType)] video_height = 0 video_width = 0 video_pol = " " video_rate = 0 if path.exists("/proc/stb/vmpeg/0/yres"): f = open("/proc/stb/vmpeg/0/yres", "r") try: video_height = int(f.read(), 16) except: pass f.close() if path.exists("/proc/stb/vmpeg/0/xres"): f = open("/proc/stb/vmpeg/0/xres", "r") try: video_width = int(f.read(), 16) except: pass f.close() if path.exists("/proc/stb/vmpeg/0/progressive"): f = open("/proc/stb/vmpeg/0/progressive", "r") try: video_pol = "p" if int(f.read(), 16) else "i" except: pass f.close() if path.exists("/proc/stb/vmpeg/0/framerate"): f = open("/proc/stb/vmpeg/0/framerate", "r") try: video_rate = int(f.read()) except: pass f.close() fps = str((video_rate + 500) / 1000) resolution = str(video_width) + "x" + str( video_height) + video_pol + fps aspect = self.getServiceInfoValue(iServiceInformation.sAspect) if aspect in (1, 2, 5, 6, 9, 0xA, 0xD, 0xE): aspect = "4:3" else: aspect = "16:9" f = open("/proc/stb/video/videomode") videomode = f.read()[:-1].replace('\n', '') f.close() Labels = ((_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Videoformat"), aspect, TYPE_TEXT), (_("Videomode"), videomode, TYPE_TEXT), (_("Videosize"), resolution, TYPE_TEXT), (_("Videocodec"), videocodec, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue( iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type": _("Transponder type"), "system": _("System"), "modulation": _("Modulation"), "orbital_position": _("Orbital position"), "frequency": _("Frequency"), "symbol_rate": _("Symbol rate"), "bandwidth": _("Bandwidth"), "polarization": _("Polarization"), "inversion": _("Inversion"), "pilot": _("Pilot"), "rolloff": _("Roll-off"), "fec_inner": _("FEC"), "code_rate_lp": _("Coderate LP"), "code_rate_hp": _("Coderate HP"), "constellation": _("Constellation"), "transmission_mode": _("Transmission mode"), "guard_interval": _("Guard interval"), "hierarchy_information": _("Hierarchy information") } Labels = [(conv[i], tp_info[i], i == "orbital_position" and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv] self.fillList(Labels)
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference( self.session.nav.getCurrentlyPlayingServiceReference( )).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference( ).toString() else: name = _('N/A') refstr = _('N/A') aspect = '-' videocodec = '-' videomode = '-' resolution = '-' if self.info: videocodec = ( 'MPEG2', 'MPEG4', 'MPEG1', 'MPEG4-II', 'VC1', 'VC1-SM', '-')[self.info and self.info.getInfo(iServiceInformation.sVideoType)] width = self.info.getInfo(iServiceInformation.sVideoWidth) height = self.info.getInfo(iServiceInformation.sVideoHeight) if width > 0 and height > 0: resolution = '%dx%d' % (width, height) resolution += ('i', 'p', '')[self.info.getInfo( iServiceInformation.sProgressive)] resolution += str( (self.info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) aspect = self.getServiceInfoValue( iServiceInformation.sAspect) if aspect in (1, 2, 5, 6, 9, 10, 13, 14): aspect = '4:3' else: aspect = '16:9' f = open('/proc/stb/video/videomode') videomode = f.read()[:-1].replace('\n', '') f.close() Labels = ((_('Name'), name, TYPE_TEXT), (_('Provider'), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_('Videoformat'), aspect, TYPE_TEXT), (_('Videomode'), videomode, TYPE_TEXT), (_('Videosize'), resolution, TYPE_TEXT), (_('Videocodec'), videocodec, TYPE_TEXT), (_('Namespace'), self.getServiceInfoValue( iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_('Service reference'), refstr, TYPE_TEXT)) self.fillList(Labels) elif self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { 'tuner_type': _('Transponder type'), 'system': _('System'), 'modulation': _('Modulation'), 'orbital_position': _('Orbital position'), 'frequency': _('Frequency'), 'symbol_rate': _('Symbol rate'), 'bandwidth': _('Bandwidth'), 'polarization': _('Polarization'), 'inversion': _('Inversion'), 'pilot': _('Pilot'), 'rolloff': _('Roll-off'), 'fec_inner': _('FEC'), 'code_rate_lp': _('Coderate LP'), 'code_rate_hp': _('Coderate HP'), 'constellation': _('Constellation'), 'transmission_mode': _('Transmission mode'), 'guard_interval': _('Guard interval'), 'hierarchy_information': _('Hierarchy information') } Labels = [(conv[i], tp_info[i], i == 'orbital_position' and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv] self.fillList(Labels)
def getText(self): service = self.source.service if service is None: return "" info = service and service.info() if not info: return "" if self.type == "CryptoInfo": self.getCryptoInfo(info) if int(config.usage.show_cryptoinfo.value) > 0: return addspace(self.createCryptoBar(info)) + self.createCryptoSpecial(info) else: return addspace(self.createCryptoBar(info)) + addspace(self.current_source) + self.createCryptoSpecial(info) if self.type == "CryptoBar": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoBar(info) else: return "" if self.type == "CryptoSeca": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoSeca(info) else: return "" if self.type == "CryptoVia": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoVia(info) else: return "" if self.type == "CryptoIrdeto": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoIrdeto(info) else: return "" if self.type == "CryptoNDS": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoNDS(info) else: return "" if self.type == "CryptoConax": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoConax(info) else: return "" if self.type == "CryptoCryptoW": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoCryptoW(info) else: return "" if self.type == "CryptoBeta": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoBeta(info) else: return "" if self.type == "CryptoNagra": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoNagra(info) else: return "" if self.type == "CryptoBiss": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoBiss(info) else: return "" if self.type == "CryptoDre": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoDre(info) else: return "" if self.type == "CryptoTandberg": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoTandberg(info) else: return "" if self.type == "CryptoSpecial": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoSpecial(info) else: return "" if self.type == "CryptoNameCaid": if int(config.usage.show_cryptoinfo.value) > 0: self.getCryptoInfo(info) return self.createCryptoNameCaid(info) else: return "" if self.type == "ResolutionString": return self.createResolution(info) if self.type == "VideoCodec": return self.createVideoCodec(info) if self.updateFEdata: feinfo = service.frontendInfo() if feinfo: self.feraw = feinfo.getAll(config.usage.infobar_frontend_source.value == "settings") if self.feraw: self.fedata = ConvertToHumanReadable(self.feraw) feraw = self.feraw if not feraw: feraw = info.getInfoObject(iServiceInformation.sTransponderData) if not feraw: return "" fedata = ConvertToHumanReadable(feraw) else: fedata = self.fedata if self.type == "All": self.getCryptoInfo(info) if int(config.usage.show_cryptoinfo.value) > 0: return addspace(self.createProviderName(info)) + self.createTransponderInfo(fedata, feraw, info) + addspace(self.createTransponderName(feraw)) + "\n"\ + addspace(self.createCryptoBar(info)) + addspace(self.createCryptoSpecial(info)) + "\n"\ + addspace(self.createPIDInfo(info)) + addspace(self.createVideoCodec(info)) + self.createResolution(info) else: return addspace(self.createProviderName(info)) + self.createTransponderInfo(fedata, feraw, info) + addspace(self.createTransponderName(feraw)) + "\n" \ + addspace(self.createCryptoBar(info)) + self.current_source + "\n" \ + addspace(self.createCryptoSpecial(info)) + addspace(self.createVideoCodec(info)) + self.createResolution(info) if self.type == "ServiceInfo": return addspace(self.createProviderName(info)) + addspace(self.createTunerSystem(fedata)) + addspace(self.createFrequency(feraw)) + addspace(self.createPolarization(fedata)) \ + addspace(self.createSymbolRate(fedata, feraw)) + addspace(self.createFEC(fedata, feraw)) + addspace(self.createModulation(fedata)) + addspace(self.createOrbPos(feraw)) + addspace(self.createTransponderName(feraw))\ + addspace(self.createVideoCodec(info)) + self.createResolution(info) if self.type == "TransponderInfo2line": return addspace(self.createProviderName(info)) + addspace(self.createTunerSystem(fedata)) + addspace(self.createTransponderName(feraw)) + '\n'\ + addspace(self.createFrequency(fedata)) + addspace(self.createPolarization(fedata))\ + addspace(self.createSymbolRate(fedata, feraw)) + self.createModulation(fedata) + '-' + addspace(self.createFEC(fedata, feraw)) if self.type == "PIDInfo": return self.createPIDInfo(info) if self.type == "ServiceRef": return self.createServiceRef(info) if not feraw: return "" if self.type == "TransponderInfo": return self.createTransponderInfo(fedata, feraw, info) if self.type == "TransponderFrequency": return self.createFrequency(feraw) if self.type == "TransponderSymbolRate": return self.createSymbolRate(fedata, feraw) if self.type == "TransponderPolarization": return self.createPolarization(fedata) if self.type == "TransponderFEC": return self.createFEC(fedata, feraw) if self.type == "TransponderModulation": return self.createModulation(fedata) if self.type == "OrbitalPosition": return self.createOrbPos(feraw) if self.type == "TunerType": return self.createTunerType(feraw) if self.type == "TunerSystem": return self.createTunerSystem(fedata) if self.type == "OrbitalPositionOrTunerSystem": return self.createOrbPosOrTunerSystem(fedata,feraw) if self.type == "TerrestrialChannelNumber": return self.createChannelNumber(fedata, feraw) return _("invalid type")
def getText(self): service = self.source.service info = service and service.info() if not info: return "" if self.type == self.XRES: video_width = None if path.exists("/proc/stb/vmpeg/0/xres"): f = open("/proc/stb/vmpeg/0/xres", "r") video_width = int(f.read(),16) f.close() if not video_width: video_width = self.getServiceInfoString(info, iServiceInformation.sVideoWidth) return "%d" % video_width elif self.type == self.YRES: video_height = None if path.exists("/proc/stb/vmpeg/0/yres"): f = open("/proc/stb/vmpeg/0/yres", "r") video_height = int(f.read(),16) f.close() if not video_height: video_height = self.getServiceInfoString(info, iServiceInformation.sVideoHeight) return "%d" % video_height elif self.type == self.APID: return self.getServiceInfoString(info, iServiceInformation.sAudioPID) elif self.type == self.VPID: return self.getServiceInfoString(info, iServiceInformation.sVideoPID) elif self.type == self.PCRPID: return self.getServiceInfoString(info, iServiceInformation.sPCRPID) elif self.type == self.PMTPID: return self.getServiceInfoString(info, iServiceInformation.sPMTPID) elif self.type == self.TXTPID: return self.getServiceInfoString(info, iServiceInformation.sTXTPID) elif self.type == self.TSID: return self.getServiceInfoString(info, iServiceInformation.sTSID) elif self.type == self.ONID: return self.getServiceInfoString(info, iServiceInformation.sONID) elif self.type == self.SID: return self.getServiceInfoString(info, iServiceInformation.sSID) elif self.type == self.FRAMERATE: video_rate = None if path.exists("/proc/stb/vmpeg/0/framerate"): f = open("/proc/stb/vmpeg/0/framerate", "r") video_rate = int(f.read()) f.close() if not video_rate: video_rate = self.getServiceInfoString(info, iServiceInformation.sFrameRate) return video_rate, lambda x: "%d fps" % ((x+500)/1000) elif self.type == self.TRANSFERBPS: return self.getServiceInfoString(info, iServiceInformation.sTransferBPS, lambda x: "%d kB/s" % (x/1024)) elif self.type == self.HAS_HBBTV: return info.getInfoString(iServiceInformation.sHBBTVUrl) elif self.type == self.FREQ_INFO: feinfo = service.frontendInfo() if feinfo is None: return "" feraw = feinfo.getAll(False) if feraw is None: return "" fedata = ConvertToHumanReadable(feraw) if fedata is None: return "" frequency = fedata.get("frequency") sr_txt = "Sr:" polarization = fedata.get("polarization_abbreviation") if polarization is None: polarization = "" symbolrate = str(int(fedata.get("symbol_rate", 0))) if symbolrate == "0": sr_txt = "" symbolrate = "" fec = fedata.get("fec_inner") if fec is None: fec = "" out = "Freq: %s %s %s %s %s" % (frequency, polarization, sr_txt, symbolrate, fec) return out return ""
def getText(self): service = self.source.service info = service and service.info() if not info: return "" if self.type == self.XRES: return self._getVideoWidthStr(info) elif self.type == self.YRES: return self._getVideoHeightStr(info) elif self.type == self.APID: return self.getServiceInfoString(info, iServiceInformation.sAudioPID) elif self.type == self.VPID: return self.getServiceInfoString(info, iServiceInformation.sVideoPID) elif self.type == self.PCRPID: return self.getServiceInfoString(info, iServiceInformation.sPCRPID) elif self.type == self.PMTPID: return self.getServiceInfoString(info, iServiceInformation.sPMTPID) elif self.type == self.TXTPID: return self.getServiceInfoString(info, iServiceInformation.sTXTPID) elif self.type == self.TSID: return self.getServiceInfoString(info, iServiceInformation.sTSID) elif self.type == self.ONID: return self.getServiceInfoString(info, iServiceInformation.sONID) elif self.type == self.SID: return self.getServiceInfoString(info, iServiceInformation.sSID) elif self.type == self.FRAMERATE: return self._getFrameRateStr(info, convert=lambda x: "%d fps" % ((x + 500) / 1000)) elif self.type == self.PROGRESSIVE: return self._getProgressiveStr(info) elif self.type == self.TRANSFERBPS: return self.getServiceInfoString(info, iServiceInformation.sTransferBPS, lambda x: "%d kB/s" % (x / 1024)) elif self.type == self.HAS_HBBTV: return info.getInfoString(iServiceInformation.sHBBTVUrl) elif self.type == self.FREQ_INFO: feinfo = service.frontendInfo() if feinfo is None: return "" feraw = feinfo.getAll(False) if feraw is None: return "" fedata = ConvertToHumanReadable(feraw) if fedata is None: return "" frequency = fedata.get("frequency") sr_txt = "Sr:" polarization = fedata.get("polarization_abbreviation") if polarization is None: polarization = "" symbolrate = str(int(fedata.get("symbol_rate", 0))) if symbolrate == "0": sr_txt = "" symbolrate = "" fec = fedata.get("fec_inner") if fec is None: fec = "" out = "Freq: %s %s %s %s %s" % (frequency, polarization, sr_txt, symbolrate, fec) return out elif self.type == self.VIDEO_INFO: progressive = self._getProgressiveStr(info) fieldrate = self._getFrameRate(info) if fieldrate > 0: if progressive == 'i': fieldrate *= 2 fieldrate = "%dHz" % ((fieldrate + 500) / 1000, ) else: fieldrate = "" return "%sx%s%s %s" % (self._getVideoWidthStr(info), self._getVideoHeightStr(info), progressive, fieldrate) return ""
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if self.transponder_info: tuner = (_("Type"), frontendData["tuner_type"], TYPE_TEXT) else: tuner = (_("NIM & Type"), chr(ord('A') + frontendData["tuner_number"]) + " - " + frontendData["tuner_type"], TYPE_TEXT) if frontendDataOrg["tuner_type"] == "DVB-S": issy = lambda x: 0 if x == -1 else x return (tuner, (_("System & Modulation"), frontendData["system"] + " " + frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency & Polarization"), "%s MHz" % (frontendData.get("frequency", 0) / 1000) + " - " + frontendData["polarization"], TYPE_TEXT), (_("Symbol rate & FEC"), "%s KSymb/s" % (frontendData.get("symbol_rate", 0) / 1000) + " - " + frontendData["fec_inner"], TYPE_TEXT), (_("Inversion, Pilot & Roll-off"), frontendData["inversion"] + " - " + str(frontendData.get("pilot", None)) + " - " + str(frontendData.get("rolloff", None)), TYPE_TEXT), (_("Input Stream ID"), issy(frontendData.get("is_id", 0)), TYPE_VALUE_DEC), (_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT), (_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC)) elif frontendDataOrg["tuner_type"] == "DVB-C": return (tuner, (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData.get("frequency", 0), TYPE_VALUE_FREQ_FLOAT), (_("Symbol rate & FEC"), "%s KSymb/s" % (frontendData.get("symbol_rate", 0) / 1000) + " - " + frontendData["fec_inner"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": return (tuner, (_("Frequency & Channel"), "%.3f MHz" % ((frontendData.get("frequency", 0) / 1000) / 1000.0) + " - " + frontendData["channel"], TYPE_TEXT), (_("Inversion & Bandwidth"), frontendData["inversion"] + " - " + str(frontendData["bandwidth"]), TYPE_TEXT), (_("Code R. LP-HP & Guard Int."), frontendData["code_rate_lp"] + " - " + frontendData["code_rate_hp"] + " - " + frontendData["guard_interval"], TYPE_TEXT), (_("Constellation & FFT mode"), frontendData["constellation"] + " - " + frontendData["transmission_mode"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "ATSC": return (tuner, (_("System & Modulation"), frontendData["system"] + " " + frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData.get("frequency", 0) / 1000, TYPE_VALUE_FREQ_FLOAT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) return []
def frontendStateChanged(self): if self.frontend is None: self.timer.start(5000, True) return x = { } self.frontend.getFrontendStatus(x) assert x, "getFrontendStatus failed!" if x["tuner_state"] in ("LOCKED", "FAILED", "LOSTLOCK"): state = self.satellite_search_session d = { } self.frontend.getTransponderData(d, False) d["tuner_type"] = 'DVB-S' # what is this doing? Nothing good by the look of it. r = ConvertToHumanReadable(d) if x["tuner_state"] == "LOCKED": freq = int(round(d["frequency"], -3)) # round to nearest 1000 parm = eDVBFrontendParametersSatellite() parm.frequency = freq if d["symbol_rate"] < 0: print "[dmmBlindscan][frontendStateChanged] WARNING blind SR is < 0... skip" if not self.auto_scan: self.parm.frequency += self.parm.symbol_rate else: parm.symbol_rate = int(round(d["symbol_rate"], -3)) parm.fec = d["fec_inner"] parm.inversion = eDVBFrontendParametersSatellite.Inversion_Unknown parm.polarisation = d["polarization"] parm.orbital_position = d["orbital_position"] parm.system = d["system"] parm.modulation = d["modulation"] if parm.system == eDVBFrontendParametersSatellite.System_DVB_S2: parm.rolloff = d["rolloff"] parm.pilot = d["pilot"] if hasattr(parm, "is_id"): parm.is_id = d["is_id"] if hasattr(parm, "pls_mode"): parm.pls_mode = d["pls_mode"] if hasattr(parm, "pls_code"): parm.pls_code = d["pls_code"] if hasattr(parm, "t2mi_plp_id"): parm.t2mi_plp_id = d["t2mi_plp_id"] if hasattr(parm, "t2mi_pid"): parm.t2mi_pid = d["t2mi_pid"] print "[dmmBlindscan][frontendStateChanged] About to run filters" parm_list = self.runFilters([parm], self.__tlist) # parm_list will contain a maximum of one transponder as the input is only one transponder if parm_list: parm = parm_list[0] self.__tlist.append(parm) fstr = "%s %s %s %s %s %s" % ( str(parm.frequency / 1000), {eDVBFrontendParametersSatellite.Polarisation_Horizontal: "H", eDVBFrontendParametersSatellite.Polarisation_Vertical: "V", eDVBFrontendParametersSatellite.Polarisation_CircularLeft: "L", eDVBFrontendParametersSatellite.Polarisation_CircularRight: "R"}.get(parm.polarisation), str(parm.symbol_rate/1000), r["fec_inner"], r["system"], r["modulation"]) if not parm_list: print "[dmmBlindscan][frontendStateChanged] Transponder removed by filters, %s" % fstr if self.auto_scan: print "[dmmBlindscan][frontendStateChanged] LOCKED at", freq, {eDVBFrontendParametersSatellite.Polarisation_Horizontal: "H", eDVBFrontendParametersSatellite.Polarisation_Vertical: "V", eDVBFrontendParametersSatellite.Polarisation_CircularLeft: "L", eDVBFrontendParametersSatellite.Polarisation_CircularRight: "R"}.get(parm.polarisation) else: print "[dmmBlindscan][frontendStateChanged] LOCKED at", freq, "SEARCHED at", self.parm.frequency, "half bw", (135L*((sr+1000)/1000)/200), "half search range", (self.parm.symbol_rate/2) self.parm.frequency = freq self.parm.frequency += (135L*((sr+999)/1000)/200) self.parm.frequency += self.parm.symbol_rate/2 if parm_list: bm = state.getConstellationBitmap(5) self.tp_found.append((fstr, bm)) state.updateConstellation(bm) if len(self.tp_found): state["list"].updateList(self.tp_found) else: state["list"].setList(self.tp_found) state["list"].setIndex(0) else: if self.auto_scan: #when driver based auto scan is used we got a tuneFailed event when the scan has scanned the last frequency... self.parm = self.setNextRange() else: self.parm.frequency += self.parm.symbol_rate if self.auto_scan: # freq = d["frequency"] # freq = int(round(float(freq*2) / 1000)) * 1000 # freq /= 2 freq = int(round(d["frequency"], -3)) # round to nearest 1000 mhz_complete, mhz_done = self.stats(freq) print "[dmmBlindscan][frontendStateChanged] CURRENT freq", freq, "%d/%d" %(mhz_done, mhz_complete) check_finished = self.parm is None else: print "[dmmBlindscan][frontendStateChanged] NEXT freq", self.parm.frequency mhz_complete, mhz_done = self.stats() check_finished = self.parm.frequency > self.range_list[self.current_range][1] if check_finished: self.parm = self.setNextRange() seconds_done = int(time() - self.start_time) if check_finished: if self.parm is None: tmpstr = _("%dMHz scanned") % mhz_complete tmpstr += ', ' tmpstr += _("%d transponders found at %d:%02d min") %(len(self.tp_found),seconds_done / 60, seconds_done % 60) state["progress"].setText(tmpstr) state.setFinished() self.frontend = None self.raw_channel = None return if self.auto_scan: tmpstr = str((freq+500)/1000) else: tmpstr = str((self.parm.frequency+500)/1000) if self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_Horizontal: tmpstr += "H" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_Vertical: tmpstr += "V" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_CircularLeft: tmpstr += "L" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_CircularRight: tmpstr += "R" tmpstr += ', ' tmpstr += "%d/%dMhz" %(mhz_done, mhz_complete) tmpstr += ", " tmpstr += _("%d transponder(s) found") %len(self.tp_found) tmpstr += ', ' seconds_complete = (seconds_done * mhz_complete) / max(mhz_done, 1) tmpstr += _("%d:%02d/%d:%02dmin") %(seconds_done / 60, seconds_done % 60, seconds_complete / 60, seconds_complete % 60) state["progress"].setText(tmpstr) self.tuneNext() else: print "[dmmBlindscan]unhandled tuner state", x["tuner_state"] self.timer.start(1500, True)
def changed(self, what): self.moveTimerText.stop() if self.instance: if (what[0] == self.CHANGED_CLEAR): self.text = "" else: service = self.source.service info = eServiceCenter.getInstance().info(service) if (info and service): tp = info.getInfoObject(service, iServiceInformation.sTransponderData) tpinfo = ConvertToHumanReadable(tp) refstr = self.source.service.toString() curref = refstr.replace("%3a", ":") streamtype = streamurl = freq = ch = pol = sys = mod = const = fec = sr = orbpos = isid = plsmode = plscode = plpid = t2mi_id = t2mi_pid = "" try: if curref.startswith("1:7:"): curref = "" if "%3a/" in refstr or ":/" in refstr: strurl = refstr.split(":") streamurl = strurl[10].replace("%3a", ":") if refstr.startswith("1:0:2"): streamtype = "Radio" elif not curref.startswith("1:0:") and "%3a/" in refstr: streamtype = "Stream" elif curref.startswith("1:0:") and "%3a/" in refstr: if "0.0.0.0:" in curref or "127.0.0.1:" in curref or "localhost:" in curref: streamtype = "TS Relay" else: streamtype = "TS Stream" elif curref.startswith("1:134:"): streamtype = "Alternative" else: streamurl = streamtype = "" if "channel" in tpinfo: try: ch = "%s/" % str(tpinfo.get("channel")) except: ch = "" if "system" in tp: try: sys = str(tpinfo.get("system")) if "DVB-S" in sys: freq = str(int(tp["frequency"]) // 1000) elif "DVB-C" in sys: freq = "%s Mhz" % str(int(tp["frequency"]) // 1000) elif "DVB-T" in sys or "ATSC" in sys: freq = "%s Mhz" % str(int(tp["frequency"]) // 1000000) else: freq = "" except: sys = "" if "plp_id" in tp and "DVB-T2" in sys: try: plpid = str(tpinfo.get("plp_id", 0)) plpid = "PLP ID:%s" % plpid except: plpid = "" if "t2mi_plp_id" in tp and "DVB-S2" in sys: try: t2mi_id = str(tpinfo.get("t2mi_plp_id", -1)) t2mi_pid = str(tpinfo.get("t2mi_pid")) if t2mi_id == "-1" or t2mi_id == "None" or t2mi_pid == "0" or t2mi_id > "255": t2mi_id = "" t2mi_pid = "" else: t2mi_id = sp("T2MI PLP") + t2mi_id if t2mi_pid == "None": t2mi_pid = "" else: t2mi_pid = sp("PID") + t2mi_pid except: t2mi_id = "" if "modulation" in tp: try: mod = str(tpinfo.get("modulation")) except: mod = "" if "polarization" in tp: try: pol = {eDVBFrontendParametersSatellite.Polarisation_Horizontal: "H", eDVBFrontendParametersSatellite.Polarisation_Vertical: "V", eDVBFrontendParametersSatellite.Polarisation_CircularLeft: "L", eDVBFrontendParametersSatellite.Polarisation_CircularRight: "R"}[tp["polarization"]] except: pol = "" if "constellation" in tp: try: const = str(tpinfo.get("constellation")) except: const = "" if "fec_inner" in tp: try: fec = str(tpinfo.get("fec_inner")) except: fec = "" if "symbol_rate" in tp: sr = str(int(tp["symbol_rate"]) // 1000) if "orbital_position" in tp: orbpos = int(tp["orbital_position"]) if orbpos > 1800: orbpos = (str((float(3600 - orbpos))/10.0) + "°W") else: orbpos = (str((float(orbpos))/10.0) + "°E") if "is_id" in tp or "pls_code" in tp or "pls_mode" in tp: isid = str(tpinfo.get("is_id", 0)) plscode = str(tpinfo.get("pls_code", 0)) plsmode = str(tpinfo.get("pls_mode", None)) if plsmode == "None" or plsmode == "Unknown" or (plsmode != "None" and plscode == "0"): plsmode = "" if isid == "None" or isid == "-1" or isid == "0": isid = "" else: isid = "IS:%s" %isid if plscode == "None" or plscode == "-1" or plscode == "0": plscode = "" if (plscode == "0" and plsmode == "Gold") or (plscode == "1" and plsmode == "Root"): plscode = plsmode = "" except: pass self.text = sp(streamtype) + sp(streamurl) + sp(orbpos) + ch + sp(freq) + sp(pol) + sp(sys) + sp(mod) + sp(plpid) + sp(sr) + sp(fec) + sp(const) + sp(isid) + sp(plsmode) + sp(plscode) + sp(t2mi_id) + t2mi_pid text_width = self.instance.calculateSize().width() if (self.instance and (text_width > self.sizeX)): self.x = len(self.text) self.idx = 0 self.backtext = self.text self.status = "start" self.moveTimerText = eTimer() self.moveTimerText.timeout.get().append(self.moveTimerTextRun) self.moveTimerText.start(2000)
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": return ((_("NIM"), chr(ord('A') + int(frontendData["tuner_number"])), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT), (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return ((_("NIM"), chr(ord('A') + int(frontendData["tuner_number"])), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": channel = getChannelNumber( frontendDataOrg["frequency"], frontendDataOrg["tuner_number"]) if supportedChannels( frontendDataOrg["tuner_number"]) else None return ((_("NIM"), chr(ord('A') + int(frontendData["tuner_number"])), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT), (_("Channel"), getChannelNumber(frontendData["frequency"], frontendData["tuner_number"]), TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("Code rate LP"), frontendData["code_rate_lp"], TYPE_TEXT), (_("Code rate HP"), frontendData["code_rate_hp"], TYPE_TEXT), (_("Constellation"), frontendData["constellation"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "ATSC": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) return []
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": data = ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) if frontendData["system"] == "DVB-S2": data += ((_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT), (_("Input Stream ID"), frontendData["is_id"], TYPE_VALUE_DEC), (_("PLS Mode"), frontendData["pls_mode"], TYPE_TEXT), (_("PLS Code"), frontendData["pls_code"], TYPE_VALUE_DEC)) return data elif frontendDataOrg["tuner_type"] == "DVB-C": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T" and frontendData[ "system"] == "DVB-T2": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["constellation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"] / 1000, TYPE_VALUE_DEC), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("FEC"), frontendData["code_rate_hp"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("PLP ID"), frontendData["plp_id"], TYPE_VALUE_DEC)) elif frontendDataOrg["tuner_type"] == "DVB-T" and frontendData[ "system"] == "DVB-T": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["constellation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"] / 1000, TYPE_VALUE_DEC), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("FEC HP"), frontendData["code_rate_hp"], TYPE_TEXT), (_("FEC LP"), frontendData["code_rate_lp"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) return []
def getText(self): service = self.source.service info = service and service.info() if not info: return "" if self.type == self.XRES: return self.getServiceInfoString(info, iServiceInformation.sVideoWidth) elif self.type == self.YRES: return self.getServiceInfoString(info, iServiceInformation.sVideoHeight) elif self.type == self.APID: return self.getServiceInfoString(info, iServiceInformation.sAudioPID) elif self.type == self.VPID: return self.getServiceInfoString(info, iServiceInformation.sVideoPID) elif self.type == self.PCRPID: return self.getServiceInfoString(info, iServiceInformation.sPCRPID) elif self.type == self.PMTPID: return self.getServiceInfoString(info, iServiceInformation.sPMTPID) elif self.type == self.TXTPID: return self.getServiceInfoString(info, iServiceInformation.sTXTPID) elif self.type == self.TSID: return self.getServiceInfoString(info, iServiceInformation.sTSID) elif self.type == self.ONID: return self.getServiceInfoString(info, iServiceInformation.sONID) elif self.type == self.SID: return self.getServiceInfoString(info, iServiceInformation.sSID) elif self.type == self.FRAMERATE: return self.getServiceInfoString( info, iServiceInformation.sFrameRate, lambda x: "%d fps" % ((x + 500) / 1000)) elif self.type == self.TRANSFERBPS: return self.getServiceInfoString(info, iServiceInformation.sTransferBPS, lambda x: "%d kB/s" % (x / 1024)) elif self.type == self.HAS_HBBTV: return info.getInfoString(iServiceInformation.sHBBTVUrl) elif self.type == self.FREQ_INFO: feinfo = service.frontendInfo() if feinfo is None: return "" feraw = feinfo.getAll(False) if feraw is None: return "" fedata = ConvertToHumanReadable(feraw) if fedata is None: return "" frequency = fedata.get("frequency") if frequency: frequency = str(frequency / 1000) sr_txt = "Sr:" polarization = fedata.get("polarization_abbreviation") if polarization is None: polarization = "" symbolrate = str(int(fedata.get("symbol_rate", 0) / 1000)) if symbolrate == "0": sr_txt = "" symbolrate = "" fec = fedata.get("fec_inner") if fec is None: fec = "" out = "Freq: %s %s %s %s %s" % (frequency, polarization, sr_txt, symbolrate, fec) return out return ""
def getText(self): service = self.source.service info = service and service.info() if not info: return '' feinfo = service.frontendInfo() if feinfo: tp = feinfo.getAll( config.usage.infobar_frontend_source.value == 'settings') if tp: tpinfo = ConvertToHumanReadable(tp) if not tp: tp = info.getInfoObject(iServiceInformation.sTransponderData) tpinfo = ConvertToHumanReadable(tp) if self.type == self.FREQINFO: refstr = str(self.reference()) if '%3a/' in refstr or ':/' in refstr: return self.streamurl() else: if 'DVB-S' in self.tunertype(tp): satf = sp(self.system(tpinfo)) + sp( self.modulation(tpinfo)) + sp(self.frequency(tp)) + sp( self.polarization(tpinfo)) + sp( self.symbolrate(tp)) + sp(self.fecinfo(tpinfo)) if 'is_id' in tpinfo or 'pls_code' in tpinfo or 'pls_mode' in tpinfo or 't2mi_plp_id' in tp: return satf + self.multistream( tpinfo) + self.t2mi_info(tpinfo) else: return satf else: if 'DVB-C' in self.tunertype(tp): return sp(self.frequency(tp)) + sp('Mhz') + sp( self.modulation(tpinfo)) + sp('SR:') + sp( self.symbolrate(tp)) + sp( 'FEC:') + self.fecinfo(tpinfo) if self.tunertype(tp) == 'DVB-T': terf = sp(self.channel(tpinfo)) + '(' + sp( self.terrafreq(tp)) + sp('Mhz)') + sp( self.constellation(tpinfo)) + sp( self.terrafec(tpinfo)) return terf if self.tunertype(tp) == 'DVB-T2': return terf + self.plpid(tpinfo) if 'ATSC' in self.tunertype(tp): return sp(self.terrafreq(tp)) + sp( 'Mhz') + self.modulation(tpinfo) return '' else: if self.type == self.VIDEOCODEC: return self.videocodec(info) if self.type == self.FPS: return self.framerate(info) if self.type == self.VIDEOSIZE: return self.videosize(info) if self.type == self.RESCODEC: vidsize = self.videosize(info) fps = self.framerate(info) vidcodec = self.videocodec(info) return vidsize + ' ' + fps + ' ' + vidcodec if self.type == self.PIDINFO: return self.pidstring(info) if self.type == self.PIDHEXINFO: return self.pidhexstring(info) if self.type == self.STREAMURL: return str(self.streamurl()) if self.type == self.PIDHEXINFO: return str(self.streamtype()) if self.type == self.HDRINFO: return self.hdr(info)
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg['tuner_type'] == 'DVB-S': return ((_('NIM'), chr(ord('A') + frontendData['tuner_number']), TYPE_TEXT), (_('Type'), frontendData['tuner_type'], TYPE_TEXT), (_('System'), frontendData['system'], TYPE_TEXT), (_('Modulation'), frontendData['modulation'], TYPE_TEXT), (_('Orbital position'), frontendData['orbital_position'], TYPE_VALUE_DEC), (_('Frequency'), frontendData['frequency'], TYPE_VALUE_DEC), (_('Symbol rate'), frontendData['symbol_rate'], TYPE_VALUE_DEC), (_('Polarization'), frontendData['polarization'], TYPE_TEXT), (_('Inversion'), frontendData['inversion'], TYPE_TEXT), (_('FEC'), frontendData['fec_inner'], TYPE_TEXT), (_('Pilot'), frontendData.get('pilot', None), TYPE_TEXT), (_('Roll-off'), frontendData.get('rolloff', None), TYPE_TEXT)) if frontendDataOrg['tuner_type'] == 'DVB-C': return ((_('NIM'), chr(ord('A') + frontendData['tuner_number']), TYPE_TEXT), (_('Type'), frontendData['tuner_type'], TYPE_TEXT), (_('Modulation'), frontendData['modulation'], TYPE_TEXT), (_('Frequency'), frontendData['frequency'], TYPE_VALUE_DEC), (_('Symbol rate'), frontendData['symbol_rate'], TYPE_VALUE_DEC), (_('Inversion'), frontendData['inversion'], TYPE_TEXT), (_('FEC'), frontendData['fec_inner'], TYPE_TEXT)) if frontendDataOrg['tuner_type'] == 'DVB-T': channel = channelnumbers.getChannelNumber( frontendDataOrg['frequency'], frontendDataOrg['tuner_number'] ) if channelnumbers.supportedChannels( frontendDataOrg['tuner_number']) else None return ((_('NIM'), chr(ord('A') + frontendData['tuner_number']), TYPE_TEXT), (_('Type'), frontendData['tuner_type'], TYPE_TEXT), (_('Frequency'), frontendData['frequency'], TYPE_VALUE_DEC), (_('Channel'), channel, TYPE_VALUE_DEC), (_('Inversion'), frontendData['inversion'], TYPE_TEXT), (_('Bandwidth'), frontendData['bandwidth'], TYPE_VALUE_DEC), (_('Code rate LP'), frontendData['code_rate_lp'], TYPE_TEXT), (_('Code rate HP'), frontendData['code_rate_hp'], TYPE_TEXT), (_('Constellation'), frontendData['constellation'], TYPE_TEXT), (_('Transmission mode'), frontendData['transmission_mode'], TYPE_TEXT), (_('Guard interval'), frontendData['guard_interval'], TYPE_TEXT), (_('Hierarchy info'), frontendData['hierarchy_information'], TYPE_TEXT)) return []
def getText(self): service = self.source.service if service is None: return "" info = service and service.info() if not info: return "" if self.type == "CryptoInfo": self.getCryptoInfo(info) if config.usage.show_cryptoinfo.value: return addspace(self.createCryptoBar( info)) + self.createCryptoSpecial(info) else: return addspace(self.createCryptoBar(info)) + addspace( self.current_source) + self.createCryptoSpecial(info) if self.type == "CryptoBar": self.getCryptoInfo(info) return self.createCryptoBar(info) if self.type == "CryptoSpecial": self.getCryptoInfo(info) return self.createCryptoSpecial(info) if self.type == "ResolutionString": return self.createResolution(info) if self.type == "VideoCodec": return self.createVideoCodec(info) if self.updateFEdata: feinfo = service.frontendInfo() if feinfo: self.feraw = feinfo.getAll(False) if self.feraw: self.fedata = ConvertToHumanReadable(self.feraw) feraw = self.feraw fedata = self.fedata if not feraw or not fedata: return "" if self.type == "All": self.getCryptoInfo(info) if config.usage.show_cryptoinfo.value: return addspace(self.createProviderName(info)) + self.createTransponderInfo(fedata,feraw) + "\n" \ + addspace(self.createCryptoBar(info)) + addspace(self.createCryptoSpecial(info)) + "\n" \ + addspace(self.createPIDInfo(info)) + addspace(self.createVideoCodec(info)) + self.createResolution(info) else: return addspace(self.createProviderName(info)) + self.createTransponderInfo(fedata,feraw) + "\n" \ + addspace(self.createCryptoBar(info)) + self.current_source + "\n" \ + addspace(self.createCryptoSpecial(info)) + addspace(self.createVideoCodec(info)) + self.createResolution(info) if self.type == "ServiceInfo": return addspace(self.createProviderName(info)) + addspace(self.createTunerSystem(fedata)) + addspace(self.createFrequency(feraw)) + addspace(self.createPolarization(fedata)) \ + addspace(self.createSymbolRate(fedata, feraw)) + addspace(self.createFEC(fedata, feraw)) + addspace(self.createModulation(fedata)) + addspace(self.createOrbPos(feraw)) \ + addspace(self.createVideoCodec(info)) + self.createResolution(info) if self.type == "XTASatInfo": return addspace(self.createOrbPos(feraw)) + addspace(self.createFrequency(feraw)) + addspace(self.createPolarization(fedata)) \ + addspace(self.createSymbolRate(fedata, feraw)) + addspace(self.createFEC(fedata, feraw)) + addspace(self.createModulation(fedata)) if self.type == "XTAResInfo": return addspace(self.createResolutionI(info)) if self.type == "TransponderInfo": return self.createTransponderInfo(fedata, feraw) if self.type == "TransponderFrequency": return self.createFrequency(feraw) if self.type == "TransponderSymbolRate": return self.createSymbolRate(fedata, feraw) if self.type == "TransponderPolarization": return self.createPolarization(fedata) if self.type == "TransponderFEC": return self.createFEC(fedata, feraw) if self.type == "TransponderModulation": return self.createModulation(fedata) if self.type == "OrbitalPosition": return self.createOrbPos(feraw) if self.type == "TunerType": return self.createTunerType(feraw) if self.type == "TunerSystem": return self.createTunerSystem(fedata) if self.type == "OrbitalPositionOrTunerSystem": return self.createOrbPosOrTunerSystem(fedata, feraw) if self.type == "PIDInfo": return self.createPIDInfo(info) return _("invalid type")
def getText(self): service = self.source.service try: info = service and service.info() except: try: info = eServiceCenter.getInstance().info(service) except: pass if not info: return "" Ret_Text = "" Sec_Text = "" Res_Text = "" showCryptoInfo = False if (self.type == self.SMART_INFO_H or self.type == self.SERVICE_INFO or self.type == self.CRYPTO_INFO or self.type == self.FREQUENCY_INFO): # HORIZONTAL sep = " " sep2 = " - " elif (self.type == self.SMART_INFO_V): # VERTIKAL sep = "\n" sep2 = "\n" else: return "" # unsupported orientation if (self.type == self.FREQUENCY_INFO): try: feinfo = (service and service.frontendInfo()) prvd = info.getInfoString(iServiceInformation.sProvider) Ret_Text = self.short(prvd) frontendDataOrg = (feinfo and feinfo.getAll(True)) except: try: frontendDataOrg = info.getInfoObject( service, iServiceInformation.sTransponderData) prvd = info.getInfoString(service, iServiceInformation.sProvider) except: pass if (frontendDataOrg is not None): frontendData = ConvertToHumanReadable(frontendDataOrg) if ((frontendDataOrg.get("tuner_type") == "DVB-S") or (frontendDataOrg.get("tuner_type") == "DVB-C")): frequency = (str( (frontendData.get("frequency") / 1000)) + " MHz") symbolrate = (str( (frontendData.get("symbol_rate") / 1000))) fec_inner = frontendData.get("fec_inner") if (frontendDataOrg.get("tuner_type") == "DVB-S"): Ret_Text += sep + frontendData.get("system") orbital_pos = int(frontendDataOrg["orbital_position"]) if orbital_pos > 1800: if orbital_pos == 3590: orb_pos = 'Thor/Intelsat' elif orbital_pos == 3560: orb_pos = 'Amos (4' elif orbital_pos == 3550: orb_pos = 'Atlantic Bird' elif orbital_pos == 3530: orb_pos = 'Nilesat/Atlantic Bird' elif orbital_pos == 3520: orb_pos = 'Atlantic Bird' elif orbital_pos == 3475: orb_pos = 'Atlantic Bird' elif orbital_pos == 3460: orb_pos = 'Express' elif orbital_pos == 3450: orb_pos = 'Telstar' elif orbital_pos == 3420: orb_pos = 'Intelsat' elif orbital_pos == 3380: orb_pos = 'Nss' elif orbital_pos == 3355: orb_pos = 'Intelsat' elif orbital_pos == 3325: orb_pos = 'Intelsat' elif orbital_pos == 3300: orb_pos = 'Hispasat' elif orbital_pos == 3285: orb_pos = 'Intelsat' elif orbital_pos == 3170: orb_pos = 'Intelsat' elif orbital_pos == 3150: orb_pos = 'Intelsat' elif orbital_pos == 3070: orb_pos = 'Intelsat' elif orbital_pos == 3045: orb_pos = 'Intelsat' elif orbital_pos == 3020: orb_pos = 'Intelsat 9' elif orbital_pos == 2990: orb_pos = 'Amazonas' elif orbital_pos == 2900: orb_pos = 'Star One' elif orbital_pos == 2880: orb_pos = 'AMC 6 (72' elif orbital_pos == 2875: orb_pos = 'Echostar 6' elif orbital_pos == 2860: orb_pos = 'Horizons' elif orbital_pos == 2810: orb_pos = 'AMC5' elif orbital_pos == 2780: orb_pos = 'NIMIQ 4' elif orbital_pos == 2690: orb_pos = 'NIMIQ 1' elif orbital_pos == 3592: orb_pos = 'Thor/Intelsat' elif orbital_pos == 2985: orb_pos = 'Echostar 3,12' elif orbital_pos == 2830: orb_pos = 'Echostar 8' elif orbital_pos == 2630: orb_pos = 'Galaxy 19' elif orbital_pos == 2500: orb_pos = 'Echostar 10,11' elif orbital_pos == 2502: orb_pos = 'DirectTV 5' elif orbital_pos == 2410: orb_pos = 'Echostar 7 Anik F3' elif orbital_pos == 2391: orb_pos = 'Galaxy 23' elif orbital_pos == 2390: orb_pos = 'Echostar 9' elif orbital_pos == 2412: orb_pos = 'DirectTV 7S' elif orbital_pos == 2310: orb_pos = 'Galaxy 27' elif orbital_pos == 2311: orb_pos = 'Ciel 2' elif orbital_pos == 2120: orb_pos = 'Echostar 2' else: orb_pos = str( (float(3600 - orbital_pos)) / 10.0) + "W" elif orbital_pos > 0: if orbital_pos == 192: orb_pos = 'Astra 1F' elif orbital_pos == 130: orb_pos = 'Hot Bird 6,7A,8' elif orbital_pos == 235: orb_pos = 'Astra 1E' elif orbital_pos == 1100: orb_pos = 'BSat 1A,2A' elif orbital_pos == 1101: orb_pos = 'N-Sat 110' elif orbital_pos == 1131: orb_pos = 'KoreaSat 5' elif orbital_pos == 1440: orb_pos = 'SuperBird 7,C2' elif orbital_pos == 1006: orb_pos = 'AsiaSat 2' elif orbital_pos == 1030: orb_pos = 'Express A2' elif orbital_pos == 1056: orb_pos = 'Asiasat 3S' elif orbital_pos == 1082: orb_pos = 'NSS 11' elif orbital_pos == 881: orb_pos = 'ST1' elif orbital_pos == 900: orb_pos = 'Yamal 201' elif orbital_pos == 917: orb_pos = 'Mesat' elif orbital_pos == 950: orb_pos = 'Insat 4B' elif orbital_pos == 951: orb_pos = 'NSS 6' elif orbital_pos == 765: orb_pos = 'Telestar' elif orbital_pos == 785: orb_pos = 'ThaiCom 5' elif orbital_pos == 800: orb_pos = 'Express' elif orbital_pos == 830: orb_pos = 'Insat 4A' elif orbital_pos == 850: orb_pos = 'Intelsat 709' elif orbital_pos == 750: orb_pos = 'Abs' elif orbital_pos == 720: orb_pos = 'Intelsat' elif orbital_pos == 705: orb_pos = 'Eutelsat W5' elif orbital_pos == 685: orb_pos = 'Intelsat' elif orbital_pos == 620: orb_pos = 'Intelsat 902' elif orbital_pos == 600: orb_pos = 'Intelsat 904' elif orbital_pos == 570: orb_pos = 'Nss' elif orbital_pos == 530: orb_pos = 'Express AM22' elif orbital_pos == 480: orb_pos = 'Eutelsat 2F2' elif orbital_pos == 450: orb_pos = 'Intelsat' elif orbital_pos == 420: orb_pos = 'Turksat 2A' elif orbital_pos == 400: orb_pos = 'Express AM1' elif orbital_pos == 390: orb_pos = 'Hellas Sat 2' elif orbital_pos == 380: orb_pos = 'Paksat 1' elif orbital_pos == 360: orb_pos = 'Eutelsat Sesat' elif orbital_pos == 335: orb_pos = 'Astra 1M' elif orbital_pos == 330: orb_pos = 'Eurobird 3' elif orbital_pos == 328: orb_pos = 'Galaxy 11' elif orbital_pos == 315: orb_pos = 'Astra 5A' elif orbital_pos == 310: orb_pos = 'Turksat' elif orbital_pos == 305: orb_pos = 'Arabsat' elif orbital_pos == 285: orb_pos = 'Eurobird 1' elif orbital_pos == 284: orb_pos = 'Eurobird/Astra' elif orbital_pos == 282: orb_pos = 'Eurobird/Astra' elif orbital_pos == 1220: orb_pos = 'AsiaSat' elif orbital_pos == 1380: orb_pos = 'Telstar 18' elif orbital_pos == 260: orb_pos = 'Badr 3/4' elif orbital_pos == 255: orb_pos = 'Eurobird 2' elif orbital_pos == 215: orb_pos = 'Eutelsat' elif orbital_pos == 216: orb_pos = 'Eutelsat W6' elif orbital_pos == 210: orb_pos = 'AfriStar 1' elif orbital_pos == 160: orb_pos = 'Eutelsat W2' elif orbital_pos == 100: orb_pos = 'Eutelsat W1' elif orbital_pos == 90: orb_pos = 'Eurobird 9' elif orbital_pos == 70: orb_pos = 'Eutelsat W3A' elif orbital_pos == 50: orb_pos = 'Sirius 4' elif orbital_pos == 48: orb_pos = 'Sirius 4' elif orbital_pos == 30: orb_pos = 'Telecom 2' else: orb_pos = str( (float(orbital_pos)) / 10.0) + "E" Ret_Text += sep + orb_pos + "\n" Ret_Text += frequency + sep + frontendData.get( "polarization_abbreviation") Ret_Text += sep + symbolrate Ret_Text += sep + frontendData.get( "modulation") + "-" + fec_inner else: Ret_Text += sep + "DVB-C " + frequency + " MHz" + sep + fec_inner + sep + symbolrate elif (frontendData.get("tuner_type") == "DVB-T"): frequency = (str( (frontendData.get("frequency") / 1000)) + " MHz") Ret_Text = "Frequency: " + frequency if (self.type == self.SMART_INFO_H or self.type == self.SMART_INFO_V or self.type == self.SERVICE_INFO): xresol = info.getInfo(iServiceInformation.sVideoWidth) yresol = info.getInfo(iServiceInformation.sVideoHeight) feinfo = (service and service.frontendInfo()) prvd = info.getInfoString(iServiceInformation.sProvider) Ret_Text = self.short(prvd) frontendDataOrg = (feinfo and feinfo.getAll(True)) if (frontendDataOrg is not None): frontendData = ConvertToHumanReadable(frontendDataOrg) if ((frontendDataOrg.get("tuner_type") == "DVB-S") or (frontendDataOrg.get("tuner_type") == "DVB-C")): frequency = (str((frontendData.get("frequency") / 1000))) symbolrate = (str( (frontendData.get("symbol_rate") / 1000))) fec_inner = frontendData.get("fec_inner") if (frontendDataOrg.get("tuner_type") == "DVB-S"): Ret_Text += sep + frontendData.get("system") Ret_Text += sep + frequency + frontendData.get( "polarization_abbreviation") Ret_Text += sep + symbolrate Ret_Text += sep + fec_inner + " " + frontendData.get( "modulation") orbital_pos = int(frontendDataOrg["orbital_position"]) if orbital_pos > 1800: orb_pos = str( (float(3600 - orbital_pos)) / 10.0) + "W" elif orbital_pos > 0: orb_pos = str((float(orbital_pos)) / 10.0) + "E" Ret_Text += sep + orb_pos else: Ret_Text += sep + "DVB-C " + frequency + " MHz" + sep + fec_inner + sep + symbolrate elif (frontendDataOrg.get("tuner_type") == "DVB-T"): frequency = (str((frontendData.get("frequency") / 1000))) Ret_Text += sep + "DVB-T" + sep + "Frequency:" + sep + frequency + " MHz" if (feinfo is not None) and (xresol > 0): Res_Text += ("MPEG2 ", "MPEG4 ", "MPEG1 ", "MPEG4-II ", "VC1 ", "VC1-SM ", "")[info.getInfo(iServiceInformation.sVideoType)] Res_Text += str(xresol) + "x" + str(yresol) Res_Text += ("i", "p", "")[info.getInfo( iServiceInformation.sProgressive)] Res_Text += str( (info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) if (self.type == self.SMART_INFO_H or self.type == self.SMART_INFO_V or self.type == self.CRYPTO_INFO): decCI = "0" Sec_Text = "" if (info.getInfo(iServiceInformation.sIsCrypted) == 1): data = self.ecmdata.getEcmData() if not config.usage.show_cryptoinfo.value: showCryptoInfo = True Sec_Text = data[0] + "\n" decCI = data[1] provid = data[2] pid = data[3] if decCI != '0': decCIfull = "%04x" % int(decCI, 16) for idline in self.idnames: if int(decCI, 16) >= int(idline[0], 16) and int( decCI, 16) <= int(idline[1], 16): decCIfull = idline[2] + ":" + decCIfull break Sec_Text += decCIfull if provid != '0': Sec_Text += ":%04x" % int(provid, 16) else: Sec_Text += ":" if pid != '0': Sec_Text += ":%04x:%04x" % (info.getInfo( iServiceInformation.sSID), int(pid, 16)) elif not config.usage.show_cryptoinfo.value: showCryptoInfo = True Sec_Text = "FTA" res = "" searchIDs = (info.getInfoObject(iServiceInformation.sCAIDs)) for idline in self.idnames: if int(decCI, 16) >= int(idline[0], 16) and int( decCI, 16) <= int(idline[1], 16): color = "\c0000??00" else: color = "\c007?7?7?" try: for oneID in searchIDs: if oneID >= int(idline[0], 16) and oneID <= int( idline[1], 16): color = "\c00????00" except: pass res += color + idline[3] + " " if (self.type != self.CRYPTO_INFO): Ret_Text += "\n" Ret_Text += res + "\c00?????? " + Sec_Text if Res_Text != "": if showCryptoInfo: Ret_Text += sep + Res_Text else: Ret_Text += "\n" + Res_Text return Ret_Text
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference()).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference().toString() else: name = _("N/A") refstr = _("N/A") aspect = "-" videocodec = "-" videomode = "-" resolution = "-" if self.info: from Components.Converter.PliExtraInfo import codec_data videocodec = codec_data.get(self.info.getInfo(iServiceInformation.sVideoType), "N/A") width = self.info.getInfo(iServiceInformation.sVideoWidth) height = self.info.getInfo(iServiceInformation.sVideoHeight) if width > 0 and height > 0: resolution = "%dx%d" % (width,height) resolution += ("i", "p", "-")[self.info.getInfo(iServiceInformation.sProgressive)] resolution += str((self.info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) aspect = self.getServiceInfoValue(iServiceInformation.sAspect) aspect = aspect in ( 1, 2, 5, 6, 9, 0xA, 0xD, 0xE ) and "4:3" or "16:9" resolution += " - ["+aspect+"]" gammas = ("SDR", "HDR", "HDR10", "HLG", "") if self.info.getInfo(iServiceInformation.sGamma) < len(gammas): gamma = gammas[self.info.getInfo(iServiceInformation.sGamma)] if gamma: resolution += " - " + gamma f = open("/proc/stb/video/videomode") videomode = f.read()[:-1].replace('\n','') f.close() Labels = ( (_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Videoformat"), aspect, TYPE_TEXT), (_("Videomode"), videomode, TYPE_TEXT), (_("Videosize"), resolution, TYPE_TEXT), (_("Videocodec"), videocodec, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type" : _("Transponder type"), "system" : _("System"), "modulation" : _("Modulation"), "orbital_position" : _("Orbital position"), "frequency" : _("Frequency"), "symbol_rate" : _("Symbol rate"), "bandwidth" : _("Bandwidth"), "polarization" : _("Polarization"), "inversion" : _("Inversion"), "pilot" : _("Pilot"), "rolloff" : _("Roll-off"), "is_id" : _("Input Stream ID"), "pls_mode" : _("PLS Mode"), "pls_code" : _("PLS Code"), "t2mi_plp_id" : _("T2MI PLP ID"), "t2mi_pip" : _("T2MI PID"), "fec_inner" : _("FEC"), "code_rate_lp" : _("Coderate LP"), "code_rate_hp" : _("Coderate HP"), "constellation" : _("Constellation"), "transmission_mode" : _("Transmission mode"), "guard_interval" : _("Guard interval"), "hierarchy_information" : _("Hierarchy information")} Labels = [(conv[i], tp_info[i], i == "orbital_position" and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv] self.fillList(Labels)
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceReference(): name = ServiceReference( self.session.nav.getCurrentlyPlayingServiceReference( )).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference( ).toString() else: name = _("N/A") refstr = _("N/A") aspect = self.getServiceInfoValue(iServiceInformation.sAspect) if aspect in (1, 2, 5, 6, 9, 0xA, 0xD, 0xE): aspect = _("4:3") else: aspect = _("16:9") width = self.info and self.info.getInfo( iServiceInformation.sVideoWidth) or -1 height = self.info and self.info.getInfo( iServiceInformation.sVideoHeight) or -1 if width != -1 and height != -1: Labels = ((_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue( iServiceInformation.sProvider), TYPE_TEXT), (_("Aspect ratio"), aspect, TYPE_TEXT), (_("Resolution"), "%dx%d" % (width, height), TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue( iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) else: Labels = ((_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue( iServiceInformation.sProvider), TYPE_TEXT), (_("Aspect ratio"), aspect, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue( iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type": _("Type"), "system": _("System"), "modulation": _("Modulation"), "orbital_position": _("Orbital position"), "frequency": _("Frequency"), "symbol_rate": _("Symbol rate"), "bandwidth": _("Bandwidth"), "polarization": _("Polarization"), "inversion": _("Inversion"), "pilot": _("Pilot"), "rolloff": _("Roll-off"), "fec_inner": _("FEC"), "code_rate_lp": _("Code rate LP"), "code_rate_hp": _("Code rate HP"), "constellation": _("Constellation"), "transmission_mode": _("Transmission mode"), "guard_interval": _("Guard interval"), "hierarchy_information": _("Hierarchy info") } Labels = [(conv[i], tp_info[i], TYPE_VALUE_DEC) for i in tp_info.keys()] self.fillList(Labels)
def getText(self): service = self.source.service info = service and service.info() if not info: return "" Ret_Text = "" Sec_Text = "" Res_Text = "" showCryptoInfo = False if (self.type == self.SMART_INFO_H or self.type == self.SERVICE_INFO or self.type == self.CRYPTO_INFO): # HORIZONTAL sep = " " sep2 = " - " elif (self.type == self.SMART_INFO_V): # VERTIKAL sep = "\n" sep2 = "\n" else: return "" # unsupported orientation if (self.type == self.SMART_INFO_H or self.type == self.SMART_INFO_V or self.type == self.SERVICE_INFO): xresol = info.getInfo(iServiceInformation.sVideoWidth) yresol = info.getInfo(iServiceInformation.sVideoHeight) feinfo = (service and service.frontendInfo()) prvd = info.getInfoString(iServiceInformation.sProvider) Ret_Text = self.short(prvd) frontendDataOrg = (feinfo and feinfo.getAll(False)) if (frontendDataOrg is not None): frontendData = ConvertToHumanReadable(frontendDataOrg) if ((frontendDataOrg.get("tuner_type") == "DVB-S") or (frontendDataOrg.get("tuner_type") == "DVB-C")): frequency = (str((frontendData.get("frequency") / 1000))) symbolrate = (str((frontendData.get("symbol_rate") / 1000))) fec_inner = frontendData.get("fec_inner") if (frontendDataOrg.get("tuner_type") == "DVB-S"): Ret_Text += sep + frontendData.get("system") Ret_Text += sep + frequency + frontendData.get("polarization_abbreviation") Ret_Text += sep + symbolrate Ret_Text += sep + fec_inner + " " + frontendData.get("modulation") orbital_pos = int(frontendDataOrg["orbital_position"]) if orbital_pos > 1800: orb_pos = str((float(3600 - orbital_pos)) / 10.0) + "W" elif orbital_pos > 0: orb_pos = str((float(orbital_pos)) / 10.0) + "E" Ret_Text += sep + orb_pos else: Ret_Text += sep + "DVB-C " + frequency + " MHz" + sep + fec_inner + sep + symbolrate elif (frontendDataOrg.get("tuner_type") == "DVB-T"): frequency = (str((frontendData.get("frequency") / 1000))) Ret_Text += sep + "DVB-T" + sep + "Frequency:" + sep + frequency + " MHz" if (feinfo is not None) and (xresol > 0): Res_Text += ("MPEG2 ", "MPEG4 ", "MPEG1 ", "MPEG4-II ", "VC1 ", "VC1-SM ", "")[info.getInfo(iServiceInformation.sVideoType)] Res_Text += str(xresol) + "x" + str(yresol) Res_Text += ("i", "p", "")[info.getInfo(iServiceInformation.sProgressive)] Res_Text += str((info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) if (self.type == self.SMART_INFO_H or self.type == self.SMART_INFO_V or self.type == self.CRYPTO_INFO): decCI = "0" Sec_Text = "" if (info.getInfo(iServiceInformation.sIsCrypted) == 1): data = self.ecmdata.getEcmData() if not config.usage.show_cryptoinfo.value: showCryptoInfo = True Sec_Text = data[0] + "\n" decCI = data[1] provid = data[2] pid = data[3] if decCI != '0': decCIfull = "%04x" % int(decCI, 16) for idline in self.idnames: if int(decCI, 16) >= int(idline[0], 16) and int(decCI, 16) <= int(idline[1], 16): decCIfull = idline[2] + ":" + decCIfull break Sec_Text += decCIfull if provid != '0': Sec_Text += ":%04x" % int(provid, 16) else: Sec_Text += ":" if pid != '0': Sec_Text += ":%04x:%04x" % (info.getInfo(iServiceInformation.sSID),int(pid, 16)) elif not config.usage.show_cryptoinfo.value: showCryptoInfo = True Sec_Text = "FTA" res = "" searchIDs = (info.getInfoObject(iServiceInformation.sCAIDs)) for idline in self.idnames: if int(decCI, 16) >= int(idline[0], 16) and int(decCI, 16) <= int(idline[1], 16): color="\c0000??00" else: color = "\c007?7?7?" try: for oneID in searchIDs: if oneID >= int(idline[0], 16) and oneID <= int(idline[1], 16): color="\c00????00" except: pass res += color + idline[3] + " " if (self.type != self.CRYPTO_INFO): Ret_Text += "\n" Ret_Text += res + "\c00?????? " + Sec_Text if Res_Text != "": if showCryptoInfo: Ret_Text += sep + Res_Text else: Ret_Text += "\n" + Res_Text return Ret_Text
def getText(self): service = self.source.service info = service and service.info() if not info: return "" if self.type == self.XRES: return self._getVideoWidthStr(info) elif self.type == self.YRES: return self._getVideoHeightStr(info) elif self.type == self.APID: return self.getServiceInfoString(info, iServiceInformation.sAudioPID) elif self.type == self.VPID: return self.getServiceInfoString(info, iServiceInformation.sVideoPID) elif self.type == self.PCRPID: return self.getServiceInfoString(info, iServiceInformation.sPCRPID) elif self.type == self.PMTPID: return self.getServiceInfoString(info, iServiceInformation.sPMTPID) elif self.type == self.TXTPID: return self.getServiceInfoString(info, iServiceInformation.sTXTPID) elif self.type == self.TSID: return self.getServiceInfoString(info, iServiceInformation.sTSID) elif self.type == self.ONID: return self.getServiceInfoString(info, iServiceInformation.sONID) elif self.type == self.SID: return self.getServiceInfoString(info, iServiceInformation.sSID) elif self.type == self.FRAMERATE: return self._getFrameRateStr(info, convert=lambda x: "%d fps" % ((x + 500) / 1000)) elif self.type == self.PROGRESSIVE: return self._getProgressiveStr(info) elif self.type == self.TRANSFERBPS: return self.getServiceInfoString(info, iServiceInformation.sTransferBPS, lambda x: "%d kB/s" % (x / 1024)) elif self.type == self.HAS_HBBTV: return info.getInfoString(iServiceInformation.sHBBTVUrl) elif self.type == self.FREQ_INFO: feinfo = service.frontendInfo() if feinfo is None: return "" feraw = feinfo.getAll(False) if feraw is None: return "" fedata = ConvertToHumanReadable(feraw) if fedata is None: return "" frequency = fedata.get("frequency") sr_txt = "Sr:" polarization = fedata.get("polarization_abbreviation") if polarization is None: polarization = "" symbolrate = str(int(fedata.get("symbol_rate", 0))) if symbolrate == "0": sr_txt = "" symbolrate = "" fec = fedata.get("fec_inner") if fec is None: fec = "" out = "Freq: %s %s %s %s %s" % (frequency, polarization, sr_txt, symbolrate, fec) return out elif self.type == self.VIDEO_INFO: progressive = self._getProgressiveStr(info) fieldrate = self._getFrameRate(info) if fieldrate > 0: if progressive == 'i': fieldrate *= 2 fieldrate = "%dHz" % ((fieldrate + 500) / 1000,) else: fieldrate = "" return "%sx%s%s %s" % (self._getVideoWidthStr(info), self._getVideoHeightStr(info), progressive, fieldrate) return ""
def frontendStateChanged(self): if self.frontend is None: self.timer.start(5000, True) return x = {} self.frontend.getFrontendStatus(x) assert x, "getFrontendStatus failed!" if x["tuner_state"] in ("LOCKED", "FAILED", "LOSTLOCK"): state = self.satellite_search_session d = {} self.frontend.getTransponderData(d, False) d["tuner_type"] = 'DVB-S' r = ConvertToHumanReadable(d) if x["tuner_state"] == "LOCKED": freq = d["frequency"] parm = eDVBFrontendParametersSatellite() parm.frequency = int(round(float(freq * 2) / 1000)) * 1000 parm.frequency /= 2 fstr = str(parm.frequency) if self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_Horizontal: fstr += "H KHz SR" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_Vertical: fstr += "V KHz SR" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_CircularLeft: fstr += "L KHz SR" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_CircularRight: fstr += "R KHz SR" sr = d["symbol_rate"] if sr < 0: print "WARNING blind SR is < 0... skip" if not self.auto_scan: self.parm.frequency += self.parm.symbol_rate else: sr_rounded = round(float(sr * 2L) / 1000) * 1000 sr_rounded /= 2 parm.symbol_rate = int(sr_rounded) fstr += str(parm.symbol_rate / 1000) parm.fec = d["fec_inner"] fstr += " " fstr += r["fec_inner"] parm.inversion = eDVBFrontendParametersSatellite.Inversion_Unknown parm.polarisation = d["polarization"] parm.orbital_position = d["orbital_position"] parm.system = d["system"] fstr += " " fstr += r["system"] parm.modulation = d["modulation"] fstr += " " fstr += r["modulation"] if parm.system == eDVBFrontendParametersSatellite.System_DVB_S2: parm.rolloff = d["rolloff"] parm.pilot = d["pilot"] parm.is_id = d["is_id"] parm.pls_mode = d["pls_mode"] self.__tlist.append(parm) if self.auto_scan: print "LOCKED at", freq else: print "LOCKED at", freq, "SEARCHED at", self.parm.frequency, "half bw", ( 135L * ((sr + 1000) / 1000) / 200), "half search range", (self.parm.symbol_rate / 2) self.parm.frequency = freq self.parm.frequency += (135L * ((sr + 999) / 1000) / 200) self.parm.frequency += self.parm.symbol_rate / 2 bm = state.getConstellationBitmap(5) self.tp_found.append((fstr, bm)) state.updateConstellation(bm) if len(self.tp_found): state["list"].updateList(self.tp_found) else: state["list"].setList(self.tp_found) state["list"].setIndex(0) else: if self.auto_scan: #when driver based auto scan is used we got a tuneFailed event when the scan has scanned the last frequency... self.parm = self.setNextRange() else: self.parm.frequency += self.parm.symbol_rate if self.auto_scan: freq = d["frequency"] freq = int(round(float(freq * 2) / 1000)) * 1000 freq /= 2 mhz_complete, mhz_done = self.stats(freq) print "CURRENT freq", freq, "%d/%d" % (mhz_done, mhz_complete) check_finished = self.parm is None else: print "NEXT freq", self.parm.frequency mhz_complete, mhz_done = self.stats() check_finished = self.parm.frequency > self.range_list[ self.current_range][1] if check_finished: self.parm = self.setNextRange() seconds_done = int(time() - self.start_time) if check_finished: if self.parm is None: tmpstr = _("%dMHz scanned") % mhz_complete tmpstr += ', ' tmpstr += _("%d transponders found at %d:%02d min") % (len( self.tp_found), seconds_done / 60, seconds_done % 60) state["progress"].setText(tmpstr) state.setFinished() self.frontend = None self.channel = None return if self.auto_scan: tmpstr = str((freq + 500) / 1000) else: tmpstr = str((self.parm.frequency + 500) / 1000) if self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_Horizontal: tmpstr += "H" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_Vertical: tmpstr += "V" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_CircularLeft: tmpstr += "L" elif self.parm.polarisation == eDVBFrontendParametersSatellite.Polarisation_CircularRight: tmpstr += "R" tmpstr += ', ' tmpstr += "%d/%dMhz" % (mhz_done, mhz_complete) tmpstr += ", " tmpstr += _("%d transponder(s) found") % len(self.tp_found) tmpstr += ', ' seconds_complete = (seconds_done * mhz_complete) / max(mhz_done, 1) tmpstr += _("%d:%02d/%d:%02dmin") % ( seconds_done / 60, seconds_done % 60, seconds_complete / 60, seconds_complete % 60) state["progress"].setText(tmpstr) self.tuneNext() else: print "unhandled tuner state", x["tuner_state"] self.timer.start(1500, True)
def information(self): if self.type is TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference( self.session.nav.getCurrentlyPlayingServiceReference( )).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference( ).toString() else: name = _("N/A") refstr = _("N/A") aspect = "-" videocodec = "-" resolution = "-" if self.info: videocodec = ( "MPEG2", "MPEG4", "MPEG1", "MPEG4-II", "VC1", "VC1-SM", "-")[self.info and self.info.getInfo(iServiceInformation.sVideoType)] width = self.info.getInfo(iServiceInformation.sVideoWidth) height = self.info.getInfo(iServiceInformation.sVideoHeight) if width > 0 and height > 0: resolution = "%dx%d " % (width, height) resolution += str( (self.info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) aspect = self.getServiceInfoValue( iServiceInformation.sAspect) if aspect in (1, 2, 5, 6, 9, 0xA, 0xD, 0xE): aspect = "4:3" else: aspect = "16:9" Labels = ((_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Videoformat"), aspect, TYPE_TEXT), (_("Videosize"), resolution, TYPE_TEXT), (_("Videocodec"), videocodec, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue( iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type": _("Transponder type"), "system": _("System"), "modulation": _("Modulation"), "orbital_position": _("Orbital position"), "frequency": _("Frequency"), "symbol_rate": _("Symbol rate"), "bandwidth": _("Bandwidth"), "polarization": _("Polarization"), "inversion": _("Inversion"), "pilot": _("Pilot"), "rolloff": _("Roll-off"), "is_id": _("Input Stream ID"), "pls_mode": _("PLS Mode"), "pls_code": _("PLS Code"), "fec_inner": _("FEC"), "code_rate_lp": _("Coderate LP"), "code_rate_hp": _("Coderate HP"), "constellation": _("Constellation"), "transmission_mode": _("Transmission mode"), "guard_interval": _("Guard interval"), "hierarchy_information": _("Hierarchy information"), "plp_id": _("PLP ID") } Labels = [(conv[i], tp_info[i], i == "orbital_position" and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv] self.fillList(Labels)
def getText(self): service = self.source.service info = service and service.info() if not info: return "" Ret_Text = "" Sec_Text = "" xresol = info.getInfo(iServiceInformation.sVideoWidth) yresol = info.getInfo(iServiceInformation.sVideoHeight) feinfo = (service and service.frontendInfo()) if (self.type == self.SMART_INFO_H): # HORIZONTAL sep = " " sep2 = " - " elif (self.type == self.SMART_INFO_V): # VERTIKAL sep = "\n" sep2 = "\n" else: return "" # unsupported orientation prvd = info.getInfoString(iServiceInformation.sProvider) Ret_Text = self.short(prvd) frontendDataOrg = (feinfo and feinfo.getAll(True)) if (frontendDataOrg is not None): frontendData = ConvertToHumanReadable(frontendDataOrg) if ((frontendDataOrg.get("tuner_type") == "DVB-S") or (frontendDataOrg.get("tuner_type") == "DVB-C")): frequency = (str((frontendData.get("frequency") / 1000))) symbolrate = (str((frontendData.get("symbol_rate") / 1000))) fec_inner = frontendData.get("fec_inner") if (frontendDataOrg.get("tuner_type") == "DVB-S"): Ret_Text += sep + frontendData.get("system") Ret_Text += sep + frequency + frontendData.get("polarization")[:1] Ret_Text += sep + symbolrate Ret_Text += sep + frontendData.get("modulation") + "-" + fec_inner orbital_pos = int(frontendData["orbital_position"]) if orbital_pos > 1800: orb_pos = str((float(3600 - orbital_pos)) / 10.0) + "W" elif orbital_pos > 0: orb_pos = str((float(orbital_pos)) / 10.0) + "E" Ret_Text += sep + orb_pos else: Ret_Text += sep + "DVB-C " + frequency + " MHz" + sep + fec_inner + sep + symbolrate elif (frontendDataOrg.get("tuner_type") == "DVB-T"): frequency = (str((frontendData.get("frequency") / 1000))) Ret_Text += sep + "DVB-T" + sep + "Frequency:" + sep + frequency + " MHz" if (feinfo is not None) and (xresol > 0): if (yresol > 580): Ret_Text += sep + "HD " else: Ret_Text += sep + "SD " Ret_Text += str(xresol) + "x" + str(yresol) if (info.getInfo(iServiceInformation.sIsCrypted) == 1): try: ecm = open(ECM_INFO, 'rb').readlines() ecminfo = {} for line in ecm: d = line.split(':', 1) if len(d) > 1: ecminfo[d[0].strip()] = d[1].strip() using = ecminfo.get('using', '') if using: # CCcam if using == 'fta': Sec_Text = _("FTA") elif using == 'emu': Sec_Text = "EMU (%ss)" % (ecminfo.get('ecm time', '?')) else: hops = ecminfo.get('hops', None) if hops and hops != '0': hops = ' @' + hops else: hops = '' Sec_Text = ecminfo.get('address', '?') + hops + " (%ss)" % ecminfo.get('ecm time', '?') else: decode = ecminfo.get('decode', None) if decode: # gbox (untested) if ecminfo['decode'] == 'Network': cardid = 'id:' + ecminfo.get('prov', '') try: share = open('/tmp/share.info', 'rb').readlines() for line in share: if cardid in line: Sec_Text = line.strip() break else: Sec_Text = cardid except: Sec_Text = decode else: Sec_Text = decode else: source = ecminfo.get('source', '') if source: # MGcam eEnc = "" eCaid = "" eSrc = "" eTime = "" for line in ecm: line = line.strip() if line.find('ECM') != -1: line = line.split(' ') eEnc = line[1] eCaid = line[5][2:-1] continue if line.find('source') != -1: line = line.split(' ') eSrc = line[4][:-1] continue if line.find('msec') != -1: line = line.split(' ') eTime = line[0] continue Sec_Text = "(%s %s %.3f @ %s)" % (eEnc,eCaid,(float(eTime)/1000),eSrc) else: reader = ecminfo.get('reader', '') if reader: #Oscam hops = ecminfo.get('hops', None) if hops and hops != '0': hops = ' @' + hops else: hops = '' Sec_Text = reader + hops + " (%ss)" % ecminfo.get('ecm time', '?') else: Sec_Text = "" pid = ecminfo.get('pid', None) decCI = ecminfo.get('caid', None) decCIfull="" if decCI != "": for idline in self.idnames: try: if decCI.upper() >= idline[0].upper() and decCI.upper() <= idline[1].upper(): decCIfull = idline[2] + ":" + decCI break except: pass Sec_Text += sep + decCIfull + sep + "pid:" + pid res = "" try: searchIDs = (info.getInfoObject(iServiceInformation.sCAIDs)) for idline in self.idnames: color = "\c007?7?7?" for oneID in searchIDs: if (oneID >= int(idline[0], 16)) and (oneID <= int(idline[1], 16)): color="\c00????00" if oneID == int(decCI,16): color="\c0000??00" break res += color + idline[3] + " " except: pass Ret_Text += "\n" + res + "\c00?????? " + Sec_Text except: Ret_Text += "\n\c007?7?7?S V I Nd Co Cw B N" + "\c00?????? No expert cryptinfo available" pass else: Ret_Text += "\n\c007?7?7?S V I Nd Co Cw B N" + "\c00?????? FTA" return Ret_Text
def getText(self): service = self.source.service try: info = service and service.info() except: try: info = eServiceCenter.getInstance().info(service) except: pass if not info: return "" Ret_Text = "" Sec_Text = "" Res_Text = "" showCryptoInfo = False if (self.type == self.SMART_INFO_H or self.type == self.SERVICE_INFO or self.type == self.CRYPTO_INFO or self.type == self.FREQUENCY_INFO): # HORIZONTAL sep = " " sep2 = " - " elif (self.type == self.SMART_INFO_V): # VERTIKAL sep = "\n" sep2 = "\n" else: return "" # unsupported orientation if (self.type == self.FREQUENCY_INFO): try: feinfo = (service and service.frontendInfo()) prvd = info.getInfoString(iServiceInformation.sProvider) Ret_Text = self.short(prvd) frontendDataOrg = (feinfo and feinfo.getAll(True)) except: try: frontendDataOrg = info.getInfoObject(service, iServiceInformation.sTransponderData) prvd = info.getInfoString(service, iServiceInformation.sProvider) except: pass if (frontendDataOrg is not None): frontendData = ConvertToHumanReadable(frontendDataOrg) if ((frontendDataOrg.get("tuner_type") == "DVB-S") or (frontendDataOrg.get("tuner_type") == "DVB-C")): frequency = (str((frontendData.get("frequency") / 1000)) + " MHz") symbolrate = (str((frontendData.get("symbol_rate") / 1000))) fec_inner = frontendData.get("fec_inner") if (frontendDataOrg.get("tuner_type") == "DVB-S"): Ret_Text += sep + frontendData.get("system") orbital_pos = int(frontendDataOrg["orbital_position"]) if orbital_pos > 1800: if orbital_pos == 3590: orb_pos = 'Thor/Intelsat' elif orbital_pos == 3560: orb_pos = 'Amos (4' elif orbital_pos == 3550: orb_pos = 'Atlantic Bird' elif orbital_pos == 3530: orb_pos = 'Nilesat/Atlantic Bird' elif orbital_pos == 3520: orb_pos = 'Atlantic Bird' elif orbital_pos == 3475: orb_pos = 'Atlantic Bird' elif orbital_pos == 3460: orb_pos = 'Express' elif orbital_pos == 3450: orb_pos = 'Telstar' elif orbital_pos == 3420: orb_pos = 'Intelsat' elif orbital_pos == 3380: orb_pos = 'Nss' elif orbital_pos == 3355: orb_pos = 'Intelsat' elif orbital_pos == 3325: orb_pos = 'Intelsat' elif orbital_pos == 3300: orb_pos = 'Hispasat' elif orbital_pos == 3285: orb_pos = 'Intelsat' elif orbital_pos == 3170: orb_pos = 'Intelsat' elif orbital_pos == 3150: orb_pos = 'Intelsat' elif orbital_pos == 3070: orb_pos = 'Intelsat' elif orbital_pos == 3045: orb_pos = 'Intelsat' elif orbital_pos == 3020: orb_pos = 'Intelsat 9' elif orbital_pos == 2990: orb_pos = 'Amazonas' elif orbital_pos == 2900: orb_pos = 'Star One' elif orbital_pos == 2880: orb_pos = 'AMC 6 (72' elif orbital_pos == 2875: orb_pos = 'Echostar 6' elif orbital_pos == 2860: orb_pos = 'Horizons' elif orbital_pos == 2810: orb_pos = 'AMC5' elif orbital_pos == 2780: orb_pos = 'NIMIQ 4' elif orbital_pos == 2690: orb_pos = 'NIMIQ 1' elif orbital_pos == 3592: orb_pos = 'Thor/Intelsat' elif orbital_pos == 2985: orb_pos = 'Echostar 3,12' elif orbital_pos == 2830: orb_pos = 'Echostar 8' elif orbital_pos == 2630: orb_pos = 'Galaxy 19' elif orbital_pos == 2500: orb_pos = 'Echostar 10,11' elif orbital_pos == 2502: orb_pos = 'DirectTV 5' elif orbital_pos == 2410: orb_pos = 'Echostar 7 Anik F3' elif orbital_pos == 2391: orb_pos = 'Galaxy 23' elif orbital_pos == 2390: orb_pos = 'Echostar 9' elif orbital_pos == 2412: orb_pos = 'DirectTV 7S' elif orbital_pos == 2310: orb_pos = 'Galaxy 27' elif orbital_pos == 2311: orb_pos = 'Ciel 2' elif orbital_pos == 2120: orb_pos = 'Echostar 2' else: orb_pos = str((float(3600 - orbital_pos))/10.0) + "W" elif orbital_pos > 0: if orbital_pos == 192: orb_pos = 'Astra 1F' elif orbital_pos == 130: orb_pos = 'Hot Bird 6,7A,8' elif orbital_pos == 235: orb_pos = 'Astra 1E' elif orbital_pos == 1100: orb_pos = 'BSat 1A,2A' elif orbital_pos == 1101: orb_pos = 'N-Sat 110' elif orbital_pos == 1131: orb_pos = 'KoreaSat 5' elif orbital_pos == 1440: orb_pos = 'SuperBird 7,C2' elif orbital_pos == 1006: orb_pos = 'AsiaSat 2' elif orbital_pos == 1030: orb_pos = 'Express A2' elif orbital_pos == 1056: orb_pos = 'Asiasat 3S' elif orbital_pos == 1082: orb_pos = 'NSS 11' elif orbital_pos == 881: orb_pos = 'ST1' elif orbital_pos == 900: orb_pos = 'Yamal 201' elif orbital_pos == 917: orb_pos = 'Mesat' elif orbital_pos == 950: orb_pos = 'Insat 4B' elif orbital_pos == 951: orb_pos = 'NSS 6' elif orbital_pos == 765: orb_pos = 'Telestar' elif orbital_pos == 785: orb_pos = 'ThaiCom 5' elif orbital_pos == 800: orb_pos = 'Express' elif orbital_pos == 830: orb_pos = 'Insat 4A' elif orbital_pos == 850: orb_pos = 'Intelsat 709' elif orbital_pos == 750: orb_pos = 'Abs' elif orbital_pos == 720: orb_pos = 'Intelsat' elif orbital_pos == 705: orb_pos = 'Eutelsat W5' elif orbital_pos == 685: orb_pos = 'Intelsat' elif orbital_pos == 620: orb_pos = 'Intelsat 902' elif orbital_pos == 600: orb_pos = 'Intelsat 904' elif orbital_pos == 570: orb_pos = 'Nss' elif orbital_pos == 530: orb_pos = 'Express AM22' elif orbital_pos == 480: orb_pos = 'Eutelsat 2F2' elif orbital_pos == 450: orb_pos = 'Intelsat' elif orbital_pos == 420: orb_pos = 'Turksat 2A' elif orbital_pos == 400: orb_pos = 'Express AM1' elif orbital_pos == 390: orb_pos = 'Hellas Sat 2' elif orbital_pos == 380: orb_pos = 'Paksat 1' elif orbital_pos == 360: orb_pos = 'Eutelsat Sesat' elif orbital_pos == 335: orb_pos = 'Astra 1M' elif orbital_pos == 330: orb_pos = 'Eurobird 3' elif orbital_pos == 328: orb_pos = 'Galaxy 11' elif orbital_pos == 315: orb_pos = 'Astra 5A' elif orbital_pos == 310: orb_pos = 'Turksat' elif orbital_pos == 305: orb_pos = 'Arabsat' elif orbital_pos == 285: orb_pos = 'Eurobird 1' elif orbital_pos == 284: orb_pos = 'Eurobird/Astra' elif orbital_pos == 282: orb_pos = 'Eurobird/Astra' elif orbital_pos == 1220: orb_pos = 'AsiaSat' elif orbital_pos == 1380: orb_pos = 'Telstar 18' elif orbital_pos == 260: orb_pos = 'Badr 3/4' elif orbital_pos == 255: orb_pos = 'Eurobird 2' elif orbital_pos == 215: orb_pos = 'Eutelsat' elif orbital_pos == 216: orb_pos = 'Eutelsat W6' elif orbital_pos == 210: orb_pos = 'AfriStar 1' elif orbital_pos == 160: orb_pos = 'Eutelsat W2' elif orbital_pos == 100: orb_pos = 'Eutelsat W1' elif orbital_pos == 90: orb_pos = 'Eurobird 9' elif orbital_pos == 70: orb_pos = 'Eutelsat W3A' elif orbital_pos == 50: orb_pos = 'Sirius 4' elif orbital_pos == 48: orb_pos = 'Sirius 4' elif orbital_pos == 30: orb_pos = 'Telecom 2' else: orb_pos = str((float(orbital_pos))/10.0) + "E" Ret_Text += sep + orb_pos + "\n" Ret_Text += frequency + sep + frontendData.get("polarization_abbreviation") Ret_Text += sep + symbolrate Ret_Text += sep + frontendData.get("modulation") + "-" + fec_inner else: Ret_Text += sep + "DVB-C " + frequency + " MHz" + sep + fec_inner + sep + symbolrate elif (frontendData.get("tuner_type") == "DVB-T"): frequency = (str((frontendData.get("frequency") / 1000)) + " MHz") Ret_Text = "Frequency: " + frequency if (self.type == self.SMART_INFO_H or self.type == self.SMART_INFO_V or self.type == self.SERVICE_INFO): xresol = info.getInfo(iServiceInformation.sVideoWidth) yresol = info.getInfo(iServiceInformation.sVideoHeight) feinfo = (service and service.frontendInfo()) prvd = info.getInfoString(iServiceInformation.sProvider) Ret_Text = self.short(prvd) frontendDataOrg = (feinfo and feinfo.getAll(True)) if (frontendDataOrg is not None): frontendData = ConvertToHumanReadable(frontendDataOrg) if ((frontendDataOrg.get("tuner_type") == "DVB-S") or (frontendDataOrg.get("tuner_type") == "DVB-C")): frequency = (str((frontendData.get("frequency") / 1000))) symbolrate = (str((frontendData.get("symbol_rate") / 1000))) fec_inner = frontendData.get("fec_inner") if (frontendDataOrg.get("tuner_type") == "DVB-S"): Ret_Text += sep + frontendData.get("system") Ret_Text += sep + frequency + frontendData.get("polarization_abbreviation") Ret_Text += sep + symbolrate Ret_Text += sep + fec_inner + " " + frontendData.get("modulation") orbital_pos = int(frontendDataOrg["orbital_position"]) if orbital_pos > 1800: orb_pos = str((float(3600 - orbital_pos)) / 10.0) + "W" elif orbital_pos > 0: orb_pos = str((float(orbital_pos)) / 10.0) + "E" Ret_Text += sep + orb_pos else: Ret_Text += sep + "DVB-C " + frequency + " MHz" + sep + fec_inner + sep + symbolrate elif (frontendDataOrg.get("tuner_type") == "DVB-T"): frequency = (str((frontendData.get("frequency") / 1000))) Ret_Text += sep + "DVB-T" + sep + "Frequency:" + sep + frequency + " MHz" if (feinfo is not None) and (xresol > 0): Res_Text += ("MPEG2 ", "MPEG4 ", "MPEG1 ", "MPEG4-II ", "VC1 ", "VC1-SM ", "")[info.getInfo(iServiceInformation.sVideoType)] Res_Text += str(xresol) + "x" + str(yresol) Res_Text += ("i", "p", "")[info.getInfo(iServiceInformation.sProgressive)] Res_Text += str((info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) if (self.type == self.SMART_INFO_H or self.type == self.SMART_INFO_V or self.type == self.CRYPTO_INFO): decCI = "0" Sec_Text = "" if (info.getInfo(iServiceInformation.sIsCrypted) == 1): data = self.ecmdata.getEcmData() if not config.usage.show_cryptoinfo.getValue(): showCryptoInfo = True Sec_Text = data[0] + "\n" decCI = data[1] provid = data[2] pid = data[3] if decCI != '0': decCIfull = "%04x" % int(decCI, 16) for idline in self.idnames: if int(decCI, 16) >= int(idline[0], 16) and int(decCI, 16) <= int(idline[1], 16): decCIfull = idline[2] + ":" + decCIfull break Sec_Text += decCIfull if provid != '0': Sec_Text += ":%04x" % int(provid, 16) else: Sec_Text += ":" if pid != '0': Sec_Text += ":%04x:%04x" % (info.getInfo(iServiceInformation.sSID),int(pid, 16)) elif not config.usage.show_cryptoinfo.getValue(): showCryptoInfo = True Sec_Text = "FTA" res = "" searchIDs = (info.getInfoObject(iServiceInformation.sCAIDs)) for idline in self.idnames: if int(decCI, 16) >= int(idline[0], 16) and int(decCI, 16) <= int(idline[1], 16): color="\c0000??00" else: color = "\c007?7?7?" try: for oneID in searchIDs: if oneID >= int(idline[0], 16) and oneID <= int(idline[1], 16): color="\c00????00" except: pass res += color + idline[3] + " " if (self.type != self.CRYPTO_INFO): Ret_Text += "\n" Ret_Text += res + "\c00?????? " + Sec_Text if Res_Text != "": if showCryptoInfo: Ret_Text += sep + Res_Text else: Ret_Text += "\n" + Res_Text return Ret_Text
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": if frontendData["frequency"] > 11699999: band = "High" else: band = "Low" t2mi = lambda x: None if x == -1 else str(x) return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_BITRATE), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Band"), band, TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT), (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT), (_("Input Stream ID"), frontendData.get("is_id", 0), TYPE_VALUE_DEC), (_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT), (_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC), (_("T2MI PLP ID"), t2mi(frontendData.get("t2mi_plp_id", -1)), TYPE_TEXT), (_("T2MI PID"), None if frontendData.get("t2mi_plp_id", -1) == -1 else str( frontendData.get( "t2mi_pid", eDVBFrontendParametersSatellite. T2MI_Default_Pid)), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_BITRATE), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT), (_("Channel"), getChannelNumber(frontendData["frequency"], frontendData["tuner_number"]), TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("Code rate LP"), frontendData["code_rate_lp"], TYPE_TEXT), (_("Code rate HP"), frontendData["code_rate_hp"], TYPE_TEXT), (_("Constellation"), frontendData["constellation"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "ATSC": return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) return []
def getText(self): service = self.source.service info = None if isinstance(service, eServiceReference): info = self.source.info elif isinstance(service, iPlayableServicePtr): info = service and service.info() service = None if not info: return '' else: if self.type == self.NAME or self.type == self.NAME_ONLY or self.type == self.NAME_EVENT: name = service and info.getName(service) if name is None: name = info.getName() name = name.replace('\xc2\x86', '').replace('\xc2\x87', '') if self.type == self.NAME_EVENT: act_event = info and info.getEvent(0) if not act_event and info: refstr = info.getInfoString(iServiceInformation.sServiceref) act_event = self.epgQuery(eServiceReference(refstr), -1, 0) if act_event is None: return '%s - ' % name else: return '%s - %s' % (name, act_event.getEventName()) elif self.type != self.NAME_ONLY and config.usage.show_infobar_channel_number.value and hasattr(self.source, 'serviceref') and self.source.serviceref and '0:0:0:0:0:0:0:0:0' not in self.source.serviceref.toString(): numservice = self.source.serviceref num = numservice and numservice.getChannelNum() or None if num is not None: return str(num) + ' ' + name else: return name else: return name else: if self.type == self.PROVIDER: return info.getInfoString(iServiceInformation.sProvider) if self.type == self.REFERENCE or self.type == self.EDITREFERENCE and hasattr(self.source, 'editmode') and self.source.editmode: if not service: refstr = info.getInfoString(iServiceInformation.sServiceref) path = refstr and eServiceReference(refstr).getPath() if path and fileExists('%s.meta' % path): fd = open('%s.meta' % path, 'r') refstr = fd.readline().strip() fd.close() return refstr nref = resolveAlternate(service) if nref: service = nref return service.toString() if self.type == self.TRANSPONDER: if service: nref = resolveAlternate(service) if nref: service = nref info = eServiceCenter.getInstance().info(service) transponder_info = info.getInfoObject(service, iServiceInformation.sTransponderData) else: transponder_info = info.getInfoObject(iServiceInformation.sTransponderData) if 'InRootOnly' in self.mode and not self.rootBouquet(): return '' if 'NoRoot' in self.mode and self.rootBouquet(): return '' if transponder_info: self.t_info = ConvertToHumanReadable(transponder_info) if self.system() == None: return '' if 'DVB-T' in self.system(): return self.dvb_t() if 'DVB-C' in self.system(): return self.dvb_c() return self.dvb_s() if service: result = service.toString() else: result = info.getInfoString(iServiceInformation.sServiceref) if '%3a//' in result: return result.rsplit('%3a//', 1)[1].split('/')[0] return '' return
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference( self.session.nav.getCurrentlyPlayingServiceReference( )).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference( ).toString() else: name = _("N/A") refstr = _("N/A") aspect = "-" videocodec = "-" videomode = "-" resolution = "-" if self.info: from Components.Converter.LdExtraInfo import codec_data videocodec = codec_data.get( self.info.getInfo(iServiceInformation.sVideoType), "N/A") width = self.info.getInfo(iServiceInformation.sVideoWidth) height = self.info.getInfo(iServiceInformation.sVideoHeight) if width > 0 and height > 0: resolution = "%dx%d" % (width, height) resolution += ("i", "p", "-")[self.info.getInfo( iServiceInformation.sProgressive)] resolution += str( (self.info.getInfo(iServiceInformation.sFrameRate) + 500) / 1000) aspect = self.getServiceInfoValue( iServiceInformation.sAspect) aspect = aspect in (1, 2, 5, 6, 9, 0xA, 0xD, 0xE) and "4:3" or "16:9" resolution += " - [" + aspect + "]" gammas = ("SDR", "HDR", "HDR10", "HLG", "") if self.info.getInfo( iServiceInformation.sGamma) < len(gammas): gamma = gammas[self.info.getInfo( iServiceInformation.sGamma)] if gamma: resolution += " - " + gamma f = open("/proc/stb/video/videomode") videomode = f.read()[:-1].replace('\n', '') f.close() import subprocess codenumbers = None codesystem = None caidssyst = None try: codenumbers = subprocess.check_output([ "timeout -t 2 -s kill dvbsnoop -n 1 -nph 1 | grep CA_system_ID | awk -F '=' '{print $2}' | awk -F ']' '{print $1}' | wc -l" ], shell=True) codesystem = subprocess.check_output([ "timeout -t 2 -s kill dvbsnoop -n 1 -nph 1 | grep CA_system_ID | awk -F '=' '{print $2}' | awk -F ']' '{print $1}'" ], shell=True) caidssyst = subprocess.check_output([ "timeout -t 2 -s kill dvbsnoop -n 1 -nph 1 | grep CA_system_ID | awk -F '(' '{print $2}' | awk -F ')' '{print $1}'" ], shell=True) except: pass Labels = ((_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Videoformat"), aspect, TYPE_TEXT), (_("Videomode"), videomode, TYPE_TEXT), (_("Videosize"), resolution, TYPE_TEXT), (_("Videocodec"), videocodec, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue( iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT), (_("Coding Systems"), codenumbers, TYPE_TEXT)) if codenumbers > 0: try: i = 0 caidssyst1 = caidssyst.splitlines() codesystem1 = codesystem.splitlines() while i < int(codenumbers): caidsystem = caidssyst1[i] + " " + codesystem1[i] i += 1 newlabel = ((_("%s " % i), caidsystem, TYPE_TEXT)) Labels = Labels + (newlabel, ) except: pass self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type": _("Transponder type"), "system": _("System"), "modulation": _("Modulation"), "orbital_position": _("Orbital position"), "frequency": _("Frequency"), "symbol_rate": _("Symbol rate"), "bandwidth": _("Bandwidth"), "polarization": _("Polarization"), "inversion": _("Inversion"), "pilot": _("Pilot"), "rolloff": _("Roll-off"), "is_id": _("Input Stream ID"), "pls_mode": _("PLS Mode"), "pls_code": _("PLS Code"), "t2mi_plp_id": _("T2MI PLP ID"), "t2mi_pip": _("T2MI PID"), "fec_inner": _("FEC"), "code_rate_lp": _("Coderate LP"), "code_rate_hp": _("Coderate HP"), "constellation": _("Constellation"), "transmission_mode": _("Transmission mode"), "guard_interval": _("Guard interval"), "hierarchy_information": _("Hierarchy information") } Labels = [(conv[i], tp_info[i], i == "orbital_position" and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv] self.fillList(Labels)
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if self.transponder_info: tuner = (_("Type"), frontendData["tuner_type"], TYPE_TEXT) else: tuner = (_("NIM & Type"), chr(ord('A') + frontendData["tuner_number"]) + " - " + frontendData["tuner_type"], TYPE_TEXT) if frontendDataOrg["tuner_type"] == "DVB-S": issy = lambda x: 0 if x == -1 else x t2mi = lambda x: None if x == -1 else str(x) return (tuner, (_("System & Modulation"), frontendData["system"] + " " + frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency & Polarization"), "%s MHz" % (frontendData.get("frequency", 0) / 1000) + " - " + frontendData["polarization"], TYPE_TEXT), (_("Symbol rate & FEC"), "%s KSymb/s" % (frontendData.get("symbol_rate", 0) / 1000) + " - " + frontendData["fec_inner"], TYPE_TEXT), (_("Inversion, Pilot & Roll-off"), frontendData["inversion"] + " - " + str(frontendData.get("pilot", None)) + " - " + str(frontendData.get("rolloff", None)), TYPE_TEXT), (_("Input Stream ID"), issy(frontendData.get("is_id", 0)), TYPE_VALUE_DEC), (_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT), (_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC), (_("T2MI PLP ID"), t2mi(frontendData.get("t2mi_plp_id", -1)), TYPE_TEXT), (_("T2MI PID"), None if frontendData.get("t2mi_plp_id", -1) == -1 else str(frontendData.get("t2mi_pid", eDVBFrontendParametersSatellite.T2MI_Default_Pid)), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return (tuner, (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData.get("frequency", 0), TYPE_VALUE_FREQ_FLOAT), (_("Symbol rate & FEC"), "%s KSymb/s" % (frontendData.get("symbol_rate", 0) / 1000) + " - " + frontendData["fec_inner"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": return (tuner, (_("Frequency & Channel"), "%.3f MHz" % ((frontendData.get("frequency", 0) / 1000) / 1000.0) + " - " + frontendData["channel"], TYPE_TEXT), (_("Inversion & Bandwidth"), frontendData["inversion"] + " - " + str(frontendData["bandwidth"]), TYPE_TEXT), (_("Code R. LP-HP & Guard Int."), frontendData["code_rate_lp"] + " - " + frontendData["code_rate_hp"] + " - " + frontendData["guard_interval"], TYPE_TEXT), (_("Constellation & FFT mode"), frontendData["constellation"] + " - " + frontendData["transmission_mode"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "ATSC": return (tuner, (_("System & Modulation"), frontendData["system"] + " " + frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData.get("frequency", 0) / 1000, TYPE_VALUE_FREQ_FLOAT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT)) return []
def information(self): if self.type == TYPE_SERVICE_INFO: if self.session.nav.getCurrentlyPlayingServiceOrGroup(): name = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference()).getServiceName() refstr = self.session.nav.getCurrentlyPlayingServiceReference().toString() else: name = _("N/A") refstr = _("N/A") aspect = "-" videocodec = "-" videomode = "-" resolution = "-" if self.info: videocodec = ("MPEG2", "MPEG4", "MPEG1", "MPEG4-II", "VC1", "VC1-SM", "-" )[self.info and self.info.getInfo(iServiceInformation.sVideoType)] video_height = 0 video_width = 0 video_pol = " " video_rate = 0 if path.exists("/proc/stb/vmpeg/0/yres"): f = open("/proc/stb/vmpeg/0/yres", "r") try: video_height = int(f.read(),16) except: pass f.close() if path.exists("/proc/stb/vmpeg/0/xres"): f = open("/proc/stb/vmpeg/0/xres", "r") try: video_width = int(f.read(),16) except: pass f.close() if path.exists("/proc/stb/vmpeg/0/progressive"): f = open("/proc/stb/vmpeg/0/progressive", "r") try: video_pol = "p" if int(f.read(),16) else "i" except: pass f.close() if path.exists("/proc/stb/vmpeg/0/framerate"): f = open("/proc/stb/vmpeg/0/framerate", "r") try: video_rate = int(f.read()) except: pass f.close() fps = str((video_rate + 500) / 1000) resolution = str(video_width) + "x" + str(video_height) + video_pol + fps aspect = self.getServiceInfoValue(iServiceInformation.sAspect) if aspect in ( 1, 2, 5, 6, 9, 0xA, 0xD, 0xE ): aspect = "4:3" else: aspect = "16:9" f = open("/proc/stb/video/videomode") videomode = f.read()[:-1].replace('\n','') f.close() Labels = ( (_("Name"), name, TYPE_TEXT), (_("Provider"), self.getServiceInfoValue(iServiceInformation.sProvider), TYPE_TEXT), (_("Videoformat"), aspect, TYPE_TEXT), (_("Videomode"), videomode, TYPE_TEXT), (_("Videosize"), resolution, TYPE_TEXT), (_("Videocodec"), videocodec, TYPE_TEXT), (_("Namespace"), self.getServiceInfoValue(iServiceInformation.sNamespace), TYPE_VALUE_HEX, 8), (_("Service reference"), refstr, TYPE_TEXT)) self.fillList(Labels) else: if self.transponder_info: tp_info = ConvertToHumanReadable(self.transponder_info) conv = { "tuner_type" : _("Transponder type"), "system" : _("System"), "modulation" : _("Modulation"), "orbital_position" : _("Orbital position"), "frequency" : _("Frequency"), "symbol_rate" : _("Symbol rate"), "bandwidth" : _("Bandwidth"), "polarization" : _("Polarization"), "inversion" : _("Inversion"), "pilot" : _("Pilot"), "rolloff" : _("Roll-off"), "fec_inner" : _("FEC"), "code_rate_lp" : _("Coderate LP"), "code_rate_hp" : _("Coderate HP"), "constellation" : _("Constellation"), "transmission_mode": _("Transmission mode"), "guard_interval" : _("Guard interval"), "hierarchy_information": _("Hierarchy information") } Labels = [(conv[i], tp_info[i], i == "orbital_position" and TYPE_VALUE_ORBIT_DEC or TYPE_VALUE_DEC) for i in tp_info.keys() if i in conv] self.fillList(Labels)
def __start(self): if self.my_timer_active == 1: self.my_timer.stop() self.my_timer_active = 0 self["ecm_info"].setText("") self["netcard_info"].setText("") self["nfreq_info"].setText("") self["orbital_pos"].setText("") self["beta_emm"].hide() self["beta_ecm"].hide() self["irdeto_emm"].hide() self["irdeto_ecm"].hide() self["seca_emm"].hide() self["seca_ecm"].hide() self["via_emm"].hide() self["via_ecm"].hide() self["nagra_emm"].hide() self["nagra_ecm"].hide() self["cw_emm"].hide() self["cw_ecm"].hide() self["nds_emm"].hide() self["nds_ecm"].hide() self["conax_emm"].hide() self["conax_ecm"].hide() self["button_fta"].show() self["button_card"].hide() self["button_emu"].hide() self["button_spider"].hide() self.currentCam = "Common Interface" if fileExists("/etc/CurrentBhCamName"): f = open("/etc/CurrentBhCamName",'r') for line in f.readlines(): line = line.replace('\n', '') line = line.strip() if len(line) > 3: self.currentCam = line f.close() self["cam_info"].setText(self.currentCam) ret = "Black Hole" all = ["Avalon", "Chaos", "Ghost"] f = open("/proc/mounts",'r') for line in f.readlines(): if line.find('/usr ') != -1: for a in all: if line.find(a) != -1: ret = a break f.close() self["Universe"].setText(_("In %s universe") % (ret)) self.VideoSize = " " isCrypt = False service = self.session.nav.getCurrentService() myinfo = service and service.info() if myinfo is not None: isCrypt = myinfo.getInfo(iServiceInformation.sIsCrypted) == 1 feinfo = service.frontendInfo() frontendData = feinfo and feinfo.getAll(True) if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": fedata = ConvertToHumanReadable(frontendData) sr = str(int(frontendData.get("symbol_rate", 0) / 1000)) freq = str(int(frontendData.get("frequency", 0) / 1000)) pol = {0: "H", 1: "V", 2: "CL", 3: "CR", 4: None}[frontendData.get("polarization", "HORIZONTAL")] fec = fedata.get("fec_inner", " ") self["nfreq_info"].setText( "Freq: " + freq + " " + pol + " Sr: " + sr + " " + fec ) orbital = fedata["orbital_position"] self["orbital_pos"].setText(orbital) elif ttype == "DVB-T": fedata = ConvertToHumanReadable(frontendData) freq = str(int(frontendData.get("frequency", 0) / 1000)) band = fedata.get("bandwidth", " ") self["nfreq_info"].setText( "Freq: " + freq + " Band: " + band) if isCrypt == True: self["button_fta"].hide() Caids = myinfo.getInfoObject(iServiceInformation.sCAIDs) for caid in Caids: caidname = self.parse_caid_txt(caid) self.show_emm(caidname) self.my_timer_count = 0 self.__updateEmuInfo()
def __start(self): if self.my_timer_active == 1: self.my_timer.stop() self.my_timer_active = 0 self['ecm_info'].setText('') self['netcard_info'].setText('') self['nfreq_info'].setText('') self['orbital_pos'].setText('') self['beta_emm'].hide() self['beta_ecm'].hide() self['irdeto_emm'].hide() self['irdeto_ecm'].hide() self['seca_emm'].hide() self['seca_ecm'].hide() self['via_emm'].hide() self['via_ecm'].hide() self['nagra_emm'].hide() self['nagra_ecm'].hide() self['cw_emm'].hide() self['cw_ecm'].hide() self['nds_emm'].hide() self['nds_ecm'].hide() self['conax_emm'].hide() self['conax_ecm'].hide() self['biss_emm'].hide() self['biss_ecm'].hide() self['bul_emm'].hide() self['bul_ecm'].hide() self['dre_emm'].hide() self['dre_ecm'].hide() self['pv_emm'].hide() self['pv_ecm'].hide() self['button_fta'].show() self['button_card'].hide() self['button_emu'].hide() self['button_cex'].hide() self['button_spider'].hide() self.currentCam = 'Common Interface' if fileExists('/etc/CurrentBhCamName'): f = open('/etc/CurrentBhCamName', 'r') for line in f.readlines(): line = line.replace('\n', '') line = line.strip() if len(line) > 3: self.currentCam = line f.close() self['cam_info'].setText(self.currentCam) ret = 'Black Hole' all = ['Avalon', 'Chaos', 'Ghost'] f = open('/proc/mounts', 'r') for line in f.readlines(): if line.find('/usr ') != -1: for a in all: if line.find(a) != -1: ret = a break f.close() self['Universe'].setText(_('In %s Universe') % ret) self.VideoSize = ' ' isCrypt = False service = self.session.nav.getCurrentService() myinfo = service and service.info() if myinfo is not None: isCrypt = myinfo.getInfo(iServiceInformation.sIsCrypted) == 1 feinfo = service.frontendInfo() frontendData = feinfo and feinfo.getAll(True) if frontendData is not None: ttype = frontendData.get('tuner_type', 'UNKNOWN') if ttype == 'DVB-S': fedata = ConvertToHumanReadable(frontendData) sr = str(int(frontendData.get('symbol_rate', 0) / 1000)) freq = str(int(frontendData.get('frequency', 0) / 1000)) pol = {0: 'H', 1: 'V', 2: 'CL', 3: 'CR', 4: None}[frontendData.get('polarization', 'HORIZONTAL')] fec = fedata.get('fec_inner', ' ') self['nfreq_info'].setText('Freq: ' + freq + ' ' + pol + ' Sr: ' + sr + ' ' + fec) orbital = fedata['orbital_position'] self['orbital_pos'].setText(orbital) elif ttype == 'DVB-T': fedata = ConvertToHumanReadable(frontendData) freq = str(int(frontendData.get('frequency', 0) / 1000)) band = fedata.get('bandwidth', ' ') orbital = fedata.get('tuner_type') self['orbital_pos'].setText(orbital) self['nfreq_info'].setText('Freq: ' + freq + ', Band: ' + band) elif ttype == 'DVB-C': fedata = ConvertToHumanReadable(frontendData) sr = str(int(frontendData.get('symbol_rate', 0) / 1000)) freq = str(int(frontendData.get('frequency', 0) / 1)) qam = fedata.get('modulation') orbital = fedata.get('tuner_type') self['orbital_pos'].setText(orbital) self['nfreq_info'].setText('Freq: ' + freq + ', ' + qam + ', Sr: ' + sr) if isCrypt == True: self['button_fta'].hide() Caids = myinfo.getInfoObject(iServiceInformation.sCAIDs) for caid in Caids: caidname = self.parse_caid_txt(caid) self.show_emm(caidname) self.my_timer_count = 0 self.__updateEmuInfo()
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": return ((_("NIM"), ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')[frontendData["tuner_number"]], TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Polarization"), frontendData["polarization"], TYPE_TEXT), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT), (_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT), (_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return ((_("NIM"), ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')[frontendData["tuner_number"]], TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("Modulation"), frontendData["modulation"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("FEC"), frontendData["fec_inner"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": data = ((_("NIM"), ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')[frontendData["tuner_number"]], TYPE_TEXT), (_("Type"), frontendData["tuner_type"], TYPE_TEXT), (_("System"), frontendData["system"], TYPE_TEXT), (_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC), (_("Inversion"), frontendData["inversion"], TYPE_TEXT), (_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC), (_("Code rate LP"), frontendData["code_rate_lp"], TYPE_TEXT), (_("Code rate HP"), frontendData["code_rate_hp"], TYPE_TEXT), (_("Constellation"), frontendData["constellation"], TYPE_TEXT), (_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT), (_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT), (_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT)) if frontendData.has_key("plp_id"): data += ((_("PLP ID"), frontendData["plp_id"], TYPE_VALUE_DEC), ) return data return []
def getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if self.transponder_info: tuner = (_("Type"), frontendData["tuner_type"], TYPE_TEXT) else: tuner = (_("NIM & Type"), chr(ord('A') + frontendData["tuner_number"]) + " - " + frontendData["tuner_type"], TYPE_TEXT) if frontendDataOrg["tuner_type"] == "DVB-S": t2mi = lambda x: None if x == -1 else str(x) if frontendData.get("is_id", eDVBFrontendParametersSatellite.No_Stream_Id_Filter) > eDVBFrontendParametersSatellite.No_Stream_Id_Filter: # multistream return (tuner, (_("System & Modulation"), "%s %s" % (frontendData["system"], frontendData["modulation"]), TYPE_TEXT), (_("Orbital position"), "%s" % frontendData["orbital_position"], TYPE_TEXT), (_("Frequency & Polarization"), "%s - %s" % (frontendData.get("frequency", 0), frontendData["polarization"]), TYPE_TEXT), (_("Symbol rate & FEC"), "%s - %s" % (frontendData.get("symbol_rate", 0), frontendData["fec_inner"]), TYPE_TEXT), (_("Input Stream ID"), "%s" % (frontendData.get("is_id", eDVBFrontendParametersSatellite.No_Stream_Id_Filter)), TYPE_TEXT), (_("PLS Mode & PLS Code"), "%s - %s" % (frontendData["pls_mode"], frontendData["pls_code"]), TYPE_TEXT), (_("T2MI PLP ID"), t2mi(frontendData.get("t2mi_plp_id", eDVBFrontendParametersSatellite.No_T2MI_PLP_Id)), TYPE_TEXT), (_("T2MI PID"), None if frontendData.get("t2mi_plp_id", eDVBFrontendParametersSatellite.No_T2MI_PLP_Id) == eDVBFrontendParametersSatellite.No_T2MI_PLP_Id else str(frontendData.get("t2mi_pid", eDVBFrontendParametersSatellite.T2MI_Default_Pid)), TYPE_TEXT), (_("Inversion, Pilot & Roll-off"), "%s - %s - %s" % (frontendData["inversion"], frontendData.get("pilot", None), str(frontendData.get("rolloff", None))), TYPE_TEXT)) else: # not multistream return (tuner, (_("System & Modulation"), "%s %s" % (frontendData["system"], frontendData["modulation"]), TYPE_TEXT), (_("Orbital position"), "%s" % frontendData["orbital_position"], TYPE_TEXT), (_("Frequency & Polarization"), "%s - %s" % (frontendData.get("frequency", 0), frontendData["polarization"]), TYPE_TEXT), (_("Symbol rate & FEC"), "%s - %s" % (frontendData.get("symbol_rate", 0), frontendData["fec_inner"]), TYPE_TEXT), (_("T2MI PLP ID"), t2mi(frontendData.get("t2mi_plp_id", eDVBFrontendParametersSatellite.No_T2MI_PLP_Id)), TYPE_TEXT), (_("T2MI PID"), None if frontendData.get("t2mi_plp_id", eDVBFrontendParametersSatellite.No_T2MI_PLP_Id) == eDVBFrontendParametersSatellite.No_T2MI_PLP_Id else str(frontendData.get("t2mi_pid", eDVBFrontendParametersSatellite.T2MI_Default_Pid)), TYPE_TEXT), (_("Inversion, Pilot & Roll-off"), "%s - %s - %s" % (frontendData["inversion"], frontendData.get("pilot", None), str(frontendData.get("rolloff", None))), TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-C": return (tuner, (_("Modulation"),"%s" % frontendData["modulation"], TYPE_TEXT), (_("Frequency"), "%s" % frontendData.get("frequency", 0), TYPE_TEXT), (_("Symbol rate & FEC"), "%s - %s" % (frontendData.get("symbol_rate", 0), frontendData["fec_inner"]), TYPE_TEXT), (_("Inversion"), "%s" % frontendData["inversion"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "DVB-T": return (tuner, (_("Frequency & Channel"), "%s - Ch. %s" % (frontendData.get("frequency", 0), getChannelNumber(frontendData["frequency"], frontendData["tuner_number"])), TYPE_TEXT), (_("Inversion & Bandwidth"), "%s - %s" % (frontendData["inversion"], frontendData["bandwidth"]), TYPE_TEXT), (_("Code R. LP-HP & Guard Int"), "%s - %s - %s" % (frontendData["code_rate_lp"], frontendData["code_rate_hp"], frontendData["guard_interval"]), TYPE_TEXT), (_("Constellation & FFT mode"), "%s - %s" % (frontendData["constellation"], frontendData["transmission_mode"]), TYPE_TEXT), (_("Hierarchy info"), "%s" % frontendData["hierarchy_information"], TYPE_TEXT)) elif frontendDataOrg["tuner_type"] == "ATSC": return (tuner, (_("System & Modulation"), "%s - %s" % (frontendData["system"], frontendData["modulation"]), TYPE_TEXT), (_("Frequency"), "%s" % frontendData.get("frequency", 0), TYPE_TEXT), (_("Inversion"), "%s" % frontendData["inversion"], TYPE_TEXT)) return []
def changed(self, what): if self.instance: if (what[0] == self.CHANGED_CLEAR): self.text = " " else: service = self.source.service info = eServiceCenter.getInstance().info(service) if (info and service): tp = info.getInfoObject( service, iServiceInformation.sTransponderData) tpinfo = ConvertToHumanReadable(tp) refstr = str(self.source.service.toString()) curref = refstr.replace("%3a", ":") streamtype = streamurl = freq = terra = ch = pol = sys = mod = const = fec = sr = orbpos = "" try: if curref.startswith("1:7:"): curref = "" if "%3a/" in refstr or ":/" in refstr: strurl = refstr.split(":") streamurl = strurl[10].replace("%3a", ":") if refstr.startswith("1:0:2"): streamtype = "Radio" elif not curref.startswith( "1:0:") and "%3a/" in refstr: streamtype = "Stream" elif curref.startswith("1:0:") and "%3a/" in refstr: if "0.0.0.0:" in curref or "127.0.0.1:" in curref or "localhost:" in curref: streamtype = "TS Relay" else: streamtype = "TS Stream" elif curref.startswith("1:134:"): streamtype = "Alternative" else: streamurl = streamtype = "" if "channel" in tpinfo: try: ch = (str(tpinfo.get("channel")) + "/") except: ch = " " if "system" in tp: try: sys = (str(tpinfo.get("system")) + " ") if "DVB-S" in sys or "DVB-C" in sys: freq = (str(int(tp["frequency"]) / 1000) + " ") elif "DVB-T" in sys or "ATSC" in sys: terra = ( str(int(tp["frequency"]) / 1000000) + " Mhz ") else: freq = terra = " " except: sys = " N/A " if "modulation" in tp: try: mod = (str(tpinfo.get("modulation")) + " ") except: mod = " " if "polarization" in tp: try: pol = { eDVBFrontendParametersSatellite.Polarisation_Horizontal: "H ", eDVBFrontendParametersSatellite.Polarisation_Vertical: "V ", eDVBFrontendParametersSatellite.Polarisation_CircularLeft: "L ", eDVBFrontendParametersSatellite.Polarisation_CircularRight: "R " }[tp["polarization"]] except: pol = " N/A " if "constellation" in tp: try: const = (str(tpinfo.get("constellation")) + " ") except: const = " " if "fec_inner" in tp: try: fec = (str(tpinfo.get("fec_inner")) + " ") except: fec = " N/A " if "symbol_rate" in tp: sr = (str(int(tp["symbol_rate"]) / 1000) + " ") if "orbital_position" in tp: orbpos = (int(tp["orbital_position"])) if orbpos > 1800: orbpos = (str( (float(3600 - orbpos)) / 10.0) + "°W ") else: orbpos = (str((float(orbpos)) / 10.0) + "°E ") except: pass self.text = (streamtype + " " + streamurl + orbpos + ch + freq + terra + pol + sys + mod + sr + fec + const)