def tune(self, transponder):
if self.frontend:
print "tuning to transponder with data", transponder
parm = eDVBFrontendParametersSatellite()
parm.frequency = transponder[0] * 1000
parm.symbol_rate = transponder[1] * 1000
parm.polarisation = transponder[2]
parm.fec = transponder[3]
parm.inversion = transponder[4]
parm.orbital_position = transponder[5]
parm.system = transponder[6]
parm.modulation = transponder[7]
parm.rolloff = transponder[8]
parm.pilot = transponder[9]
if len(transponder) > 12:
parm.is_id = transponder[10]
parm.pls_mode = transponder[11]
parm.pls_code = transponder[12]
else:
parm.is_id = -1
parm.pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
parm.pls_code = 0
feparm = eDVBFrontendParameters()
feparm.setDVBS(parm, self.ignore_rotor)
self.lastparm = feparm
self.frontend.tune(feparm)
def startSatelliteTransponderSearch(self, nim_idx, orb_pos):
self.frontend = None
self.orb_pos = orb_pos
self.nim = nimmanager.nim_slots[nim_idx]
tunername = nimmanager.getNimName(nim_idx)
self.__tlist = [ ]
self.tp_found = [ ]
self.current_range = None
self.range_list = [ ]
tuner_no = -1
print "tunername", tunername
if tunername in ("BCM4505", "BCM4506 (internal)", "Alps BSBE1 C01A/D01A."):
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
self.session.nav.stopService()
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
if self.session.pipshown: # try to disable pip
self.session.pipshown = False
self.session.deleteDialog(self.session.pip)
del self.session.pip
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
print "couldn't allocate tuner %d for blindscan!!!" %nim_idx
return
# self.frontend.getStateChangeSignal().append(self.frontendStateChanged)
if self.scan_sat.bs_vertical.value:
self.range_list.append((self.scan_sat.bs_freq_start.value * 1000, self.scan_sat.bs_freq_stop.value * 1000, eDVBFrontendParametersSatellite.Polarisation_Vertical))
if self.scan_sat.bs_horizontal.value:
self.range_list.append((self.scan_sat.bs_freq_start.value * 1000, self.scan_sat.bs_freq_stop.value * 1000, eDVBFrontendParametersSatellite.Polarisation_Horizontal))
self.parm = self.setNextRange()
if self.parm is not None:
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm)
self.start_time = time()
tmpstr = _("Try to find used satellite transponders...")
else:
tmpstr = _("Nothing to scan! Press Exit!")
x = { }
data = self.frontend.getFrontendData(x)
tuner_no = x["tuner_number"]
else:
tmpstr = _("Blindscan is not supported by this tuner (%s)") %tunername
self.satellite_search_session = self.session.openWithCallback(self.satelliteTransponderSearchSessionClosed, SatBlindscanState, tuner_no, tmpstr)
self.timer = eTimer()
self.timer.callback.append(self.frontendStateChanged)
self.frontendStateChanged()
def tune(self, transponder): if self.frontend: print "tuning to transponder with data", transponder parm = eDVBFrontendParametersSatellite() parm.frequency = transponder[0] * 1000 parm.symbol_rate = transponder[1] * 1000 parm.polarisation = transponder[2] parm.fec = transponder[3] parm.inversion = transponder[4] parm.orbital_position = transponder[5] parm.system = 0 # FIXMEE !! HARDCODED DVB-S (add support for DVB-S2) parm.modulation = 1 # FIXMEE !! HARDCODED QPSK feparm = eDVBFrontendParameters() feparm.setDVBS(parm) self.lastparm = feparm self.frontend.tune(feparm)
def tune(self, transponder):
if self.frontend:
print "tuning to transponder with data", transponder
parm = eDVBFrontendParametersSatellite()
parm.frequency = transponder[0] * 1000
parm.symbol_rate = transponder[1] * 1000
parm.polarisation = transponder[2]
parm.fec = transponder[3]
parm.inversion = transponder[4]
parm.orbital_position = transponder[5]
parm.system = 0 # FIXMEE !! HARDCODED DVB-S (add support for DVB-S2)
parm.modulation = 1 # FIXMEE !! HARDCODED QPSK
feparm = eDVBFrontendParameters()
feparm.setDVBS(parm)
self.lastparm = feparm
self.frontend.tune(feparm)
def tune(self, transponder): if self.frontend: print "tuning to transponder with data", transponder parm = eDVBFrontendParametersSatellite() parm.frequency = transponder[0] * 1000 parm.symbol_rate = transponder[1] * 1000 parm.polarisation = transponder[2] parm.fec = transponder[3] parm.inversion = transponder[4] parm.orbital_position = transponder[5] parm.system = transponder[6] parm.modulation = transponder[7] parm.rolloff = transponder[8] parm.pilot = transponder[9] feparm = eDVBFrontendParameters() feparm.setDVBS(parm, self.ignore_rotor) self.lastparm = feparm self.frontend.tune(feparm)
def tune(self, transponder):
if self.frontend:
print "tuning to transponder with data", transponder
parm = eDVBFrontendParametersSatellite()
parm.frequency = transponder[0] * 1000
parm.symbol_rate = transponder[1] * 1000
parm.polarisation = transponder[2]
parm.fec = transponder[3]
parm.inversion = transponder[4]
parm.orbital_position = transponder[5]
parm.system = transponder[6]
parm.modulation = transponder[7]
parm.rolloff = transponder[8]
parm.pilot = transponder[9]
feparm = eDVBFrontendParameters()
feparm.setDVBS(parm)
self.lastparm = feparm
self.frontend.tune(feparm)
def tune(self, transponder): if self.frontend: print "tuning to transponder with data", transponder parm = eDVBFrontendParametersSatellite() parm.frequency = int(transponder[0] * 1000) parm.symbol_rate = transponder[1] * 1000 parm.polarisation = transponder[2] parm.fec = transponder[3] parm.inversion = transponder[4] parm.orbital_position = transponder[5] parm.system = transponder[6] parm.modulation = transponder[7] parm.rolloff = transponder[8] parm.pilot = transponder[9] parm.is_id = transponder[10] if len(transponder) > 10 else -1 parm.pls_mode = transponder[11] if len(transponder) > 11 else eDVBFrontendParametersSatellite.PLS_Unknown parm.pls_code = transponder[12] if len(transponder) > 12 else 0 feparm = eDVBFrontendParameters() feparm.setDVBS(parm, self.ignore_rotor) self.lastparm = feparm self.frontend.tune(feparm)
def startSatelliteTransponderSearch(self, nim_idx, orb_pos):
if hasattr(self, 'self.frontend'):
del self.frontend
if hasattr(self, 'self.channel'):
del self.channel
self.frontend = self.channel = None
self.orb_pos = orb_pos
self.nim = nimmanager.nim_slots[nim_idx]
tunername = nimmanager.getNimName(nim_idx)
self.__tlist = []
self.tp_found = []
self.current_range = None
self.range_list = []
tuner_no = -1
self.auto_scan = False
print "tunername", tunername
if tunername in ("BCM4505", "BCM4506 (internal)", "BCM4506",
"Alps BSBE1 C01A/D01A.", "Si2166B"):
self.auto_scan = tunername == 'Si2166B'
(self.channel,
self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
self.session.nav.stopService()
(self.channel, self.frontend) = self.tryGetRawFrontend(
nim_idx, False, False)
if not self.frontend:
if self.session.pipshown:
if hasattr(self.session, 'infobar'):
try:
slist = self.session.infobar.servicelist
if slist and slist.dopipzap:
slist.togglePipzap()
except:
pass
self.session.pipshown = False
if hasattr(self.session, 'pip'):
del self.session.pip
(self.channel, self.frontend) = self.tryGetRawFrontend(
nim_idx, False, False)
if not self.frontend:
print "couldn't allocate tuner %d for blindscan!!!" % nim_idx
text = _("Sorry, this tuner is in use.")
if self.session.nav.getRecordings():
text += "\n"
text += _(
"Maybe the reason that recording is currently running."
)
self.session.open(MessageBox, text,
MessageBox.TYPE_ERROR)
return
band_cutoff_frequency = 11700000
s1 = self.scan_sat.bs_freq_start.value * 1000
s2 = self.scan_sat.bs_freq_stop.value * 1000
start = self.min_freq = min(s1, s2)
stop = self.max_freq = max(s1, s2)
if self.auto_scan: # hack for driver based blindscan... extend search range +/- 50Mhz
limits = self.scan_sat.bs_freq_limits
start -= 50000
stop += 50000
if start < limits[0]:
start = limits[0]
if stop > limits[1]:
stop = limits[1]
if self.scan_sat.bs_horizontal.value:
if self.auto_scan and band_cutoff_frequency and stop > band_cutoff_frequency:
if start < band_cutoff_frequency:
self.range_list.append(
(start, min(stop, band_cutoff_frequency),
eDVBFrontendParametersSatellite.
Polarisation_Horizontal))
if stop > band_cutoff_frequency:
self.range_list.append(
(max(band_cutoff_frequency,
start), stop, eDVBFrontendParametersSatellite.
Polarisation_Horizontal))
else:
self.range_list.append(
(start, stop, eDVBFrontendParametersSatellite.
Polarisation_Horizontal))
if self.scan_sat.bs_vertical.value:
if self.auto_scan and band_cutoff_frequency:
if start < band_cutoff_frequency:
self.range_list.append(
(start, min(stop, band_cutoff_frequency),
eDVBFrontendParametersSatellite.
Polarisation_Vertical))
if stop > band_cutoff_frequency:
self.range_list.append(
(max(band_cutoff_frequency,
start), stop, eDVBFrontendParametersSatellite.
Polarisation_Vertical))
else:
self.range_list.append((
start, stop,
eDVBFrontendParametersSatellite.Polarisation_Vertical))
self.parm = self.setNextRange()
if self.parm is not None:
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm)
self.start_time = time()
tmpstr = _("Try to find used satellite transponders...")
else:
tmpstr = _("Nothing to scan! Press Exit!")
x = {}
data = self.frontend.getFrontendData(x)
tuner_no = x["tuner_number"]
else:
if "Sundtek DVB-S/S2" in tunername and "V" in tunername:
tmpstr = _("Use Sundtek full hardware blind scan!")
else:
tmpstr = _(
"Dreambox blind scan is not supported by this tuner (%s)!"
) % tunername
self.session.open(MessageBox, tmpstr, MessageBox.TYPE_ERROR)
return
self.satellite_search_session = self.session.openWithCallback(
self.satelliteTransponderSearchSessionClosed, SatBlindscanState,
tuner_no, tmpstr)
#if self.auto_scan:
self.timer = eTimer()
self.timer.callback.append(self.updateStateSat)
self.timer.stop()
self.updateStateSat()
def setParamsFe(params):
params_fe = eDVBFrontendParameters()
params_fe.setDVBT(params)
return params_fe
def tuneNext(self): if self.parm is not None: tparm = eDVBFrontendParameters() tparm.setDVBS(self.parm, False) self.frontend.tune(tparm, True)
def tuneCabObj(self, transponderObj): if self.frontend: feparm = eDVBFrontendParameters() feparm.setDVBC(transponderObj) self.lastparm = feparm self.frontend.tune(feparm)
def startSatelliteTransponderSearch(self, nim_idx, orb_pos):
if hasattr(self, 'self.frontend'):
del self.frontend
if hasattr(self, 'self.channel'):
del self.channel
self.frontend = self.channel = None
self.orb_pos = orb_pos
self.nim = nimmanager.nim_slots[nim_idx]
tunername = nimmanager.getNimName(nim_idx)
self.__tlist = [ ]
self.tp_found = [ ]
self.current_range = None
self.range_list = [ ]
tuner_no = -1
self.auto_scan = False
print "tunername", tunername
if tunername in ("BCM4505", "BCM4506 (internal)", "BCM4506", "Alps BSBE1 C01A/D01A.", "Si2166B"):
self.auto_scan = tunername == 'Si2166B'
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
self.session.nav.stopService()
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
if self.session.pipshown:
if hasattr(self.session, 'infobar'):
try:
slist = self.session.infobar.servicelist
if slist and slist.dopipzap:
slist.togglePipzap()
except:
pass
self.session.pipshown = False
if hasattr(self.session, 'pip'):
del self.session.pip
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
print "couldn't allocate tuner %d for blindscan!!!" %nim_idx
text = _("Sorry, this tuner is in use.")
if self.session.nav.getRecordings():
text += "\n"
text += _("Maybe the reason that recording is currently running.")
self.session.open(MessageBox, text, MessageBox.TYPE_ERROR)
return
band_cutoff_frequency = 11700000
s1 = self.scan_sat.bs_freq_start.value * 1000
s2 = self.scan_sat.bs_freq_stop.value * 1000
start = self.min_freq = min(s1,s2)
stop = self.max_freq = max(s1,s2)
if self.auto_scan: # hack for driver based blindscan... extend search range +/- 50Mhz
limits = self.scan_sat.bs_freq_limits
start -= 50000
stop += 50000
if start < limits[0]:
start = limits[0]
if stop >limits[1]:
stop = limits[1]
if self.scan_sat.bs_horizontal.value:
if self.auto_scan and band_cutoff_frequency and stop > band_cutoff_frequency:
if start < band_cutoff_frequency:
self.range_list.append((start, min(stop, band_cutoff_frequency), eDVBFrontendParametersSatellite.Polarisation_Horizontal))
if stop > band_cutoff_frequency:
self.range_list.append((max(band_cutoff_frequency, start), stop, eDVBFrontendParametersSatellite.Polarisation_Horizontal))
else:
self.range_list.append((start, stop, eDVBFrontendParametersSatellite.Polarisation_Horizontal))
if self.scan_sat.bs_vertical.value:
if self.auto_scan and band_cutoff_frequency:
if start < band_cutoff_frequency:
self.range_list.append((start, min(stop, band_cutoff_frequency), eDVBFrontendParametersSatellite.Polarisation_Vertical))
if stop > band_cutoff_frequency:
self.range_list.append((max(band_cutoff_frequency, start), stop, eDVBFrontendParametersSatellite.Polarisation_Vertical))
else:
self.range_list.append((start, stop, eDVBFrontendParametersSatellite.Polarisation_Vertical))
self.parm = self.setNextRange()
if self.parm is not None:
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm)
self.start_time = time()
tmpstr = _("Try to find used satellite transponders...")
else:
tmpstr = _("Nothing to scan! Press Exit!")
x = { }
data = self.frontend.getFrontendData(x)
tuner_no = x["tuner_number"]
else:
if "Sundtek DVB-S/S2" in tunername and "V" in tunername:
tmpstr = _("Use Sundtek full hardware blind scan!")
else:
tmpstr = _("Dreambox blind scan is not supported by this tuner (%s)!") % tunername
self.session.open(MessageBox, tmpstr, MessageBox.TYPE_ERROR)
return
self.satellite_search_session = self.session.openWithCallback(self.satelliteTransponderSearchSessionClosed, SatBlindscanState, tuner_no, tmpstr)
#if self.auto_scan:
self.timer = eTimer()
self.timer.callback.append(self.updateStateSat)
self.timer.stop()
self.updateStateSat()
def tuneSatObj(self, transponderObj):
if self.frontend:
feparm = eDVBFrontendParameters()
feparm.setDVBS(transponderObj, self.ignore_rotor)
self.lastparm = feparm
self.frontend.tune(feparm)
def doTune(self):
print>>log, "[ABM-main][doTune] searching for tuner for %s" % self.providers[self.currentAction]["name"]
from Screens.Standby import inStandby
if self.providers[self.currentAction]["streamtype"] == "dvbs":
transponder = self.providers[self.currentAction]["transponder"]
else:
bouquet_key = None
providers_tmp = self.abm_settings_str.split("|")
for provider_tmp in providers_tmp:
provider_config = ProviderConfig(provider_tmp)
provider_key = provider_config.getProvider()
if self.currentAction != provider_key:
continue
bouquet_key = provider_config.getArea()
if not bouquet_key:
print>>log, "[ABM-main][doTune] No area found"
self.showError(_('No area found'))
return
transponder = self.providers[self.currentAction]["bouquets"][bouquet_key]
nimList = []
for nim in nimmanager.nim_slots:
if self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S"):
try:
if nim.isFBCTuner() and not nim.isFBCRoot():
continue # do not load FBC links, only root tuners
except:
pass
try: # OpenPLi Hot Switch compatible image
if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and \
{"dvbs": "DVB-S", "dvbc": "DVB-C", "dvbt": "DVB-T"}.get(self.providers[self.currentAction]["streamtype"], "UNKNOWN") in [x[:5] for x in nim.getTunerTypesEnabled()]:
nimList.append(nim.slot)
except AttributeError:
try:
if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and \
((self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S")) or \
(self.providers[self.currentAction]["streamtype"] == "dvbc" and (nim.isCompatible("DVB-C") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-C")))) or \
(self.providers[self.currentAction]["streamtype"] == "dvbt" and (nim.isCompatible("DVB-T") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-T"))))):
nimList.append(nim.slot)
except AttributeError: # OpenATV > 5.3
if (self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.canBeCompatible("DVB-S") and nim.config_mode_dvbs not in ("loopthrough", "satposdepends", "nothing")) or \
(self.providers[self.currentAction]["streamtype"] == "dvbc" and nim.canBeCompatible("DVB-C") and nim.config_mode_dvbc != "nothing") or \
(self.providers[self.currentAction]["streamtype"] == "dvbt" and nim.canBeCompatible("DVB-T") and nim.config_mode_dvbt != "nothing"):
nimList.append(nim.slot)
if len(nimList) == 0:
print>>log, "[ABM-main][doTune] No NIMs found"
self.showError(_('No NIMs found for ') + self.providers[self.currentAction]["name"])
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print>>log, "[ABM-main][doTune] Cannot retrieve Resource Manager instance"
self.showError(_('Cannot retrieve Resource Manager instance'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
print>>log, "[ABM-main][doTune] Search NIM for orbital position %d" % transponder["orbital_position"]
else:
print>>log, "[ABM-main][doTune] Search NIM"
# stop pip if running
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
print>>log, "[ABM-main][doTune] Stopping PIP."
# stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends")
currentlyPlayingNIM = None
currentService = self.session and self.session.nav.getCurrentService()
frontendInfo = currentService and currentService.frontendInfo()
frontendData = frontendInfo and frontendInfo.getAll(True)
if frontendData is not None:
currentlyPlayingNIM = frontendData.get("tuner_number", None)
if self.providers[self.currentAction]["streamtype"] == "dvbs" and currentlyPlayingNIM is not None and nimmanager.nim_slots[currentlyPlayingNIM].isCompatible("DVB-S"):
try:
nimConfigMode = nimmanager.nim_slots[currentlyPlayingNIM].config_mode
except AttributeError: # OpenATV > 5.3
nimConfigMode = nimmanager.nim_slots[currentlyPlayingNIM].config_mode_dvbs
if nimConfigMode in ("loopthrough", "satposdepends"):
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
currentlyPlayingNIM = None
print>>log, "[ABM-main][doTune] The active service was using a %s tuner, so had to be stopped (slot id %s)." % (nimConfigMode, currentlyPlayingNIM)
del frontendInfo
del currentService
current_slotid = -1
if self.rawchannel:
del(self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
if self.providers[self.currentAction]["streamtype"] == "dvbs":
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print>>log, "[ABM-main][doTune] Nim found on slot id %d with sat %s" % (slotid, sat[1])
current_slotid = slotid
break
else:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print>>log, "[ABM-main][doTune] Nim found on slot id %d" % (slotid)
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print>>log, "[ABM-main][doTune] No valid NIM found"
self.showError(_('No valid NIM found for ') + self.providers[self.currentAction]["name"])
return
if not self.rawchannel:
# if we are here the only possible option is to close the active service
if currentlyPlayingNIM in nimList:
slotid = currentlyPlayingNIM
if self.providers[self.currentAction]["streamtype"] == "dvbs":
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
print>>log, "[ABM-main][doTune] Nim found on slot id %d but it's busy. Stopping active service" % slotid
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print>>log, "[ABM-main][doTune] The active service was stopped, and the NIM is now free to use."
current_slotid = slotid
break
else:
print>>log, "[ABM-main][doTune] Nim found on slot id %d but it's busy. Stopping active service" % slotid
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print>>log, "[ABM-main][doTune] The active service was stopped, and the NIM is now free to use."
current_slotid = slotid
if not self.rawchannel:
if self.session.nav.RecordTimer.isRecording():
print>>log, "[ABM-main][doTune] Cannot free NIM because a recording is in progress"
self.showError(_('Cannot free NIM because a recording is in progress'))
return
else:
print>>log, "[ABM-main][doTune] Cannot get the NIM"
self.showError(_('Cannot get the NIM'))
return
# set extended timeout for rotors
self.motorised = False
if self.providers[self.currentAction]["streamtype"] == "dvbs" and self.isRotorSat(current_slotid, transponder["orbital_position"]):
self.motorised = True
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR
print>>log, "[ABM-main][doTune] Motorised dish. Will wait up to %i seconds for tuner lock." % (self.LOCK_TIMEOUT/10)
else:
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED
print>>log, "[ABM-main][doTune] Fixed dish. Will wait up to %i seconds for tuner lock." % (self.LOCK_TIMEOUT/10)
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print>>log, "[ABM-main][doTune] Cannot get frontend"
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print>>log, "[ABM-main][doTune] Cannot allocate the demuxer."
self.showError(_('Cannot allocate the demuxer.'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
try: # if distro is MIS capable
params.pls_mode = eDVBFrontendParametersSatellite.PLS_Root
params.is_id = -1
params.pls_code = 1
except:
pass
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
elif self.providers[self.currentAction]["streamtype"] == "dvbt":
params = eDVBFrontendParametersTerrestrial()
params.frequency = transponder["frequency"]
params.bandwidth = transponder["bandwidth"]
params.code_rate_hp = transponder["code_rate_hp"]
params.code_rate_lp = transponder["code_rate_lp"]
params.inversion = transponder["inversion"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.transmission_mode = transponder["transmission_mode"]
params.guard_interval = transponder["guard_interval"]
params.hierarchy = transponder["hierarchy"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBT(params)
elif self.providers[self.currentAction]["streamtype"] == "dvbc":
params = eDVBFrontendParametersCable()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.fec_inner = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.modulation = transponder["modulation"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBC(params)
try:
self.rawchannel.requestTsidOnid()
except (TypeError):
# for compatibility with some third party images
self.rawchannel.requestTsidOnid(self.gotTsidOnid)
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.current_slotid = current_slotid
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
def tuneNext(self):
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm)
def getFrontend(self):
print("[MisPlsLcnScan][getFrontend] searching for available tuner")
nimList = []
for nim in nimmanager.nim_slots:
if not nim.isCompatible("DVB-S") or \
not nim.isMultistream() or \
nim.isFBCLink() or \
(hasattr(nim, 'config_mode_dvbs') and nim.config_mode_dvbs or nim.config_mode) in ("loopthrough", "satposdepends", "nothing") or \
self.transpondercurrent.orbital_position not in [sat[0] for sat in nimmanager.getSatListForNim(nim.slot)]:
continue
nimList.append(nim.slot)
if len(nimList) == 0:
print("[MisPlsLcnScan][getFrontend] No compatible tuner found")
self.showError(_('No compatible tuner found'))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print(
"[MisPlsLcnScan][getFrontend] Cannot retrieve Resource Manager instance"
)
self.showError(_('Cannot retrieve Resource Manager instance'))
return
# stop pip if running
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
print("[MisPlsLcnScan][getFrontend] Stopping PIP.")
# stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends")
currentlyPlayingNIM = None
currentService = self.session and self.session.nav.getCurrentService()
frontendInfo = currentService and currentService.frontendInfo()
frontendData = frontendInfo and frontendInfo.getAll(True)
if frontendData is not None:
currentlyPlayingNIM = frontendData.get("tuner_number", None)
if currentlyPlayingNIM is not None and nimmanager.nim_slots[
currentlyPlayingNIM].isCompatible("DVB-S"):
nimConfigMode = hasattr(
nimmanager.nim_slots[currentlyPlayingNIM],
"config_mode_dvbs"
) and nimmanager.nim_slots[
currentlyPlayingNIM].config_mode_dvbs or nimmanager.nim_slots[
currentlyPlayingNIM].config_mode
if nimConfigMode in ("loopthrough", "satposdepends"):
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
currentlyPlayingNIM = None
print(
"[MisPlsLcnScan][getFrontend] The active service was using a %s tuner, so had to be stopped (slot id %s)."
% (nimConfigMode, currentlyPlayingNIM))
del frontendInfo
del currentService
current_slotid = -1
if self.rawchannel:
del (self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList = [
slot for slot in nimList if
not self.isRotorSat(slot, self.transpondercurrent.orbital_position)
] + [
slot for slot in nimList
if self.isRotorSat(slot, self.transpondercurrent.orbital_position)
] #If we have a choice of dishes try "fixed" before "motorised".
for slotid in nimList:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print(
"[MisPlsLcnScan][getFrontend] Nim found on slot id %d with sat %s"
% (slotid,
nimmanager.getSatName(
self.transpondercurrent.orbital_position)))
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print("[MisPlsLcnScan][getFrontend] No valid NIM found")
self.showError(
_('No valid NIM found for %s') %
PROVIDERS[config.plugins.MisPlsLcnScan.provider.value]["name"])
return
if not self.rawchannel:
# if we are here the only possible option is to close the active service
if currentlyPlayingNIM in nimList:
slotid = currentlyPlayingNIM
print(
"[MisPlsLcnScan][getFrontend] Nim found on slot id %d but it's busy. Stopping active service"
% slotid)
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print(
"[MisPlsLcnScan][getFrontend] The active service was stopped, and the NIM is now free to use."
)
current_slotid = slotid
if not self.rawchannel:
if self.session.nav.RecordTimer.isRecording():
print(
"[MisPlsLcnScan][getFrontend] Cannot free NIM because a recording is in progress"
)
self.showError(
_('Cannot free NIM because a recording is in progress')
)
return
else:
print("[MisPlsLcnScan][getFrontend] Cannot get the NIM")
self.showError(_('Cannot get the NIM'))
return
# set extended timeout for rotors
self.motorised = False
if self.isRotorSat(current_slotid,
self.transpondercurrent.orbital_position):
self.motorised = True
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR
print(
"[MisPlsLcnScan][getFrontend] Motorised dish. Will wait up to %i seconds for tuner lock."
% (self.LOCK_TIMEOUT // 10))
else:
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED
print(
"[MisPlsLcnScan][getFrontend] Fixed dish. Will wait up to %i seconds for tuner lock."
% (self.LOCK_TIMEOUT // 10))
self.selectedNIM = current_slotid # Remember for downloading SI tables
self["tuner_text"].setText(chr(ord('A') + current_slotid))
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print("[MisPlsLcnScan][getFrontend] Cannot get frontend")
self.showError(_('Cannot get frontend'))
return
self.demuxer_id = self.rawchannel.reserveDemux()
if self.demuxer_id < 0:
print("[MisPlsLcnScan][getFrontend] Cannot allocate the demuxer.")
self.showError(_('Cannot allocate the demuxer.'))
return
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(self.transpondercurrent, False)
# try:
# self.rawchannel.requestTsidOnid()
# except (TypeError):
# # for compatibility with some third party images
# self.rawchannel.requestTsidOnid(self.gotTsidOnid)
self.frontend.tune(params_fe)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
def tuneNext(self):
if self.parm is not None:
print("[dmmBlindscan][tuneNext] pos %d, freq %d, pol %d, sys %d" % (self.parm.orbital_position, self.parm.frequency, self.parm.polarisation, self.parm.system))
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm, True)
def doTune(self):
from Screens.Standby import inStandby
transponder = self.providers[self.currentAction]["transponder"]
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
print>>log, "[AutoBouquetsMaker] No DVB-S NIMs founds"
self.showError(_('No DVB-S NIMs founds'))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print>>log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance"
self.showError(_('Cannot retrieve Resource Manager instance'))
return
print>>log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder["orbital_position"]
current_slotid = -1
if self.rawchannel:
del(self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print>>log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (slotid, sat[1])
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print>>log, "[AutoBouquetsMaker] No valid NIM found"
self.showError(_('No valid NIM found'))
return
if not self.rawchannel:
print>>log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stop current service" % current_slotid
if self.session.nav.RecordTimer.isRecording():
print>>log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress"
self.showError(_('Cannot free NIM because a record is in progress'))
return
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
if self.session.pipshown:
self.session.pipshown = False
self.rawchannel = resmanager.allocateRawChannel(current_slotid)
if not self.rawchannel:
print>>log, "[AutoBouquetsMaker] Cannot get the NIM"
self.showError(_('Cannot get the NIM'))
return
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print>>log, "[AutoBouquetsMaker] Cannot get frontend"
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print>>log, "[AutoBouquetsMaker] Cannot allocate the demuxer"
self.showError(_('Cannot allocate the demuxer'))
return
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
self.rawchannel.requestTsidOnid()
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
def doTune(self):
print("[ABM-main][doTune] searching for tuner for %s" %
self.providers[self.currentAction]["name"],
file=log)
from Screens.Standby import inStandby
if self.providers[self.currentAction]["streamtype"] == "dvbs":
transponder = self.providers[self.currentAction]["transponder"]
else:
bouquet_key = None
providers_tmp = self.abm_settings_str.split("|")
for provider_tmp in providers_tmp:
provider_config = ProviderConfig(provider_tmp)
provider_key = provider_config.getProvider()
if self.currentAction != provider_key:
continue
bouquet_key = provider_config.getArea()
if not bouquet_key:
print("[ABM-main][doTune] No area found", file=log)
self.showError(_('No area found'))
return
transponder = self.providers[
self.currentAction]["bouquets"][bouquet_key]
self.transponder = transponder
nimList = []
tunerSelectionAlgorithm = "UNKNOWN" # for debug
for nim in nimmanager.nim_slots:
if self.providers[self.currentAction][
"streamtype"] == "dvbs" and nim.isCompatible("DVB-S"):
try:
if nim.isFBCLink():
continue # do not load FBC links, only root tuners
except:
pass
try: # OpenPLi Hot Switch compatible image
if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and \
{"dvbs": "DVB-S", "dvbc": "DVB-C", "dvbt": "DVB-T"}.get(self.providers[self.currentAction]["streamtype"], "UNKNOWN") in [x[:5] for x in nim.getTunerTypesEnabled()]:
if self.validNIM(nim.slot):
nimList.append(nim.slot)
tunerSelectionAlgorithm = "OpenPLi Hot Switch compatible"
except AttributeError:
try:
if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and \
((self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S")) or
(self.providers[self.currentAction]["streamtype"] == "dvbc" and (nim.isCompatible("DVB-C") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-C")))) or
(self.providers[self.currentAction]["streamtype"] == "dvbt" and (nim.isCompatible("DVB-T") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-T"))))):
if self.validNIM(nim.slot):
nimList.append(nim.slot)
tunerSelectionAlgorithm = "Conventional"
except AttributeError: # OpenATV > 5.3
if (self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.canBeCompatible("DVB-S") and nim.config_mode_dvbs not in ("loopthrough", "satposdepends", "nothing")) or \
(self.providers[self.currentAction]["streamtype"] == "dvbc" and nim.canBeCompatible("DVB-C") and nim.config_mode_dvbc != "nothing") or \
(self.providers[self.currentAction]["streamtype"] == "dvbt" and nim.canBeCompatible("DVB-T") and nim.config_mode_dvbt != "nothing"):
if self.validNIM(nim.slot):
nimList.append(nim.slot)
tunerSelectionAlgorithm = "OpenATV > 5.3"
print("[ABM-main][doTune] tuner selection algorithm '%s'" %
tunerSelectionAlgorithm,
file=log)
if len(nimList) == 0:
print("[ABM-main][doTune] No NIMs found", file=log)
self.showError(
_('No NIMs found for ') +
self.providers[self.currentAction]["name"])
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print(
"[ABM-main][doTune] Cannot retrieve Resource Manager instance",
file=log)
self.showError(_('Cannot retrieve Resource Manager instance'))
return
if self.providers[self.currentAction][
"streamtype"] == "dvbs": # If we have a choice of dishes sort the nimList so "fixed" dishes have a higher priority than "motorised".
nimList = [
slot for slot in nimList
if not self.isRotorSat(slot, transponder["orbital_position"])
] + [
slot for slot in nimList
if self.isRotorSat(slot, transponder["orbital_position"])
]
# stop pip if running
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
print("[ABM-main][doTune] Stopping PIP.", file=log)
# find currently playing nim
currentlyPlayingNIM = None
currentService = self.session and self.session.nav.getCurrentService()
frontendInfo = currentService and currentService.frontendInfo()
frontendData = frontendInfo and frontendInfo.getAll(True)
if frontendData is not None:
currentlyPlayingNIM = frontendData.get("tuner_number", None)
# stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends"), as running in this configuration will prevent getting rawchannel on the root tuner.
if self.providers[self.currentAction][
"streamtype"] == "dvbs" and currentlyPlayingNIM is not None and nimmanager.nim_slots[
currentlyPlayingNIM].isCompatible("DVB-S"):
try:
nimConfigMode = nimmanager.nim_slots[
currentlyPlayingNIM].config_mode
except AttributeError: # OpenATV > 5.3
nimConfigMode = nimmanager.nim_slots[
currentlyPlayingNIM].config_mode_dvbs
if nimConfigMode in ("loopthrough", "satposdepends"):
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
currentlyPlayingNIM = None
print(
"[ABM-main][doTune] The active service was using a %s tuner, so had to be stopped (slot id %s)."
% (nimConfigMode, currentlyPlayingNIM),
file=log)
del frontendInfo
del currentService
self.releaseFrontend()
for current_slotid in nimList:
self.rawchannel = resmanager.allocateRawChannel(current_slotid)
if self.rawchannel:
print("[ABM-main][doTune] Tuner %s selected%s" %
(chr(ord('A') + current_slotid),
(" for orbital position %d" %
transponder["orbital_position"]
if "orbital_position" in transponder else "")),
file=log)
break
if not self.rawchannel:
# if we are here the only possible option is to close the active service
if currentlyPlayingNIM in nimList:
print(
"[ABM-main][doTune] Tuner %s has been selected but it's busy. Stopping currently playing service."
% chr(ord('A') + currentlyPlayingNIM),
file=log)
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
self.rawchannel = resmanager.allocateRawChannel(
currentlyPlayingNIM)
if self.rawchannel:
print(
"[ABM-main][doTune] The active service was stopped, and tuner %s is now free to use."
% chr(ord('A') + currentlyPlayingNIM),
file=log)
current_slotid = currentlyPlayingNIM
if not self.rawchannel:
if self.session.nav.RecordTimer.isRecording():
print(
"[ABM-main][doTune] Cannot free NIM because a recording is in progress",
file=log)
self.showError(
_('Cannot free NIM because a recording is in progress')
)
return
else:
print("[ABM-main][doTune] Cannot get the NIM", file=log)
self.showError(_('Cannot get the NIM'))
return
# set extended timeout for rotors
self.motorised = False
if self.providers[self.currentAction][
"streamtype"] == "dvbs" and self.isRotorSat(
current_slotid, transponder["orbital_position"]):
self.motorised = True
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR
print(
"[ABM-main][doTune] Motorised dish. Will wait up to %i seconds for tuner lock."
% (self.LOCK_TIMEOUT // 10),
file=log)
else:
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED
print(
"[ABM-main][doTune] Fixed dish. Will wait up to %i seconds for tuner lock."
% (self.LOCK_TIMEOUT // 10),
file=log)
if not inStandby:
self["tuner_text"].setText(chr(ord('A') + current_slotid))
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print("[ABM-main][doTune] Cannot get frontend", file=log)
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print("[ABM-main][doTune] Cannot allocate the demuxer.", file=log)
self.showError(_('Cannot allocate the demuxer.'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
if hasattr(eDVBFrontendParametersSatellite, "No_Stream_Id_Filter"):
params.is_id = eDVBFrontendParametersSatellite.No_Stream_Id_Filter
if hasattr(eDVBFrontendParametersSatellite, "PLS_Gold"):
params.pls_mode = eDVBFrontendParametersSatellite.PLS_Gold
if hasattr(eDVBFrontendParametersSatellite,
"PLS_Default_Gold_Code"):
params.pls_code = eDVBFrontendParametersSatellite.PLS_Default_Gold_Code
if hasattr(eDVBFrontendParametersSatellite, "No_T2MI_PLP_Id"):
params.t2mi_plp_id = eDVBFrontendParametersSatellite.No_T2MI_PLP_Id
if hasattr(eDVBFrontendParametersSatellite, "T2MI_Default_Pid"):
params.t2mi_pid = eDVBFrontendParametersSatellite.T2MI_Default_Pid
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
elif self.providers[self.currentAction]["streamtype"] == "dvbt":
params = eDVBFrontendParametersTerrestrial()
params.frequency = transponder["frequency"]
params.bandwidth = transponder["bandwidth"]
params.code_rate_hp = transponder["code_rate_hp"]
params.code_rate_lp = transponder["code_rate_lp"]
params.inversion = transponder["inversion"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.transmission_mode = transponder["transmission_mode"]
params.guard_interval = transponder["guard_interval"]
params.hierarchy = transponder["hierarchy"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBT(params)
elif self.providers[self.currentAction]["streamtype"] == "dvbc":
params = eDVBFrontendParametersCable()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.fec_inner = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.modulation = transponder["modulation"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBC(params)
try:
self.rawchannel.requestTsidOnid()
except TypeError:
# for compatibility with some third party images
self.rawchannel.requestTsidOnid(self.gotTsidOnid)
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.current_slotid = current_slotid
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
def startSatelliteTransponderSearch(self):
self.releaseFrontend()
self.nim = nimmanager.nim_slots[self.feid]
tunername = nimmanager.getNimName(self.feid)
self.__tlist = []
self.tp_found = []
self.current_range = None
self.range_list = [] # contains tuples, (start, stop, polarisation), max length 4, i.e. 4 sub-bands
tuner_no = -1
self.auto_scan = False
print("[dmmBlindscan][startSatelliteTransponderSearch] tunername", tunername)
if nimmanager.nim_slots[self.feid].supportsBlindScan() or tunername in ("BCM4505", "BCM4506 (internal)", "BCM4506", "Alps BSBE1 C01A/D01A.", "Si2166B", "Si2169C"):
self.auto_scan = nimmanager.nim_slots[self.feid].supportsBlindScan() or tunername in ("Si2166B", "Si2169C")
if not self.prepareFrontend():
print("[dmmBlindscan][startSatelliteTransponderSearch] couldn't allocate tuner %d for blindscan!" % self.feid)
text = _("Sorry, this tuner is in use.")
if self.session.nav.getRecordings():
text += _("\nA recording is in progress.")
self.session.open(MessageBox, text, MessageBox.TYPE_ERROR)
return
band_cutoff_frequency = 11700001
s1 = self.dmmBlindscan.freq_start.value * 1000
s2 = self.dmmBlindscan.freq_stop.value * 1000
start = min(s1, s2)
stop = max(s1, s2)
if self.auto_scan: # hack for driver based blindscan... extend search range +/- 50Mhz
freq_limits = list(map(lambda x: x * 1000, self.freq_limits))
start -= 50000
stop += 50000
if start < freq_limits[0]:
start = freq_limits[0]
if stop > freq_limits[1]:
stop = freq_limits[1]
pols = {eDVBFrontendParametersSatellite.Polarisation_Horizontal: "horizontal", eDVBFrontendParametersSatellite.Polarisation_Vertical: "vertical"}
for pol in (eDVBFrontendParametersSatellite.Polarisation_Vertical, eDVBFrontendParametersSatellite.Polarisation_Horizontal):
if pols[pol] in self.dmmBlindscan.polarization.value:
if self.auto_scan:
pol or self.range_list.append((start, min(stop, start + 5000), pol)) # hack alert, this is crap and should not be here, but scan misses a lot of services without it.
if start < band_cutoff_frequency:
self.range_list.append((start, min(stop, band_cutoff_frequency - 1), pol))
if stop > band_cutoff_frequency:
self.range_list.append((max(band_cutoff_frequency, start), stop, pol))
else:
self.range_list.append((start, stop, pol))
# if self.dmmBlindscan.multiple_scan.value > 1:
# self.range_list = [self.range_list[i//self.dmmBlindscan.multiple_scan.value] for i in range(len(self.range_list)*self.dmmBlindscan.multiple_scan.value)]
print("[dmmBlindscan][startSatelliteTransponderSearch] self.range_list", self.range_list)
self.parm = self.setNextRange()
if self.parm is not None:
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm, True)
self.start_time = time()
tmpstr = _("Searching for active satellite transponders...")
else:
tmpstr = _("Nothing to scan! Press Exit!")
x = {}
data = self.frontend.getFrontendData(x)
tuner_no = x["tuner_number"]
else:
if "Sundtek DVB-S/S2" in tunername and "V" in tunername:
tmpstr = _("Use Sundtek full hardware blind scan!")
else:
tmpstr = _("Hardware blind scan is not supported by this tuner (%s)!") % tunername
self.session.open(MessageBox, tmpstr, MessageBox.TYPE_ERROR)
return
self.satellite_search_session = self.session.openWithCallback(self.satelliteTransponderSearchSessionClosed, DmmBlindscanState, tuner_no, tmpstr)
#if self.auto_scan:
self.timer = eTimer()
self.timer.callback.append(self.updateStateSat)
self.timer.stop()
self.updateStateSat()
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 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 startSatelliteTransponderSearch(self, nim_idx, orb_pos):
self.frontend = None
self.orb_pos = orb_pos
self.nim = nimmanager.nim_slots[nim_idx]
tunername = nimmanager.getNimName(nim_idx)
self.__tlist = [ ]
self.tp_found = [ ]
self.current_range = None
self.range_list = [ ]
tuner_no = -1
self.auto_scan = False
self.timer = eTimer()
self.timer.callback.append(self.updateStateSat)
print "tunername", tunername
if tunername in ("BCM4505", "BCM4506 (internal)", "BCM4506", "Alps BSBE1 C01A/D01A.", "Si2166B", "Si2169C"):
self.auto_scan = tunername == 'Si2166B' or tunername == 'Si2169C'
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
self.session.nav.stopService()
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
if self.session.pipshown: # try to disable pip
self.session.pipshown = False
self.session.deleteDialog(self.session.pip)
del self.session.pip
(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
print "couldn't allocate tuner %d for blindscan!!!" %nim_idx
return
# self.frontend.getStateChangeSignal().append(self.frontendStateChanged)
band_cutoff_frequency = self.nim_sat_band_cutoff_frequency[nim_idx][orb_pos][0]
s1 = self.scan_sat.bs_freq_start.value * 1000
s2 = self.scan_sat.bs_freq_stop.value * 1000
start = self.min_freq = min(s1,s2)
stop = self.max_freq = max(s1,s2)
if self.auto_scan: # hack for driver based blindscan... extend search range +/- 50MHz
limits = self.scan_sat.bs_freq_limits
start -= 50000
stop += 50000
if start < limits[0]:
start = limits[0]
if stop >limits[1]:
stop = limits[1]
if self.scan_sat.bs_horizontal.value:
if self.auto_scan and band_cutoff_frequency and stop > band_cutoff_frequency:
if start < band_cutoff_frequency:
self.range_list.append((start, min(stop, band_cutoff_frequency), eDVBFrontendParametersSatellite.Polarisation_Horizontal))
if stop > band_cutoff_frequency:
self.range_list.append((max(band_cutoff_frequency, start), stop, eDVBFrontendParametersSatellite.Polarisation_Horizontal))
else:
self.range_list.append((start, stop, eDVBFrontendParametersSatellite.Polarisation_Horizontal))
if self.scan_sat.bs_vertical.value:
if self.auto_scan and band_cutoff_frequency:
if start < band_cutoff_frequency:
self.range_list.append((start, min(stop, band_cutoff_frequency), eDVBFrontendParametersSatellite.Polarisation_Vertical))
if stop > band_cutoff_frequency:
self.range_list.append((max(band_cutoff_frequency, start), stop, eDVBFrontendParametersSatellite.Polarisation_Vertical))
else:
self.range_list.append((start, stop, eDVBFrontendParametersSatellite.Polarisation_Vertical))
self.parm = self.setNextRange()
if self.parm is not None:
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm)
self.start_time = time()
tmpstr = _("Try to find used satellite transponders...")
else:
tmpstr = _("Nothing to scan! Press Exit!")
x = { }
data = self.frontend.getFrontendData(x)
tuner_no = x["tuner_number"]
self.updateStateSat()
else:
tmpstr = _("Blindscan is not supported by this tuner (%s)") %tunername
self.satellite_search_session = self.session.openWithCallback(self.satelliteTransponderSearchSessionClosed, SatBlindscanState, tuner_no, tmpstr)
def startSatelliteTransponderSearch(self, nim_idx, orb_pos):
self.frontend = None
self.orb_pos = orb_pos
self.nim = nimmanager.nim_slots[nim_idx]
tunername = nimmanager.getNimName(nim_idx)
self.__tlist = []
self.tp_found = []
self.current_range = None
self.range_list = []
tuner_no = -1
self.auto_scan = False
self.timer = eTimer()
self.timer.callback.append(self.updateStateSat)
print "tunername", tunername
if tunername in ("BCM4505", "BCM4506 (internal)", "BCM4506",
"Alps BSBE1 C01A/D01A.", "Si2166B", "Si2169C"):
self.auto_scan = tunername == 'Si2166B' or tunername == 'Si2169C'
(self.channel,
self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
if not self.frontend:
self.session.nav.stopService()
(self.channel, self.frontend) = self.tryGetRawFrontend(
nim_idx, False, False)
if not self.frontend:
if self.session.pipshown: # try to disable pip
self.session.pipshown = False
self.session.deleteDialog(self.session.pip)
del self.session.pip
(self.channel, self.frontend) = self.tryGetRawFrontend(
nim_idx, False, False)
if not self.frontend:
print "couldn't allocate tuner %d for blindscan!!!" % nim_idx
return
# self.frontend.getStateChangeSignal().append(self.frontendStateChanged)
band_cutoff_frequency = self.nim_sat_band_cutoff_frequency[
nim_idx][orb_pos][0]
s1 = self.scan_sat.bs_freq_start.value * 1000
s2 = self.scan_sat.bs_freq_stop.value * 1000
start = self.min_freq = min(s1, s2)
stop = self.max_freq = max(s1, s2)
if self.auto_scan: # hack for driver based blindscan... extend search range +/- 50MHz
limits = self.scan_sat.bs_freq_limits
start -= 50000
stop += 50000
if start < limits[0]:
start = limits[0]
if stop > limits[1]:
stop = limits[1]
if self.scan_sat.bs_horizontal.value:
if self.auto_scan and band_cutoff_frequency and stop > band_cutoff_frequency:
if start < band_cutoff_frequency:
self.range_list.append(
(start, min(stop, band_cutoff_frequency),
eDVBFrontendParametersSatellite.
Polarisation_Horizontal))
if stop > band_cutoff_frequency:
self.range_list.append(
(max(band_cutoff_frequency,
start), stop, eDVBFrontendParametersSatellite.
Polarisation_Horizontal))
else:
self.range_list.append(
(start, stop, eDVBFrontendParametersSatellite.
Polarisation_Horizontal))
if self.scan_sat.bs_vertical.value:
if self.auto_scan and band_cutoff_frequency:
if start < band_cutoff_frequency:
self.range_list.append(
(start, min(stop, band_cutoff_frequency),
eDVBFrontendParametersSatellite.
Polarisation_Vertical))
if stop > band_cutoff_frequency:
self.range_list.append(
(max(band_cutoff_frequency,
start), stop, eDVBFrontendParametersSatellite.
Polarisation_Vertical))
else:
self.range_list.append((
start, stop,
eDVBFrontendParametersSatellite.Polarisation_Vertical))
self.parm = self.setNextRange()
if self.parm is not None:
tparm = eDVBFrontendParameters()
tparm.setDVBS(self.parm, False)
self.frontend.tune(tparm)
self.start_time = time()
tmpstr = _("Try to find used satellite transponders...")
else:
tmpstr = _("Nothing to scan! Press Exit!")
x = {}
data = self.frontend.getFrontendData(x)
tuner_no = x["tuner_number"]
self.updateStateSat()
else:
tmpstr = _(
"Blindscan is not supported by this tuner (%s)") % tunername
self.satellite_search_session = self.session.openWithCallback(
self.satelliteTransponderSearchSessionClosed, SatBlindscanState,
tuner_no, tmpstr)
def doTune(self):
from Screens.Standby import inStandby
if self.providers[self.currentAction]["streamtype"] == "dvbs":
transponder = self.providers[self.currentAction]["transponder"]
else:
bouquet_key = None
providers_tmp = config.autobouquetsmaker.providers.value.split("|")
for provider_tmp in providers_tmp:
provider_config = ProviderConfig(provider_tmp)
provider_key = provider_config.getProvider()
if self.currentAction != provider_key:
continue
bouquet_key = provider_config.getArea()
if not bouquet_key:
print >> log, "[AutoBouquetsMaker] No area found"
self.showError(_('No area found'))
return
transponder = self.providers[
self.currentAction]["bouquets"][bouquet_key]
nimList = []
for nim in nimmanager.nim_slots:
if (self.providers[self.currentAction]["streamtype"] == "dvbs"
and nim.isCompatible("DVB-S")
and nim.config_mode not in ("loopthrough")) or (
self.providers[self.currentAction]["streamtype"]
== "dvbc" and nim.isCompatible("DVB-C")) or (
self.providers[self.currentAction]["streamtype"]
== "dvbt" and nim.isCompatible("DVB-T")):
nimList.append(nim.slot)
if len(nimList) == 0:
print >> log, "[AutoBouquetsMaker] No NIMs found"
self.showError(_('No NIMs found'))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print >> log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance"
self.showError(_('Cannot retrieve Resource Manager instance'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
print >> log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder[
"orbital_position"]
else:
print >> log, "[AutoBouquetsMaker] Search NIM"
current_slotid = -1
if self.rawchannel:
del (self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
if self.providers[self.currentAction]["streamtype"] == "dvbs":
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (
slotid, sat[1])
current_slotid = slotid
break
else:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d" % (
slotid)
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print >> log, "[AutoBouquetsMaker] No valid NIM found"
self.showError(_('No valid NIM found'))
return
if not self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stop current service" % current_slotid
if self.session.nav.RecordTimer.isRecording():
print >> log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress"
self.showError(
_('Cannot free NIM because a record is in progress'))
return
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
if self.session.pipshown:
self.session.pipshown = False
self.rawchannel = resmanager.allocateRawChannel(current_slotid)
if not self.rawchannel:
print >> log, "[AutoBouquetsMaker] Cannot get the NIM"
self.showError(_('Cannot get the NIM'))
return
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print >> log, "[AutoBouquetsMaker] Cannot get frontend"
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print >> log, "[AutoBouquetsMaker] Cannot allocate the demuxer"
self.showError(_('Cannot allocate the demuxer'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
elif self.providers[self.currentAction]["streamtype"] == "dvbt":
params = eDVBFrontendParametersTerrestrial()
params.frequency = transponder["frequency"]
params.bandwidth = transponder["bandwidth"]
params.code_rate_hp = transponder["code_rate_hp"]
params.code_rate_lp = transponder["code_rate_lp"]
params.inversion = transponder["inversion"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.transmission_mode = transponder["transmission_mode"]
params.guard_interval = transponder["guard_interval"]
params.hierarchy = transponder["hierarchy"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBT(params)
elif self.providers[self.currentAction]["streamtype"] == "dvbc":
params = eDVBFrontendParametersCable()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.fec_inner = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.modulation = transponder["modulation"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBC(params)
self.rawchannel.requestTsidOnid()
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
def tuneCabObj(self, transponderObj):
if self.frontend:
feparm = eDVBFrontendParameters()
feparm.setDVBC(transponderObj)
self.lastparm = feparm
self.frontend.tune(feparm)
def doTune(self):
from Screens.Standby import inStandby
if self.providers[self.currentAction]["streamtype"] == "dvbs":
transponder = self.providers[self.currentAction]["transponder"]
else:
bouquet_key = None
providers_tmp = config.autobouquetsmaker.providers.value.split("|")
for provider_tmp in providers_tmp:
provider_config = ProviderConfig(provider_tmp)
provider_key = provider_config.getProvider()
if self.currentAction != provider_key:
continue
bouquet_key = provider_config.getArea()
if not bouquet_key:
print>>log, "[AutoBouquetsMaker] No area found"
self.showError(_('No area found'))
return
transponder = self.providers[self.currentAction]["bouquets"][bouquet_key]
nimList = []
for nim in nimmanager.nim_slots:
if (self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S") and nim.config_mode not in ("loopthrough")) or (self.providers[self.currentAction]["streamtype"] == "dvbc" and nim.isCompatible("DVB-C")) or (self.providers[self.currentAction]["streamtype"] == "dvbt" and nim.isCompatible("DVB-T")):
nimList.append(nim.slot)
if len(nimList) == 0:
print>>log, "[AutoBouquetsMaker] No NIMs found"
self.showError(_('No NIMs found'))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print>>log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance"
self.showError(_('Cannot retrieve Resource Manager instance'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
print>>log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder["orbital_position"]
else:
print>>log, "[AutoBouquetsMaker] Search NIM"
current_slotid = -1
if self.rawchannel:
del(self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
if self.providers[self.currentAction]["streamtype"] == "dvbs":
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print>>log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (slotid, sat[1])
current_slotid = slotid
break
else:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print>>log, "[AutoBouquetsMaker] Nim found on slot id %d" % (slotid)
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print>>log, "[AutoBouquetsMaker] No valid NIM found"
self.showError(_('No valid NIM found'))
return
if not self.rawchannel:
print>>log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stop current service" % current_slotid
if self.session.nav.RecordTimer.isRecording():
print>>log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress"
self.showError(_('Cannot free NIM because a record is in progress'))
return
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
if self.session.pipshown:
self.session.pipshown = False
self.rawchannel = resmanager.allocateRawChannel(current_slotid)
if not self.rawchannel:
print>>log, "[AutoBouquetsMaker] Cannot get the NIM"
self.showError(_('Cannot get the NIM'))
return
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print>>log, "[AutoBouquetsMaker] Cannot get frontend"
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print>>log, "[AutoBouquetsMaker] Cannot allocate the demuxer"
self.showError(_('Cannot allocate the demuxer'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
elif self.providers[self.currentAction]["streamtype"] == "dvbt":
params = eDVBFrontendParametersTerrestrial()
params.frequency = transponder["frequency"]
params.bandwidth = transponder["bandwidth"]
params.code_rate_hp = transponder["code_rate_hp"]
params.code_rate_lp = transponder["code_rate_lp"]
params.inversion = transponder["inversion"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.transmission_mode = transponder["transmission_mode"]
params.guard_interval = transponder["guard_interval"]
params.hierarchy = transponder["hierarchy"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBT(params)
elif self.providers[self.currentAction]["streamtype"] == "dvbc":
params = eDVBFrontendParametersCable()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.fec_inner = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.modulation = transponder["modulation"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBC(params)
self.rawchannel.requestTsidOnid()
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
def tuneSatObj(self, transponderObj): if self.frontend: feparm = eDVBFrontendParameters() feparm.setDVBS(transponderObj, self.ignore_rotor) self.lastparm = feparm self.frontend.tune(feparm)
def setParamsFe(params):
params_fe = eDVBFrontendParameters()
params_fe.setDVBT(params)
return params_fe
def tuneNext(self): if self.parm is not None: tparm = eDVBFrontendParameters() tparm.setDVBS(self.parm, False) self.frontend.tune(tparm)
def doTune(self):
from Screens.Standby import inStandby
if self.providers[self.currentAction]["streamtype"] == "dvbs":
transponder = self.providers[self.currentAction]["transponder"]
else:
bouquet_key = None
providers_tmp = config.autobouquetsmaker.providers.value.split("|")
for provider_tmp in providers_tmp:
provider_config = ProviderConfig(provider_tmp)
provider_key = provider_config.getProvider()
if self.currentAction != provider_key:
continue
bouquet_key = provider_config.getArea()
if not bouquet_key:
print >> log, "[AutoBouquetsMaker] No area found"
self.showError(_("No area found"))
return
transponder = self.providers[self.currentAction]["bouquets"][bouquet_key]
nimList = []
for nim in nimmanager.nim_slots:
if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and (
(self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S"))
or (self.providers[self.currentAction]["streamtype"] == "dvbc" and nim.isCompatible("DVB-C"))
or (self.providers[self.currentAction]["streamtype"] == "dvbt" and nim.isCompatible("DVB-T"))
):
nimList.append(nim.slot)
if len(nimList) == 0:
print >> log, "[AutoBouquetsMaker] No NIMs found"
self.showError(_("No NIMs found"))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print >> log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance"
self.showError(_("Cannot retrieve Resource Manager instance"))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
print >> log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder["orbital_position"]
else:
print >> log, "[AutoBouquetsMaker] Search NIM"
# stop pip if running
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
print >> log, "[AutoBouquetsMaker] Stopping PIP."
# stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends")
currentlyPlayingNIM = None
currentService = self.session and self.session.nav.getCurrentService()
frontendInfo = currentService and currentService.frontendInfo()
frontendData = frontendInfo and frontendInfo.getAll(True)
if frontendData is not None:
currentlyPlayingNIM = frontendData.get("tuner_number", None)
if self.providers[self.currentAction]["streamtype"] == "dvbs" and currentlyPlayingNIM is not None:
nimConfigMode = nimmanager.nim_slots[currentlyPlayingNIM].config_mode
if nimConfigMode in ("loopthrough", "satposdepends"):
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
currentlyPlayingNIM = None
print >> log, "[AutoBouquetsMaker] The active service was using a %s tuner, so had to be stopped (slot id %s)." % (
nimConfigMode,
currentlyPlayingNIM,
)
del frontendInfo
del currentService
current_slotid = -1
if self.rawchannel:
del (self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
if self.providers[self.currentAction]["streamtype"] == "dvbs":
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (slotid, sat[1])
current_slotid = slotid
break
else:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d" % (slotid)
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print >> log, "[AutoBouquetsMaker] No valid NIM found"
self.showError(_("No valid NIM found"))
return
if not self.rawchannel:
# if we are here the only possible option is to close the active service
if currentlyPlayingNIM in nimList:
slotid = currentlyPlayingNIM
if self.providers[self.currentAction]["streamtype"] == "dvbs":
sats = nimmanager.getSatListForNim(currentlyPlayingNIM)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stopping active service" % currentlyPlayingNIM
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
self.rawchannel = resmanager.allocateRawChannel(slotid)
break
else:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stopping active service" % currentlyPlayingNIM
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
self.rawchannel = resmanager.allocateRawChannel(slotid)
if not self.rawchannel:
if self.session.nav.RecordTimer.isRecording():
print >> log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress"
self.showError(_("Cannot free NIM because a recording is in progress"))
return
else:
print >> log, "[AutoBouquetsMaker] Cannot get the NIM"
self.showError(_("Cannot get the NIM"))
return
# set extended timeout for rotors
if self.providers[self.currentAction]["streamtype"] == "dvbs" and self.isRotorSat(
slotid, transponder["orbital_position"]
):
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR
print >> log, "[AutoBouquetsMaker] Motorised dish. Will wait up to %i seconds for tuner lock." % (
self.LOCK_TIMEOUT / 10
)
else:
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED
print >> log, "[AutoBouquetsMaker] Fixed dish. Will wait up to %i seconds for tuner lock." % (
self.LOCK_TIMEOUT / 10
)
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print >> log, "[AutoBouquetsMaker] Cannot get frontend"
self.showError(_("Cannot get frontend"))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print >> log, "[AutoBouquetsMaker] Cannot allocate the demuxer"
self.showError(_("Cannot allocate the demuxer"))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
elif self.providers[self.currentAction]["streamtype"] == "dvbt":
params = eDVBFrontendParametersTerrestrial()
params.frequency = transponder["frequency"]
params.bandwidth = transponder["bandwidth"]
params.code_rate_hp = transponder["code_rate_hp"]
params.code_rate_lp = transponder["code_rate_lp"]
params.inversion = transponder["inversion"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.transmission_mode = transponder["transmission_mode"]
params.guard_interval = transponder["guard_interval"]
params.hierarchy = transponder["hierarchy"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBT(params)
elif self.providers[self.currentAction]["streamtype"] == "dvbc":
params = eDVBFrontendParametersCable()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.fec_inner = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.modulation = transponder["modulation"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBC(params)
self.rawchannel.requestTsidOnid()
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
def doTune(self):
from Screens.Standby import inStandby
if self.providers[self.currentAction]["streamtype"] == "dvbs":
transponder = self.providers[self.currentAction]["transponder"]
else:
bouquet_key = None
providers_tmp = config.autobouquetsmaker.providers.value.split("|")
for provider_tmp in providers_tmp:
provider_config = ProviderConfig(provider_tmp)
provider_key = provider_config.getProvider()
if self.currentAction != provider_key:
continue
bouquet_key = provider_config.getArea()
if not bouquet_key:
print >> log, "[AutoBouquetsMaker] No area found"
self.showError(_('No area found'))
return
transponder = self.providers[
self.currentAction]["bouquets"][bouquet_key]
nimList = []
for nim in nimmanager.nim_slots:
if (nim.config_mode not in
("loopthrough", "satposdepends", "nothing")) and (
(self.providers[self.currentAction]["streamtype"] == "dvbs"
and nim.isCompatible("DVB-S")) or
(self.providers[self.currentAction]["streamtype"] == "dvbc"
and nim.isCompatible("DVB-C")) or
(self.providers[self.currentAction]["streamtype"] == "dvbt"
and nim.isCompatible("DVB-T"))):
nimList.append(nim.slot)
if len(nimList) == 0:
print >> log, "[AutoBouquetsMaker] No NIMs found"
self.showError(_('No NIMs found'))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print >> log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance"
self.showError(_('Cannot retrieve Resource Manager instance'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
print >> log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder[
"orbital_position"]
else:
print >> log, "[AutoBouquetsMaker] Search NIM"
# stop pip if running
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
print >> log, "[AutoBouquetsMaker] Stopping PIP."
# stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends")
currentlyPlayingNIM = None
currentService = self.session and self.session.nav.getCurrentService()
frontendInfo = currentService and currentService.frontendInfo()
frontendData = frontendInfo and frontendInfo.getAll(True)
if frontendData is not None:
currentlyPlayingNIM = frontendData.get("tuner_number", None)
if self.providers[self.currentAction][
"streamtype"] == "dvbs" and currentlyPlayingNIM is not None:
nimConfigMode = nimmanager.nim_slots[
currentlyPlayingNIM].config_mode
if nimConfigMode in ("loopthrough", "satposdepends"):
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
currentlyPlayingNIM = None
print >> log, "[AutoBouquetsMaker] The active service was using a %s tuner, so had to be stopped (slot id %s)." % (
nimConfigMode, currentlyPlayingNIM)
del frontendInfo
del currentService
current_slotid = -1
if self.rawchannel:
del (self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
if self.providers[self.currentAction]["streamtype"] == "dvbs":
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (
slotid, sat[1])
current_slotid = slotid
break
else:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d" % (
slotid)
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print >> log, "[AutoBouquetsMaker] No valid NIM found"
self.showError(_('No valid NIM found'))
return
if not self.rawchannel:
# if we are here the only possible option is to close the active service
if currentlyPlayingNIM in nimList:
slotid = currentlyPlayingNIM
if self.providers[self.currentAction]["streamtype"] == "dvbs":
sats = nimmanager.getSatListForNim(currentlyPlayingNIM)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stopping active service" % currentlyPlayingNIM
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
self.rawchannel = resmanager.allocateRawChannel(
slotid)
break
else:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stopping active service" % currentlyPlayingNIM
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
self.rawchannel = resmanager.allocateRawChannel(slotid)
if not self.rawchannel:
if self.session.nav.RecordTimer.isRecording():
print >> log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress"
self.showError(
_('Cannot free NIM because a recording is in progress')
)
return
else:
print >> log, "[AutoBouquetsMaker] Cannot get the NIM"
self.showError(_('Cannot get the NIM'))
return
# set extended timeout for rotors
if self.providers[self.currentAction][
"streamtype"] == "dvbs" and self.isRotorSat(
slotid, transponder["orbital_position"]):
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR
print >> log, "[AutoBouquetsMaker] Motorised dish. Will wait up to %i seconds for tuner lock." % (
self.LOCK_TIMEOUT / 10)
else:
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED
print >> log, "[AutoBouquetsMaker] Fixed dish. Will wait up to %i seconds for tuner lock." % (
self.LOCK_TIMEOUT / 10)
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print >> log, "[AutoBouquetsMaker] Cannot get frontend"
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print >> log, "[AutoBouquetsMaker] Cannot allocate the demuxer"
self.showError(_('Cannot allocate the demuxer'))
return
if self.providers[self.currentAction]["streamtype"] == "dvbs":
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
elif self.providers[self.currentAction]["streamtype"] == "dvbt":
params = eDVBFrontendParametersTerrestrial()
params.frequency = transponder["frequency"]
params.bandwidth = transponder["bandwidth"]
params.code_rate_hp = transponder["code_rate_hp"]
params.code_rate_lp = transponder["code_rate_lp"]
params.inversion = transponder["inversion"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.transmission_mode = transponder["transmission_mode"]
params.guard_interval = transponder["guard_interval"]
params.hierarchy = transponder["hierarchy"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBT(params)
elif self.providers[self.currentAction]["streamtype"] == "dvbc":
params = eDVBFrontendParametersCable()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.fec_inner = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.modulation = transponder["modulation"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBC(params)
self.rawchannel.requestTsidOnid()
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
def doTune(self):
from Screens.Standby import inStandby
transponder = self.providers[self.currentAction]["transponder"]
nimList = nimmanager.getNimListOfType("DVB-S")
if len(nimList) == 0:
print >> log, "[AutoBouquetsMaker] No DVB-S NIMs founds"
self.showError(_('No DVB-S NIMs founds'))
return
resmanager = eDVBResourceManager.getInstance()
if not resmanager:
print >> log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance"
self.showError(_('Cannot retrieve Resource Manager instance'))
return
print >> log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder[
"orbital_position"]
current_slotid = -1
if self.rawchannel:
del (self.rawchannel)
self.frontend = None
self.rawchannel = None
nimList.reverse() # start from the last
for slotid in nimList:
sats = nimmanager.getSatListForNim(slotid)
for sat in sats:
if sat[0] == transponder["orbital_position"]:
if current_slotid == -1: # mark the first valid slotid in case of no other one is free
current_slotid = slotid
self.rawchannel = resmanager.allocateRawChannel(slotid)
if self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (
slotid, sat[1])
current_slotid = slotid
break
if self.rawchannel:
break
if current_slotid == -1:
print >> log, "[AutoBouquetsMaker] No valid NIM found"
self.showError(_('No valid NIM found'))
return
if not self.rawchannel:
print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stop current service" % current_slotid
if self.session.nav.RecordTimer.isRecording():
print >> log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress"
self.showError(
_('Cannot free NIM because a record is in progress'))
return
self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
if self.session.pipshown:
self.session.pipshown = False
self.rawchannel = resmanager.allocateRawChannel(current_slotid)
if not self.rawchannel:
print >> log, "[AutoBouquetsMaker] Cannot get the NIM"
self.showError(_('Cannot get the NIM'))
return
self.frontend = self.rawchannel.getFrontend()
if not self.frontend:
print >> log, "[AutoBouquetsMaker] Cannot get frontend"
self.showError(_('Cannot get frontend'))
return
demuxer_id = self.rawchannel.reserveDemux()
if demuxer_id < 0:
print >> log, "[AutoBouquetsMaker] Cannot allocate the demuxer"
self.showError(_('Cannot allocate the demuxer'))
return
params = eDVBFrontendParametersSatellite()
params.frequency = transponder["frequency"]
params.symbol_rate = transponder["symbol_rate"]
params.polarisation = transponder["polarization"]
params.fec = transponder["fec_inner"]
params.inversion = transponder["inversion"]
params.orbital_position = transponder["orbital_position"]
params.system = transponder["system"]
params.modulation = transponder["modulation"]
params.rolloff = transponder["roll_off"]
params.pilot = transponder["pilot"]
params_fe = eDVBFrontendParameters()
params_fe.setDVBS(params, False)
self.rawchannel.requestTsidOnid()
self.frontend.tune(params_fe)
self.manager.setAdapter(0) # FIX: use the correct device
self.manager.setDemuxer(demuxer_id)
self.manager.setFrontend(current_slotid)
self.lockcounter = 0
self.locktimer = eTimer()
self.locktimer.callback.append(self.checkTunerLock)
self.locktimer.start(100, 1)
