lib/python/Plugins/SystemPlugins/VideoEnhancement/plugin.py

   1 from Plugins.Plugin import PluginDescriptor
   2 from Components.ConfigList import ConfigListScreen
   3 from Components.config import getConfigListEntry, config, ConfigBoolean
   4 from Components.ActionMap import ActionMap
   5 from Components.Button import Button
   6 from Components.Label import Label
   7 from Screens.Screen import Screen
   8 from Screens.VirtualKeyBoard import VirtualKeyBoard
   9 from Screens.ChoiceBox import ChoiceBox
  10 from Screens.MessageBox import MessageBox
  11 from enigma import ePoint
  12 from Tools import Notifications
  13 from Tools.HardwareInfo import HardwareInfo
  14 from VideoEnhancement import video_enhancement
  15 import os
  16
  17 class VideoEnhancementSetup(Screen, ConfigListScreen):
  18
  19         skin = """
  20                 <screen name="VideoEnhancementSetup" position="center,center" size="560,430" title="VideoEnhancementSetup">
  21                 <ePixmap pixmap="skin_default/buttons/red.png" position="0,0" size="140,40" alphatest="on" />
  22                 <ePixmap pixmap="skin_default/buttons/green.png" position="140,0" size="140,40" alphatest="on" />
  23                 <ePixmap pixmap="skin_default/buttons/yellow.png" position="280,0" size="140,40" alphatest="on" />
  24                 <ePixmap pixmap="skin_default/buttons/blue.png" position="420,0" size="140,40" alphatest="on" />
  25                 <widget name="key_red" position="0,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" />
  26                 <widget name="key_green" position="140,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
  27                 <widget name="key_yellow" position="280,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" transparent="1" />
  28                 <widget name="key_blue" position="420,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" transparent="1" />
  29                 <widget name="config" position="5,50" size="550,340" scrollbarMode="showOnDemand" />
  30                 <ePixmap pixmap="skin_default/div-h.png" position="0,390" zPosition="1" size="560,2" />
  31                 <widget name="introduction" position="5,400" size="550,25" zPosition="10" font="Regular;21" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
  32
  33         </screen>"""
  34
  35         def __init__(self, session, hw):
  36                 Screen.__init__(self, session)
  37
  38                 self.session = session
  39                 self.hw = hw
  40                 self.onChangedEntry = [ ]
  41                 self.setup_title = "Videoenhancement"
  42
  43                 self.contrastEntry = None
  44                 self.saturationEntry = None
  45                 self.hueEntry = None
  46                 self.brightnessEntry = None
  47                 self.splitEntry = None
  48                 self.sharpnessEntry = None
  49                 self.auto_fleshEntry = None
  50                 self.green_boostEntry = None
  51                 self.blue_boostEntry = None
  52                 self.block_noise_reductionEntry = None
  53                 self.mosquito_noise_reductionEntry = None
  54                 self.digital_contour_removalEntry = None
  55                 self.dynamic_contrastEntry = None
  56
  57                 # handle hotplug by re-creating setup
  58                 self.onShow.append(self.startHotplug)
  59                 self.onHide.append(self.stopHotplug)
  60
  61                 self.list = [ ]
  62                 self.xtdlist = [ ]
  63                 self.hw_type = HardwareInfo().get_device_name()
  64                 ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry)
  65
  66                 self["actions"] = ActionMap(["SetupActions", "ColorActions"],
  67                         {
  68                                 "cancel": self.keyCancel,
  69                                 "save": self.apply,
  70                                 "yellow": self.keyYellow,
  71                                 "blue": self.keyBlue,
  72                         }, -2)
  73
  74                 self["key_red"] = Button(_("Cancel"))
  75                 self["key_green"] = Button(_("OK"))
  76                 self["key_yellow"] = Button(_("Last config"))
  77                 self["key_blue"] = Button(_("Default"))
  78                 self["introduction"] = Label()
  79
  80                 self.createSetup()
  81                 self.rememberOldSettings()
  82                 self.onLayoutFinish.append(self.layoutFinished)
  83
  84         def layoutFinished(self):
  85                 self.setTitle(_("Video enhancement setup"))
  86
  87         def startHotplug(self):
  88                 self.hw.on_hotplug.append(self.createSetup)
  89
  90         def stopHotplug(self):
  91                 self.hw.on_hotplug.remove(self.createSetup)
  92
  93         def rememberOldSettings(self):
  94                 self.oldContrast = config.pep.contrast.value
  95                 self.oldSaturation = config.pep.saturation.value
  96                 self.oldHue = config.pep.hue.value
  97                 self.oldBrightness = config.pep.brightness.value
  98                 self.oldBlock_noise = config.pep.block_noise_reduction.value
  99                 self.oldMosquito_noise = config.pep.mosquito_noise_reduction.value
 100                 self.oldDigital_contour = config.pep.digital_contour_removal.value
 101                 if self.hw_type == 'dm8000':
 102                         self.oldSplit = config.pep.split.value
 103                         self.oldSharpness = config.pep.sharpness.value
 104                         self.oldAuto_flesh = config.pep.auto_flesh.value
 105                         self.oldGreen_boost = config.pep.green_boost.value
 106                         self.oldBlue_boost = config.pep.blue_boost.value
 107                         self.oldDynamic_contrast = config.pep.dynamic_contrast.value
 108
 109         def createSetup(self):
 110                 self.contrastEntry = getConfigListEntry(_("Contrast"), config.pep.contrast)
 111                 self.saturationEntry = getConfigListEntry(_("Saturation"), config.pep.saturation)
 112                 self.hueEntry = getConfigListEntry(_("Hue"), config.pep.hue)
 113                 self.brightnessEntry = getConfigListEntry(_("Brightness"), config.pep.brightness)
 114                 self.block_noise_reductionEntry = getConfigListEntry(_("Block noise reduction"), config.pep.block_noise_reduction)
 115                 self.mosquito_noise_reductionEntry = getConfigListEntry(_("Mosquito noise reduction"), config.pep.mosquito_noise_reduction)
 116                 self.digital_contour_removalEntry = getConfigListEntry(_("Digital contour removal"), config.pep.digital_contour_removal)
 117
 118                 self.list = [
 119                         self.contrastEntry
 120                 ]
 121
 122                 self.list.extend((
 123                         self.saturationEntry,
 124                         self.hueEntry,
 125                         self.brightnessEntry
 126                 ))
 127                 if self.hw_type == 'dm800':
 128                         self.list.extend((
 129                                 self.block_noise_reductionEntry,
 130                                 self.mosquito_noise_reductionEntry,
 131                                 self.digital_contour_removalEntry
 132                         ))
 133
 134                 elif self.hw_type == 'dm8000':
 135                         self.splitEntry = getConfigListEntry(_("Split preview mode"), config.pep.split)
 136                         self.sharpnessEntry = getConfigListEntry(_("Sharpness"), config.pep.sharpness)
 137                         self.auto_fleshEntry = getConfigListEntry(_("Auto flesh"), config.pep.auto_flesh)
 138                         self.green_boostEntry = getConfigListEntry(_("Green boost"), config.pep.green_boost)
 139                         self.blue_boostEntry = getConfigListEntry(_("Blue boost"), config.pep.blue_boost)
 140                         self.dynamic_contrastEntry = getConfigListEntry(_("Dynamic contrast"), config.pep.dynamic_contrast)
 141
 142                         self.xtdlist = [
 143                                 self.splitEntry
 144                         ]
 145
 146                         self.xtdlist.extend((
 147                                 self.sharpnessEntry,
 148                                 self.auto_fleshEntry,
 149                                 self.green_boostEntry,
 150                                 self.blue_boostEntry,
 151                                 self.block_noise_reductionEntry,
 152                                 self.mosquito_noise_reductionEntry,
 153                                 self.digital_contour_removalEntry,
 154                                 self.dynamic_contrastEntry
 155                         ))
 156
 157                         self.list.extend((
 158                                 self.splitEntry,
 159                                 self.sharpnessEntry,
 160                                 self.auto_fleshEntry,
 161                                 self.green_boostEntry,
 162                                 self.blue_boostEntry,
 163                                 self.block_noise_reductionEntry,
 164                                 self.mosquito_noise_reductionEntry,
 165                                 self.digital_contour_removalEntry,
 166                                 self.dynamic_contrastEntry
 167                         ))
 168
 169                 self["config"].list = self.list
 170                 self["config"].l.setSeperation(300)
 171                 self["config"].l.setList(self.list)
 172                 if not self.selectionChanged in self["config"].onSelectionChanged:
 173                         self["config"].onSelectionChanged.append(self.selectionChanged)
 174                 self.selectionChanged()
 175
 176         def selectionChanged(self):
 177                 self["introduction"].setText(_("Current value: ") + self.getCurrentValue())
 178
 179         def PreviewClosed(self):
 180                 self["config"].invalidate(self["config"].getCurrent())
 181                 self.createSetup()
 182
 183         def keyLeft(self):
 184                 current = self["config"].getCurrent()
 185                 if current == self.splitEntry:
 186                         ConfigListScreen.keyLeft(self)
 187                         self.createSetup()
 188                 elif current != self.splitEntry and current in self.xtdlist:
 189                         self.previewlist = [
 190                                 current,
 191                                 self.splitEntry
 192                         ]
 193                         self.session.openWithCallback(self.PreviewClosed, VideoEnhancementPreview, configEntry = self.previewlist, oldSplitMode = config.pep.split.value)
 194                 else:
 195                         self.previewlist = [
 196                                 current
 197                         ]
 198                         self.session.openWithCallback(self.PreviewClosed, VideoEnhancementPreview, configEntry = self.previewlist)
 199
 200         def keyRight(self):
 201                 current = self["config"].getCurrent()
 202                 if current == self.splitEntry:
 203                         ConfigListScreen.keyRight(self)
 204                         self.createSetup()
 205                 elif current != self.splitEntry and current in self.xtdlist:
 206                         self.previewlist = [
 207                                 current,
 208                                 self.splitEntry
 209                         ]
 210                         self.session.openWithCallback(self.PreviewClosed, VideoEnhancementPreview, configEntry = self.previewlist, oldSplitMode = config.pep.split.value )
 211                 else:
 212                         self.previewlist = [
 213                                 current
 214                         ]
 215                         self.session.openWithCallback(self.PreviewClosed, VideoEnhancementPreview, configEntry = self.previewlist)
 216
 217         def confirm(self, confirmed):
 218                 if not confirmed:
 219                         print "not confirmed"
 220                 else:
 221                         if self.splitEntry is not None:
 222                                 config.pep.split.setValue('off')
 223                         self.keySave()
 224
 225         def apply(self):
 226                 self.session.openWithCallback(self.confirm, MessageBox, _("Use this video enhancement settings?"), MessageBox.TYPE_YESNO, timeout = 20, default = False)
 227
 228         def cancelConfirm(self, result):
 229                 if not result:
 230                         return
 231                 self.keyYellowConfirm(True)
 232                 self.close()
 233
 234         def keyCancel(self):
 235                 if self["config"].isChanged():
 236                         self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
 237                 else:
 238                         self.close()
 239
 240         def keyYellowConfirm(self, confirmed):
 241                 if not confirmed:
 242                         print "not confirmed"
 243                 else:
 244                         if self.contrastEntry is not None:
 245                                 config.pep.contrast.setValue(self.oldContrast)
 246                         if self.saturationEntry is not None:
 247                                 config.pep.saturation.setValue(self.oldSaturation)
 248                         if self.hueEntry is not None:
 249                                 config.pep.hue.setValue(self.oldHue)
 250                         if self.brightnessEntry is not None:
 251                                 config.pep.brightness.setValue(self.oldBrightness)
 252                         if self.block_noise_reductionEntry is not None:
 253                                 config.pep.block_noise_reduction.setValue(self.oldBlock_noise)
 254                         if self.mosquito_noise_reductionEntry is not None:
 255                                 config.pep.mosquito_noise_reduction.setValue(self.oldMosquito_noise)
 256                         if self.digital_contour_removalEntry is not None:
 257                                 config.pep.digital_contour_removal.setValue(self.oldDigital_contour)
 258
 259                         if self.hw_type == 'dm8000':
 260                                 if self.splitEntry is not None:
 261                                         config.pep.split.setValue('off')
 262                                 if self.sharpnessEntry is not None:
 263                                         config.pep.sharpness.setValue(self.oldSharpness)
 264                                 if self.auto_fleshEntry is not None:
 265                                         config.pep.auto_flesh.setValue(self.oldAuto_flesh)
 266                                 if self.green_boostEntry is not None:
 267                                         config.pep.green_boost.setValue(self.oldGreen_boost)
 268                                 if self.blue_boostEntry is not None:
 269                                         config.pep.blue_boost.setValue(self.oldBlue_boost)
 270                                 if self.dynamic_contrastEntry is not None:
 271                                         config.pep.dynamic_contrast.setValue(self.oldDynamic_contrast)
 272                         self.keySave()
 273
 274         def keyYellow(self):
 275                 self.session.openWithCallback(self.keyYellowConfirm, MessageBox, _("Reset video enhancement settings to your last configuration?"), MessageBox.TYPE_YESNO, timeout = 20, default = False)
 276
 277         def keyBlueConfirm(self, confirmed):
 278                 if not confirmed:
 279                         print "not confirmed"
 280                 else:
 281                         if self.contrastEntry is not None:
 282                                 config.pep.contrast.setValue(128)
 283                         if self.saturationEntry is not None:
 284                                 config.pep.saturation.setValue(128)
 285                         if self.hueEntry is not None:
 286                                 config.pep.hue.setValue(128)
 287                         if self.brightnessEntry is not None:
 288                                 config.pep.brightness.setValue(128)
 289                         if self.block_noise_reductionEntry is not None:
 290                                 config.pep.block_noise_reduction.setValue(0)
 291                         if self.mosquito_noise_reductionEntry is not None:
 292                                 config.pep.mosquito_noise_reduction.setValue(0)
 293                         if self.digital_contour_removalEntry is not None:
 294                                 config.pep.digital_contour_removal.setValue(0)
 295
 296                         if self.hw_type == 'dm8000':
 297                                 if self.splitEntry is not None:
 298                                         config.pep.split.setValue('off')
 299                                 if self.sharpnessEntry is not None:
 300                                         config.pep.sharpness.setValue(0)
 301                                 if self.auto_fleshEntry is not None:
 302                                         config.pep.auto_flesh.setValue(0)
 303                                 if self.green_boostEntry is not None:
 304                                         config.pep.green_boost.setValue(0)
 305                                 if self.blue_boostEntry is not None:
 306                                         config.pep.blue_boost.setValue(0)
 307                                 if self.dynamic_contrastEntry is not None:
 308                                         config.pep.dynamic_contrast.setValue(0)
 309                         self.keySave()
 310
 311         def keyBlue(self):
 312                 self.session.openWithCallback(self.keyBlueConfirm, MessageBox, _("Reset video enhancement settings to system defaults?"), MessageBox.TYPE_YESNO, timeout = 20, default = False)
 313
 314         # for summary:
 315         def changedEntry(self):
 316                 for x in self.onChangedEntry:
 317                         x()
 318
 319         def getCurrentEntry(self):
 320                 return self["config"].getCurrent()[0]
 321
 322         def getCurrentValue(self):
 323                 return str(self["config"].getCurrent()[1].getText())
 324
 325         def createSummary(self):
 326                 from Screens.Setup import SetupSummary
 327                 return SetupSummary
 328
 329
 330 class VideoEnhancementPreview(Screen, ConfigListScreen):
 331
 332         skin = """
 333                 <screen name="VideoEnhancementPreview" position="90,430" size="560,110" title="VideoEnhancementPreview">
 334                 <ePixmap pixmap="skin_default/buttons/red.png" position="0,0" size="140,40" alphatest="on" />
 335                 <ePixmap pixmap="skin_default/buttons/green.png" position="140,0" size="140,40" alphatest="on" />
 336                 <widget name="key_red" position="0,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" />
 337                 <widget name="key_green" position="140,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
 338                 <widget name="config" position="5,50" size="550,60" scrollbarMode="showOnDemand" />
 339         </screen>"""
 340
 341         def __init__(self, session, configEntry = None, oldSplitMode = None):
 342                 Screen.__init__(self, session)
 343
 344                 self.onChangedEntry = [ ]
 345                 self.setup_title = "Videoenhancement"
 346                 self.oldSplitMode = oldSplitMode
 347
 348                 self.list = [ ]
 349                 self.configEntry = configEntry
 350                 ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changedEntry)
 351
 352                 self["actions"] = ActionMap(["SetupActions"],
 353                         {
 354                                 "cancel": self.keyCancel,
 355                                 "save": self.keySave,
 356                         }, -2)
 357
 358                 self["key_red"] = Button(_("Cancel"))
 359                 self["key_green"] = Button(_("OK"))
 360
 361                 self.createSetup()
 362                 self.onLayoutFinish.append(self.layoutFinished)
 363
 364         def layoutFinished(self):
 365                 self.setTitle(_("Video enhancement preview"))
 366
 367         def createSetup(self):
 368                 self.list = [ ]
 369                 if self.configEntry is not None:
 370                         self.list = self.configEntry
 371                 self["config"].list = self.list
 372                 self["config"].l.setSeperation(300)
 373                 self["config"].l.setList(self.list)
 374
 375         def keyLeft(self):
 376                 ConfigListScreen.keyLeft(self)
 377                 self.createSetup()
 378
 379         def keyRight(self):
 380                 ConfigListScreen.keyRight(self)
 381                 self.createSetup()
 382
 383         def keySave(self):
 384                 if self.oldSplitMode is not None:
 385                         currentSplitMode = config.pep.split.value
 386                         if self.oldSplitMode == 'off' and currentSplitMode != 'off':
 387                                 config.pep.split.setValue('off')
 388                         else:
 389                                 pass
 390                 self.close()
 391
 392         def keyCancel(self):
 393                 for x in self["config"].list:
 394                         x[1].cancel()
 395                 if self.oldSplitMode is not None:
 396                         currentSplitMode = config.pep.split.value
 397                         if self.oldSplitMode == 'off' and currentSplitMode != 'off':
 398                                 config.pep.split.setValue('off')
 399                         else:
 400                                 pass
 401                 self.close()
 402
 403         # for summary:
 404         def changedEntry(self):
 405                 for x in self.onChangedEntry:
 406                         x()
 407
 408         def getCurrentEntry(self):
 409                 return self["config"].getCurrent()[0]
 410
 411         def getCurrentValue(self):
 412                 return str(self["config"].getCurrent()[1].getText())
 413
 414         def createSummary(self):
 415                 from Screens.Setup import SetupSummary
 416                 return SetupSummary
 417
 418
 419 def videoEnhancementSetupMain(session, **kwargs):
 420         session.open(VideoEnhancementSetup, video_enhancement)
 421
 422
 423 def startSetup(menuid):
 424         if menuid != "system":
 425                 return [ ]
 426
 427         return [(_("Video enhancement settings") , videoEnhancementSetupMain, "videoenhancement_setup", 41)]
 428
 429
 430 def Plugins(**kwargs):
 431         list = []
 432         if config.usage.setup_level.index >= 2: # expert+
 433                 hw_type = HardwareInfo().get_device_name()
 434                 if hw_type == 'dm8000' or hw_type == 'dm800':
 435                         if (os.path.exists("/proc/stb/vmpeg/0/pep_apply") == True):
 436                                 list.append(PluginDescriptor(name=_("Videoenhancement Setup"), description=_("Advanced Video Enhancement Setup"), where = PluginDescriptor.WHERE_MENU, fnc=startSetup))
 437         return list