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, loadPic
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_SKIN_IMAGE
23 from settings import MediaPlayerSettings
26 class MyPlayList(PlayList):
28 PlayList.__init__(self)
30 def PlayListShuffle(self):
31 random.shuffle(self.list)
32 self.l.setList(self.list)
34 self.oldCurrPlaying = -1
36 class MediaPixmap(Pixmap):
37 def applySkin(self, desktop, screen):
38 self.default_pixmap = None
39 if self.skinAttributes is not None:
40 for (attrib, value) in self.skinAttributes:
41 if attrib == "pixmap":
42 self.default_pixmap = value
44 if self.default_pixmap is None:
45 self.default_pixmap = resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/no_coverArt.png")
46 self.coverFileNames = ["folder.png", "folder.jpg"]
47 return Pixmap.applySkin(self, desktop, screen)
49 class MediaPlayer(Screen, InfoBarBase, InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications, InfoBarSubtitleSupport, HelpableScreen):
51 ENABLE_RESUME_SUPPORT = True
53 def __init__(self, session, args = None):
54 Screen.__init__(self, session)
55 InfoBarAudioSelection.__init__(self)
56 InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
57 InfoBarNotifications.__init__(self)
58 InfoBarBase.__init__(self)
59 InfoBarSubtitleSupport.__init__(self)
60 HelpableScreen.__init__(self)
62 self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
63 self.session.nav.stopService()
65 self.playlistparsers = {}
66 self.addPlaylistParser(PlaylistIOM3U, "m3u")
67 self.addPlaylistParser(PlaylistIOPLS, "pls")
68 self.addPlaylistParser(PlaylistIOInternal, "e2pls")
70 # 'None' is magic to start at the list of mountpoints
71 defaultDir = config.mediaplayer.defaultDir.getValue()
72 self.filelist = FileList(defaultDir, matchingPattern = "(?i)^.*\.(mp2|mp3|ogg|ts|wav|wave|m3u|pls|e2pls|mpg|vob|avi|mkv|mp4|dat|flac)", useServiceRef = True, additionalExtensions = "4098:m3u 4098:e2pls 4098:pls")
73 self["filelist"] = self.filelist
75 self.playlist = MyPlayList()
76 #self.playlist = PlayList()
77 self.is_closing = False
79 self["playlist"] = self.playlist
81 self["PositionGauge"] = ServicePositionGauge(self.session.nav)
83 self["currenttext"] = Label("")
85 self["artisttext"] = Label(_("Artist:"))
86 self["artist"] = Label("")
87 self["titletext"] = Label(_("Title:"))
88 self["title"] = Label("")
89 self["albumtext"] = Label(_("Album:"))
90 self["album"] = Label("")
91 self["yeartext"] = Label(_("Year:"))
92 self["year"] = Label("")
93 self["genretext"] = Label(_("Genre:"))
94 self["genre"] = Label("")
95 self["coverArt"] = MediaPixmap()
96 self["repeat"] = MultiPixmap()
98 self.seek_target = None
100 class MoviePlayerActionMap(NumberActionMap):
101 def __init__(self, player, contexts = [ ], actions = { }, prio=0):
102 NumberActionMap.__init__(self, contexts, actions, prio)
105 def action(self, contexts, action):
107 return NumberActionMap.action(self, contexts, action)
110 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
112 "ok": (self.ok, _("add file to playlist")),
113 "cancel": (self.exit, _("exit mediaplayer")),
116 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions",
118 "play": (self.xplayEntry, _("play entry")),
119 "pause": (self.pauseEntry, _("pause")),
120 "stop": (self.stopEntry, _("stop entry")),
121 "previous": (self.previousMarkOrEntry, _("play from previous mark or playlist entry")),
122 "next": (self.nextMarkOrEntry, _("play from next mark or playlist entry")),
123 "menu": (self.showMenu, _("menu")),
124 "skipListbegin": (self.skip_listbegin, _("jump to listbegin")),
125 "skipListend": (self.skip_listend, _("jump to listend")),
126 "prevBouquet": (self.switchToPlayList, _("switch to playlist")),
127 "nextBouquet": (self.switchToFileList, _("switch to filelist")),
128 "delete": (self.deletePlaylistEntry, _("delete playlist entry")),
129 "shift_stop": (self.clear_playlist, _("clear playlist")),
130 "shift_record": (self.playlist.PlayListShuffle, _("shuffle playlist")),
131 "subtitles": (self.subtitleSelection, _("Subtitle selection")),
134 self["InfobarEPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
136 "showEventInfo": (self.showEventInformation, _("show event details")),
139 self["actions"] = MoviePlayerActionMap(self, ["DirectionActions"],
141 "right": self.rightDown,
142 "rightRepeated": self.doNothing,
143 "rightUp": self.rightUp,
144 "left": self.leftDown,
145 "leftRepeated": self.doNothing,
146 "leftUp": self.leftUp,
149 "upRepeated": self.up,
150 "upUp": self.doNothing,
152 "downRepeated": self.down,
153 "downUp": self.doNothing,
156 InfoBarSeek.__init__(self, actionmap = "MediaPlayerSeekActions")
158 self.onClose.append(self.delMPTimer)
159 self.onClose.append(self.__onClose)
161 self.righttimer = False
162 self.rightKeyTimer = eTimer()
163 self.rightKeyTimer.callback.append(self.rightTimerFire)
165 self.lefttimer = False
166 self.leftKeyTimer = eTimer()
167 self.leftKeyTimer.callback.append(self.leftTimerFire)
169 self.currList = "filelist"
171 self.coverArtFileName = ""
172 self.isAudioCD = False
173 self.AudioCD_albuminfo = {}
177 self.playlistIOInternal = PlaylistIOInternal()
178 list = self.playlistIOInternal.open(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
181 self.playlist.addFile(x.ref)
182 self.playlist.updateList()
184 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
186 iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
187 iPlayableService.evUser+11: self.__evDecodeError,
188 iPlayableService.evUser+12: self.__evPluginError
194 def createSummary(self):
195 return MediaPlayerLCDScreen
198 self.playlistIOInternal.clear()
199 for x in self.playlist.list:
200 self.playlistIOInternal.addService(ServiceReference(x[0]))
201 if self.savePlaylistOnExit:
202 self.playlistIOInternal.save(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
203 if config.mediaplayer.saveDirOnExit.getValue():
204 config.mediaplayer.defaultDir.setValue(self.filelist.getCurrentDirectory())
205 config.mediaplayer.defaultDir.save()
208 def checkSkipShowHideLock(self):
209 self.updatedSeekState()
211 def doEofInternal(self, playing):
218 self.session.nav.playService(self.oldService)
220 def __evUpdatedInfo(self):
221 currPlay = self.session.nav.getCurrentService()
222 currenttitle = currPlay.info().getInfo(iServiceInformation.sCurrentTitle)
223 totaltitles = currPlay.info().getInfo(iServiceInformation.sTotalTitles)
224 sTitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
225 print "[__evUpdatedInfo] title %d of %d (%s)" % (currenttitle, totaltitles, sTitle)
226 self.readTitleInformation()
228 def __evDecodeError(self):
229 currPlay = self.session.nav.getCurrentService()
230 sVideoType = currPlay.info().getInfoString(iServiceInformation.sVideoType)
231 print "[__evDecodeError] video-codec %s can't be decoded by hardware" % (sVideoType)
232 self.session.open(MessageBox, _("This Dreambox can't decode %s video streams!") % sVideoType, type = MessageBox.TYPE_INFO,timeout = 20 )
234 def __evPluginError(self):
235 currPlay = self.session.nav.getCurrentService()
236 message = currPlay.info().getInfoString(iServiceInformation.sUser+12)
237 print "[__evPluginError]" , message
238 self.session.open(MessageBox, message, type = MessageBox.TYPE_INFO,timeout = 20 )
240 def delMPTimer(self):
241 del self.rightKeyTimer
242 del self.leftKeyTimer
244 def readTitleInformation(self):
245 currPlay = self.session.nav.getCurrentService()
246 if currPlay is not None:
247 sTitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
248 sAlbum = currPlay.info().getInfoString(iServiceInformation.sAlbum)
249 sGenre = currPlay.info().getInfoString(iServiceInformation.sGenre)
250 sArtist = currPlay.info().getInfoString(iServiceInformation.sArtist)
251 sYear = currPlay.info().getInfoString(iServiceInformation.sTimeCreate)
254 if not self.isAudioCD:
255 sTitle = currPlay.info().getName().split('/')[-1]
257 sTitle = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()].getName()
259 if self.AudioCD_albuminfo:
260 if sAlbum == "" and "title" in self.AudioCD_albuminfo:
261 sAlbum = self.AudioCD_albuminfo["title"]
262 if sGenre == "" and "genre" in self.AudioCD_albuminfo:
263 sGenre = self.AudioCD_albuminfo["genre"]
264 if sArtist == "" and "artist" in self.AudioCD_albuminfo:
265 sArtist = self.AudioCD_albuminfo["artist"]
266 if "year" in self.AudioCD_albuminfo:
267 sYear = self.AudioCD_albuminfo["year"]
269 self.updateMusicInformation( sArtist, sTitle, sAlbum, sYear, sGenre, clear = True )
271 self.updateMusicInformation()
273 def updateMusicInformation(self, artist = "", title = "", album = "", year = "", genre = "", clear = False):
274 self.updateSingleMusicInformation("artist", artist, clear)
275 self.updateSingleMusicInformation("title", title, clear)
276 self.updateSingleMusicInformation("album", album, clear)
277 self.updateSingleMusicInformation("year", year, clear)
278 self.updateSingleMusicInformation("genre", genre, clear)
280 def updateSingleMusicInformation(self, name, info, clear):
281 if info != "" or clear:
282 if self[name].getText() != info:
283 self[name].setText(info)
285 def updateCoverArtPixmap(self, path):
286 while not path.endswith("/"):
288 new_coverArtFileName = self["coverArt"].default_pixmap
289 for filename in self["coverArt"].coverFileNames:
290 if fileExists(path + filename):
291 new_coverArtFileName = path + filename
292 if self.coverArtFileName != new_coverArtFileName:
293 self.coverArtFileName = new_coverArtFileName
294 pixmap = loadPic(self.coverArtFileName, 116, 116, AVSwitch().getAspectRatioSetting()/2,1,0,0)
295 if pixmap is not None:
296 self["coverArt"].instance.setPixmap(pixmap.__deref__())
299 self.lefttimer = True
300 self.leftKeyTimer.start(1000)
303 self.righttimer = True
304 self.rightKeyTimer.start(1000)
308 self.leftKeyTimer.stop()
309 self.lefttimer = False
310 self[self.currList].pageUp()
311 self.updateCurrentInfo()
315 self.rightKeyTimer.stop()
316 self.righttimer = False
317 self[self.currList].pageDown()
318 self.updateCurrentInfo()
320 def leftTimerFire(self):
321 self.leftKeyTimer.stop()
322 self.lefttimer = False
323 self.switchToFileList()
325 def rightTimerFire(self):
326 self.rightKeyTimer.stop()
327 self.righttimer = False
328 self.switchToPlayList()
330 def switchToFileList(self):
331 self.currList = "filelist"
332 self.filelist.selectionEnabled(1)
333 self.playlist.selectionEnabled(0)
334 self.updateCurrentInfo()
336 def switchToPlayList(self):
337 if len(self.playlist) != 0:
338 self.currList = "playlist"
339 self.filelist.selectionEnabled(0)
340 self.playlist.selectionEnabled(1)
341 self.updateCurrentInfo()
344 self[self.currList].up()
345 self.updateCurrentInfo()
348 self[self.currList].down()
349 self.updateCurrentInfo()
351 def showAfterSeek(self):
354 def showAfterCuesheetOperation(self):
357 def hideAfterResume(self):
360 def getIdentifier(self, ref):
365 return text.split('/')[-1]
367 # FIXME: maybe this code can be optimized
368 def updateCurrentInfo(self):
370 if self.currList == "filelist":
371 idx = self.filelist.getSelectionIndex()
372 r = self.filelist.list[idx]
379 self.summaries.setText(text,1)
382 if idx < len(self.filelist.list):
383 r = self.filelist.list[idx]
387 self.summaries.setText(text,3)
389 self.summaries.setText(" ",3)
392 if idx < len(self.filelist.list):
393 r = self.filelist.list[idx]
397 self.summaries.setText(text,4)
399 self.summaries.setText(" ",4)
402 if not self.filelist.canDescent():
403 r = self.filelist.getServiceRef()
407 self["currenttext"].setText(os_path.basename(text))
409 if self.currList == "playlist":
410 t = self.playlist.getSelection()
413 #display current selected entry on LCD
414 text = self.getIdentifier(t)
415 self.summaries.setText(text,1)
416 self["currenttext"].setText(text)
417 idx = self.playlist.getSelectionIndex()
419 if idx < len(self.playlist):
420 currref = self.playlist.getServiceRefList()[idx]
421 text = self.getIdentifier(currref)
422 self.summaries.setText(text,3)
424 self.summaries.setText(" ",3)
427 if idx < len(self.playlist):
428 currref = self.playlist.getServiceRefList()[idx]
429 text = self.getIdentifier(currref)
430 self.summaries.setText(text,4)
432 self.summaries.setText(" ",4)
435 if self.currList == "filelist":
436 if self.filelist.canDescent():
437 self.filelist.descent()
438 self.updateCurrentInfo()
442 if self.currList == "playlist":
443 selection = self["playlist"].getSelection()
444 self.changeEntry(self.playlist.getSelectionIndex())
448 if self.currList == "filelist":
449 if self.filelist.canDescent():
450 menu.append((_("add directory to playlist"), "copydir"))
452 menu.append((_("add files to playlist"), "copyfiles"))
453 menu.append((_("switch to playlist"), "playlist"))
454 menu.append((_("delete file"), "deletefile"))
456 menu.append((_("switch to filelist"), "filelist"))
457 menu.append((_("shuffle playlist"), "shuffle"))
458 menu.append((_("Delete entry"), "deleteentry"))
459 menu.append((_("clear playlist"), "clear"))
460 menu.append((_("hide player"), "hide"));
461 menu.append((_("save playlist"), "saveplaylist"));
462 menu.append((_("load playlist"), "loadplaylist"));
463 menu.append((_("delete saved playlist"), "deleteplaylist"));
464 menu.append((_("Edit settings"), "settings"))
465 drivepath = harddiskmanager.getAutofsMountpoint(harddiskmanager.getCD())
466 if pathExists(drivepath):
467 menu.insert(0,(_("Play Audio-CD..."), "audiocd"))
468 self.session.openWithCallback(self.menuCallback, ChoiceBox, title="", list=menu)
470 def menuCallback(self, choice):
474 if choice[1] == "copydir":
475 self.copyDirectory(self.filelist.getSelection()[0])
476 elif choice[1] == "copyfiles":
478 self.playlist.clear()
479 self.isAudioCD = False
480 self.copyDirectory(os_path.dirname(self.filelist.getSelection()[0].getPath()) + "/", recursive = False)
481 self.playServiceRefEntry(self.filelist.getServiceRef())
482 elif choice[1] == "playlist":
483 self.switchToPlayList()
484 elif choice[1] == "filelist":
485 self.switchToFileList()
486 elif choice[1] == "deleteentry":
487 if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
490 elif choice[1] == "clear":
491 self.clear_playlist()
492 elif choice[1] == "hide":
494 elif choice[1] == "saveplaylist":
496 elif choice[1] == "loadplaylist":
498 elif choice[1] == "deleteplaylist":
499 self.delete_saved_playlist()
500 elif choice[1] == "shuffle":
501 self.playlist.PlayListShuffle()
502 elif choice[1] == "deletefile":
504 elif choice[1] == "settings":
505 self.session.openWithCallback(self.applySettings, MediaPlayerSettings, self)
506 elif choice[1] == "audiocd":
507 from Components.Scanner import scanDevice
508 drivepath = harddiskmanager.getAutofsMountpoint(harddiskmanager.getCD())
509 self.cdAudioTrackFiles = []
510 res = scanDevice(drivepath)
511 list = [ (r.description, r, res[r], self.session) for r in res ]
513 (desc, scanner, files, session) = list[0]
515 if file.mimetype == "audio/x-cda":
516 self.cdAudioTrackFiles.append(file.path)
519 def playAudioCD(self):
520 from enigma import eServiceReference
521 from Plugins.Extensions.CDInfo.plugin import Query
523 if len(self.cdAudioTrackFiles):
524 self.playlist.clear()
525 self.savePlaylistOnExit = False
526 self.isAudioCD = True
527 for file in self.cdAudioTrackFiles:
528 ref = eServiceReference(4097, 0, file)
529 self.playlist.addFile(ref)
533 self.switchToPlayList()
535 def applySettings(self):
536 self.savePlaylistOnExit = config.mediaplayer.savePlaylistOnExit.getValue()
537 if config.mediaplayer.repeat.getValue() == True:
538 self["repeat"].setPixmapNum(1)
540 self["repeat"].setPixmapNum(0)
542 def showEventInformation(self):
543 from Screens.EventView import EventViewSimple
544 from ServiceReference import ServiceReference
545 evt = self[self.currList].getCurrentEvent()
547 self.session.open(EventViewSimple, evt, ServiceReference(self.getCurrent()))
549 # also works on filelist (?)
550 def getCurrent(self):
551 return self["playlist"].getCurrent()
553 def deletePlaylistEntry(self):
554 if self.currList == "playlist":
555 if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
559 def skip_listbegin(self):
560 if self.currList == "filelist":
561 self.filelist.moveToIndex(0)
563 self.playlist.moveToIndex(0)
564 self.updateCurrentInfo()
566 def skip_listend(self):
567 if self.currList == "filelist":
568 idx = len(self.filelist.list)
569 self.filelist.moveToIndex(idx - 1)
571 self.playlist.moveToIndex(len(self.playlist)-1)
572 self.updateCurrentInfo()
574 def save_playlist(self):
575 self.session.openWithCallback(self.save_playlist2,InputBox, title=_("Please enter filename (empty = use current date)"),windowTitle = _("Save Playlist"))
577 def save_playlist2(self, name):
581 name = strftime("%y%m%d_%H%M%S")
583 self.playlistIOInternal.clear()
584 for x in self.playlist.list:
585 self.playlistIOInternal.addService(ServiceReference(x[0]))
586 self.playlistIOInternal.save(resolveFilename(SCOPE_PLAYLIST) + name)
588 def load_playlist(self):
590 playlistdir = resolveFilename(SCOPE_PLAYLIST)
592 for i in os_listdir(playlistdir):
593 listpath.append((i,playlistdir + i))
595 print "Error while scanning subdirs ",e
596 self.session.openWithCallback(self.PlaylistSelected, ChoiceBox, title=_("Please select a playlist..."), list = listpath)
598 def PlaylistSelected(self,path):
600 self.clear_playlist()
601 extension = path[0].rsplit('.',1)[-1]
602 if self.playlistparsers.has_key(extension):
603 playlist = self.playlistparsers[extension]()
604 list = playlist.open(path[1])
606 self.playlist.addFile(x.ref)
607 self.playlist.updateList()
609 def delete_saved_playlist(self):
611 playlistdir = resolveFilename(SCOPE_PLAYLIST)
613 for i in os_listdir(playlistdir):
614 listpath.append((i,playlistdir + i))
616 print "Error while scanning subdirs ",e
617 self.session.openWithCallback(self.DeletePlaylistSelected, ChoiceBox, title=_("Please select a playlist to delete..."), list = listpath)
619 def DeletePlaylistSelected(self,path):
621 self.delname = path[1]
622 self.session.openWithCallback(self.deleteConfirmed, MessageBox, _("Do you really want to delete %s?") % (path[1]))
624 def deleteConfirmed(self, confirmed):
627 os_remove(self.delname)
629 self.session.open(MessageBox, _("Delete failed!, %s") %e, MessageBox.TYPE_ERROR)
631 def clear_playlist(self):
632 self.isAudioCD = False
634 self.playlist.clear()
635 self.switchToFileList()
637 def copyDirectory(self, directory, recursive = True):
638 print "copyDirectory", directory
639 filelist = FileList(directory, useServiceRef = True, isTop = True)
641 for x in filelist.getFileList():
642 if x[0][1] == True: #isDir
644 self.copyDirectory(x[0][0])
645 elif filelist.getServiceRef() and filelist.getServiceRef().type == 4097:
646 self.playlist.addFile(x[0][0])
647 self.playlist.updateList()
649 def deleteFile(self):
650 if self.currList == "filelist":
651 self.service = self.filelist.getServiceRef()
653 self.service = self.playlist.getSelection()
654 if self.service is None:
656 if self.service.type != 4098 and self.session.nav.getCurrentlyPlayingServiceReference() is not None:
657 if self.service == self.session.nav.getCurrentlyPlayingServiceReference():
660 serviceHandler = eServiceCenter.getInstance()
661 offline = serviceHandler.offlineOperations(self.service)
662 info = serviceHandler.info(self.service)
663 name = info and info.getName(self.service)
665 if offline is not None:
667 if not offline.deleteFromDisk(1):
670 self.session.openWithCallback(self.deleteConfirmed_offline, MessageBox, _("Do you really want to delete %s?") % (name))
672 self.session.openWithCallback(self.close, MessageBox, _("You cannot delete this!"), MessageBox.TYPE_ERROR)
674 def deleteConfirmed_offline(self, confirmed):
676 serviceHandler = eServiceCenter.getInstance()
677 offline = serviceHandler.offlineOperations(self.service)
679 if offline is not None:
681 if not offline.deleteFromDisk(0):
684 self.session.open(MessageBox, _("Delete failed!"), MessageBox.TYPE_ERROR)
686 self.removeListEntry()
688 def removeListEntry(self):
689 currdir = self.filelist.getCurrentDirectory()
690 self.filelist.changeDir(currdir)
695 if len(self.playlist) > 0:
696 for x in self.playlist.list:
697 if self.service == x[0]:
698 self.playlist.deleteFile(index)
702 self.playlist.updateList()
703 if self.currList == "playlist":
704 if len(self.playlist) == 0:
705 self.switchToFileList()
708 if self.filelist.getServiceRef().type == 4098: # playlist
709 ServiceRef = self.filelist.getServiceRef()
710 extension = ServiceRef.getPath()[ServiceRef.getPath().rfind('.') + 1:]
711 if self.playlistparsers.has_key(extension):
712 playlist = self.playlistparsers[extension]()
713 list = playlist.open(ServiceRef.getPath())
715 self.playlist.addFile(x.ref)
716 self.playlist.updateList()
718 self.playlist.addFile(self.filelist.getServiceRef())
719 self.playlist.updateList()
720 if len(self.playlist) == 1:
723 def addPlaylistParser(self, parser, extension):
724 self.playlistparsers[extension] = parser
727 next = self.playlist.getCurrentIndex() + 1
728 if next < len(self.playlist):
729 self.changeEntry(next)
730 elif ( len(self.playlist) > 0 ) and ( config.mediaplayer.repeat.getValue() == True ):
734 def nextMarkOrEntry(self):
735 if not self.jumpPreviousNextMark(lambda x: x):
736 next = self.playlist.getCurrentIndex() + 1
737 if next < len(self.playlist):
738 self.changeEntry(next)
742 def previousMarkOrEntry(self):
743 if not self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True):
744 next = self.playlist.getCurrentIndex() - 1
746 self.changeEntry(next)
748 def deleteEntry(self):
749 self.playlist.deleteFile(self.playlist.getSelectionIndex())
750 self.playlist.updateList()
751 if len(self.playlist) == 0:
752 self.switchToFileList()
754 def changeEntry(self, index):
755 self.playlist.setCurrentPlaying(index)
758 def playServiceRefEntry(self, serviceref):
759 serviceRefList = self.playlist.getServiceRefList()
760 for count in range(len(serviceRefList)):
761 if serviceRefList[count] == serviceref:
762 self.changeEntry(count)
765 def xplayEntry(self):
766 if self.currList == "playlist":
770 self.playlist.clear()
771 self.isAudioCD = False
772 sel = self.filelist.getSelection()
774 if sel[1]: # can descent
775 # add directory to playlist
776 self.copyDirectory(sel[0])
778 # add files to playlist
779 self.copyDirectory(os_path.dirname(sel[0].getPath()) + "/", recursive = False)
780 if len(self.playlist) > 0:
784 if len(self.playlist.getServiceRefList()):
785 needsInfoUpdate = False
786 currref = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()]
787 if self.session.nav.getCurrentlyPlayingServiceReference() is None or currref != self.session.nav.getCurrentlyPlayingServiceReference():
788 self.session.nav.playService(self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()])
789 info = eServiceCenter.getInstance().info(currref)
790 description = info and info.getInfoString(currref, iServiceInformation.sDescription) or ""
791 self["title"].setText(description)
792 # display just playing musik on LCD
793 idx = self.playlist.getCurrentIndex()
794 currref = self.playlist.getServiceRefList()[idx]
795 text = self.getIdentifier(currref)
797 ext = text[-4:].lower()
799 # FIXME: the information if the service contains video (and we should hide our window) should com from the service instead
800 if ext not in [".mp2", ".mp3", ".wav", ".ogg", "flac"] and not self.isAudioCD:
803 needsInfoUpdate = True
804 self.summaries.setText(text,1)
806 # get the next two entries
808 if idx < len(self.playlist):
809 currref = self.playlist.getServiceRefList()[idx]
810 text = self.getIdentifier(currref)
811 self.summaries.setText(text,3)
813 self.summaries.setText(" ",3)
816 if idx < len(self.playlist):
817 currref = self.playlist.getServiceRefList()[idx]
818 text = self.getIdentifier(currref)
819 self.summaries.setText(text,4)
821 self.summaries.setText(" ",4)
823 idx = self.playlist.getCurrentIndex()
824 currref = self.playlist.getServiceRefList()[idx]
825 text = currref.getPath()
826 ext = text[-4:].lower()
827 if ext not in [".mp2", ".mp3", ".wav", ".ogg", "flac"] and not self.isAudioCD:
830 needsInfoUpdate = True
832 self.unPauseService()
833 if needsInfoUpdate == True:
834 path = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()].getPath()
835 self.updateCoverArtPixmap(path)
837 pngname = self["coverArt"].default_pixmap
838 self.coverArtFileName = pngname
839 self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
840 self.readTitleInformation()
842 def updatedSeekState(self):
843 if self.seekstate == self.SEEK_STATE_PAUSE:
844 self.playlist.pauseFile()
845 elif self.seekstate == self.SEEK_STATE_PLAY:
846 self.playlist.playFile()
847 elif self.isStateForward(self.seekstate):
848 self.playlist.forwardFile()
849 elif self.isStateBackward(self.seekstate):
850 self.playlist.rewindFile()
852 def pauseEntry(self):
854 if self.seekstate == self.SEEK_STATE_PAUSE:
860 self.playlist.stopFile()
861 self.session.nav.playService(None)
862 self.updateMusicInformation(clear=True)
865 def unPauseService(self):
866 self.setSeekState(self.SEEK_STATE_PLAY)
868 def subtitleSelection(self):
869 from Screens.Subtitles import Subtitles
870 self.session.open(Subtitles)
872 class MediaPlayerLCDScreen(Screen):
874 <screen position="0,0" size="132,64" title="LCD Text">
875 <widget name="text1" position="4,0" size="132,35" font="Regular;16"/>
876 <widget name="text3" position="4,36" size="132,14" font="Regular;10"/>
877 <widget name="text4" position="4,49" size="132,14" font="Regular;10"/>
880 def __init__(self, session, parent):
881 Screen.__init__(self, session)
882 self["text1"] = Label("Mediaplayer")
883 self["text3"] = Label("")
884 self["text4"] = Label("")
886 def setText(self, text, line):
888 if text[-4:] == ".mp3":
891 text = text + textleer*10
893 self["text1"].setText(text)
895 self["text3"].setText(text)
897 self["text4"].setText(text)
899 def main(session, **kwargs):
900 session.open(MediaPlayer)
902 def menu(menuid, **kwargs):
903 if menuid == "mainmenu":
904 return [(_("Media player"), main, "media_player", 45)]
907 def filescan_open(list, session, **kwargs):
908 from enigma import eServiceReference
910 mp = session.open(MediaPlayer)
912 mp.savePlaylistOnExit = False
915 if file.mimetype == "video/MP2T":
919 ref = eServiceReference(stype, 0, file.path)
920 mp.playlist.addFile(ref)
923 mp.switchToPlayList()
925 def audioCD_open(list, session, **kwargs):
926 from enigma import eServiceReference
928 mp = session.open(MediaPlayer)
929 mp.cdAudioTrackFiles = []
931 mp.cdAudioTrackFiles.append(file.path)
934 def filescan(**kwargs):
935 from Components.Scanner import Scanner, ScanPath
937 Scanner(mimetypes = ["video/mpeg", "video/MP2T", "video/x-msvideo"],
940 ScanPath(path = "", with_subdirs = False),
943 description = "View Movies...",
944 openfnc = filescan_open,
946 Scanner(mimetypes = ["video/x-vcd"],
949 ScanPath(path = "mpegav", with_subdirs = False),
950 ScanPath(path = "MPEGAV", with_subdirs = False),
953 description = "View Video CD...",
954 openfnc = filescan_open,
956 Scanner(mimetypes = ["audio/mpeg", "audio/x-wav", "application/ogg", "audio/x-flac"],
959 ScanPath(path = "", with_subdirs = False),
962 description = "Play Music...",
963 openfnc = filescan_open,
966 from Plugins.Extensions.CDInfo.plugin import Query
968 Scanner(mimetypes = ["audio/x-cda"],
971 ScanPath(path = "", with_subdirs = False),
974 description = "Play Audio-CD...",
975 openfnc = audioCD_open,
981 from Plugins.Plugin import PluginDescriptor
982 def Plugins(**kwargs):
984 PluginDescriptor(name = "MediaPlayer", description = "Play back media files", where = PluginDescriptor.WHERE_MENU, fnc = menu),
985 PluginDescriptor(name = "MediaPlayer", where = PluginDescriptor.WHERE_FILESCAN, fnc = filescan)