def updateStatus(self): if self.frontend: self.frontendStatus.clear() 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() tpdata = self.tuner.getTransponderData() if tpdata: transponderdata = ConvertToHumanReadable(tpdata, "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": 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)) 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), (_("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 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 "" 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.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 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_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)) 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 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), ) 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), ) 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": 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 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 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": if frontendData.get("is_id", -1) > -1: # 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", -1)), TYPE_TEXT), (_("PLS Mode & PLS Code"), "%s - %s" % (frontendData["pls_mode"], frontendData["pls_code"]), 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), (_("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 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.get("frequency", 0), TYPE_VALUE_FREQ_FLOAT), (_("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 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 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 getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) tunerType = frontendDataOrg["tuner_type"] if tunerType == feSatellite: return ((_("NIM"), ('A', 'B', 'C', 'D')[frontendData["slot_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 tunerType == feCable: return ((_("NIM"), ('A', 'B', 'C', 'D')[frontendData["slot_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 tunerType == feTerrestrial: return ((_("NIM"), ('A', 'B', 'C', 'D')[frontendData["slot_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), (_("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": 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')[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 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 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": if frontendData.get("is_id", -1) > -1: # 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", -1)), TYPE_TEXT), (_("PLS Mode & PLS Code"), "%s - %s" % (frontendData["pls_mode"], frontendData["pls_code"]), 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), (_("Inversion, Pilot & Roll-off"), "%s - %s - %s" % (frontendData["inversion"], frontendData.get("pilot", None), str(frontendData.get("rolloff", None))), TYPE_TEXT))
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 = (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 = (str(int(tp["frequency"]) / 1000) + " Mhz") elif "DVB-T" in sys or "ATSC" in sys: freq = ( str(int(tp["frequency"]) / 1000000) + " Mhz") 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:") + 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 is not "None" and plscode == "0"): plsmode = "" if isid == "None" or isid == "-1" or isid == "0": isid = "" else: isid = ("IS:") + 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.decode("utf8")) self.idx = 0 self.backtext = self.text self.status = "start" self.moveTimerText = eTimer() self.moveTimerText.timeout.get().append( self.moveTimerTextRun) self.moveTimerText.start(2000)
class ServiceName2(Converter, object): NAME = 0 NUMBER = 1 BOUQUET = 2 PROVIDER = 3 REFERENCE = 4 ORBPOS = 5 TPRDATA = 6 SATELLITE = 7 ALLREF = 8 FORMAT = 9 def __init__(self, type): Converter.__init__(self, type) if type == "Name" or not len(str(type)): self.type = self.NAME elif type == "Number": self.type = self.NUMBER elif type == "Bouquet": self.type = self.BOUQUET elif type == "Provider": self.type = self.PROVIDER elif type == "Reference": self.type = self.REFERENCE elif type == "OrbitalPos": self.type = self.ORBPOS elif type == "TpansponderInfo": self.type = self.TPRDATA elif type == "Satellite": self.type = self.SATELLITE elif type == "AllRef": self.type = self.ALLREF else: self.type = self.FORMAT self.sfmt = type[:] try: if (self.type == 1 or (self.type == 9 and '%n' in self.sfmt)) and correctChannelNumber: ChannelNumberClasses.append(self.forceChanged) except: pass self.refstr = self.isStream = self.ref = self.info = self.what = self.tpdata = None self.Timer = eTimer() self.Timer.callback.append(self.neededChange) self.IPTVcontrol = self.isAdditionalService(type=0) self.AlternativeControl = self.isAdditionalService(type=1) def isAdditionalService(self, type=0): def searchService(serviceHandler, bouquet): istype = False servicelist = serviceHandler.list(bouquet) if not servicelist is None: while True: s = servicelist.getNext() if not s.valid(): break if not (s.flags & (eServiceReference.isMarker | eServiceReference.isDirectory)): if type: if s.flags & eServiceReference.isGroup: istype = True return istype else: if '%3a//' in s.toString().lower(): istype = True return istype return istype isService = False serviceHandler = eServiceCenter.getInstance() if not config.usage.multibouquet.value: service_types_tv = '1:7:1:0:0:0:0:0:0:0:(type == 1) || (type == 17) || (type == 22) || (type == 25) || (type == 134) || (type == 195)' rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet' % ( service_types_tv) else: rootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.tv" ORDER BY bouquet' bouquet = eServiceReference(rootstr) if not config.usage.multibouquet.value: isService = searchService(serviceHandler, bouquet) else: bouquetlist = serviceHandler.list(bouquet) if not bouquetlist is None: while True: bouquet = bouquetlist.getNext() if not bouquet.valid(): break if bouquet.flags & eServiceReference.isDirectory: isService = searchService(serviceHandler, bouquet) if isService: break return isService def getServiceNumber(self, ref): def searchHelper(serviceHandler, num, bouquet): servicelist = serviceHandler.list(bouquet) if not servicelist is None: while True: s = servicelist.getNext() if not s.valid(): break if not (s.flags & (eServiceReference.isMarker | eServiceReference.isDirectory)): num += 1 if s == ref: return s, num return None, num if isinstance(ref, eServiceReference): isRadioService = ref.getData(0) in (2, 10) lastpath = isRadioService and config.radio.lastroot.value or config.tv.lastroot.value if 'FROM BOUQUET' not in lastpath: if 'FROM PROVIDERS' in lastpath: return 'P', 'Provider' if 'FROM SATELLITES' in lastpath: return 'S', 'Satellites' if ') ORDER BY name' in lastpath: return 'A', 'All Services' return 0, 'N/A' try: acount = config.plugins.NumberZapExt.enable.value and config.plugins.NumberZapExt.acount.value or config.usage.alternative_number_mode.value except: acount = False rootstr = '' for x in lastpath.split(';'): if x != '': rootstr = x serviceHandler = eServiceCenter.getInstance() if acount is True or not config.usage.multibouquet.value: bouquet = eServiceReference(rootstr) service, number = searchHelper(serviceHandler, 0, bouquet) else: if isRadioService: bqrootstr = '1:7:2:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.radio" ORDER BY bouquet' else: bqrootstr = '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.tv" ORDER BY bouquet' number = 0 cur = eServiceReference(rootstr) bouquet = eServiceReference(bqrootstr) bouquetlist = serviceHandler.list(bouquet) if not bouquetlist is None: while True: bouquet = bouquetlist.getNext() if not bouquet.valid(): break if bouquet.flags & eServiceReference.isDirectory: service, number = searchHelper( serviceHandler, number, bouquet) if not service is None and cur == bouquet: break if not service is None: info = serviceHandler.info(bouquet) name = info and info.getName(bouquet) or '' return number, name return 0, '' def getProviderName(self, ref): if isinstance(ref, eServiceReference): from Screens.ChannelSelection import service_types_radio, service_types_tv typestr = ref.getData(0) in ( 2, 10) and service_types_radio or service_types_tv pos = typestr.rfind(':') rootstr = '%s (channelID == %08x%04x%04x) && %s FROM PROVIDERS ORDER BY name' % ( typestr[:pos + 1], ref.getUnsignedData(4), ref.getUnsignedData(2), ref.getUnsignedData(3), typestr[pos + 1:]) provider_root = eServiceReference(rootstr) serviceHandler = eServiceCenter.getInstance() providerlist = serviceHandler.list(provider_root) if not providerlist is None: while True: provider = providerlist.getNext() if not provider.valid(): break if provider.flags & eServiceReference.isDirectory: servicelist = serviceHandler.list(provider) if not servicelist is None: while True: service = servicelist.getNext() if not service.valid(): break if service == ref: info = serviceHandler.info(provider) return info and info.getName( provider) or "Unknown" return "" def getTransponderInfo(self, info, ref, fmt): result = "" if self.tpdata is None: if ref: self.tpdata = ref and info.getInfoObject( ref, iServiceInformation.sTransponderData) else: self.tpdata = info.getInfoObject( iServiceInformation.sTransponderData) self.fedata = ConvertToHumanReadable(self.tpdata) if not isinstance(self.tpdata, dict): self.tpdata = None return result if self.isStream: type = 'IPTV' else: type = self.tpdata.get('tuner_type', '') if not fmt or fmt == 'T': if type == 'DVB-C': fmt = [ "t ", "F ", "Y ", "i ", "f ", "M" ] #(type frequency symbol_rate inversion fec modulation) elif type == 'DVB-T': if ref: fmt = [ "O ", "F ", "h ", "m ", "g ", "c", "k " ] #(orbital_position code_rate_hp transmission_mode guard_interval constellation) else: fmt = [ "t ", "F ", "h ", "m ", "g ", "c", "k " ] #(type frequency code_rate_hp transmission_mode guard_interval constellation) elif type == 'IPTV': return _("Streaming") else: fmt = [ "O ", "F", "p ", "Y ", "f" ] #(orbital_position frequency polarization symbol_rate fec) for line in fmt: f = line[:1] if f == 't': # %t - tuner_type (dvb-s/s2/c/t) if type == 'DVB-S': result += _("Satellite") elif type == 'DVB-C': result += _("Cable") elif type == 'DVB-T': result += _("Terrestrial") elif type == 'IPTV': result += _("Stream-tv") else: result += 'N/A' elif f == 's': # %s - system (dvb-s/s2/c/t) if type == 'DVB-S': x = self.tpdata.get('system', 0) result += x in range(2) and { 0: 'DVB-S', 1: 'DVB-S2' }[x] or '' elif type == 'DVB-C': x = self.tpdata.get('system', 0) result += x in range(2) and { 0: 'DVB-C', 1: 'DVB-C2' }[x] or '' elif type == 'DVB-T': x = self.tpdata.get('system', 0) result += x in range(2) and { 0: 'DVB-T', 1: 'DVB-T2' }[x] or '' else: result += type elif f == 'F': # %F - frequency (dvb-s/s2/c/t) in KHz if type == 'DVB-S': result += '%d' % round( self.tpdata.get('frequency', 0) / 1000.0) elif type in ('DVB-T', 'DVB-C'): result += '%d MHz' % round( self.tpdata.get('frequency', 0) / 1000000.0) elif f == 'k': # %k ch number t2 if type == 'DVB-T': result += self.fedata.get("channel") or '' elif f == 'f': # %f - fec_inner (dvb-s/s2/c/t) if type in ('DVB-S', 'DVB-C'): x = self.tpdata.get('fec_inner', 15) result += x in range(10) + [15] and { 0: 'Auto', 1: '1/2', 2: '2/3', 3: '3/4', 4: '5/6', 5: '7/8', 6: '8/9', 7: '3/5', 8: '4/5', 9: '9/10', 15: 'None' }[x] or '' elif type == 'DVB-T': x = self.tpdata.get('code_rate_lp', 5) result += x in range(6) and { 0: '1/2', 1: '2/3', 2: '3/4', 3: '5/6', 4: '7/8', 5: 'Auto' }[x] or '' elif f == 'i': # %i - inversion (dvb-s/s2/c/t) if type in ('DVB-S', 'DVB-C', 'DVB-T'): x = self.tpdata.get('inversion', 2) result += x in range(3) and { 0: 'On', 1: 'Off', 2: 'Auto' }[x] or '' elif f == 'O': # %O - orbital_position (dvb-s/s2) if type == 'DVB-S': x = self.tpdata.get('orbital_position', 0) result += x > 1800 and "%d.%d°W" % ( (3600 - x) / 10, (3600 - x) % 10) or "%d.%d°E" % (x / 10, x % 10) elif type == 'DVB-T': x = self.tpdata.get('system', 0) result += x in range(2) and { 0: 'DVB-T', 1: 'DVB-T2' }[x] or '' elif type == 'DVB-C': result += 'DVB-C' elif type == 'Iptv': result += 'Stream' elif f == 'M': # %M - modulation (dvb-s/s2/c) x = self.tpdata.get('modulation', 1) if type == 'DVB-S': result += x in range(4) and { 0: 'Auto', 1: 'QPSK', 2: '8PSK', 3: 'QAM16' }[x] or '' elif type == 'DVB-C': result += x in range(6) and { 0: 'Auto', 1: 'QAM16', 2: 'QAM32', 3: 'QAM64', 4: 'QAM128', 5: 'QAM256' }[x] or '' elif f == 'p': # %p - polarization (dvb-s/s2) if type == 'DVB-S': x = self.tpdata.get('polarization', 0) result += x in range(4) and { 0: 'H', 1: 'V', 2: 'L', 3: 'R' }[x] or '?' elif f == 'Y': # %Y - symbol_rate (dvb-s/s2/c) if type in ('DVB-S', 'DVB-C'): result += '%d' % (self.tpdata.get('symbol_rate', 0) / 1000) elif f == 'r': # %r - rolloff (dvb-s2) if not self.isStream: x = self.tpdata.get('rolloff') if not x is None: result += x in range(3) and { 0: '0.35', 1: '0.25', 2: '0.20' }[x] or '' elif f == 'o': # %o - pilot (dvb-s2) if not self.isStream: x = self.tpdata.get('pilot') if not x is None: result += x in range(3) and { 0: 'Off', 1: 'On', 2: 'Auto' }[x] or '' elif f == 'c': # %c - constellation (dvb-t) if type == 'DVB-T': x = self.tpdata.get('constellation', 3) result += x in range(4) and { 0: 'QPSK', 1: 'QAM16', 2: 'QAM64', 3: 'Auto' }[x] or '' elif f == 'l': # %l - code_rate_lp (dvb-t) if type == 'DVB-T': x = self.tpdata.get('code_rate_lp', 5) result += x in range(6) and { 0: '1/2', 1: '2/3', 2: '3/4', 3: '5/6', 4: '7/8', 5: 'Auto' }[x] or '' elif f == 'h': # %h - code_rate_hp (dvb-t) if type == 'DVB-T': x = self.tpdata.get('code_rate_hp', 5) result += x in range(6) and { 0: '1/2', 1: '2/3', 2: '3/4', 3: '5/6', 4: '7/8', 5: 'Auto' }[x] or '' elif f == 'm': # %m - transmission_mode (dvb-t) if type == 'DVB-T': x = self.tpdata.get('transmission_mode', 2) result += x in range(3) and { 0: '2k', 1: '8k', 2: 'Auto' }[x] or '' elif f == 'g': # %g - guard_interval (dvb-t) if type == 'DVB-T': x = self.tpdata.get('guard_interval', 4) result += x in range(5) and { 0: '1/32', 1: '1/16', 2: '1/8', 3: '1/4', 4: 'Auto' }[x] or '' elif f == 'b': # %b - bandwidth (dvb-t) if type == 'DVB-T': x = self.tpdata.get('bandwidth', 1) result += x in range(4) and { 0: '8 MHz', 1: '7 MHz', 2: '6 MHz', 3: 'Auto' }[x] or '' elif f == 'e': # %e - hierarchy_information (dvb-t) if type == 'DVB-T': x = self.tpdata.get('hierarchy_information', 4) result += x in range(5) and { 0: 'None', 1: '1', 2: '2', 3: '4', 4: 'Auto' }[x] or '' result += line[1:] return result def getSatelliteName(self, ref): if isinstance(ref, eServiceReference): orbpos = ref.getUnsignedData(4) >> 16 if orbpos == 0xFFFF: #Cable return _("Cable") elif orbpos == 0xEEEE: #Terrestrial # return _("Terrestrial") try: nimfile = open('/proc/bus/nim_sockets') except IOError: return current_slot = None for line in nimfile: if not line: break line = line.strip() if line.startswith('NIM Socket'): parts = line.split(' ') current_slot = int(parts[2][:-1]) from Components.NimManager import nimmanager return str(nimmanager.getTerrestrialDescription(current_slot)) else: #Satellite orbpos = ref.getData(4) >> 16 if orbpos < 0: orbpos += 3600 try: from Components.NimManager import nimmanager return str(nimmanager.getSatDescription(orbpos)) except: dir = ref.flags & (eServiceReference.isDirectory | eServiceReference.isMarker) if not dir: refString = ref.toString().lower() if refString.startswith('-1'): return '' elif refString.startswith('1:134:'): return _("Alternative") elif refString.startswith('4097:'): return _("Internet") else: return orbpos > 1800 and "%d.%d°W" % ( (3600 - orbpos) / 10, (3600 - orbpos) % 10) or "%d.%d°E" % (orbpos / 10, orbpos % 10) return "" def getIPTVProvider(self, refstr): iptv_prov = '/etc/enigma2/iptvprov.list' if os.path.isfile(iptv_prov): with open(iptv_prov, "r") as f: for d in f.readlines(): if d.split(',')[0] in refstr: return d.split(',')[1].strip() elif '4097' in refstr or '5001' in refstr or '5002' in refstr: return "StreamTV" return "" def getPlayingref(self, ref): playingref = None if NavigationInstance.instance: playingref = NavigationInstance.instance.getCurrentlyPlayingServiceReference( ) if not playingref: playingref = eServiceReference() return playingref def resolveAlternate(self, ref): nref = getBestPlayableServiceReference(ref, self.getPlayingref(ref)) if not nref: nref = getBestPlayableServiceReference(ref, eServiceReference(), True) return nref def getReferenceType(self, refstr, ref): if ref is None: if NavigationInstance.instance: playref = NavigationInstance.instance.getCurrentlyPlayingServiceReference( ) if playref: refstr = playref.toString() or '' prefix = '' if refstr.startswith('4097:'): prefix += "GStreamer " if '%3a//' in refstr: sref = ' '.join(refstr.split(':')[10:]) refstr = prefix + sref else: sref = ':'.join(refstr.split(':')[:10]) refstr = prefix + sref else: if refstr != '': prefix = '' if refstr.startswith("1:7:"): if 'FROM BOUQUET' in refstr: prefix += "Bouquet " elif '(provider == ' in refstr: prefix += "Provider " elif '(satellitePosition == ' in refstr: prefix += "Satellit " elif '(channelID == ' in refstr: prefix += "Current tr " elif refstr.startswith('1:134:'): prefix += "Alter " elif refstr.startswith('1:64:'): prefix += "Marker " elif refstr.startswith('4097:'): prefix += "GStreamer " if self.isStream: if self.refstr: if '%3a//' in self.refstr: sref = ' '.join(self.refstr.split(':')[10:]) else: sref = ':'.join(self.refstr.split(':')[:10]) else: sref = ' '.join(refstr.split(':')[10:]) return prefix + sref else: if self.refstr: sref = ':'.join(self.refstr.split(':')[:10]) else: sref = ':'.join(refstr.split(':')[:10]) return prefix + sref return refstr @cached def getText(self): service = self.source.service if isinstance(service, iPlayableServicePtr): info = service and service.info() ref = None else: # reference info = service and self.source.info ref = service if not info: return "" refname = 'ServiceName2.ref' searchpath = [ '/etc/enigma2/', '/usr/lib/enigma2/python/Components/Converter/' ] if ref: refstr = ref.toString() else: refstr = info.getInfoString(iServiceInformation.sServiceref) if refstr is None: refstr = '' if self.AlternativeControl: if ref and refstr.startswith('1:134:') and self.ref is None: nref = self.resolveAlternate(ref) if nref: self.ref = nref self.info = eServiceCenter.getInstance().info(self.ref) self.refstr = self.ref.toString() if not self.info: return "" if self.IPTVcontrol: if '%3a//' in refstr or (self.refstr and '%3a//' in self.refstr ) or refstr.startswith('4097:'): self.isStream = True if self.type == self.NAME: name = ref and (info.getName(ref) or 'N/A') or (info.getName() or 'N/A') prefix = '' if self.ref: prefix = " (alter)" name += prefix return name.replace('\xc2\x86', '').replace('\xc2\x87', '') elif self.type == self.NUMBER: try: service = self.source.serviceref num = service and service.getChannelNum() or None except: num = None if num: return str(num) else: num, bouq = self.getServiceNumber(ref or eServiceReference( info.getInfoString(iServiceInformation.sServiceref))) return num and str(num) or '' elif self.type == self.BOUQUET: num, bouq = self.getServiceNumber(ref or eServiceReference( info.getInfoString(iServiceInformation.sServiceref))) return bouq elif self.type == self.PROVIDER: tmpprov = tmpref = refpath = '' if self.isStream: if self.refstr: tmpprov = self.getIPTVProvider(self.refstr) tmpprov = self.getIPTVProvider(refstr) else: if self.ref: tmpprov = self.getProviderName(self.ref) if ref: tmpprov = self.getProviderName(ref) else: tmpprov = info.getInfoString( iServiceInformation.sProvider) or '' if '' is tmpprov or 'Unknown' in tmpprov: if self.refstr: tmpref = self.refstr else: tmpref = refstr for i in range(len(searchpath)): if os.path.isfile('%s%s' % (searchpath[i], refname)): refpath = '%s%s' % (searchpath[i], refname) if not '' is refpath: tmpref = ':'.join(tmpref.split(':')[:10]) reffile = open(refpath, 'r').read() if not reffile.endswith('\r\n\r\n'): reffile = '%s\r\n' % reffile for line in reffile.splitlines(True): if line.startswith(tmpref): tmpprov = line.strip('\r').strip('\n').split( ':')[-1].strip() return tmpprov return tmpprov elif self.type == self.REFERENCE: if self.refstr: return self.refstr return refstr elif self.type == self.ORBPOS: if self.isStream: return "Stream" else: if self.ref and self.info: return self.getTransponderInfo(self.info, self.ref, 'O') return self.getTransponderInfo(info, ref, 'O') elif self.type == self.TPRDATA: if self.isStream: return "Streaming" else: if self.ref and self.info: return self.getTransponderInfo(self.info, self.ref, 'T') return self.getTransponderInfo(info, ref, 'T') elif self.type == self.SATELLITE: if self.isStream: return "Internet" else: if self.ref: return self.getSatelliteName(self.ref) #test# return self.getSatelliteName(ref or eServiceReference( info.getInfoString(iServiceInformation.sServiceref))) elif self.type == self.ALLREF: tmpref = self.getReferenceType(refstr, ref) if 'Bouquet' in tmpref or 'Satellit' in tmpref or 'Provider' in tmpref: return ' ' elif '%3a' in tmpref: return ':'.join(refstr.split(':')[:10]) return tmpref elif self.type == self.FORMAT: num = bouq = '' tmp = self.sfmt[:].split("%") if tmp: ret = tmp[0] tmp.remove(ret) else: return "" for line in tmp: f = line[:1] if f == 'N': # %N - Name name = ref and (info.getName(ref) or 'N/A') or (info.getName() or 'N/A') postfix = '' if self.ref: postfix = " (alter)" name += postfix ret += name.replace('\xc2\x86', '').replace('\xc2\x87', '') elif f == 'n': # %n - Number try: service = self.source.serviceref num = service and service.getChannelNum() or None except: num = None if num: ret += str(num) else: num, bouq = self.getServiceNumber( ref or eServiceReference( info.getInfoString( iServiceInformation.sServiceref))) ret += num and str(num) or '' elif f == 'B': # %B - Bouquet num, bouq = self.getServiceNumber(ref or eServiceReference( info.getInfoString(iServiceInformation.sServiceref))) ret += bouq elif f == 'P': # %P - Provider tmpprov = tmpref = refpath = '' if self.isStream: if self.refstr: tmpprov = self.getIPTVProvider(self.refstr) tmpprov = self.getIPTVProvider(refstr) else: if self.ref: tmpprov = self.getProviderName(self.ref) if ref: tmpprov = self.getProviderName(ref) else: tmpprov = info.getInfoString( iServiceInformation.sProvider) or '' if '' is tmpprov or 'Unknown' in tmpprov: if self.refstr: tmpref = self.refstr else: tmpref = refstr for i in range(len(searchpath)): if os.path.isfile('%s%s' % (searchpath[i], refname)): refpath = '%s%s' % (searchpath[i], refname) if not '' is refpath: tmpref = ':'.join(tmpref.split(':')[:10]) reffile = open(refpath, 'r').read() if not reffile.endswith('\r\n\r\n'): reffile = '%s\r\n' % reffile for line in reffile.splitlines(True): if line.startswith(tmpref): tmpprov = line.strip('\r').strip( '\n').split(':')[-1].strip() ret += tmpprov elif f == 'R': # %R - Reference if self.refstr: ret += self.refstr else: ret += refstr elif f == 'S': # %S - Satellite if self.isStream: ret += _("Stream:") + " " + refstr.replace( "%3a", ":").rsplit( "://", 1)[1].split("/")[0].split(":")[0] else: if self.ref: ret += self.getSatelliteName(self.ref) else: ret += self.getSatelliteName( ref or eServiceReference( info.getInfoString( iServiceInformation.sServiceref)) ).replace( "Europe, Middle East, Africa: DVB-T/T2 Frequencies", "EMEA").split(" ")[0].strip() elif f == 'A': # %A - AllRef tmpref = self.getReferenceType(refstr, ref) if 'Bouquet' in tmpref or 'Satellit' in tmpref or 'Provider' in tmpref: ret += ' ' elif '%3a' in tmpref: ret += ':'.join(refstr.split(':')[:10]) else: ret += tmpref elif f in 'TtsFfiOMpYrokclhmgbe': if self.ref: ret += self.getTransponderInfo(self.info, self.ref, f) else: ret += self.getTransponderInfo(info, ref, f) ret += line[1:] return '%s' % ' '.join((ret.replace('N/A', '').strip()).split()) text = property(getText) def neededChange(self): if self.what: Converter.changed(self, self.what) self.what = None def forceChanged(self, what): if what == True: self.refstr = self.isStream = self.ref = self.info = self.tpdata = None Converter.changed(self, (self.CHANGED_ALL, )) self.what = None def changed(self, what): if what[0] != self.CHANGED_SPECIFIC or what[1] in ( iPlayableService.evStart, ): self.refstr = self.isStream = self.ref = self.info = self.tpdata = None if self.type in (self.NUMBER,self.BOUQUET) or \ (self.type == self.FORMAT and ('%n' in self.sfmt or '%B' in self.sfmt)): self.what = what self.Timer.start(200, True) else: Converter.changed(self, what)
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 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 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 __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['nagra_emm'].hide() self['nagra_ecm'].hide() self['seca_emm'].hide() self['seca_ecm'].hide() self['td_emm'].hide() self['td_ecm'].hide() self['via_emm'].hide() self['via_ecm'].hide() self['biss_emm'].hide() self['biss_ecm'].hide() self['bul_emm'].hide() self['bul_ecm'].hide() self['conax_emm'].hide() self['conax_ecm'].hide() self['cw_emm'].hide() self['cw_ecm'].hide() self['dre_emm'].hide() self['dre_ecm'].hide() self['nds_emm'].hide() self['nds_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() return
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 getText(self): service = self.source.service info = service and service.info() if not info: return '' if self.type == self.XRES: return self._getVideoWidthStr(info) if self.type == self.YRES: return self._getVideoHeightStr(info) if self.type == self.APID: return self.getServiceInfoString(info, iServiceInformation.sAudioPID) if self.type == self.VPID: return self.getServiceInfoString(info, iServiceInformation.sVideoPID) if self.type == self.PCRPID: return self.getServiceInfoString(info, iServiceInformation.sPCRPID) if self.type == self.PMTPID: return self.getServiceInfoString(info, iServiceInformation.sPMTPID) if self.type == self.TXTPID: return self.getServiceInfoString(info, iServiceInformation.sTXTPID) if self.type == self.TSID: return self.getServiceInfoString(info, iServiceInformation.sTSID) if self.type == self.ONID: return self.getServiceInfoString(info, iServiceInformation.sONID) if self.type == self.SID: return self.getServiceInfoHexString(info, iServiceInformation.sSID) if self.type == self.FRAMERATE: video_rate = None 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() if not video_rate: try: video_rate = int( self.getServiceInfoString( info, iServiceInformation.sFrameRate)) except: return 'N/A fps' return (video_rate, lambda x: '%d fps' % ((x + 500) / 1000)) if self.type == self.PROGRESSIVE: return self._getProgressiveStr(info) if self.type == self.TRANSFERBPS: return self.getServiceInfoString(info, iServiceInformation.sTransferBPS, lambda x: '%d kB/s' % (x / 1024)) if self.type == self.HAS_HBBTV: return info.getInfoString(iServiceInformation.sHBBTVUrl) if self.type == self.VIDEO_PARAMS: yres = info.getInfo(iServiceInformation.sVideoHeight) frame_rate = info.getInfo(iServiceInformation.sFrameRate) progressive = info.getInfo(iServiceInformation.sProgressive) print 'yres', yres, 'frame_rate', frame_rate, 'progressive', progressive if not progressive: frame_rate *= 2 frame_rate = (frame_rate + 500) / 1000 return '%d%s%d' % (yres, 'p' if progressive else 'i', frame_rate) if 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 if self.type == self.VIDEO_INFO: if self._isHDMIIn(info): return '' 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 __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 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 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 getFEData(self, frontendDataOrg): if frontendDataOrg and len(frontendDataOrg): frontendData = ConvertToHumanReadable(frontendDataOrg) if frontendDataOrg["tuner_type"] == "DVB-S": data = ((_("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_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 nimmanager.isSupportMultistream( int(frontendData["tuner_number"])): data += ((_("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)) return data 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_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"), chr(ord('A') + int(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 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 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: video_rate = None 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() if not video_rate: try: video_rate = int( self.getServiceInfoString( info, iServiceInformation.sFrameRate)) except: return "N/A fps" return video_rate, 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 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 H.264", "MPEG1", "MPEG4-VC", "VC1", "VC1-SM", "HEVC H.265", "")[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: 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 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 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 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 = "" try: searchIDs = (info.getInfoObject(iServiceInformation.sCAIDs)) except: searchIDs = 0 pass 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 "" 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 __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': 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)) 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)) if 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 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 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)