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