code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Screens/AudioSelection.py

   1 from Screen import Screen
   2 from Components.ServiceEventTracker import ServiceEventTracker
   3 from Components.ActionMap import ActionMap
   4 from Components.ConfigList import ConfigListScreen
   5 from Components.ChoiceList import ChoiceList, ChoiceEntryComponent
   6 from Components.config import config, ConfigSubsection, getConfigListEntry, ConfigNothing, ConfigSelection, ConfigOnOff
   7 from Components.MultiContent import MultiContentEntryText
   8 from Components.Sources.List import List
   9 from Components.Sources.Boolean import Boolean
  10 from Components.SystemInfo import SystemInfo
  11
  12 from enigma import iPlayableService
  13
  14 from Tools.ISO639 import LanguageCodes
  15 from Tools.BoundFunction import boundFunction
  16 FOCUS_CONFIG, FOCUS_STREAMS = range(2)
  17
  18 class AudioSelection(Screen, ConfigListScreen):
  19         def __init__(self, session, infobar=None):
  20                 Screen.__init__(self, session)
  21
  22                 self["streams"] = List([])
  23                 self["key_red"] = Boolean(False)
  24                 self["key_green"] = Boolean(False)
  25                 self["key_yellow"] = Boolean(True)
  26                 self["key_blue"] = Boolean(False)
  27
  28                 ConfigListScreen.__init__(self, [])
  29                 self.infobar = infobar or self.session.infobar
  30
  31                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
  32                         {
  33                                 iPlayableService.evUpdatedInfo: self.__updatedInfo
  34                         })
  35                 self.cached_subtitle_checked = False
  36                 self.__selected_subtitle = None
  37
  38                 self["actions"] = ActionMap(["ColorActions", "SetupActions", "DirectionActions"],
  39                 {
  40                         "red": self.keyRed,
  41                         "green": self.keyGreen,
  42                         "yellow": self.keyYellow,
  43                         "blue": self.keyBlue,
  44                         "ok": self.keyOk,
  45                         "cancel": self.cancel,
  46                         "up": self.keyUp,
  47                         "down": self.keyDown,
  48                 }, -3)
  49
  50                 self.settings = ConfigSubsection()
  51                 choicelist = [("audio",_("audio tracks")), ("subtitles",_("Subtitles"))]
  52                 self.settings.menupage = ConfigSelection(choices = choicelist)
  53                 self.settings.menupage.addNotifier(self.fillList)
  54                 self.onLayoutFinish.append(self.__layoutFinished)
  55
  56         def __layoutFinished(self):
  57                 self["config"].instance.setSelectionEnable(False)
  58                 self.focus = FOCUS_STREAMS
  59
  60         def fillList(self, arg=None):
  61                 streams = []
  62                 conflist = []
  63                 selectedidx = 0
  64
  65                 service = self.session.nav.getCurrentService()
  66                 self.audioTracks = audio = service and service.audioTracks()
  67                 n = audio and audio.getNumberOfTracks() or 0
  68
  69                 if self.settings.menupage.getValue() == "audio":
  70                         self.setTitle(_("Select audio track"))
  71                         if SystemInfo["CanDownmixAC3"]:
  72                                 print "config.av.downmix_ac3.value=", config.av.downmix_ac3.value
  73                                 self.settings.downmix = ConfigOnOff(default=config.av.downmix_ac3.value)
  74                                 self.settings.downmix.addNotifier(self.changeAC3Downmix, initial_call = False)
  75                                 conflist.append(getConfigListEntry(_("AC3 downmix"), self.settings.downmix))
  76                                 self["key_red"] = Boolean(True)
  77
  78                         if n > 0:
  79                                 self.audioChannel = service.audioChannel()
  80                                 print "self.audioChannel.getCurrentChannel()", self.audioChannel.getCurrentChannel()
  81                                 choicelist = [("0",_("left")), ("1",_("stereo")), ("2", _("right"))]
  82                                 self.settings.channelmode = ConfigSelection(choices = choicelist, default = str(self.audioChannel.getCurrentChannel()))
  83                                 self.settings.channelmode.addNotifier(self.changeMode, initial_call = False)
  84                                 conflist.append(getConfigListEntry(_("Channel"), self.settings.channelmode))
  85                                 self["key_green"] = Boolean(True)
  86
  87                                 selectedAudio = self.audioTracks.getCurrentTrack()
  88                                 print "selectedAudio:", selectedAudio
  89
  90                                 for x in range(n):
  91                                         number = str(x)
  92                                         i = audio.getTrackInfo(x)
  93                                         languages = i.getLanguage().split('/')
  94                                         description = i.getDescription() or _("<unknown>")
  95                                         selected = ""
  96                                         language = ""
  97
  98                                         if selectedAudio == x:
  99                                                 selected = _("Running")
 100                                                 selectedidx = x
 101
 102                                         cnt = 0
 103                                         for lang in languages:
 104                                                 if cnt:
 105                                                         language += ' / '
 106                                                 if LanguageCodes.has_key(lang):
 107                                                         language += LanguageCodes[lang][0]
 108                                                 elif lang == "und":
 109                                                         _("<unknown>")
 110                                                 else:
 111                                                         language += lang
 112                                                 cnt += 1
 113
 114                                         streams.append((x, "", number, description, language, selected))
 115
 116                                 #if hasattr(self, "runPlugin"):
 117                                         #class PluginCaller:
 118                                                 #def __init__(self, fnc, *args):
 119                                                         #self.fnc = fnc
 120                                                         #self.args = args
 121                                                 #def __call__(self, *args, **kwargs):
 122                                                         #self.fnc(*self.args)
 123
 124                                         #Plugins = [ (p.name, PluginCaller(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_AUDIOMENU) ]
 125
 126                                         #for p in Plugins:
 127                                                 #selection += 1
 128                                                 #flist.append((p[0], "CALLFUNC", p[1]))
 129                                                 #if availableKeys:
 130                                                         #usedKeys.append(availableKeys[0])
 131                                                         #del availableKeys[0]
 132                                                 #else:
 133                                                         #usedKeys.append("")
 134                         else:
 135                                 streams = [(None, "", "", _("none"), "")]
 136
 137                 elif self.settings.menupage.getValue() == "subtitles":
 138                         self.setTitle(_("Subtitle selection"))
 139
 140                         self.settings.dummy = ConfigNothing()
 141                         conflist.append(getConfigListEntry("", self.settings.dummy))
 142                         conflist.append(getConfigListEntry("", self.settings.dummy))
 143
 144                         if self.subtitlesEnabled():
 145                                 sel = self.infobar.selected_subtitle
 146                         else:
 147                                 sel = None
 148
 149                         idx = 0
 150
 151                         subtitlelist = self.getSubtitleList()
 152
 153                         if len(subtitlelist):
 154                                 for x in subtitlelist:
 155                                         number = str(x[1])
 156                                         description = "?"
 157                                         language = _("<unknown>")
 158                                         selected = ""
 159
 160                                         if sel and x[:4] == sel[:4]:
 161                                                 selected = _("Running")
 162                                                 selectedidx = idx
 163
 164                                         if x[4] != "und":
 165                                                 if LanguageCodes.has_key(x[4]):
 166                                                         language = LanguageCodes[x[4]][0]
 167                                                 else:
 168                                                         language = x[4]
 169
 170                                         if x[0] == 0:
 171                                                 description = "DVB"
 172                                                 number = "%x" % (x[1])
 173
 174                                         elif x[0] == 1:
 175                                                 description = "TTX"
 176                                                 number = "%x%02x" % (x[3],x[2])
 177
 178                                         elif x[0] == 2:
 179                                                 types = (" UTF-8 text "," SSA / AAS "," .SRT file ")
 180                                                 description = types[x[2]]
 181
 182                                         streams.append((x, "", number, description, language, selected))
 183                                         idx += 1
 184
 185                         else:
 186                                 streams = [(None, "", "", _("none"), "")]
 187
 188                 conflist.append(getConfigListEntry(_("Menu"), self.settings.menupage))
 189                 self["config"].list = conflist
 190                 self["config"].l.setList(conflist)
 191
 192                 self["streams"].list = streams
 193                 self["streams"].setIndex(selectedidx)
 194
 195         def __updatedInfo(self):
 196                 self.fillList()
 197
 198         def getSubtitleList(self):
 199                 s = self.infobar and self.infobar.getCurrentServiceSubtitle()
 200                 l = s and s.getSubtitleList() or [ ]
 201                 return l
 202
 203         def subtitlesEnabled(self):
 204                 return self.infobar.subtitles_enabled
 205
 206         def enableSubtitle(self, subtitles):
 207                 print "[enableSubtitle]", subtitles
 208                 if self.infobar.selected_subtitle != subtitles:
 209                         self.infobar.subtitles_enabled = False
 210                         self.infobar.selected_subtitle = subtitles
 211                         if subtitles:
 212                                 self.infobar.subtitles_enabled = True
 213
 214         def changeAC3Downmix(self, downmix):
 215                 print "changeAC3Downmix config.av.downmix_ac3.value=", config.av.downmix_ac3.value, downmix.getValue()
 216                 if downmix.getValue() == True:
 217                         config.av.downmix_ac3.value = True
 218                 else:
 219                         config.av.downmix_ac3.value = False
 220                 config.av.downmix_ac3.save()
 221
 222         def changeMode(self, mode):
 223                 print "changeMode", mode, mode.getValue()
 224                 if mode is not None:
 225                         self.audioChannel.selectChannel(int(mode.getValue()))
 226
 227         def changeAudio(self, audio):
 228                 print "changeAudio", audio, "self.session.nav.getCurrentService().audioTracks().getNumberOfTracks():", self.session.nav.getCurrentService().audioTracks().getNumberOfTracks()
 229                 track = int(audio)
 230                 if isinstance(track, int):
 231                         if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > track:
 232                                 self.audioTracks.selectTrack(track)
 233
 234         def keyLeft(self):
 235                 if self.focus == FOCUS_CONFIG:
 236                         ConfigListScreen.keyLeft(self)
 237                 elif self.focus == FOCUS_STREAMS:
 238                         self["streams"].setIndex(0)
 239
 240         def keyRight(self):
 241                 if self.focus == FOCUS_CONFIG:
 242                         ConfigListScreen.keyRight(self)
 243                 elif self.focus == FOCUS_STREAMS and self["streams"].count():
 244                         self["streams"].setIndex(self["streams"].count()-1)
 245
 246         def keyRed(self):
 247                 self.colorkey(0)
 248
 249         def keyGreen(self):
 250                 self.colorkey(1)
 251
 252         def keyYellow(self):
 253                 self.colorkey(2)
 254
 255         def keyBlue(self):
 256                 pass
 257
 258         def colorkey(self, idx):
 259                 self["config"].setCurrentIndex(idx)
 260                 ConfigListScreen.keyRight(self)
 261
 262         def keyUp(self):
 263                 print "[keyUp]", self["streams"].getIndex()
 264                 if self.focus == FOCUS_CONFIG:
 265                         self["config"].instance.moveSelection(self["config"].instance.moveUp)
 266                 elif self.focus == FOCUS_STREAMS:
 267                         if self["streams"].getIndex() == 0:
 268                                 self["config"].instance.setSelectionEnable(True)
 269                                 self["streams"].style = "notselected"
 270                                 self["config"].setCurrentIndex(len(self["config"].getList())-1)
 271                                 self.focus = FOCUS_CONFIG
 272                         else:
 273                                 self["streams"].selectPrevious()
 274
 275         def keyDown(self):
 276                 print "[keyDown]", self["config"].getCurrentIndex(), len(self["config"].getList())-1
 277                 if self.focus == FOCUS_CONFIG:
 278                         if self["config"].getCurrentIndex() < len(self["config"].getList())-1:
 279                                 self["config"].instance.moveSelection(self["config"].instance.moveDown)
 280                         else:
 281                                 self["config"].instance.setSelectionEnable(False)
 282                                 self["streams"].style = "default"
 283                                 self.focus = FOCUS_STREAMS
 284                 elif self.focus == FOCUS_STREAMS:
 285                         self["streams"].selectNext()
 286
 287         def keyOk(self):
 288                 print "[keyok]", self["streams"].list, self["streams"].getCurrent()
 289                 if self.focus == FOCUS_STREAMS and self["streams"].list:
 290                         cur = self["streams"].getCurrent()
 291                         if self.settings.menupage.getValue() == "audio" and cur[0] is not None:
 292                                 self.changeAudio(cur[2])
 293                                 self.__updatedInfo()
 294                         if self.settings.menupage.getValue() == "subtitles" and cur[0] is not None:
 295                                 if self.infobar.selected_subtitle == cur[0]:
 296                                         self.enableSubtitle(None)
 297                                         selectedidx = self["streams"].getIndex()
 298                                         self.__updatedInfo()
 299                                         self["streams"].setIndex(selectedidx)
 300                                 else:
 301                                         self.enableSubtitle(cur[0])
 302                                         self.__updatedInfo()
 303                 #self.close()
 304                 elif self.focus == FOCUS_CONFIG:
 305                         self.keyRight()
 306
 307         def cancel(self):
 308                 self.close()