X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/f55319ddea837e4ec2dac563228d42b886719d9b..327ae996e0a3a685dff1663f600493e103adb098:/lib/python/Plugins/SystemPlugins/Videomode/plugin.py diff --git a/lib/python/Plugins/SystemPlugins/Videomode/plugin.py b/lib/python/Plugins/SystemPlugins/Videomode/plugin.py index e40914b3..115e81f7 100644 --- a/lib/python/Plugins/SystemPlugins/Videomode/plugin.py +++ b/lib/python/Plugins/SystemPlugins/Videomode/plugin.py @@ -1,194 +1,96 @@ from Screens.Screen import Screen from Plugins.Plugin import PluginDescriptor +from Components.SystemInfo import SystemInfo +from Components.ConfigList import ConfigListScreen +from Components.config import getConfigListEntry, config, ConfigBoolean -from enigma import eTimer +from VideoHardware import video_hw -from Components.ActionMap import ActionMap -from Components.Label import Label -from Components.Pixmap import Pixmap -from Screens.MessageBox import MessageBox -from Components.ConfigList import ConfigListScreen -from Components.config import getConfigListEntry, config, ConfigNothing -from Components.config import ConfigSelection - -from Tools.CList import CList - -# The "VideoHardware" is the interface to /proc/stb/video. -# It generates hotplug events, and gives you the list of -# available and preferred modes, as well as handling the currently -# selected mode. No other strict checking is done. -class VideoHardware: - rates = { } # high-level, use selectable modes. - - modes = { } # a list of (high-level) modes for a certain port. - - rates["PAL"] = { "50Hz": { 50: "pal", 60: "pal"}, - "60Hz": { 50: "pal60", 60: "pal60"}, - "multi": { 50: "pal", 60: "pal60"} } - rates["NTSC"] = { "60Hz": { 50: "ntsc", 60: "ntsc"} } - rates["Multi"] = { "multi": { 50: "pal", 60: "ntsc"} } - rates["720p"] = { "50Hz": { 50: "720p50", 60: "720p50"}, - "60Hz": { 50: "720p", 60: "720p"}, - "multi": { 50: "720p50", 60: "720p"} } - rates["1080i"] = { "50Hz": { 50: "1080i50", 60: "1080i50"}, - "60Hz": { 50: "1080i", 60: "1080i"}, - "multi": { 50: "1080i50", 60: "1080i"} } - rates["PC"] = { - "1024x768": { 60: "1024x768"}, # not possible on DM7025 - "800x600" : { 60: "800x600"}, # also not possible - "720x480" : { 60: "720x480"}, - "720x576" : { 60: "720x576"}, - "1280x720": { 60: "1280x720"}, - "1280x720 multi": { 50: "1280x720_50", 60: "1280x720"}, - "1920x1080": { 60: "1920x1080"}, - "1920x1080 multi": { 50: "1920x1080", 60: "1920x1080_50"}, - "1280x1024" : { 60: "1280x1024"}, - "640x480" : { 60: "640x480"} - } - - modes["Scart"] = ["PAL", "NTSC", "Multi"] - modes["YPrPb"] = ["720p", "1080i"] - modes["DVI"] = ["720p", "1080i", "PC"] - - def __init__(self): - self.last_modes_preferred = [ ] - self.on_hotplug = CList() - self.ignore_preferred = False # "edid override" - - self.readAvailableModes() - self.readPreferredModes() - - # until we have the hotplug poll socket - self.timer = eTimer() - self.timer.timeout.get().append(self.readAvailableModes) - self.timer.start(1000) - - def readAvailableModes(self): - try: - modes = open("/proc/stb/video/videomode_choices").read()[:-1] - except IOError: - print "couldn't read available videomodes." - self.modes_available = [ ] - return - self.modes_available = modes.split(' ') - - def readPreferredModes(self): - try: - modes = open("/proc/stb/video/videomode_preferred").read()[:-1] - self.modes_preferred = modes.split(' ') - except IOError: - print "reading preferred modes failed, using all modes" - self.modes_preferred = self.modes_available - - if self.modes_preferred != self.last_modes_preferred: - self.last_modes_preferred = self.modes_preferred - self.on_hotplug("DVI") # must be DVI - - # check if a high-level mode with a given rate is available. - def isModeAvailable(self, port, mode, rate): - rate = self.rates[mode][rate] - for mode in rate.values(): - # DVI modes must be in "modes_preferred" - if port == "DVI": - if mode not in self.modes_preferred and not self.ignore_preferred: - return False - if mode not in self.modes_available: - return False - return True - - def setMode(self, port, mode, rate): - # we can ignore "port" - self.current_mode = mode - modes = self.rates[mode][rate] - - mode_50 = modes.get(50) - mode_60 = modes.get(60) - if mode_50 is None: - mode_50 = mode_60 - if mode_60 is None: - mode_60 = mode_50 - - try: - open("/proc/stb/video/videomode_60hz", "w").write(mode_50) - open("/proc/stb/video/videomode_50hz", "w").write(mode_60) - except IOError: - try: - # fallback if no possibility to setup 50/60 hz mode - open("/proc/stb/video/videomode", "w").write(mode_50) - except IOError: - print "setting videomode failed." - - def isPortAvailable(self, port): - # fixme - return True - - def getPortList(self): - return [port for port in self.modes if self.isPortAvailable(port)] - - # get a list with all modes, with all rates, for a given port. - def getModeList(self, port): - res = [ ] - for mode in self.modes[port]: - # list all rates which are completely valid - rates = [rate for rate in self.rates[mode] if self.isModeAvailable(port, mode, rate)] - - # if at least one rate is ok, add this mode - if len(rates): - res.append( (mode, rates) ) - return res - -video_hw = VideoHardware() +config.misc.videowizardenabled = ConfigBoolean(default = True) class VideoSetup(Screen, ConfigListScreen): def __init__(self, session, hw): Screen.__init__(self, session) self.skinName = "Setup" + self.setup_title = "Videomode Setup" self.hw = hw + self.onChangedEntry = [ ] + + # handle hotplug by re-creating setup + self.onShow.append(self.startHotplug) + self.onHide.append(self.stopHotplug) self.list = [ ] - ConfigListScreen.__init__(self, self.list) + ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changedEntry) - self["actions"] = ActionMap(["OkCancelActions"], + from Components.ActionMap import ActionMap + self["actions"] = ActionMap(["SetupActions"], { - "ok": self.ok, - "cancel": self.cancel - },-1) + "cancel": self.keyCancel, + "save": self.apply, + }, -2) - self["title"] = Label(_("Video-Setup")) + from Components.Label import Label + self["title"] = Label(_("A/V Settings")) self["oktext"] = Label(_("OK")) self["canceltext"] = Label(_("Cancel")) + + from Components.Pixmap import Pixmap self["ok"] = Pixmap() self["cancel"] = Pixmap() - # the following data is static for user selection, however not static for different attached hardware. - - # create list of output ports - portlist = self.hw.getPortList() + self.createSetup() + self.grabLastGoodMode() - # create list of available modes - self.config_port = ConfigSelection(choices = [(port, _(port)) for port in portlist]) - self.config_mode = { } - self.config_rate = { } + def startHotplug(self): + self.hw.on_hotplug.append(self.createSetup) - for port in portlist: - modes = self.hw.getModeList(port) - print "port:", port, "modes:", modes - if len(modes): - self.config_mode[port] = ConfigSelection(choices = [mode for (mode, rates) in modes]) - for (mode, rates) in modes: - self.config_rate[mode] = ConfigSelection(choices = rates) - self.createSetup() + def stopHotplug(self): + self.hw.on_hotplug.remove(self.createSetup) def createSetup(self): + level = config.usage.setup_level.index + self.list = [ ] - self.list.append(getConfigListEntry(_("Output Type"), self.config_port)) + self.list.append(getConfigListEntry(_("Video Output"), config.av.videoport)) # if we have modes for this port: - if self.config_port.value in self.config_mode: + if config.av.videoport.value in config.av.videomode: # add mode- and rate-selection: - self.list.append(getConfigListEntry(_("Mode"), self.config_mode[self.config_port.value])) - self.list.append(getConfigListEntry(_("Rate"), self.config_rate[self.config_mode[self.config_port.value].value])) + self.list.append(getConfigListEntry(_("Mode"), config.av.videomode[config.av.videoport.value])) + self.list.append(getConfigListEntry(_("Refresh Rate"), config.av.videorate[config.av.videomode[config.av.videoport.value].value])) + + port = config.av.videoport.value + if port not in config.av.videomode: + mode = None + else: + mode = config.av.videomode[port].value + + # some modes (720p, 1080i) are always widescreen. Don't let the user select something here, "auto" is not what he wants. + force_wide = self.hw.isWidescreenMode(port, mode) + + if not force_wide: + self.list.append(getConfigListEntry(_("Aspect Ratio"), config.av.aspect)) + + if force_wide or config.av.aspect.value in ["16_9", "16_10"]: + self.list.append(getConfigListEntry(_("Display 4:3 content as"), config.av.policy_43)) + elif config.av.aspect.value == "4_3": + self.list.append(getConfigListEntry(_("Display 16:9 content as"), config.av.policy_169)) + +# if config.av.videoport.value == "DVI": +# self.list.append(getConfigListEntry(_("Allow Unsupported Modes"), config.av.edid_override)) + if config.av.videoport.value == "Scart": + self.list.append(getConfigListEntry(_("Color Format"), config.av.colorformat)) + if level >= 1: + self.list.append(getConfigListEntry(_("WSS on 4:3"), config.av.wss)) + if SystemInfo["ScartSwitch"]: + self.list.append(getConfigListEntry(_("Auto scart switching"), config.av.vcrswitch)) + + if level >= 1: + self.list.append(getConfigListEntry(_("AC3 default"), config.av.defaultac3)) + if SystemInfo["CanDownmixAC3"]: + self.list.append(getConfigListEntry(_("AC3 downmix"), config.av.downmix_ac3)) self["config"].list = self.list self["config"].l.setList(self.list) @@ -201,53 +103,93 @@ class VideoSetup(Screen, ConfigListScreen): ConfigListScreen.keyRight(self) self.createSetup() - def cancel(self): - self.close() - - def confirm(self, do_revert): - if do_revert: - print "cannot revert yet :)" + def confirm(self, confirmed): + if not confirmed: + self.hw.setMode(*self.last_good) + else: + self.keySave() + + def grabLastGoodMode(self): + port = config.av.videoport.value + mode = config.av.videomode[port].value + rate = config.av.videorate[mode].value + self.last_good = (port, mode, rate) + + def apply(self): + port = config.av.videoport.value + mode = config.av.videomode[port].value + rate = config.av.videorate[mode].value + if (port, mode, rate) != self.last_good: + self.hw.setMode(port, mode, rate) + from Screens.MessageBox import MessageBox + self.session.openWithCallback(self.confirm, MessageBox, "Is this videomode ok?", MessageBox.TYPE_YESNO, timeout = 20, default = False) else: - self.close() - - def ok(self): - port = self.config_port.value - mode = self.config_mode[port].value - rate = self.config_rate[mode].value - self.hw.setMode(port, mode, rate) - self.session.openWithCallback(self.confirm, MessageBox, "Revert to old settings?", MessageBox.TYPE_YESNO, timeout = 5) - -#class VideomodeHotplug: -# def __init__(self, hw): -# self.hw = hw -# self.hw.on_hotplug.append(self.hotplug) -# -# def hotplug(self, what): -# print "hotplug detected on port '%s'" % (what) -# ... -# -#hotplug = None -# -#def startHotplug(self): -# global hotplug -# hotplug = VideomodeHotplug() -# hotplug.start() -# -#def stopHotplug(self): -# global hotplug -# hotplug.stop() -# -# -#def autostart(reason, session = None, **kwargs): -# if session is not None: -# global my_global_session -# my_global_session = session -# return -# -# if reason == 0: -# startHotplug() -# elif reason == 1: -# stopHotplug() + self.keySave() + + # for summary: + def changedEntry(self): + for x in self.onChangedEntry: + x() + + def getCurrentEntry(self): + return self["config"].getCurrent()[0] + + def getCurrentValue(self): + return str(self["config"].getCurrent()[1].getText()) + + def createSummary(self): + from Screens.Setup import SetupSummary + return SetupSummary + +class VideomodeHotplug: + def __init__(self, hw): + self.hw = hw + + def start(self): + self.hw.on_hotplug.append(self.hotplug) + + def stop(self): + self.hw.on_hotplug.remove(self.hotplug) + + def hotplug(self, what): + print "hotplug detected on port '%s'" % (what) + port = config.av.videoport.value + mode = config.av.videomode[port].value + rate = config.av.videorate[mode].value + + if not self.hw.isModeAvailable(port, mode, rate): + print "mode %s/%s/%s went away!" % (port, mode, rate) + modelist = self.hw.getModeList(port) + if not len(modelist): + print "sorry, no other mode is available (unplug?). Doing nothing." + return + mode = modelist[0][0] + rate = modelist[0][1] + print "setting %s/%s/%s" % (port, mode, rate) + self.hw.setMode(port, mode, rate) + +hotplug = None + +def startHotplug(): + global hotplug, video_hw + hotplug = VideomodeHotplug(video_hw) + hotplug.start() + +def stopHotplug(): + global hotplug + hotplug.stop() + + +def autostart(reason, session = None, **kwargs): + if session is not None: + global my_global_session + my_global_session = session + return + + if reason == 0: + startHotplug() + elif reason == 1: + stopHotplug() def videoSetupMain(session, **kwargs): session.open(VideoSetup, video_hw) @@ -256,10 +198,17 @@ def startSetup(menuid): if menuid != "system": return [ ] - return [(_("Video Setup"), videoSetupMain, "video_setup", None)] + return [(_("A/V Settings") + "...", videoSetupMain, "av_setup", 40)] + +def VideoWizard(*args, **kwargs): + from VideoWizard import VideoWizard + return VideoWizard(*args, **kwargs) def Plugins(**kwargs): - return [ -# PluginDescriptor(where = [PluginDescriptor.WHERE_SESSIONSTART, PluginDescriptor.WHERE_AUTOSTART], fnc = autostart), - PluginDescriptor(name=_("Video Setup"), description=_("Advanced Video Setup"), where = PluginDescriptor.WHERE_MENU, fnc=startSetup) + list = [ +# PluginDescriptor(where = [PluginDescriptor.WHERE_SESSIONSTART, PluginDescriptor.WHERE_AUTOSTART], fnc = autostart), + PluginDescriptor(name=_("Video Setup"), description=_("Advanced Video Setup"), where = PluginDescriptor.WHERE_MENU, fnc=startSetup) ] + if config.misc.videowizardenabled.value: + list.append(PluginDescriptor(name=_("Video Wizard"), where = PluginDescriptor.WHERE_WIZARD, fnc=(0, VideoWizard))) + return list