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