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