lib/python/Plugins/SystemPlugins/Videomode/VideoHardware.py

   1 from Screens.Screen import Screen
   2 from Plugins.Plugin import PluginDescriptor
   3
   4 from enigma import eTimer
   5
   6 from Components.ActionMap import ActionMap
   7 from Components.Label import Label
   8 from Components.Pixmap import Pixmap
   9 from Screens.MessageBox import MessageBox
  10 from Screens.Setup import SetupSummary
  11 from Components.ConfigList import ConfigListScreen
  12 from Components.config import getConfigListEntry, config, ConfigSelection, ConfigSubDict, ConfigYesNo
  13
  14 from Tools.CList import CList
  15
  16 # The "VideoHardware" is the interface to /proc/stb/video.
  17 # It generates hotplug events, and gives you the list of
  18 # available and preferred modes, as well as handling the currently
  19 # selected mode. No other strict checking is done.
  20 class VideoHardware:
  21         rates = { } # high-level, use selectable modes.
  22
  23         modes = { }  # a list of (high-level) modes for a certain port.
  24
  25         rates["PAL"] =                  { "50Hz":               { 50: "pal", 60: "pal"},
  26                                                                                                 "60Hz":         { 50: "pal60", 60: "pal60"},
  27                                                                                                 "multi":        { 50: "pal", 60: "pal60"} }
  28         rates["NTSC"] =                 { "60Hz":       { 50: "ntsc", 60: "ntsc"} }
  29         rates["Multi"] =                { "multi":      { 50: "pal", 60: "ntsc"} }
  30         rates["720p"] =                 {       "50Hz":         { 50: "720p50", 60: "720p50"},
  31                                                                                                 "60Hz":         { 50: "720p", 60: "720p"},
  32                                                                                                 "multi":        { 50: "720p50", 60: "720p"} }
  33         rates["1080i"] =                { "50Hz":               { 50: "1080i50", 60: "1080i50"},
  34                                                                                                 "60Hz":         { 50: "1080i", 60: "1080i"},
  35                                                                                                 "multi":        { 50: "1080i50", 60: "1080i"} }
  36         rates["PC"] = {
  37                 "1024x768": { 60: "1024x768"}, # not possible on DM7025
  38                 "800x600" : { 60: "800x600"},  # also not possible
  39                 "720x480" : { 60: "720x480"},
  40                 "720x576" : { 60: "720x576"},
  41                 "1280x720": { 60: "1280x720"},
  42                 "1280x720 multi": { 50: "1280x720_50", 60: "1280x720"},
  43                 "1920x1080": { 60: "1920x1080"},
  44                 "1920x1080 multi": { 50: "1920x1080", 60: "1920x1080_50"},
  45                 "1280x1024" : { 60: "1280x1024"},
  46                 "1366x768" : { 60: "1366x768"},
  47                 "1366x768 multi" : { 50: "1366x768", 60: "1366x768_50"},
  48                 "1280x768": { 60: "1280x768"},
  49                 "640x480" : { 60: "640x480"}
  50         }
  51
  52         modes["Scart"] = ["PAL", "NTSC", "Multi"]
  53         modes["YPbPr"] = ["720p", "1080i"]
  54         modes["DVI"] = ["720p", "1080i", "PC"]
  55         modes["DVI-PC"] = ["PC"]
  56
  57         widescreen_modes = set(["720p", "1080i"])
  58
  59         def __init__(self):
  60                 self.last_modes_preferred =  [ ]
  61                 self.on_hotplug = CList()
  62                 self.standby = False
  63                 self.current_mode = None
  64                 self.current_port = None
  65
  66                 self.readAvailableModes()
  67
  68                 self.createConfig()
  69 #               self.on_hotplug.append(self.createConfig)
  70
  71                 self.readPreferredModes()
  72
  73                 # take over old AVSwitch component :)
  74                 from Components.AVSwitch import AVSwitch
  75 #               config.av.colorformat.notifiers = [ ]
  76                 config.av.aspectratio.notifiers = [ ]
  77                 config.av.tvsystem.notifiers = [ ]
  78                 config.av.wss.notifiers = [ ]
  79                 AVSwitch.setInput = self.AVSwitchSetInput
  80
  81                 config.av.aspect.addNotifier(self.updateAspect)
  82                 config.av.wss.addNotifier(self.updateAspect)
  83                 config.av.policy_169.addNotifier(self.updateAspect)
  84                 config.av.policy_43.addNotifier(self.updateAspect)
  85
  86                 # until we have the hotplug poll socket
  87 #               self.timer = eTimer()
  88 #               self.timer.callback.append(self.readPreferredModes)
  89 #               self.timer.start(1000)
  90
  91                 config.av.colorformat.addNotifier(self.updateFastblank)
  92
  93         def AVSwitchSetInput(self, mode):
  94                 self.standby = mode == "SCART"
  95                 self.updateStandby()
  96
  97         def readAvailableModes(self):
  98                 try:
  99                         modes = open("/proc/stb/video/videomode_choices").read()[:-1]
 100                 except IOError:
 101                         print "couldn't read available videomodes."
 102                         self.modes_available = [ ]
 103                         return
 104                 self.modes_available = modes.split(' ')
 105
 106         def readPreferredModes(self):
 107                 try:
 108                         modes = open("/proc/stb/video/videomode_preferred").read()[:-1]
 109                         self.modes_preferred = modes.split(' ')
 110                 except IOError:
 111                         print "reading preferred modes failed, using all modes"
 112                         self.modes_preferred = self.modes_available
 113
 114                 if self.modes_preferred != self.last_modes_preferred:
 115                         self.last_modes_preferred = self.modes_preferred
 116                         print "hotplug on dvi"
 117                         self.on_hotplug("DVI") # must be DVI
 118
 119         # check if a high-level mode with a given rate is available.
 120         def isModeAvailable(self, port, mode, rate):
 121                 rate = self.rates[mode][rate]
 122                 for mode in rate.values():
 123                         # DVI modes must be in "modes_preferred"
 124 #                       if port == "DVI":
 125 #                               if mode not in self.modes_preferred and not config.av.edid_override.value:
 126 #                                       print "no, not preferred"
 127 #                                       return False
 128                         if mode not in self.modes_available:
 129                                 return False
 130                 return True
 131
 132         def isWidescreenMode(self, port, mode):
 133                 return mode in self.widescreen_modes
 134
 135         def setMode(self, port, mode, rate, force = None):
 136                 print "setMode - port:", port, "mode:", mode, "rate:", rate
 137                 # we can ignore "port"
 138                 self.current_mode = mode
 139                 self.current_port = port
 140                 modes = self.rates[mode][rate]
 141
 142                 mode_50 = modes.get(50)
 143                 mode_60 = modes.get(60)
 144                 if mode_50 is None or force == 60:
 145                         mode_50 = mode_60
 146                 if mode_60 is None or force == 50:
 147                         mode_60 = mode_50
 148
 149                 try:
 150                         open("/proc/stb/video/videomode_50hz", "w").write(mode_50)
 151                         open("/proc/stb/video/videomode_60hz", "w").write(mode_60)
 152                 except IOError:
 153                         try:
 154                                 # fallback if no possibility to setup 50/60 hz mode
 155                                 open("/proc/stb/video/videomode", "w").write(mode_50)
 156                         except IOError:
 157                                 print "setting videomode failed."
 158
 159                 try:
 160                         open("/etc/videomode", "w").write(mode_50) # use 50Hz mode (if available) for booting
 161                 except IOError:
 162                         print "writing initial videomode to /etc/videomode failed."
 163
 164                 self.updateAspect(None)
 165
 166         def saveMode(self, port, mode, rate):
 167                 config.av.videoport.value = port
 168                 config.av.videoport.save()
 169                 config.av.videomode[port].value = mode
 170                 config.av.videomode[port].save()
 171                 config.av.videorate[mode].value = rate
 172                 config.av.videorate[mode].save()
 173
 174         def isPortAvailable(self, port):
 175                 # fixme
 176                 return True
 177
 178         def isPortUsed(self, port):
 179                 if port == "DVI":
 180                         self.readPreferredModes()
 181                         return len(self.modes_preferred) != 0
 182                 else:
 183                         return True
 184
 185         def getPortList(self):
 186                 return [port for port in self.modes if self.isPortAvailable(port)]
 187
 188         # get a list with all modes, with all rates, for a given port.
 189         def getModeList(self, port):
 190                 print "getModeList for port", port
 191                 res = [ ]
 192                 for mode in self.modes[port]:
 193                         # list all rates which are completely valid
 194                         rates = [rate for rate in self.rates[mode] if self.isModeAvailable(port, mode, rate)]
 195
 196                         # if at least one rate is ok, add this mode
 197                         if len(rates):
 198                                 res.append( (mode, rates) )
 199                 return res
 200
 201         def createConfig(self, *args):
 202                 # create list of output ports
 203                 portlist = self.getPortList()
 204
 205                 # create list of available modes
 206                 config.av.videoport = ConfigSelection(choices = [(port, _(port)) for port in portlist])
 207                 config.av.videomode = ConfigSubDict()
 208                 config.av.videorate = ConfigSubDict()
 209
 210                 for port in portlist:
 211                         modes = self.getModeList(port)
 212                         if len(modes):
 213                                 config.av.videomode[port] = ConfigSelection(choices = [mode for (mode, rates) in modes])
 214                         for (mode, rates) in modes:
 215                                 config.av.videorate[mode] = ConfigSelection(choices = rates)
 216
 217         def setConfiguredMode(self):
 218                 port = config.av.videoport.value
 219                 if port not in config.av.videomode:
 220                         print "current port not available, not setting videomode"
 221                         return
 222
 223                 mode = config.av.videomode[port].value
 224
 225                 if mode not in config.av.videorate:
 226                         print "current mode not available, not setting videomode"
 227                         return
 228
 229                 rate = config.av.videorate[mode].value
 230                 self.setMode(port, mode, rate)
 231
 232         def updateAspect(self, cfgelement):
 233                 # determine aspect = {any,4:3,16:9,16:10}
 234                 # determine policy = {bestfit,letterbox,panscan,nonlinear}
 235
 236                 # based on;
 237                 #   config.av.videoport.value: current video output device
 238                 #     Scart:
 239                 #   config.av.aspect:
 240                 #     4_3:            use policy_169
 241                 #     16_9,16_10:     use policy_43
 242                 #     auto            always "bestfit"
 243                 #   config.av.policy_169
 244                 #     letterbox       use letterbox
 245                 #     panscan         use panscan
 246                 #     scale           use bestfit
 247                 #   config.av.policy_43
 248                 #     pillarbox       use panscan
 249                 #     panscan         use letterbox  ("panscan" is just a bad term, it's inverse-panscan)
 250                 #     nonlinear       use nonlinear
 251                 #     scale           use bestfit
 252
 253                 port = config.av.videoport.value
 254                 if port not in config.av.videomode:
 255                         print "current port not available, not setting videomode"
 256                         return
 257                 mode = config.av.videomode[port].value
 258
 259                 force_widescreen = self.isWidescreenMode(port, mode)
 260
 261                 is_widescreen = force_widescreen or config.av.aspect.value in ["16_9", "16_10"]
 262                 is_auto = config.av.aspect.value == "auto"
 263
 264                 if is_widescreen:
 265                         if force_widescreen:
 266                                 aspect = "16:9"
 267                         else:
 268                                 aspect = {"16_9": "16:9", "16_10": "16:10"}[config.av.aspect.value]
 269                         policy = {"pillarbox": "panscan", "panscan": "letterbox", "nonlinear": "nonlinear", "scale": "bestfit"}[config.av.policy_43.value]
 270                 elif is_auto:
 271                         aspect = "any"
 272                         policy = "bestfit"
 273                 else:
 274                         aspect = "4:3"
 275                         policy = {"letterbox": "letterbox", "panscan": "panscan", "scale": "bestfit"}[config.av.policy_169.value]
 276
 277                 if not config.av.wss.value:
 278                         wss = "auto(4:3_off)"
 279                 else:
 280                         wss = "auto"
 281
 282                 print "-> setting aspect, policy, wss", aspect, policy, wss
 283                 open("/proc/stb/video/aspect", "w").write(aspect)
 284                 open("/proc/stb/video/policy", "w").write(policy)
 285                 open("/proc/stb/denc/0/wss", "w").write(wss)
 286                 self.updateSlowblank()
 287                 self.updateFastblank()
 288
 289         def updateSlowblank(self):
 290                 if self.standby:
 291                         from Components.SystemInfo import SystemInfo
 292                         if SystemInfo["ScartSwitch"]:
 293                                 input = "scart"
 294                                 sb = "vcr"
 295                         else:
 296                                 input = "off"
 297                                 sb = "0"
 298                 else:
 299                         input = "encoder"
 300                         sb = "auto"
 301
 302                 open("/proc/stb/avs/0/sb", "w").write(sb)
 303                 open("/proc/stb/avs/0/input", "w").write(input)
 304
 305         def updateStandby(self):
 306                 self.updateSlowblank()
 307                 self.updateFastblank()
 308
 309         def updateFastblank(self, *args):
 310                 if self.standby:
 311                         from Components.SystemInfo import SystemInfo
 312                         if SystemInfo["ScartSwitch"]:
 313                                 fb = "vcr"
 314                         else:
 315                                 fb = "low"
 316                 else:
 317                         if self.current_port == "Scart" and config.av.colorformat.value == "rgb":
 318                                 fb = "high"
 319                         else:
 320                                 fb = "low"
 321                 open("/proc/stb/avs/0/fb", "w").write(fb)
 322
 323 config.av.edid_override = ConfigYesNo(default = False)
 324 video_hw = VideoHardware()
 325 video_hw.setConfiguredMode()