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", "AVC", "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 += 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 updateStatus(self):
if self.frontend:
self.frontendStatus.clear()
self.frontend.getFrontendStatus(self.frontendStatus)
self["snr_db"].update()
self["snr_percentage"].update()
self["ber_value"].update()
self["snr_bar"].update()
self["ber_bar"].update()
self["lock_state"].update()
tpdata = self.tuner.getTransponderData()
if tpdata:
transponderdata = ConvertToHumanReadable(tpdata, "DVB-S")
self["frequency_value"].setText(
str(transponderdata.get("frequency")))
self["symbolrate_value"].setText(
str(transponderdata.get("symbol_rate")))
self["fec_value"].setText(str(transponderdata.get("fec_inner")))
if self.frontendStatus.get(
"tuner_locked",
0) == 1 and self.isMoving and self.stopOnLock:
self.diseqccommand("stop")
self.isMoving = False
self.stopOnLock = False
self.updateColors(self.getCurrentConfigPath())
self.statusTimer.start(50, True)
def getFEData(self, frontendDataOrg):
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
return [(label, frontendData[data], format_type)
for (label, data, format_type) in ServiceInfo.infoLabels
if data in frontendData]
return []
def getFEData(self, frontendDataOrg):
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
if self.transponder_info:
tuner = (_("Type"), frontendData["tuner_type"], TYPE_TEXT)
else:
tuner = (_("NIM & Type"), chr(ord('A') + frontendData["tuner_number"]) + " - " + frontendData["tuner_type"], TYPE_TEXT)
if frontendDataOrg["tuner_type"] == "DVB-S":
return (tuner,
(_("System & Modulation"), frontendData["system"] + " " + frontendData["modulation"], TYPE_TEXT),
(_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC),
(_("Frequency & Polarization"), "%s MHz" % (frontendData["frequency"] / 1000) + " - " + frontendData["polarization"], TYPE_TEXT),
(_("Symbol rate & FEC"), "%s KSymb/s" % (frontendData["symbol_rate"] / 1000) + " - " + frontendData["fec_inner"], TYPE_TEXT),
(_("Inversion, Pilot & Roll-off"), frontendData["inversion"] + " - " + str(frontendData.get("pilot", None)) + " - " + str(frontendData.get("rolloff", None)), TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "DVB-C":
return (tuner,
(_("Modulation"), frontendData["modulation"], TYPE_TEXT),
(_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT),
(_("Symbol rate & FEC"), "%s KSymb/s" % (frontendData["symbol_rate"] / 1000) + " - " + frontendData["fec_inner"], TYPE_TEXT),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "DVB-T":
return (tuner,
(_("Frequency & Channel"), "%.3f MHz" % ((frontendData["frequency"] / 1000) / 1000.0) + " - Ch. " + getChannelNumber(frontendData["frequency"], frontendData["tuner_number"]), TYPE_TEXT),
(_("Inversion & Bandwidth"), frontendData["inversion"] + " - " + str(frontendData["bandwidth"]), TYPE_TEXT),
(_("Code R. LP-HP & Guard Int."), frontendData["code_rate_lp"] + " - " + frontendData["code_rate_hp"] + " - " + frontendData["guard_interval"], TYPE_TEXT),
(_("Constellation & FFT mode"), frontendData["constellation"] + " - " + frontendData["transmission_mode"], TYPE_TEXT),
(_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "ATSC":
return (tuner,
(_("System & Modulation"), frontendData["system"] + " " + frontendData["modulation"], TYPE_TEXT),
(_("Frequency"), frontendData["frequency"] / 1000, TYPE_VALUE_FREQ_FLOAT),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT))
return []
def getFEData(self, frontendDataOrg):
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
if frontendDataOrg["tuner_type"] == "DVB-S":
return ((_("NIM"),
chr(ord('A') + frontendData["tuner_number"]),
TYPE_TEXT), (_("Type"), frontendData["tuner_type"],
TYPE_TEXT),
(_("System"), frontendData["system"],
TYPE_TEXT), (_("Modulation"),
frontendData["modulation"], TYPE_TEXT),
(_("Orbital position"),
frontendData["orbital_position"], TYPE_VALUE_DEC),
(_("Frequency"), frontendData["frequency"],
TYPE_VALUE_DEC), (_("Symbol rate"),
frontendData["symbol_rate"],
TYPE_VALUE_DEC),
(_("Polarization"), frontendData["polarization"],
TYPE_TEXT), (_("Inversion"),
frontendData["inversion"], TYPE_TEXT),
(_("FEC"), frontendData["fec_inner"], TYPE_TEXT),
(_("Pilot"), frontendData.get("pilot", None),
TYPE_TEXT), (_("Roll-off"),
frontendData.get("rolloff",
None), TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "DVB-C":
return ((_("NIM"),
chr(ord('A') + frontendData["tuner_number"]),
TYPE_TEXT), (_("Type"), frontendData["tuner_type"],
TYPE_TEXT), (_("Modulation"),
frontendData["modulation"],
TYPE_TEXT),
(_("Frequency"), frontendData["frequency"],
TYPE_VALUE_DEC), (_("Symbol rate"),
frontendData["symbol_rate"],
TYPE_VALUE_DEC),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT),
(_("FEC"), frontendData["fec_inner"], TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "DVB-T":
return ((_("NIM"),
chr(ord('A') + frontendData["tuner_number"]),
TYPE_TEXT), (_("Type"), frontendData["tuner_type"],
TYPE_TEXT), (_("Frequency"),
frontendData["frequency"],
TYPE_VALUE_DEC),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT),
(_("Bandwidth"), frontendData["bandwidth"],
TYPE_VALUE_DEC),
(_("Code rate LP"), frontendData["code_rate_lp"],
TYPE_TEXT), (_("Code rate HP"),
frontendData["code_rate_hp"], TYPE_TEXT),
(_("Constellation"), frontendData["constellation"],
TYPE_TEXT), (_("Transmission mode"),
frontendData["transmission_mode"],
TYPE_TEXT),
(_("Guard interval"), frontendData["guard_interval"],
TYPE_TEXT), (_("Hierarchy info"),
frontendData["hierarchy_information"],
TYPE_TEXT))
return []
def getText(self):
service = self.source.service
info = service and service.info()
if not info:
return ""
if self.type == self.XRES:
return self.getServiceInfoString(info, iServiceInformation.sVideoWidth)
elif self.type == self.YRES:
return self.getServiceInfoString(info, iServiceInformation.sVideoHeight)
elif self.type == self.APID:
return self.getServiceInfoString(info, iServiceInformation.sAudioPID)
elif self.type == self.VPID:
return self.getServiceInfoString(info, iServiceInformation.sVideoPID)
elif self.type == self.PCRPID:
return self.getServiceInfoString(info, iServiceInformation.sPCRPID)
elif self.type == self.PMTPID:
return self.getServiceInfoString(info, iServiceInformation.sPMTPID)
elif self.type == self.TXTPID:
return self.getServiceInfoString(info, iServiceInformation.sTXTPID)
elif self.type == self.TSID:
return self.getServiceInfoString(info, iServiceInformation.sTSID)
elif self.type == self.ONID:
return self.getServiceInfoString(info, iServiceInformation.sONID)
elif self.type == self.SID:
return self.getServiceInfoString(info, iServiceInformation.sSID)
elif self.type == self.FRAMERATE:
return self.getServiceInfoString(info, iServiceInformation.sFrameRate, lambda x: "%d fps" % ((x+500)/1000))
elif self.type == self.TRANSFERBPS:
return self.getServiceInfoString(info, iServiceInformation.sTransferBPS, lambda x: "%d kB/s" % (x/1024))
elif self.type == self.FREQ_INFO:
feinfo = service.frontendInfo()
if feinfo is None:
return ""
feraw = feinfo.getAll(False)
if feraw is None:
return ""
fedata = ConvertToHumanReadable(feraw)
if fedata is None:
return ""
frequency = fedata.get("frequency")
if frequency:
frequency = str(frequency / 1000)
sr_txt = "Sr:"
polarization = fedata.get("polarization_abbreviation")
if polarization is None:
polarization = ""
symbolrate = str(int(fedata.get("symbol_rate", 0) / 1000))
if symbolrate == "0":
sr_txt = ""
symbolrate = ""
fec = fedata.get("fec_inner")
if fec is None:
fec = ""
out = "Freq: %s %s %s %s %s" % (frequency, polarization, sr_txt, symbolrate, fec)
return out
return ""
def getText(self): service = self.source.service info = service and service.info() if not info: return '' if tp: tpinfo = ConvertToHumanReadable(tp) if not tp: tp = info.getInfoObject(iServiceInformation.sTransponderData) tpinfo = ConvertToHumanReadable(tp) if self.type == self.DUMMY: refstr = str(self.reference()) if '%3a' in refstrr: return self.streamurl() else: if self.type == self.STREAMURL: return str(self.streamurl()) if self.type == self.STREAMTYPE: return str(self.streamtype())
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"),
"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 getText(self):
service = self.source.service
if isinstance(service, iPlayableServicePtr):
info = service and service.info()
ref = None
else: # reference
info = service and self.source.info
ref = service
if not info:
return ""
if ref:
nref = resolveAlternate(ref)
if nref:
ref = nref
info = eServiceCenter.getInstance().info(ref)
transponderraw = info.getInfoObject(
ref, iServiceInformation.sTransponderData)
ref = ref.toString().replace("%3a", ":")
else:
transponderraw = info.getInfoObject(
iServiceInformation.sTransponderData)
ref = info.getInfoString(iServiceInformation.sServiceref)
if "InRootOnly" in self.type and not self.rootBouquet():
return ""
if "NoRoot" in self.type and self.rootBouquet():
return ""
if transponderraw:
transponderdata = ConvertToHumanReadable(transponderraw)
# retreive onid and tsid from service reference
[onid, tsid] = [int(x, 16) for x in ref.split(':')[4:6]]
if not transponderdata["system"]:
transponderdata["system"] = transponderraw.get(
"tuner_type", "None")
try:
if "DVB-T" in transponderdata["system"]:
return "%s %s-%s %s %d MHz %s" % (
transponderdata["system"], tsid, onid,
transponderdata["channel"],
transponderdata["frequency"] / 1000000 + 0.5,
transponderdata["bandwidth"])
elif "DVB-C" in transponderdata["system"]:
return "%s %s-%s %d MHz %d %s %s" % (transponderdata["system"], tsid, onid, transponderdata["frequency"]/1000 + 0.5, transponderdata["symbol_rate"]/1000 + 0.5, transponderdata["fec_inner"], \
transponderdata["modulation"])
elif "ATSC" in transponderdata["system"]:
return "%s %s-%s %d MHz %s" % (
transponderdata["system"], tsid, onid,
transponderdata["frequency"] / 1000 + 0.5,
transponderdata["modulation"])
return "%s %s-%s %d %s %d %s %s %s" % (transponderdata["system"], tsid, onid, transponderdata["frequency"]/1000 + 0.5, transponderdata["polarization_abbreviation"], transponderdata["symbol_rate"]/1000 + 0.5, \
transponderdata["fec_inner"], transponderdata["modulation"], transponderdata["detailed_satpos" in self.type and "orbital_position" or "orb_pos"])
except:
return ""
if "://" in ref:
return _("Stream") + " " + ref.rsplit("://", 1)[1].split("/")[0]
return ""
def GetCurrentFeId(self):
feId = -1
sref = self.session.nav.getCurrentService()
if sref is not None:
feInfo = sref.frontendInfo()
feDatas = feInfo and feInfo.getAll(False)
if feDatas and len(feDatas):
feData = ConvertToHumanReadable(feDatas)
feId = int(feData["tuner_number"])
return feId
def getText(self):
service = self.source.service
if isinstance(service, iPlayableServicePtr):
info = service and service.info()
ref = None
else: # reference
info = service and self.source.info
ref = service
if not info:
return ""
if self.type == self.NAME:
name = ref and info.getName(ref)
if name is None:
name = info.getName()
return name.replace('\xc2\x86', '').replace('\xc2\x87', '')
elif self.type == self.PROVIDER:
return info.getInfoString(iServiceInformation.sProvider)
elif self.type == self.REFERENCE or self.type == self.EDITREFERENCE and hasattr(
self.source, "editmode") and self.source.editmode:
if not ref:
return info.getInfoString(iServiceInformation.sServiceref)
nref = resolveAlternate(ref)
if nref:
ref = nref
return ref.toString()
elif self.type == self.TRANSPONDER:
if ref:
nref = resolveAlternate(ref)
if nref:
ref = nref
info = eServiceCenter.getInstance().info(ref)
transponder_info = info.getInfoObject(
ref, 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 "DVB-T" in self.system():
return self.dvb_t()
elif "DVB-C" in self.system():
return self.dvb_c()
return self.dvb_s()
if ref:
result = ref.toString()
else:
result = info.getInfoString(iServiceInformation.sServiceref)
if "%3a//" in result:
return result.rsplit("%3a//", 1)[1].split("/")[0]
return ""
def getFEData(self, frontendDataOrg):
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
if frontendDataOrg["tuner_type"] == "DVB-S":
if frontendData["frequency"] > 11699999 :
band = "High"
else:
band = "Low"
return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("System"), frontendData["system"], TYPE_TEXT),
(_("Modulation"), frontendData["modulation"], TYPE_TEXT),
(_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC),
(_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ),
(_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_BITRATE),
(_("Polarization"), frontendData["polarization"], TYPE_TEXT),
(_("Band"), band, TYPE_TEXT),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT),
(_("FEC"), frontendData["fec_inner"], TYPE_TEXT),
(_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT),
(_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT),
(_("Input Stream ID"), frontendData.get("is_id", 0), TYPE_VALUE_DEC),
(_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT),
(_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC))
elif frontendDataOrg["tuner_type"] == "DVB-C":
return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("Modulation"), frontendData["modulation"], TYPE_TEXT),
(_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT),
(_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_BITRATE),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT),
(_("FEC"), frontendData["fec_inner"], TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "DVB-T":
return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT),
(_("Channel"), getChannelNumber(frontendData["frequency"], frontendData["tuner_number"]), TYPE_VALUE_DEC),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT),
(_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC),
(_("Code rate LP"), frontendData["code_rate_lp"], TYPE_TEXT),
(_("Code rate HP"), frontendData["code_rate_hp"], TYPE_TEXT),
(_("Constellation"), frontendData["constellation"], TYPE_TEXT),
(_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT),
(_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT),
(_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "ATSC":
return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("System"), frontendData["system"], TYPE_TEXT),
(_("Modulation"), frontendData["modulation"], TYPE_TEXT),
(_("Frequency"), frontendData["frequency"], TYPE_VALUE_FREQ_FLOAT),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT))
return [ ]
def getFEData(self, frontendDataOrg):
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
if frontendDataOrg["tuner_type"] == "DVB-S":
t2mi = lambda x: None if x == -1 else str(x)
return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("System"), frontendData["system"], TYPE_TEXT),
(_("Modulation"), frontendData["modulation"], TYPE_TEXT),
(_("Orbital position"), frontendData["orbital_position"], TYPE_VALUE_DEC),
(_("Frequency"), frontendData.get("frequency", 0), TYPE_VALUE_FREQ_FLOAT),
(_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC),
(_("Polarization"), frontendData["polarization"], TYPE_TEXT),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT),
(_("FEC"), frontendData["fec_inner"], TYPE_TEXT),
(_("Pilot"), frontendData.get("pilot", None), TYPE_TEXT),
(_("Roll-off"), frontendData.get("rolloff", None), TYPE_TEXT),
(_("Input Stream ID"), frontendData.get("is_id", 0), TYPE_VALUE_DEC),
(_("PLS Mode"), frontendData.get("pls_mode", None), TYPE_TEXT),
(_("PLS Code"), frontendData.get("pls_code", 0), TYPE_VALUE_DEC),
(_("T2MI PLP ID"), t2mi(frontendData.get("t2mi_plp_id", -1)), TYPE_TEXT),
(_("T2MI PID"), None if frontendData.get("t2mi_plp_id", -1) == -1 else str(frontendData.get("t2mi_pid", eDVBFrontendParametersSatellite.T2MI_Default_Pid)), TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "DVB-C":
return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("Modulation"), frontendData["modulation"], TYPE_TEXT),
(_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC),
(_("Symbol rate"), frontendData["symbol_rate"], TYPE_VALUE_DEC),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT),
(_("FEC"), frontendData["fec_inner"], TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "DVB-T":
channel = channelnumbers.getChannelNumber(frontendDataOrg["frequency"], frontendDataOrg["tuner_number"]) if channelnumbers.supportedChannels(frontendDataOrg["tuner_number"]) else None
return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC),
(_("Channel"), channel, TYPE_VALUE_DEC),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT),
(_("Bandwidth"), frontendData["bandwidth"], TYPE_VALUE_DEC),
(_("Code rate LP"), frontendData["code_rate_lp"], TYPE_TEXT),
(_("Code rate HP"), frontendData["code_rate_hp"], TYPE_TEXT),
(_("Constellation"), frontendData["constellation"], TYPE_TEXT),
(_("Transmission mode"), frontendData["transmission_mode"], TYPE_TEXT),
(_("Guard interval"), frontendData["guard_interval"], TYPE_TEXT),
(_("Hierarchy info"), frontendData["hierarchy_information"], TYPE_TEXT))
elif frontendDataOrg["tuner_type"] == "ATSC":
return ((_("NIM"), chr(ord('A') + frontendData["tuner_number"]), TYPE_TEXT),
(_("Type"), frontendData["tuner_type"], TYPE_TEXT),
(_("System"), frontendData["system"], TYPE_TEXT),
(_("Modulation"), frontendData["modulation"], TYPE_TEXT),
(_("Frequency"), frontendData["frequency"], TYPE_VALUE_DEC),
(_("Inversion"), frontendData["inversion"], TYPE_TEXT))
return []
def getFEData(frontendDataOrg):
from Tools.Transponder import ConvertToHumanReadable
try:
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
if frontendDataOrg['tuner_type'] == 'DVB-S':
return str(FormatWithCommas(int(frontendData['frequency']) / 1000)) + ' MHz ' + str(FormatWithCommas(int(frontendData['symbol_rate']) / 1000)) + ' ' + str(frontendData['polarization'][0:1]) + ' ' + str(frontendData['fec_inner'])
if frontendDataOrg['tuner_type'] == 'DVB-C':
return str(frontendData['frequency']) + ' ' + str(frontendData['symbol_rate'])
if frontendDataOrg['tuner_type'] == 'DVB-T':
return str(FormatWithCommas(int(frontendData['frequency']) / 1000)) + ' Khz (UHF ' + str(devchfr(frontendData['frequency'])) + ') ' + str(frontendData['bandwidth'])
return ' '
except:
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 getText(self):
service = self.source.service
if isinstance(service, iPlayableServicePtr):
info = service and service.info()
ref = None
else: # reference
info = service and self.source.info
ref = service
if not info:
return ""
if ref:
nref = resolveAlternate(ref)
if nref:
ref = nref
info = eServiceCenter.getInstance().info(ref)
transponderraw = info.getInfoObject(
ref, iServiceInformation.sTransponderData)
else:
transponderraw = info.getInfoObject(
iServiceInformation.sTransponderData)
if "InRootOnly" in self.type and not self.rootBouquet():
return ""
if "NoRoot" in self.type and self.rootBouquet():
return ""
if transponderraw:
transponderdata = ConvertToHumanReadable(transponderraw)
if not transponderdata:
return ""
if "DVB-T" in transponderdata["system"]:
return "%s %s %d MHz %s" % (
"DVB-T", transponderdata["channel"],
transponderdata["frequency"] / 1000000 + 0.5,
transponderdata["bandwidth"])
elif "DVB-C" in transponderdata["system"]:
return "%s %d MHz %d %s %s" % ("DVB-C", transponderdata["frequency"]/1000 + 0.5, transponderdata["symbol_rate"]/1000 + 0.5, transponderdata["fec_inner"], \
transponderdata["modulation"])
return "%s %d %s %d %s %s %s" % (transponderdata["system"], transponderdata["frequency"]/1000 + 0.5, transponderdata["polarization_abbreviation"], transponderdata["symbol_rate"]/1000 + 0.5, \
transponderdata["fec_inner"], transponderdata["modulation"], transponderdata["detailed_satpos" in self.type and "orbital_position" or "orb_pos"])
if ref:
result = ref.toString()
else:
result = info.getInfoString(iServiceInformation.sServiceref)
if "%3a//" in result:
return _("Stream") + " " + result.rsplit("%3a//",
1)[1].split("/")[0]
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 tuningChangedTo(self, tp):
def setLowRateAdapterCount(symbolrate):
# change the measurement time and update interval in case of low symbol rate,
# since more time is needed for the front end in that case.
# It is an heuristic determination without any pretence. For symbol rates
# of 5000 the interval is multiplied by 3 until 15000 which is seen
# as a high symbol rate. Linear interpolation elsewhere.
return max(int(round((3 - 1) * (symbolrate - 15000) / (5000 - 15000) + 1)), 1)
self.symbolrate = tp[1]
self.polarisation = tp[2]
self.MAX_LOW_RATE_ADAPTER_COUNT = setLowRateAdapterCount(self.symbolrate)
transponderdata = ConvertToHumanReadable(self.tuner.getTransponderData(), "DVB-S")
self["frequency_value"].setText(str(transponderdata.get("frequency")))
self["symbolrate_value"].setText(str(transponderdata.get("symbol_rate")))
self["fec_value"].setText(str(transponderdata.get("fec_inner")))
self["polarisation"].setText(str(transponderdata.get("polarization")))
def getFEData(self, frontendDataOrg):
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
if self.transponder_info:
tuner = (_("Type"), frontendData["tuner_type"], TYPE_TEXT)
else:
tuner = (_("NIM & Type"), chr(ord('A') + frontendData["tuner_number"]) + " - " + frontendData["tuner_type"], TYPE_TEXT)
if frontendDataOrg["tuner_type"] == "DVB-S":
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 getTunerInfo(self, service):
tunerinfo = ""
info = (service and service.info())
Ret_Text = ""
xresol = info.getInfo(iServiceInformation.sVideoWidth)
yresol = info.getInfo(iServiceInformation.sVideoHeight)
if info:
try:
Ret_Text = str(xresol) + "x" + str(yresol)
transponderData = ConvertToHumanReadable(info.getInfoObject(iServiceInformation.sTransponderData))
tunerType = transponderData.get("tuner_type")
symbolRate = transponderData.get("symbol_rate", "")
frequency = transponderData.get("frequency", "")
polarization = transponderData.get("polarization", "").replace(_("Horizontal"), "H").replace(_("Vertical"), "V").replace(_("Circular left"), "CL").replace(_("Circular right"), "CR")
fec = transponderData.get("fec_inner", "")
if (tunerType == _("Satellite")):
frequency = (str((int(frequency) / 1000)) + " MHz")
symbolRate = (str((int(symbolRate) / 1000)))
tunerinfo = (((((((Ret_Text + " ") + frequency + " ") + polarization) + " ") + fec) + " ") + symbolRate)
return tunerinfo
except:
return ""
def getFEData(self, frontendDataOrg):
if frontendDataOrg and len(frontendDataOrg):
frontendData = ConvertToHumanReadable(frontendDataOrg)
if self.transponder_info:
tuner = (_("Type"), frontendData["tuner_type"], TYPE_TEXT)
else:
tuner = (_("NIM & Type"), chr(ord('A') + frontendData["tuner_number"]) + " - " + frontendData["tuner_type"], TYPE_TEXT)
if frontendDataOrg["tuner_type"] == "DVB-S":
if frontendData.get("is_id", -1) > -1: # multistream
return (tuner,
(_("System & Modulation"), "%s %s" % (frontendData["system"], frontendData["modulation"]), TYPE_TEXT),
(_("Orbital position"), "%s" % frontendData["orbital_position"], TYPE_TEXT),
(_("Frequency & Polarization"), "%s - %s" % (frontendData.get("frequency", 0), frontendData["polarization"]), TYPE_TEXT),
(_("Symbol rate & FEC"), "%s - %s" % (frontendData.get("symbol_rate", 0), frontendData["fec_inner"]), TYPE_TEXT),
(_("Input Stream ID"), "%s" % (frontendData.get("is_id", -1)), TYPE_TEXT),
(_("PLS Mode & PLS Code"), "%s - %s" % (frontendData["pls_mode"], frontendData["pls_code"]), TYPE_TEXT),
(_("Inversion, Pilot & Roll-off"), "%s - %s - %s" % (frontendData["inversion"], frontendData.get("pilot", None), str(frontendData.get("rolloff", None))), TYPE_TEXT))
else: # not multistream
return (tuner,
(_("System & Modulation"), "%s %s" % (frontendData["system"], frontendData["modulation"]), TYPE_TEXT),
(_("Orbital position"), "%s" % frontendData["orbital_position"], TYPE_TEXT),
(_("Frequency & Polarization"), "%s - %s" % (frontendData.get("frequency", 0), frontendData["polarization"]), TYPE_TEXT),
(_("Symbol rate & FEC"), "%s - %s" % (frontendData.get("symbol_rate", 0), frontendData["fec_inner"]), TYPE_TEXT),
(_("Inversion, Pilot & Roll-off"), "%s - %s - %s" % (frontendData["inversion"], frontendData.get("pilot", None), str(frontendData.get("rolloff", None))), TYPE_TEXT))
def 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.getValue()) > 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.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoBar(info)
else:
return ""
if self.type == "CryptoSeca":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoSeca(info)
else:
return ""
if self.type == "CryptoVia":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoVia(info)
else:
return ""
if self.type == "CryptoIrdeto":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoIrdeto(info)
else:
return ""
if self.type == "CryptoNDS":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoNDS(info)
else:
return ""
if self.type == "CryptoConax":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoConax(info)
else:
return ""
if self.type == "CryptoCryptoW":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoCryptoW(info)
else:
return ""
if self.type == "CryptoBeta":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoBeta(info)
else:
return ""
if self.type == "CryptoNagra":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoNagra(info)
else:
return ""
if self.type == "CryptoBiss":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoBiss(info)
else:
return ""
if self.type == "CryptoDre":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoDre(info)
else:
return ""
if self.type == "CryptoSpecial":
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoSpecial(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(True)
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 int(config.usage.show_cryptoinfo.getValue()) > 0:
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 == "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 == "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
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.getValue()) > 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.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoBar(info)
else:
return ''
if self.type == 'CryptoSeca':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoSeca(info)
else:
return ''
if self.type == 'CryptoVia':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoVia(info)
else:
return ''
if self.type == 'CryptoIrdeto':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoIrdeto(info)
else:
return ''
if self.type == 'CryptoNDS':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoNDS(info)
else:
return ''
if self.type == 'CryptoConax':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoConax(info)
else:
return ''
if self.type == 'CryptoCryptoW':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoCryptoW(info)
else:
return ''
if self.type == 'CryptoBeta':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoBeta(info)
else:
return ''
if self.type == 'CryptoNagra':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoNagra(info)
else:
return ''
if self.type == 'CryptoBiss':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoBiss(info)
else:
return ''
if self.type == 'CryptoDre':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoDre(info)
else:
return ''
if self.type == 'CryptoSpecial':
if int(config.usage.show_cryptoinfo.getValue()) > 0:
self.getCryptoInfo(info)
return self.createCryptoSpecial(info)
else:
return ''
if self.type == 'ResolutionString':
return self.createResolution(info)
elif self.type == 'VideoCodec':
return self.createVideoCodec(info)
if self.updateFEdata:
feinfo = service.frontendInfo()
if feinfo:
self.feraw = feinfo.getAll(True)
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 int(config.usage.show_cryptoinfo.getValue()) > 0:
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(fedata)) + addspace(
self.createPolarization(fedata)) + addspace(
self.createSymbolRate(fedata)) + addspace(
self.createFEC(fedata)) + addspace(
self.createModulation(fedata)) + addspace(
self.createOrbPos(feraw)) + addspace(
self.createVideoCodec(info)
) + self.createResolution(info)
elif self.type == 'TransponderInfo2line':
return addspace(self.createProviderName(info)) + addspace(
self.createTunerSystem(fedata)) + addspace(
self.createTransponderName(feraw)
) + '\n' + self.createFrequency(
fedata) + addspace(' MHz') + addspace(
self.createPolarization(fedata)) + addspace(
self.createSymbolRate(fedata)
) + self.createModulation(fedata) + '-' + addspace(
self.createFEC(fedata))
elif self.type == 'TransponderInfo':
return self.createTransponderInfo(fedata, feraw)
elif self.type == 'TransponderFrequency':
return self.createFrequency(fedata)
elif self.type == 'TransponderSymbolRate':
return self.createSymbolRate(fedata)
elif self.type == 'TransponderPolarization':
return self.createPolarization(fedata)
elif self.type == 'TransponderFEC':
return self.createFEC(fedata)
elif self.type == 'TransponderModulation':
return self.createModulation(fedata)
elif self.type == 'OrbitalPosition':
return self.createOrbPos(feraw)
elif self.type == 'TunerType':
return self.createTunerType(feraw)
elif self.type == 'TunerSystem':
return self.createTunerSystem(fedata)
elif self.type == 'OrbitalPositionOrTunerSystem':
return self.createOrbPosOrTunerSystem(fedata, feraw)
elif self.type == 'PIDInfo':
return self.createPIDInfo(info)
else:
return _('invalid type')
def frontendStateChanged(self):
state = []
state = self.frontend.getState()
# print "State=", state[1]
if state[1] > 1:
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"]
# print "SR before round", sr
if sr < 0:
print "WARNING blind SR is < 0... skip"
self.parm.frequency += self.parm.symbol_rate
else:
sr_rounded = round(float(sr * 2L) / 1000) * 1000
sr_rounded /= 2
# print "SR after round", sr_rounded
parm.symbol_rate = int(sr_rounded)
fstr += str(parm.symbol_rate / 1000)
parm.fec = d["fec_inner"]
fstr += " "
fstr += r["fec_inner"]
parm.inversion = d["inversion"]
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)
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:
self.parm.frequency += self.parm.symbol_rate
print "NEXT freq", self.parm.frequency
mhz_complete, mhz_done = self.stats()
seconds_done = int(time() - self.start_time)
if self.parm.frequency > self.range_list[
self.current_range][1]:
self.parm = self.setNextRange()
if self.parm is not None:
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm)
else:
tmpstr = _("%dMHz scanned") % mhz_complete
tmpstr += ', '
tmpstr += _("%d transponders found at %d:%02dmin") % (
len(self.tp_found), seconds_done / 60,
seconds_done % 60)
state["progress"].setText(tmpstr)
state.setFinished()
# self.frontend.getStateChangeSignal().remove(self.frontendStateChanged)
self.frontend = None
self.channel = None
return
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) / mhz_done
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(500, True)
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)
# iq - [
# if config.usage.show_cryptoinfo.value:
if config.usage.show_cryptoinfo.value != "off":
# ]
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)
# iq - [
# if config.usage.show_cryptoinfo.value:
if config.usage.show_cryptoinfo.value != "off":
# ]
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(fedata)) + addspace(self.createPolarization(fedata)) \
+ addspace(self.createSymbolRate(fedata)) + addspace(self.createFEC(fedata)) + addspace(self.createModulation(fedata)) + addspace(self.createOrbPos(feraw)) \
+ addspace(self.createVideoCodec(info)) + self.createResolution(info)
if self.type == "TransponderInfo":
return self.createTransponderInfo(fedata, feraw)
if self.type == "TransponderFrequency":
return self.createFrequency(fedata)
if self.type == "TransponderSymbolRate":
return self.createSymbolRate(fedata)
if self.type == "TransponderPolarization":
return self.createPolarization(fedata)
if self.type == "TransponderFEC":
return self.createFEC(fedata)
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 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"), ":".join(refstr.split(":")[:10]), TYPE_TEXT)]
if "%3a//" in refstr:
Labels.append((_("URL"), refstr.split(":")[10].replace("%3a", ":"), 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 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 = "%s %s %s %s %s %s" % (
self.system(tpinfo), self.modulation(tpinfo),
self.frequency(tp), self.polarization(tpinfo),
self.symbolrate(tp), 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 sp(satf) + self.multistream(
tpinfo) + self.t2mi_info(tpinfo)
else:
return satf
elif "DVB-C" in self.tunertype(tp):
return "%s Mhz %s SR: %s FEC: %s" % (
self.frequency(tp), self.modulation(tpinfo),
self.symbolrate(tp), self.fecinfo(tpinfo))
elif self.tunertype(tp) == "DVB-T":
terf = "%s (%s Mhz) %s %s" % (
self.channel(tpinfo), self.terrafreq(tp),
self.constellation(tpinfo), self.terrafec(tpinfo))
return terf
elif self.tunertype(tp) == "DVB-T2":
return sp(terf) + self.plpid(tpinfo)
elif "ATSC" in self.tunertype(tp):
return "%s (Mhz) %s" % (self.terrafreq(tp),
self.modulation(tpinfo))
return ""
elif self.type == self.ORBITAL:
refstr = str(self.reference())
if "%3a/" in refstr or ":/" in refstr:
return self.streamtype()
else:
if "DVB-S" in self.tunertype(tp):
return "%s (%s)" % (self.satname(tp), self.orbital(tp))
elif "DVB-C" in self.tunertype(
tp) or "DVB-T" in self.tunertype(
tp) or "ATSC" in self.tunertype(tp):
return self.system(tpinfo)
return ""
elif self.type == self.VIDEOCODEC:
return self.videocodec(info)
elif self.type == self.FPS:
return self.framerate(info)
elif self.type == self.VIDEOSIZE:
return self.videosize(info)
elif self.type == self.RESCODEC:
vidsize = self.videosize(info)
fps = self.framerate(info)
vidcodec = self.videocodec(info)
return "%s %s %s" % (vidsize, fps, vidcodec)
elif self.type == self.PIDINFO:
return self.pidstring(info)
elif self.type == self.PIDHEXINFO:
return self.pidhexstring(info)
elif self.type == self.STREAMURL:
return str(self.streamurl())
elif self.type == self.PIDHEXINFO:
return str(self.streamtype())
elif self.type == self.HDRINFO:
return self.hdr(info)
def getText(self):
service = self.source.service
if service is None:
return ""
info = service and service.info()
if not info:
return ""
if self.type == "ResolutionString":
return self.createResolutionString(info)
if self.type == "Resolution":
return self.createResolution(info)
if self.type == "VideoCodec":
return self.createVideoCodec(info)
if self.type == "AudioCodec":
return self.createAudioCodec(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 == "ServiceInfo":
return addspace(self.createProviderName(info)) + addspace(self.createTunerSystem(fedata)) + addspace(self.createFrequency(fedata)) + addspace(self.createPolarization(fedata))\
+ addspace(self.createSymbolRate(fedata)) + addspace(self.createFEC(fedata)) + addspace(self.createModulation(fedata)) + addspace(self.createOrbPos(feraw))\
+ addspace(self.createVideoCodec(info)) + self.createResolutionString(info)
if self.type == "TunerInfo":
return self.createTunerSystem(
fedata) + ", " + self.createFrequency(fedata) + " MHz"
if self.type == "SignalInfo":
return "SR " + self.createSymbolRate(
fedata) + ", FEC " + self.createFEC(
fedata) + ", " + self.createModulation(fedata)
if self.type == "VideoInfo":
return self.createVideoCodec(info) + ", " + self.createResolution(
info) + ", " + self.createFrameRate(info) + " fps"
if self.type == "TransponderInfo":
return self.createTransponderInfo(fedata, feraw)
if self.type == "TransponderFrequency":
return self.createFrequency(fedata)
if self.type == "TransponderSymbolRate":
return self.createSymbolRate(fedata)
if self.type == "TransponderPolarization":
return self.createPolarization(fedata)
if self.type == "TransponderFEC":
return self.createFEC(fedata)
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 == "Provider":
return self.createProviderName(info)
if self.type == "Caids":
return self.createCaids(info)
return _("invalid type")
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 == "Resolution":
return self.createResolution(info)
if self.type == "ResolutionString":
return addspace(
self.createResolution(info)) + self.createGamma(info)
if self.type == "VideoCodec":
return self.createVideoCodec(info)
if self.type == "Gamma":
return self.createGamma(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)
fedata = ConvertToHumanReadable(feraw)
else:
fedata = self.fedata
if self.type == "All":
self.getCryptoInfo(info)
if config.usage.show_cryptoinfo.value:
return addspace(self.createProviderName(info)) + self.createTransponderInfo(fedata, feraw, info) + "\n" \
+ addspace(self.createCryptoBar(info)) + addspace(self.createCryptoSpecial(info)) + "\n" \
+ addspace(self.createPIDInfo(info)) + addspace(self.createVideoCodec(info)) + addspace(self.createResolution(info)) + self.createGamma(info)
else:
return addspace(self.createProviderName(info)) + self.createTransponderInfo(fedata, feraw, info) + "\n" \
+ addspace(self.createCryptoBar(info)) + self.current_source + "\n" \
+ addspace(self.createCryptoSpecial(info)) + addspace(self.createVideoCodec(info)) + addspace(self.createResolution(info)) + self.createGamma(info)
if self.type == "PIDInfo":
return self.createPIDInfo(info)
if not feraw:
return ""
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)) + addspace(self.createResolution(info)) + self.createGamma(info)
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)
if self.type == "TransponderInfoMisPls":
return self.createMisPls(fedata)
return _("invalid type")
def getText(self):
service = self.source.service
info = service and service.info()
if not info:
return ""
if self.type == self.XRES:
return self._getVideoWidthStr(info)
elif self.type == self.YRES:
return self._getVideoHeightStr(info)
elif self.type == self.APID:
return self.getServiceInfoString(info,
iServiceInformation.sAudioPID)
elif self.type == self.VPID:
return self.getServiceInfoString(info,
iServiceInformation.sVideoPID)
elif self.type == self.PCRPID:
return self.getServiceInfoString(info, iServiceInformation.sPCRPID)
elif self.type == self.PMTPID:
return self.getServiceInfoString(info, iServiceInformation.sPMTPID)
elif self.type == self.TXTPID:
return self.getServiceInfoString(info, iServiceInformation.sTXTPID)
elif self.type == self.TSID:
return self.getServiceInfoString(info, iServiceInformation.sTSID)
elif self.type == self.ONID:
return self.getServiceInfoString(info, iServiceInformation.sONID)
elif self.type == self.SID:
return self.getServiceInfoString(info, iServiceInformation.sSID)
elif self.type == self.FRAMERATE:
video_rate = None
if path.exists("/proc/stb/vmpeg/0/framerate"):
f = open("/proc/stb/vmpeg/0/framerate", "r")
try:
video_rate = int(f.read())
except:
pass
f.close()
if not video_rate:
try:
video_rate = int(
self.getServiceInfoString(
info, iServiceInformation.sFrameRate))
except:
return "N/A fps"
return video_rate, lambda x: "%d fps" % ((x + 500) / 1000)
elif self.type == self.PROGRESSIVE:
return self._getProgressiveStr(info)
elif self.type == self.TRANSFERBPS:
return self.getServiceInfoString(info,
iServiceInformation.sTransferBPS,
lambda x: "%d kB/s" % (x / 1024))
elif self.type == self.HAS_HBBTV:
return info.getInfoString(iServiceInformation.sHBBTVUrl)
elif self.type == self.FREQ_INFO:
feinfo = service.frontendInfo()
if feinfo is None:
return ""
feraw = feinfo.getAll(False)
if feraw is None:
return ""
fedata = ConvertToHumanReadable(feraw)
if fedata is None:
return ""
frequency = fedata.get("frequency")
sr_txt = "Sr:"
polarization = fedata.get("polarization_abbreviation")
if polarization is None:
polarization = ""
symbolrate = str(int(fedata.get("symbol_rate", 0)))
if symbolrate == "0":
sr_txt = ""
symbolrate = ""
fec = fedata.get("fec_inner")
if fec is None:
fec = ""
out = "Freq: %s %s %s %s %s" % (frequency, polarization, sr_txt,
symbolrate, fec)
return out
elif self.type == self.VIDEO_INFO:
progressive = self._getProgressiveStr(info)
fieldrate = self._getFrameRate(info)
if fieldrate > 0:
if progressive == 'i':
fieldrate *= 2
fieldrate = "%dHz" % ((fieldrate + 500) / 1000, )
else:
fieldrate = ""
return "%sx%s%s %s" % (self._getVideoWidthStr(info),
self._getVideoHeightStr(info), progressive,
fieldrate)
return ""