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