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, ConfigNothing, ConfigSlider
+from Components.Sources.StaticText import StaticText
-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 Screens.Setup import SetupSummary
-from Components.ConfigList import ConfigListScreen
-from Components.config import getConfigListEntry, config, ConfigNothing, ConfigSelection, ConfigSubDict
-
-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.on_hotplug.append(self.createConfig)
- 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
-
- def createConfig(self, *args):
- # create list of output ports
- portlist = self.getPortList()
-
- # create list of available modes
- config.av.videoport = ConfigSelection(choices = [(port, _(port)) for port in portlist])
- config.av.videomode = ConfigSubDict()
- config.av.videorate = ConfigSubDict()
-
- for port in portlist:
- modes = self.getModeList(port)
- if len(modes):
- config.av.videomode[port] = ConfigSelection(choices = [mode for (mode, rates) in modes])
- for (mode, rates) in modes:
- config.av.videorate[mode] = ConfigSelection(choices = rates)
-
-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"
+ # for the skin: first try VideoSetup, then Setup, this allows individual skinning
+ self.skinName = ["VideoSetup", "Setup" ]
+ self.setup_title = _("A/V Settings")
self.hw = hw
self.onChangedEntry = [ ]
self.list = [ ]
ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changedEntry)
+ from Components.ActionMap import ActionMap
self["actions"] = ActionMap(["SetupActions"],
{
"cancel": self.keyCancel,
"save": self.apply,
}, -2)
- self["title"] = Label(_("Video-Setup"))
-
- self["oktext"] = Label(_("OK"))
- self["canceltext"] = Label(_("Cancel"))
- self["ok"] = Pixmap()
- self["cancel"] = Pixmap()
+ self["key_red"] = StaticText(_("Cancel"))
+ self["key_green"] = StaticText(_("OK"))
self.createSetup()
self.grabLastGoodMode()
+ self.onLayoutFinish.append(self.layoutFinished)
+
+ def layoutFinished(self):
+ self.setTitle(self.setup_title)
def startHotplug(self):
self.hw.on_hotplug.append(self.createSetup)
self.hw.on_hotplug.remove(self.createSetup)
def createSetup(self):
- self.list = [ ]
- self.list.append(getConfigListEntry(_("Output Type"), config.av.videoport))
+ level = config.usage.setup_level.index
+
+ self.list = [
+ getConfigListEntry(_("Video Output"), config.av.videoport)
+ ]
# if we have modes for this port:
if config.av.videoport.value in config.av.videomode:
# add mode- and rate-selection:
self.list.append(getConfigListEntry(_("Mode"), config.av.videomode[config.av.videoport.value]))
- self.list.append(getConfigListEntry(_("Rate"), config.av.videorate[config.av.videomode[config.av.videoport.value].value]))
+ if config.av.videomode[config.av.videoport.value].value == 'PC':
+ self.list.append(getConfigListEntry(_("Resolution"), config.av.videorate[config.av.videomode[config.av.videoport.value].value]))
+ else:
+ 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.extend((
+ getConfigListEntry(_("Display 4:3 content as"), config.av.policy_43),
+ getConfigListEntry(_("Display >16:9 content as"), config.av.policy_169)
+ ))
+ 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.list.extend((
+ getConfigListEntry(_("General AC3 Delay"), config.av.generalAC3delay),
+ getConfigListEntry(_("General PCM Delay"), config.av.generalPCMdelay)
+ ))
+
+ if SystemInfo["CanChangeOsdAlpha"]:
+ self.list.append(getConfigListEntry(_("OSD visibility"), config.av.osd_alpha))
+
+ if not isinstance(config.av.scaler_sharpness, ConfigNothing):
+ self.list.append(getConfigListEntry(_("Scaler sharpness"), config.av.scaler_sharpness))
self["config"].list = self.list
self["config"].l.setList(self.list)
def confirm(self, confirmed):
if not confirmed:
+ config.av.videoport.value = self.last_good[0]
+ config.av.videomode[self.last_good[0]].value = self.last_good[1]
+ config.av.videorate[self.last_good[1]].value = self.last_good[2]
self.hw.setMode(*self.last_good)
else:
self.keySave()
port = config.av.videoport.value
mode = config.av.videomode[port].value
rate = config.av.videorate[mode].value
- if (port, mode, rate) != self.last_good or True:
+ if (port, mode, rate) != self.last_good:
self.hw.setMode(port, mode, rate)
- self.session.openWithCallback(self.confirm, MessageBox, "Is this videomode ok?", MessageBox.TYPE_YESNO, timeout = 5, default = False)
+ from Screens.MessageBox import MessageBox
+ self.session.openWithCallback(self.confirm, MessageBox, _("Is this videomode ok?"), MessageBox.TYPE_YESNO, timeout = 20, default = False)
else:
self.keySave()
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
-# 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()
+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)
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
git.cweiske.de / enigma2.git / blobdiff