--- /dev/null
+from Screens.Screen import Screen
+from Plugins.Plugin import PluginDescriptor
+
+from enigma import eTimer
+
+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()
+
+class VideoSetup(Screen, ConfigListScreen):
+ def __init__(self, session, hw):
+ Screen.__init__(self, session)
+ self.skinName = "Setup"
+ self.hw = hw
+
+ self.list = [ ]
+ ConfigListScreen.__init__(self, self.list)
+
+ self["actions"] = ActionMap(["OkCancelActions"],
+ {
+ "ok": self.ok,
+ "cancel": self.cancel
+ },-1)
+
+ self["title"] = Label(_("Video-Setup"))
+
+ self["oktext"] = Label(_("OK"))
+ self["canceltext"] = Label(_("Cancel"))
+ 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()
+
+ # create list of available modes
+ self.config_port = ConfigSelection(choices = [(port, _(port)) for port in portlist])
+ self.config_mode = { }
+ self.config_rate = { }
+
+ 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 createSetup(self):
+ self.list = [ ]
+ self.list.append(getConfigListEntry(_("Output Type"), self.config_port))
+
+ # if we have modes for this port:
+ if self.config_port.value in self.config_mode:
+ # 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["config"].list = self.list
+ self["config"].l.setList(self.list)
+
+ def keyLeft(self):
+ ConfigListScreen.keyLeft(self)
+ self.createSetup()
+
+ def keyRight(self):
+ ConfigListScreen.keyRight(self)
+ self.createSetup()
+
+ def cancel(self):
+ self.close()
+
+ def confirm(self, do_revert):
+ if do_revert:
+ print "cannot revert yet :)"
+ 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()
+
+def videoSetupMain(session, **kwargs):
+ session.open(VideoSetup, video_hw)
+
+def startSetup(menuid):
+ if menuid != "system":
+ return [ ]
+
+ return [(_("Video Setup"), videoSetupMain, "video_setup", None)]
+
+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)
+ ]
git.cweiske.de / enigma2.git / commitdiff