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