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