afb8772e9ce492769ae7bea0efc49ee03ed14c8c
[enigma2.git] / lib / python / Plugins / Extensions / MediaPlayer / plugin.py
1 from os import path as os_path, remove as os_remove, listdir as os_listdir, popen
2 from time import strftime
3 from enigma import iPlayableService, eTimer, eServiceCenter, iServiceInformation
4 from Screens.Screen import Screen
5 from Screens.MessageBox import MessageBox
6 from Screens.InputBox import InputBox
7 from Components.ActionMap import NumberActionMap, HelpableActionMap
8 from Components.Label import Label
9 from Components.Pixmap import Pixmap,MultiPixmap
10 from Components.Label import Label
11 from Components.FileList import FileList
12 from Components.MediaPlayer import PlayList
13 from Tools.Directories import resolveFilename, SCOPE_CONFIG, SCOPE_PLAYLIST, SCOPE_SKIN_IMAGE
14 from Components.ServicePosition import ServicePositionGauge
15 from Components.ServiceEventTracker import ServiceEventTracker, InfoBarBase
16 from Components.Playlist import PlaylistIOInternal, PlaylistIOM3U, PlaylistIOPLS
17 from Screens.InfoBarGenerics import InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications, InfoBarSubtitleSupport
18 from ServiceReference import ServiceReference
19 from Screens.ChoiceBox import ChoiceBox
20 from Screens.HelpMenu import HelpableScreen
21 import random
22
23 class MyPlayList(PlayList):
24         def __init__(self):
25                 PlayList.__init__(self)
26
27         def PlayListShuffle(self):
28                 random.shuffle(self.list)
29                 self.l.setList(self.list)
30                 self.currPlaying = -1
31                 self.oldCurrPlaying = -1
32
33 class MediaPixmap(Pixmap):
34         def applySkin(self, desktop, screen):
35                 self.default_pixmap = None
36                 if self.skinAttributes is not None:
37                         for (attrib, value) in self.skinAttributes:
38                                 if attrib == "pixmap":
39                                         self.default_pixmap = value
40                                         break
41                 if self.default_pixmap is None:
42                         self.default_pixmap = resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/no_coverArt.png")
43                 return Pixmap.applySkin(self, desktop, screen)
44
45 class MediaPlayer(Screen, InfoBarBase, InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications, InfoBarSubtitleSupport, HelpableScreen):
46         ALLOW_SUSPEND = True
47         ENABLE_RESUME_SUPPORT = True
48
49         def __init__(self, session, args = None):
50                 Screen.__init__(self, session)
51                 InfoBarAudioSelection.__init__(self)
52                 InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
53                 InfoBarNotifications.__init__(self)
54                 InfoBarBase.__init__(self)
55                 InfoBarSubtitleSupport.__init__(self)
56                 HelpableScreen.__init__(self)
57                 self.summary = None
58                 self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
59                 self.session.nav.stopService()
60
61                 self.playlistparsers = {}
62                 self.addPlaylistParser(PlaylistIOM3U, "m3u")
63                 self.addPlaylistParser(PlaylistIOPLS, "pls")
64                 self.addPlaylistParser(PlaylistIOInternal, "e2pls")
65
66                 # 'None' is magic to start at the list of mountpoints
67                 self.filelist = FileList(None, matchingPattern = "(?i)^.*\.(mp3|ogg|ts|wav|wave|m3u|pls|e2pls|mpg|vob|avi|mkv|dat|flac)", useServiceRef = True, additionalExtensions = "4098:m3u 4098:e2pls 4098:pls")
68                 self["filelist"] = self.filelist
69
70                 self.playlist = MyPlayList()
71                 #self.playlist = PlayList()
72                 self.is_closing = False
73                 self.delname = ""
74                 self["playlist"] = self.playlist
75
76                 self["PositionGauge"] = ServicePositionGauge(self.session.nav)
77
78                 self["currenttext"] = Label("")
79
80                 self["artisttext"] = Label(_("Artist:"))
81                 self["artist"] = Label("")
82                 self["titletext"] = Label(_("Title:"))
83                 self["title"] = Label("")
84                 self["albumtext"] = Label(_("Album:"))
85                 self["album"] = Label("")
86                 self["yeartext"] = Label(_("Year:"))
87                 self["year"] = Label("")
88                 self["genretext"] = Label(_("Genre:"))
89                 self["genre"] = Label("")
90                 self["coverArt"] = MediaPixmap()
91                 self["repeat"] = MultiPixmap()
92
93                 self.repeat = False
94                 self.seek_target = None
95
96                 class MoviePlayerActionMap(NumberActionMap):
97                         def __init__(self, player, contexts = [ ], actions = { }, prio=0):
98                                 NumberActionMap.__init__(self, contexts, actions, prio)
99                                 self.player = player
100
101                         def action(self, contexts, action):
102                                 self.player.show()
103                                 return NumberActionMap.action(self, contexts, action)
104
105
106                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", 
107                         {
108                                 "ok": (self.ok, _("add file to playlist")),
109                                 "cancel": (self.exit, _("exit mediaplayer")),
110                         }, -2)
111
112                 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions", 
113                         {
114                                 "play": (self.xplayEntry, _("play entry")),
115                                 "pause": (self.pauseEntry, _("pause")),
116                                 "stop": (self.stopEntry, _("stop entry")),
117                                 "previous": (self.previousMarkOrEntry, _("play from previous mark or playlist entry")),
118                                 "next": (self.nextMarkOrEntry, _("play from next mark or playlist entry")),
119                                 "menu": (self.showMenu, _("menu")),
120                                 "skipListbegin": (self.skip_listbegin, _("jump to listbegin")),
121                                 "skipListend": (self.skip_listend, _("jump to listend")),
122                                 "prevBouquet": (self.switchToPlayList, _("switch to playlist")),
123                                 "nextBouquet": (self.switchToFileList, _("switch to filelist")),
124                                 "delete": (self.deletePlaylistEntry, _("delete playlist entry")),
125                                 "shift_stop": (self.clear_playlist, _("clear playlist")),
126                                 "shift_record": (self.playlist.PlayListShuffle, _("shuffle playlist")),
127                                 "subtitles": (self.subtitleSelection, _("Subtitle selection")),
128                         }, -2)
129
130                 self["InfobarEPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
131                         {
132                                 "showEventInfo": (self.showEventInformation, _("show event details")),
133                         })
134
135                 self["actions"] = MoviePlayerActionMap(self, ["DirectionActions"], 
136                 {
137                         "right": self.rightDown,
138                         "rightRepeated": self.doNothing,
139                         "rightUp": self.rightUp,
140                         "left": self.leftDown,
141                         "leftRepeated": self.doNothing,
142                         "leftUp": self.leftUp,
143
144                         "up": self.up,
145                         "upRepeated": self.up,
146                         "upUp": self.doNothing,
147                         "down": self.down,
148                         "downRepeated": self.down,
149                         "downUp": self.doNothing,
150                 }, -2)
151
152                 InfoBarSeek.__init__(self, actionmap = "MediaPlayerSeekActions")
153
154                 self.onClose.append(self.delMPTimer)
155                 self.onClose.append(self.__onClose)
156
157                 self.righttimer = False
158                 self.rightKeyTimer = eTimer()
159                 self.rightKeyTimer.callback.append(self.rightTimerFire)
160
161                 self.lefttimer = False
162                 self.leftKeyTimer = eTimer()
163                 self.leftKeyTimer.callback.append(self.leftTimerFire)
164
165                 self.currList = "filelist"
166
167                 self.coverArtFileName = ""
168                 self.isAudioCD = False
169                 self.AudioCD_albuminfo = {}
170                 self.savePlaylistOnExit = True
171
172                 self.playlistIOInternal = PlaylistIOInternal()
173                 list = self.playlistIOInternal.open(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
174                 if list:
175                         for x in list:
176                                 self.playlist.addFile(x.ref)
177                         self.playlist.updateList()
178
179                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
180                         {
181                                 iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
182                                 iPlayableService.evUser+11: self.__evDecodeError,
183                                 iPlayableService.evUser+12: self.__evPluginError
184                         })
185
186         def doNothing(self):
187                 pass
188
189         def createSummary(self):
190                 return MediaPlayerLCDScreen
191
192         def exit(self):
193                 self.session.openWithCallback(self.exitCB, MessageBox, _("Do you really want to exit?"), timeout=5)
194
195         def exitCB(self, answer):
196                 if answer == True:
197                         self.playlistIOInternal.clear()
198                         for x in self.playlist.list:
199                                 self.playlistIOInternal.addService(ServiceReference(x[0]))
200                         if self.savePlaylistOnExit:
201                                 self.playlistIOInternal.save(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
202                         self.close()
203
204         def checkSkipShowHideLock(self):
205                 self.updatedSeekState()
206
207         def doEofInternal(self, playing):
208                 if playing:
209                         self.nextEntry()
210                 else:
211                         self.show()
212
213         def __onClose(self):
214                 self.session.nav.playService(self.oldService)
215
216         def __evUpdatedInfo(self):
217                 currPlay = self.session.nav.getCurrentService()
218                 currenttitle = currPlay.info().getInfo(iServiceInformation.sCurrentTitle)
219                 totaltitles = currPlay.info().getInfo(iServiceInformation.sTotalTitles)
220                 sTitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
221                 print "[__evUpdatedInfo] title %d of %d (%s)" % (currenttitle, totaltitles, sTitle)
222                 self.readTitleInformation()
223
224         def __evDecodeError(self):
225                 currPlay = self.session.nav.getCurrentService()
226                 sVideoType = currPlay.info().getInfoString(iServiceInformation.sVideoType)
227                 print "[__evDecodeError] video-codec %s can't be decoded by hardware" % (sVideoType)
228                 self.session.open(MessageBox, _("This Dreambox can't decode %s video streams!") % sVideoType, type = MessageBox.TYPE_INFO,timeout = 20 )
229
230         def __evPluginError(self):
231                 currPlay = self.session.nav.getCurrentService()
232                 message = currPlay.info().getInfoString(iServiceInformation.sUser+12)
233                 print "[__evPluginError]" , message
234                 self.session.open(MessageBox, ("GStreamer Error: missing %s") % message, type = MessageBox.TYPE_INFO,timeout = 20 )
235
236         def delMPTimer(self):
237                 del self.rightKeyTimer
238                 del self.leftKeyTimer
239
240         def readTitleInformation(self):
241                 currPlay = self.session.nav.getCurrentService()
242                 if currPlay is not None:
243                         sTitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
244                         sAlbum = currPlay.info().getInfoString(iServiceInformation.sAlbum)
245                         sGenre = currPlay.info().getInfoString(iServiceInformation.sGenre)
246                         sArtist = currPlay.info().getInfoString(iServiceInformation.sArtist)
247                         sYear = ""
248
249                         if sTitle == "":
250                                 if not self.isAudioCD:
251                                         sTitle = currPlay.info().getName().split('/')[-1]
252                                 else:
253                                         sTitle = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()].getName()
254
255                         if self.AudioCD_albuminfo:
256                                 if sAlbum == "" and "title" in self.AudioCD_albuminfo:
257                                         sAlbum = self.AudioCD_albuminfo["title"]
258                                 if sGenre == "" and "genre" in self.AudioCD_albuminfo:
259                                         sGenre = self.AudioCD_albuminfo["genre"]
260                                 if sArtist == "" and "artist" in self.AudioCD_albuminfo:
261                                         sArtist = self.AudioCD_albuminfo["artist"]
262                                 if "year" in self.AudioCD_albuminfo:
263                                         sYear = self.AudioCD_albuminfo["year"]
264
265                         self.updateMusicInformation( sArtist, sTitle, sAlbum, sYear, sGenre, clear = True )
266                 else:
267                         self.updateMusicInformation()
268
269         def updateMusicInformation(self, artist = "", title = "", album = "", year = "", genre = "", clear = False):
270                 self.updateSingleMusicInformation("artist", artist, clear)
271                 self.updateSingleMusicInformation("title", title, clear)
272                 self.updateSingleMusicInformation("album", album, clear)
273                 self.updateSingleMusicInformation("year", year, clear)
274                 self.updateSingleMusicInformation("genre", genre, clear)
275
276         def updateSingleMusicInformation(self, name, info, clear):
277                 if info != "" or clear:
278                         if self[name].getText() != info:
279                                 self[name].setText(info)
280
281         def updateCoverArtPixmap(self, path):
282                 while not path.endswith("/"):
283                         path = path[:-1]
284                 pngname = path + "folder.png"
285                 
286                 if not os_path.exists(pngname):
287                         pngname = self["coverArt"].default_pixmap
288                 if self.coverArtFileName != pngname:
289                         self.coverArtFileName = pngname
290                         self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
291
292         def leftDown(self):
293                 self.lefttimer = True
294                 self.leftKeyTimer.start(1000)
295
296         def rightDown(self):
297                 self.righttimer = True
298                 self.rightKeyTimer.start(1000)
299
300         def leftUp(self):
301                 if self.lefttimer:
302                         self.leftKeyTimer.stop()
303                         self.lefttimer = False
304                         self[self.currList].pageUp()
305                         self.updateCurrentInfo()
306
307         def rightUp(self):
308                 if self.righttimer:
309                         self.rightKeyTimer.stop()
310                         self.righttimer = False
311                         self[self.currList].pageDown()
312                         self.updateCurrentInfo()
313
314         def leftTimerFire(self):
315                 self.leftKeyTimer.stop()
316                 self.lefttimer = False
317                 self.switchToFileList()
318
319         def rightTimerFire(self):
320                 self.rightKeyTimer.stop()
321                 self.righttimer = False
322                 self.switchToPlayList()
323
324         def switchToFileList(self):
325                 self.currList = "filelist"
326                 self.filelist.selectionEnabled(1)
327                 self.playlist.selectionEnabled(0)
328                 self.updateCurrentInfo()
329
330         def switchToPlayList(self):
331                 if len(self.playlist) != 0:
332                         self.currList = "playlist"
333                         self.filelist.selectionEnabled(0)
334                         self.playlist.selectionEnabled(1)
335                         self.updateCurrentInfo()
336
337         def up(self):
338                 self[self.currList].up()
339                 self.updateCurrentInfo()
340
341         def down(self):
342                 self[self.currList].down()
343                 self.updateCurrentInfo()
344
345         def showAfterSeek(self):
346                 self.show()
347
348         def showAfterCuesheetOperation(self):
349                 self.show()
350
351         def hideAfterResume(self):
352                 self.hide()
353
354         def getIdentifier(self, ref):
355                 if self.isAudioCD:
356                         return ref.getName()
357                 else:
358                         text = ref.getPath()
359                         return text.split('/')[-1]
360
361         # FIXME: maybe this code can be optimized 
362         def updateCurrentInfo(self):
363                 text = ""
364                 if self.currList == "filelist":
365                         idx = self.filelist.getSelectionIndex()
366                         r = self.filelist.list[idx]
367                         text = r[1][7]
368                         if r[0][1] == True:
369                                 if len(text) < 2:
370                                         text += " "
371                                 if text[:2] != "..":
372                                         text = "/" + text
373                         self.summaries.setText(text,1)
374
375                         idx += 1
376                         if idx < len(self.filelist.list):
377                                 r = self.filelist.list[idx]
378                                 text = r[1][7]
379                                 if r[0][1] == True:
380                                         text = "/" + text
381                                 self.summaries.setText(text,3)
382                         else:
383                                 self.summaries.setText(" ",3)
384
385                         idx += 1
386                         if idx < len(self.filelist.list):
387                                 r = self.filelist.list[idx]
388                                 text = r[1][7]
389                                 if r[0][1] == True:
390                                         text = "/" + text
391                                 self.summaries.setText(text,4)
392                         else:
393                                 self.summaries.setText(" ",4)
394
395                         text = ""
396                         if not self.filelist.canDescent():
397                                 r = self.filelist.getServiceRef()
398                                 if r is None:
399                                         return
400                                 text = r.getPath()
401                                 self["currenttext"].setText(os_path.basename(text))
402
403                 if self.currList == "playlist":
404                         t = self.playlist.getSelection()
405                         if t is None:
406                                 return
407                         #display current selected entry on LCD
408                         text = self.getIdentifier(t)
409                         self.summaries.setText(text,1)
410                         self["currenttext"].setText(text)
411                         idx = self.playlist.getSelectionIndex()
412                         idx += 1
413                         if idx < len(self.playlist):
414                                 currref = self.playlist.getServiceRefList()[idx]
415                                 text = self.getIdentifier(currref)
416                                 self.summaries.setText(text,3)
417                         else:
418                                 self.summaries.setText(" ",3)
419
420                         idx += 1
421                         if idx < len(self.playlist):
422                                 currref = self.playlist.getServiceRefList()[idx]
423                                 text = self.getIdentifier(currref)
424                                 self.summaries.setText(text,4)
425                         else:
426                                 self.summaries.setText(" ",4)
427
428         def ok(self):
429                 if self.currList == "filelist":
430                         if self.filelist.canDescent():
431                                 self.filelist.descent()
432                                 self.updateCurrentInfo()
433                         else:
434                                 self.copyFile()
435
436                 if self.currList == "playlist":
437                         selection = self["playlist"].getSelection()
438                         self.changeEntry(self.playlist.getSelectionIndex())
439
440         def showMenu(self):
441                 menu = []
442                 if self.currList == "filelist":
443                         if self.filelist.canDescent():
444                                 menu.append((_("add directory to playlist"), "copydir"))
445                         else:
446                                 menu.append((_("add files to playlist"), "copyfiles"))
447                         menu.append((_("switch to playlist"), "playlist"))
448                 else:
449                         menu.append((_("switch to filelist"), "filelist"))
450
451                         menu.append((_("shuffle playlist"), "shuffle"))
452
453                         menu.append((_("delete"), "delete"))
454                         menu.append((_("clear playlist"), "clear"))
455                 menu.append((_("hide player"), "hide"));
456                 menu.append((_("save playlist"), "saveplaylist"));
457                 menu.append((_("load playlist"), "loadplaylist"));
458                 menu.append((_("delete saved playlist"), "deleteplaylist"));
459                 menu.append((_("repeat playlist"), "repeat"));
460                 self.session.openWithCallback(self.menuCallback, ChoiceBox, title="", list=menu)
461
462         def menuCallback(self, choice):
463                 if choice is None:
464                         return
465
466                 if choice[1] == "copydir":
467                         self.copyDirectory(self.filelist.getSelection()[0])
468                 elif choice[1] == "copyfiles":
469                         self.stopEntry()
470                         self.playlist.clear()
471                         self.copyDirectory(os_path.dirname(self.filelist.getSelection()[0].getPath()) + "/", recursive = False)
472                         self.playServiceRefEntry(self.filelist.getServiceRef())
473                 elif choice[1] == "playlist":
474                         self.switchToPlayList()
475                 elif choice[1] == "filelist":
476                         self.switchToFileList()
477                 elif choice[1] == "delete":
478                         if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
479                                 self.stopEntry()
480                         self.deleteEntry()
481                 elif choice[1] == "clear":
482                         self.stopEntry()
483                         self.playlist.clear()
484                         self.switchToFileList()
485                 elif choice[1] == "hide":
486                         self.hide()
487                 elif choice[1] == "saveplaylist":
488                         self.save_playlist()
489                 elif choice[1] == "loadplaylist":
490                         self.load_playlist()
491                 elif choice[1] == "deleteplaylist":
492                         self.delete_saved_playlist()
493                 elif choice[1] == "shuffle":
494                         self.playlist.PlayListShuffle()
495                 elif choice[1] == "repeat":
496                         if self.repeat == True:
497                                 self.repeat = False
498                                 self["repeat"].setPixmapNum(0)
499                         else:
500                                 self.repeat = True
501                                 self["repeat"].setPixmapNum(1)
502
503         def showEventInformation(self):
504                 from Screens.EventView import EventViewSimple
505                 from ServiceReference import ServiceReference
506                 evt = self[self.currList].getCurrentEvent()
507                 if evt:
508                         self.session.open(EventViewSimple, evt, ServiceReference(self.getCurrent()))
509
510         # also works on filelist (?)
511         def getCurrent(self):
512                 return self["playlist"].getCurrent()
513
514         def deletePlaylistEntry(self):
515                 if self.currList == "playlist":
516                         if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
517                                 self.stopEntry()
518                         self.deleteEntry()
519
520         def skip_listbegin(self):
521                 if self.currList == "filelist":
522                         self.filelist.moveToIndex(0)
523                 else:
524                         self.playlist.moveToIndex(0)
525                 self.updateCurrentInfo()
526
527         def skip_listend(self):
528                 if self.currList == "filelist":
529                         idx = len(self.filelist.list)
530                         self.filelist.moveToIndex(idx - 1)
531                 else:
532                         self.playlist.moveToIndex(len(self.playlist)-1)
533                 self.updateCurrentInfo()
534
535         def save_playlist(self):
536                 self.session.openWithCallback(self.save_playlist2,InputBox, title=_("Please enter filename (empty = use current date)"),windowTitle = _("Save Playlist"))
537
538         def save_playlist2(self, name):
539                 if name is not None:
540                         name = name.strip()
541                         if name == "":
542                                 name = strftime("%y%m%d_%H%M%S")
543                         name += ".e2pls"
544                         self.playlistIOInternal.clear()
545                         for x in self.playlist.list:
546                                 self.playlistIOInternal.addService(ServiceReference(x[0]))
547                         self.playlistIOInternal.save(resolveFilename(SCOPE_PLAYLIST) + name)
548
549         def load_playlist(self):
550                 listpath = []
551                 playlistdir = resolveFilename(SCOPE_PLAYLIST)
552                 try:
553                         for i in os_listdir(playlistdir):
554                                 listpath.append((i,playlistdir + i))
555                 except IOError,e:
556                         print "Error while scanning subdirs ",e
557                 self.session.openWithCallback(self.PlaylistSelected, ChoiceBox, title=_("Please select a playlist..."), list = listpath)
558
559         def PlaylistSelected(self,path):
560                 if path is not None:
561                         self.clear_playlist()
562                         self.playlistIOInternal = PlaylistIOInternal()
563                         list = self.playlistIOInternal.open(path[1])
564                         if list:
565                                 for x in list:
566                                         self.playlist.addFile(x.ref)
567                                 self.playlist.updateList()
568
569         def delete_saved_playlist(self):
570                 listpath = []
571                 playlistdir = resolveFilename(SCOPE_PLAYLIST)
572                 try:
573                         for i in os_listdir(playlistdir):
574                                 listpath.append((i,playlistdir + i))
575                 except IOError,e:
576                         print "Error while scanning subdirs ",e
577                 self.session.openWithCallback(self.DeletePlaylistSelected, ChoiceBox, title=_("Please select a playlist to delete..."), list = listpath)
578
579         def DeletePlaylistSelected(self,path):
580                 if path is not None:
581                         self.delname = path[1]
582                         self.session.openWithCallback(self.deleteConfirmed, MessageBox, _("Do you really want to delete %s?") % (path[1]))
583
584         def deleteConfirmed(self, confirmed):
585                 if confirmed:
586                         os_remove(self.delname)
587
588         def clear_playlist(self):
589                 self.stopEntry()
590                 self.playlist.clear()
591                 self.switchToFileList()
592
593         def copyDirectory(self, directory, recursive = True):
594                 print "copyDirectory", directory
595                 filelist = FileList(directory, useServiceRef = True, isTop = True)
596
597                 for x in filelist.getFileList():
598                         if x[0][1] == True: #isDir
599                                 if recursive:
600                                         self.copyDirectory(x[0][0])
601                         else:
602                                 self.playlist.addFile(x[0][0])
603                 self.playlist.updateList()
604
605         def copyFile(self):
606                 if self.filelist.getServiceRef().type == 4098: # playlist
607                         ServiceRef = self.filelist.getServiceRef()
608                         extension = ServiceRef.getPath()[ServiceRef.getPath().rfind('.') + 1:]
609                         print "extension:", extension
610                         if self.playlistparsers.has_key(extension):
611                                 playlist = self.playlistparsers[extension]()
612                                 list = playlist.open(ServiceRef.getPath())
613                                 for x in list:
614                                         self.playlist.addFile(x.ref)
615                 else:
616                         self.playlist.addFile(self.filelist.getServiceRef())
617                         self.playlist.updateList()
618                         if len(self.playlist) == 1:
619                                 self.changeEntry(0)
620
621         def addPlaylistParser(self, parser, extension):
622                 self.playlistparsers[extension] = parser
623
624         def nextEntry(self):
625                 next = self.playlist.getCurrentIndex() + 1
626                 if next < len(self.playlist):
627                         self.changeEntry(next)
628                 elif ( len(self.playlist) > 0 ) and ( self.repeat == True ):
629                         self.stopEntry()
630                         self.changeEntry(0)
631
632         def nextMarkOrEntry(self):
633                 if not self.jumpPreviousNextMark(lambda x: x):
634                         next = self.playlist.getCurrentIndex() + 1
635                         if next < len(self.playlist):
636                                 self.changeEntry(next)
637                         else:
638                                 self.doSeek(-1)
639
640         def previousMarkOrEntry(self):
641                 if not self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True):
642                         next = self.playlist.getCurrentIndex() - 1
643                         if next >= 0:
644                                 self.changeEntry(next)
645
646         def deleteEntry(self):
647                 self.playlist.deleteFile(self.playlist.getSelectionIndex())
648                 self.playlist.updateList()
649                 if len(self.playlist) == 0:
650                         self.switchToFileList()
651
652         def changeEntry(self, index):
653                 self.playlist.setCurrentPlaying(index)
654                 self.playEntry()
655
656         def playServiceRefEntry(self, serviceref):
657                 serviceRefList = self.playlist.getServiceRefList()
658                 for count in range(len(serviceRefList)):
659                         if serviceRefList[count] == serviceref:
660                                 self.changeEntry(count)
661                                 break
662                         
663         def xplayEntry(self):
664                 if self.currList == "playlist":
665                         self.playEntry()
666                 else:
667                         self.stopEntry()
668                         self.playlist.clear()
669                         sel = self.filelist.getSelection()
670                         if sel:
671                                 if sel[1]: # can descent
672                                         # add directory to playlist
673                                         self.copyDirectory(sel[0])
674                                 else:
675                                         # add files to playlist
676                                         self.copyDirectory(os_path.dirname(sel[0].getPath()) + "/", recursive = False)
677                         if len(self.playlist) > 0:
678                                 self.changeEntry(0)
679         
680         def playEntry(self):
681                 if len(self.playlist.getServiceRefList()):
682                         needsInfoUpdate = False
683                         currref = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()]
684                         if self.session.nav.getCurrentlyPlayingServiceReference() is None or currref != self.session.nav.getCurrentlyPlayingServiceReference():
685                                 self.session.nav.playService(self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()])
686                                 info = eServiceCenter.getInstance().info(currref)
687                                 description = info and info.getInfoString(currref, iServiceInformation.sDescription) or ""
688                                 self["title"].setText(description)
689                                 # display just playing musik on LCD
690                                 idx = self.playlist.getCurrentIndex()
691                                 currref = self.playlist.getServiceRefList()[idx]
692                                 text = self.getIdentifier(currref)
693                                 text = ">"+text
694                                 ext = text[-4:].lower()
695
696                                 # FIXME: the information if the service contains video (and we should hide our window) should com from the service instead 
697                                 if ext not in [".mp3", ".wav", ".ogg", "flac"] and not self.isAudioCD:
698                                         self.hide()
699                                 else:
700                                         needsInfoUpdate = True
701                                 self.summaries.setText(text,1)
702
703                                 # get the next two entries
704                                 idx += 1
705                                 if idx < len(self.playlist):
706                                         currref = self.playlist.getServiceRefList()[idx]
707                                         text = self.getIdentifier(currref)
708                                         self.summaries.setText(text,3)
709                                 else:
710                                         self.summaries.setText(" ",3)
711
712                                 idx += 1
713                                 if idx < len(self.playlist):
714                                         currref = self.playlist.getServiceRefList()[idx]
715                                         text = self.getIdentifier(currref)
716                                         self.summaries.setText(text,4)
717                                 else:
718                                         self.summaries.setText(" ",4)
719                         else:
720                                 idx = self.playlist.getCurrentIndex()
721                                 currref = self.playlist.getServiceRefList()[idx]
722                                 text = currref.getPath()
723                                 ext = text[-4:].lower()
724                                 if ext not in [".mp3", ".wav", ".ogg", "flac"] and not self.isAudioCD:
725                                         self.hide()
726                                 else:
727                                         needsInfoUpdate = True
728
729                         self.unPauseService()
730                         if needsInfoUpdate == True:
731                                 self.updateCoverArtPixmap(currref.getPath())
732                         else:
733                                 pngname = self["coverArt"].default_pixmap
734                                 self.coverArtFileName = pngname
735                                 self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
736                         self.readTitleInformation()
737
738         def updatedSeekState(self):
739                 if self.seekstate == self.SEEK_STATE_PAUSE:
740                         self.playlist.pauseFile()
741                 elif self.seekstate == self.SEEK_STATE_PLAY:
742                         self.playlist.playFile()
743                 elif self.isStateForward(self.seekstate):
744                         self.playlist.forwardFile()
745                 elif self.isStateBackward(self.seekstate):
746                         self.playlist.rewindFile()
747
748         def pauseEntry(self):
749                 self.pauseService()
750                 if self.seekstate == self.SEEK_STATE_PAUSE:
751                         self.show()
752                 else:
753                         self.hide()
754
755         def stopEntry(self):
756                 self.playlist.stopFile()
757                 self.session.nav.playService(None)
758                 self.updateMusicInformation(clear=True)
759                 self.show()
760
761         def unPauseService(self):
762                 self.setSeekState(self.SEEK_STATE_PLAY)
763                 
764         def subtitleSelection(self):
765                 from Screens.Subtitles import Subtitles
766                 self.session.open(Subtitles)            
767
768 class MediaPlayerLCDScreen(Screen):
769         skin = """
770         <screen position="0,0" size="132,64" title="LCD Text">
771                 <widget name="text1" position="4,0" size="132,35" font="Regular;16"/>
772                 <widget name="text3" position="4,36" size="132,14" font="Regular;10"/>
773                 <widget name="text4" position="4,49" size="132,14" font="Regular;10"/>
774         </screen>"""
775
776         def __init__(self, session, parent):
777                 Screen.__init__(self, session)
778                 self["text1"] = Label("Mediaplayer")
779                 self["text3"] = Label("")
780                 self["text4"] = Label("")
781
782         def setText(self, text, line):
783                 print "lcd set text:", text, line
784                 if len(text) > 10:
785                         if text[-4:] == ".mp3":
786                                 text = text[:-4]
787                 textleer = "    "
788                 text = text + textleer*10
789                 if line == 1:
790                         self["text1"].setText(text)
791                 elif line == 3:
792                         self["text3"].setText(text)
793                 elif line == 4:
794                         self["text4"].setText(text)
795
796 def main(session, **kwargs):
797         session.open(MediaPlayer)
798
799 def menu(menuid, **kwargs):
800         if menuid == "mainmenu":
801                 return [(_("Media player"), main, "media_player", 45)]
802         return []
803
804 def filescan_open(list, session, **kwargs):
805         from enigma import eServiceReference
806
807         mp = session.open(MediaPlayer)
808         mp.playlist.clear()
809         mp.savePlaylistOnExit = False
810
811         for file in list:
812                 if file.mimetype == "video/MP2T":
813                         stype = 1
814                 else:
815                         stype = 4097
816                 ref = eServiceReference(stype, 0, file.path)
817                 mp.playlist.addFile(ref)
818
819         mp.changeEntry(0)
820         mp.switchToPlayList()
821
822 def audioCD_open(list, session, **kwargs):
823         from enigma import eServiceReference
824
825         mp = session.open(MediaPlayer)
826
827         mp.playlist.clear()
828         mp.savePlaylistOnExit = False
829         mp.isAudioCD = True
830
831         for file in list:
832                 ref = eServiceReference(4097, 0, file.path)
833                 mp.playlist.addFile(ref)
834         from Plugins.Extensions.CDInfo.plugin import Query
835         cdinfo = Query(mp)
836         cdinfo.scan()
837
838         mp.changeEntry(0)
839         mp.switchToPlayList()
840
841 def filescan(**kwargs):
842         from Components.Scanner import Scanner, ScanPath
843         mediatypes = [
844                 Scanner(mimetypes = ["video/mpeg", "video/MP2T", "video/x-msvideo"],
845                         paths_to_scan =
846                                 [
847                                         ScanPath(path = "", with_subdirs = False),
848                                 ],
849                         name = "Movie",
850                         description = "View Movies...",
851                         openfnc = filescan_open,
852                 ),
853                 Scanner(mimetypes = ["video/x-vcd"],
854                         paths_to_scan =
855                                 [
856                                         ScanPath(path = "mpegav", with_subdirs = False),
857                                         ScanPath(path = "MPEGAV", with_subdirs = False),
858                                 ],
859                         name = "Video CD",
860                         description = "View Video CD...",
861                         openfnc = filescan_open,
862                 ),
863                 Scanner(mimetypes = ["audio/mpeg", "audio/x-wav", "application/ogg", "audio/x-flac"],
864                         paths_to_scan =
865                                 [
866                                         ScanPath(path = "", with_subdirs = False),
867                                 ],
868                         name = "Music",
869                         description = "Play Music...",
870                         openfnc = filescan_open,
871                 )]
872         try:
873                 from Plugins.Extensions.CDInfo.plugin import Query
874                 mediatypes.append(
875                 Scanner(mimetypes = ["audio/x-cda"],
876                         paths_to_scan =
877                                 [
878                                         ScanPath(path = "", with_subdirs = False),
879                                 ],
880                         name = "Audio-CD",
881                         description = "Play Audio-CD...",
882                         openfnc = audioCD_open,
883                 ))
884                 return mediatypes
885         except ImportError:
886                 return mediatypes
887
888 from Plugins.Plugin import PluginDescriptor
889 def Plugins(**kwargs):
890         return [
891                 PluginDescriptor(name = "MediaPlayer", description = "Play back media files", where = PluginDescriptor.WHERE_MENU, fnc = menu),
892                 PluginDescriptor(name = "MediaPlayer", where = PluginDescriptor.WHERE_FILESCAN, fnc = filescan)
893         ]