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
4 from Screens.Screen import Screen
5 from Screens.MessageBox import MessageBox
6 from Screens.InputBox import InputBox
7 from Components.ActionMap import NumberActionMap, HelpableActionMap
8 from Components.Label import Label
9 from Components.Pixmap import Pixmap,MultiPixmap
10 from Components.Label import Label
11 from Components.FileList import FileList
12 from Components.MediaPlayer import PlayList
13 from Tools.Directories import resolveFilename, SCOPE_CONFIG, SCOPE_PLAYLIST, SCOPE_SKIN_IMAGE
14 from Components.ServicePosition import ServicePositionGauge
15 from Components.ServiceEventTracker import ServiceEventTracker, InfoBarBase
16 from Components.Playlist import PlaylistIOInternal, PlaylistIOM3U, PlaylistIOPLS
17 from Screens.InfoBarGenerics import InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications, InfoBarSubtitleSupport
18 from ServiceReference import ServiceReference
19 from Screens.ChoiceBox import ChoiceBox
20 from Screens.HelpMenu import HelpableScreen
21 from Components.Harddisk import harddiskmanager
22 from Tools.Directories import fileExists, pathExists
25 class MyPlayList(PlayList):
27 PlayList.__init__(self)
29 def PlayListShuffle(self):
30 random.shuffle(self.list)
31 self.l.setList(self.list)
33 self.oldCurrPlaying = -1
35 class MediaPixmap(Pixmap):
36 def applySkin(self, desktop, screen):
37 self.default_pixmap = None
38 if self.skinAttributes is not None:
39 for (attrib, value) in self.skinAttributes:
40 if attrib == "pixmap":
41 self.default_pixmap = value
43 if self.default_pixmap is None:
44 self.default_pixmap = resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/no_coverArt.png")
45 return Pixmap.applySkin(self, desktop, screen)
47 class MediaPlayer(Screen, InfoBarBase, InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications, InfoBarSubtitleSupport, HelpableScreen):
49 ENABLE_RESUME_SUPPORT = True
51 def __init__(self, session, args = None):
52 Screen.__init__(self, session)
53 InfoBarAudioSelection.__init__(self)
54 InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
55 InfoBarNotifications.__init__(self)
56 InfoBarBase.__init__(self)
57 InfoBarSubtitleSupport.__init__(self)
58 HelpableScreen.__init__(self)
60 self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
61 self.session.nav.stopService()
63 self.playlistparsers = {}
64 self.addPlaylistParser(PlaylistIOM3U, "m3u")
65 self.addPlaylistParser(PlaylistIOPLS, "pls")
66 self.addPlaylistParser(PlaylistIOInternal, "e2pls")
68 # 'None' is magic to start at the list of mountpoints
69 self.filelist = FileList(None, 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")
70 self["filelist"] = self.filelist
72 self.playlist = MyPlayList()
73 #self.playlist = PlayList()
74 self.is_closing = False
76 self["playlist"] = self.playlist
78 self["PositionGauge"] = ServicePositionGauge(self.session.nav)
80 self["currenttext"] = Label("")
82 self["artisttext"] = Label(_("Artist:"))
83 self["artist"] = Label("")
84 self["titletext"] = Label(_("Title:"))
85 self["title"] = Label("")
86 self["albumtext"] = Label(_("Album:"))
87 self["album"] = Label("")
88 self["yeartext"] = Label(_("Year:"))
89 self["year"] = Label("")
90 self["genretext"] = Label(_("Genre:"))
91 self["genre"] = Label("")
92 self["coverArt"] = MediaPixmap()
93 self["repeat"] = MultiPixmap()
96 self.seek_target = None
98 class MoviePlayerActionMap(NumberActionMap):
99 def __init__(self, player, contexts = [ ], actions = { }, prio=0):
100 NumberActionMap.__init__(self, contexts, actions, prio)
103 def action(self, contexts, action):
105 return NumberActionMap.action(self, contexts, action)
108 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
110 "ok": (self.ok, _("add file to playlist")),
111 "cancel": (self.exit, _("exit mediaplayer")),
114 self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions",
116 "play": (self.xplayEntry, _("play entry")),
117 "pause": (self.pauseEntry, _("pause")),
118 "stop": (self.stopEntry, _("stop entry")),
119 "previous": (self.previousMarkOrEntry, _("play from previous mark or playlist entry")),
120 "next": (self.nextMarkOrEntry, _("play from next mark or playlist entry")),
121 "menu": (self.showMenu, _("menu")),
122 "skipListbegin": (self.skip_listbegin, _("jump to listbegin")),
123 "skipListend": (self.skip_listend, _("jump to listend")),
124 "prevBouquet": (self.switchToPlayList, _("switch to playlist")),
125 "nextBouquet": (self.switchToFileList, _("switch to filelist")),
126 "delete": (self.deletePlaylistEntry, _("delete playlist entry")),
127 "shift_stop": (self.clear_playlist, _("clear playlist")),
128 "shift_record": (self.playlist.PlayListShuffle, _("shuffle playlist")),
129 "subtitles": (self.subtitleSelection, _("Subtitle selection")),
132 self["InfobarEPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
134 "showEventInfo": (self.showEventInformation, _("show event details")),
137 self["actions"] = MoviePlayerActionMap(self, ["DirectionActions"],
139 "right": self.rightDown,
140 "rightRepeated": self.doNothing,
141 "rightUp": self.rightUp,
142 "left": self.leftDown,
143 "leftRepeated": self.doNothing,
144 "leftUp": self.leftUp,
147 "upRepeated": self.up,
148 "upUp": self.doNothing,
150 "downRepeated": self.down,
151 "downUp": self.doNothing,
154 InfoBarSeek.__init__(self, actionmap = "MediaPlayerSeekActions")
156 self.onClose.append(self.delMPTimer)
157 self.onClose.append(self.__onClose)
159 self.righttimer = False
160 self.rightKeyTimer = eTimer()
161 self.rightKeyTimer.callback.append(self.rightTimerFire)
163 self.lefttimer = False
164 self.leftKeyTimer = eTimer()
165 self.leftKeyTimer.callback.append(self.leftTimerFire)
167 self.currList = "filelist"
169 self.coverArtFileName = ""
170 self.isAudioCD = False
171 self.AudioCD_albuminfo = {}
172 self.savePlaylistOnExit = True
174 self.playlistIOInternal = PlaylistIOInternal()
175 list = self.playlistIOInternal.open(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
178 self.playlist.addFile(x.ref)
179 self.playlist.updateList()
181 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
183 iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
184 iPlayableService.evUser+11: self.__evDecodeError,
185 iPlayableService.evUser+12: self.__evPluginError
191 def createSummary(self):
192 return MediaPlayerLCDScreen
195 self.session.openWithCallback(self.exitCB, MessageBox, _("Do you really want to exit?"), timeout=5)
197 def exitCB(self, answer):
199 self.playlistIOInternal.clear()
200 for x in self.playlist.list:
201 self.playlistIOInternal.addService(ServiceReference(x[0]))
202 if self.savePlaylistOnExit:
203 self.playlistIOInternal.save(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
206 def checkSkipShowHideLock(self):
207 self.updatedSeekState()
209 def doEofInternal(self, playing):
216 self.session.nav.playService(self.oldService)
218 def __evUpdatedInfo(self):
219 currPlay = self.session.nav.getCurrentService()
220 currenttitle = currPlay.info().getInfo(iServiceInformation.sCurrentTitle)
221 totaltitles = currPlay.info().getInfo(iServiceInformation.sTotalTitles)
222 sTitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
223 print "[__evUpdatedInfo] title %d of %d (%s)" % (currenttitle, totaltitles, sTitle)
224 self.readTitleInformation()
226 def __evDecodeError(self):
227 currPlay = self.session.nav.getCurrentService()
228 sVideoType = currPlay.info().getInfoString(iServiceInformation.sVideoType)
229 print "[__evDecodeError] video-codec %s can't be decoded by hardware" % (sVideoType)
230 self.session.open(MessageBox, _("This Dreambox can't decode %s video streams!") % sVideoType, type = MessageBox.TYPE_INFO,timeout = 20 )
232 def __evPluginError(self):
233 currPlay = self.session.nav.getCurrentService()
234 message = currPlay.info().getInfoString(iServiceInformation.sUser+12)
235 print "[__evPluginError]" , message
236 self.session.open(MessageBox, message, type = MessageBox.TYPE_INFO,timeout = 20 )
238 def delMPTimer(self):
239 del self.rightKeyTimer
240 del self.leftKeyTimer
242 def readTitleInformation(self):
243 currPlay = self.session.nav.getCurrentService()
244 if currPlay is not None:
245 sTitle = currPlay.info().getInfoString(iServiceInformation.sTitle)
246 sAlbum = currPlay.info().getInfoString(iServiceInformation.sAlbum)
247 sGenre = currPlay.info().getInfoString(iServiceInformation.sGenre)
248 sArtist = currPlay.info().getInfoString(iServiceInformation.sArtist)
249 sYear = currPlay.info().getInfoString(iServiceInformation.sTimeCreate)
252 if not self.isAudioCD:
253 sTitle = currPlay.info().getName().split('/')[-1]
255 sTitle = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()].getName()
257 if self.AudioCD_albuminfo:
258 if sAlbum == "" and "title" in self.AudioCD_albuminfo:
259 sAlbum = self.AudioCD_albuminfo["title"]
260 if sGenre == "" and "genre" in self.AudioCD_albuminfo:
261 sGenre = self.AudioCD_albuminfo["genre"]
262 if sArtist == "" and "artist" in self.AudioCD_albuminfo:
263 sArtist = self.AudioCD_albuminfo["artist"]
264 if "year" in self.AudioCD_albuminfo:
265 sYear = self.AudioCD_albuminfo["year"]
267 self.updateMusicInformation( sArtist, sTitle, sAlbum, sYear, sGenre, clear = True )
269 self.updateMusicInformation()
271 def updateMusicInformation(self, artist = "", title = "", album = "", year = "", genre = "", clear = False):
272 self.updateSingleMusicInformation("artist", artist, clear)
273 self.updateSingleMusicInformation("title", title, clear)
274 self.updateSingleMusicInformation("album", album, clear)
275 self.updateSingleMusicInformation("year", year, clear)
276 self.updateSingleMusicInformation("genre", genre, clear)
278 def updateSingleMusicInformation(self, name, info, clear):
279 if info != "" or clear:
280 if self[name].getText() != info:
281 self[name].setText(info)
283 def updateCoverArtPixmap(self, path):
284 while not path.endswith("/"):
286 pngname = path + "folder.png"
288 if not fileExists(pngname):
289 pngname = self["coverArt"].default_pixmap
290 if self.coverArtFileName != pngname:
291 self.coverArtFileName = pngname
292 self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
295 self.lefttimer = True
296 self.leftKeyTimer.start(1000)
299 self.righttimer = True
300 self.rightKeyTimer.start(1000)
304 self.leftKeyTimer.stop()
305 self.lefttimer = False
306 self[self.currList].pageUp()
307 self.updateCurrentInfo()
311 self.rightKeyTimer.stop()
312 self.righttimer = False
313 self[self.currList].pageDown()
314 self.updateCurrentInfo()
316 def leftTimerFire(self):
317 self.leftKeyTimer.stop()
318 self.lefttimer = False
319 self.switchToFileList()
321 def rightTimerFire(self):
322 self.rightKeyTimer.stop()
323 self.righttimer = False
324 self.switchToPlayList()
326 def switchToFileList(self):
327 self.currList = "filelist"
328 self.filelist.selectionEnabled(1)
329 self.playlist.selectionEnabled(0)
330 self.updateCurrentInfo()
332 def switchToPlayList(self):
333 if len(self.playlist) != 0:
334 self.currList = "playlist"
335 self.filelist.selectionEnabled(0)
336 self.playlist.selectionEnabled(1)
337 self.updateCurrentInfo()
340 self[self.currList].up()
341 self.updateCurrentInfo()
344 self[self.currList].down()
345 self.updateCurrentInfo()
347 def showAfterSeek(self):
350 def showAfterCuesheetOperation(self):
353 def hideAfterResume(self):
356 def getIdentifier(self, ref):
361 return text.split('/')[-1]
363 # FIXME: maybe this code can be optimized
364 def updateCurrentInfo(self):
366 if self.currList == "filelist":
367 idx = self.filelist.getSelectionIndex()
368 r = self.filelist.list[idx]
375 self.summaries.setText(text,1)
378 if idx < len(self.filelist.list):
379 r = self.filelist.list[idx]
383 self.summaries.setText(text,3)
385 self.summaries.setText(" ",3)
388 if idx < len(self.filelist.list):
389 r = self.filelist.list[idx]
393 self.summaries.setText(text,4)
395 self.summaries.setText(" ",4)
398 if not self.filelist.canDescent():
399 r = self.filelist.getServiceRef()
403 self["currenttext"].setText(os_path.basename(text))
405 if self.currList == "playlist":
406 t = self.playlist.getSelection()
409 #display current selected entry on LCD
410 text = self.getIdentifier(t)
411 self.summaries.setText(text,1)
412 self["currenttext"].setText(text)
413 idx = self.playlist.getSelectionIndex()
415 if idx < len(self.playlist):
416 currref = self.playlist.getServiceRefList()[idx]
417 text = self.getIdentifier(currref)
418 self.summaries.setText(text,3)
420 self.summaries.setText(" ",3)
423 if idx < len(self.playlist):
424 currref = self.playlist.getServiceRefList()[idx]
425 text = self.getIdentifier(currref)
426 self.summaries.setText(text,4)
428 self.summaries.setText(" ",4)
431 if self.currList == "filelist":
432 if self.filelist.canDescent():
433 self.filelist.descent()
434 self.updateCurrentInfo()
438 if self.currList == "playlist":
439 selection = self["playlist"].getSelection()
440 self.changeEntry(self.playlist.getSelectionIndex())
444 if self.currList == "filelist":
445 if self.filelist.canDescent():
446 menu.append((_("add directory to playlist"), "copydir"))
448 menu.append((_("add files to playlist"), "copyfiles"))
449 menu.append((_("switch to playlist"), "playlist"))
451 menu.append((_("switch to filelist"), "filelist"))
453 menu.append((_("shuffle playlist"), "shuffle"))
455 menu.append((_("delete"), "delete"))
456 menu.append((_("clear playlist"), "clear"))
457 menu.append((_("hide player"), "hide"));
458 menu.append((_("save playlist"), "saveplaylist"));
459 menu.append((_("load playlist"), "loadplaylist"));
460 menu.append((_("delete saved playlist"), "deleteplaylist"));
461 menu.append((_("repeat playlist"), "repeat"));
462 drivepath = harddiskmanager.getAutofsMountpoint(harddiskmanager.getCD())
463 if pathExists(drivepath):
464 menu.insert(0,(_("Play Audio-CD..."), "audiocd"))
465 self.session.openWithCallback(self.menuCallback, ChoiceBox, title="", list=menu)
467 def menuCallback(self, choice):
471 if choice[1] == "copydir":
472 self.copyDirectory(self.filelist.getSelection()[0])
473 elif choice[1] == "copyfiles":
475 self.playlist.clear()
476 self.copyDirectory(os_path.dirname(self.filelist.getSelection()[0].getPath()) + "/", recursive = False)
477 self.playServiceRefEntry(self.filelist.getServiceRef())
478 elif choice[1] == "playlist":
479 self.switchToPlayList()
480 elif choice[1] == "filelist":
481 self.switchToFileList()
482 elif choice[1] == "delete":
483 if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
486 elif choice[1] == "clear":
488 self.playlist.clear()
489 self.switchToFileList()
490 elif choice[1] == "hide":
492 elif choice[1] == "saveplaylist":
494 elif choice[1] == "loadplaylist":
496 elif choice[1] == "deleteplaylist":
497 self.delete_saved_playlist()
498 elif choice[1] == "shuffle":
499 self.playlist.PlayListShuffle()
500 elif choice[1] == "repeat":
501 if self.repeat == True:
503 self["repeat"].setPixmapNum(0)
506 self["repeat"].setPixmapNum(1)
507 elif choice[1] == "audiocd":
508 from Components.Scanner import scanDevice
509 drivepath = harddiskmanager.getAutofsMountpoint(harddiskmanager.getCD())
510 self.cdAudioTrackFiles = []
511 res = scanDevice(drivepath)
512 list = [ (r.description, r, res[r], self.session) for r in res ]
514 (desc, scanner, files, session) = list[0]
516 if file.mimetype == "audio/x-cda":
517 self.cdAudioTrackFiles.append(file.path)
520 def playAudioCD(self):
521 from enigma import eServiceReference
522 from Plugins.Extensions.CDInfo.plugin import Query
524 if len(self.cdAudioTrackFiles):
525 self.playlist.clear()
526 self.savePlaylistOnExit = False
527 self.isAudioCD = True
528 for file in self.cdAudioTrackFiles:
529 ref = eServiceReference(4097, 0, file)
530 self.playlist.addFile(ref)
534 self.switchToPlayList()
536 def showEventInformation(self):
537 from Screens.EventView import EventViewSimple
538 from ServiceReference import ServiceReference
539 evt = self[self.currList].getCurrentEvent()
541 self.session.open(EventViewSimple, evt, ServiceReference(self.getCurrent()))
543 # also works on filelist (?)
544 def getCurrent(self):
545 return self["playlist"].getCurrent()
547 def deletePlaylistEntry(self):
548 if self.currList == "playlist":
549 if self.playlist.getSelectionIndex() == self.playlist.getCurrentIndex():
553 def skip_listbegin(self):
554 if self.currList == "filelist":
555 self.filelist.moveToIndex(0)
557 self.playlist.moveToIndex(0)
558 self.updateCurrentInfo()
560 def skip_listend(self):
561 if self.currList == "filelist":
562 idx = len(self.filelist.list)
563 self.filelist.moveToIndex(idx - 1)
565 self.playlist.moveToIndex(len(self.playlist)-1)
566 self.updateCurrentInfo()
568 def save_playlist(self):
569 self.session.openWithCallback(self.save_playlist2,InputBox, title=_("Please enter filename (empty = use current date)"),windowTitle = _("Save Playlist"))
571 def save_playlist2(self, name):
575 name = strftime("%y%m%d_%H%M%S")
577 self.playlistIOInternal.clear()
578 for x in self.playlist.list:
579 self.playlistIOInternal.addService(ServiceReference(x[0]))
580 self.playlistIOInternal.save(resolveFilename(SCOPE_PLAYLIST) + name)
582 def load_playlist(self):
584 playlistdir = resolveFilename(SCOPE_PLAYLIST)
586 for i in os_listdir(playlistdir):
587 listpath.append((i,playlistdir + i))
589 print "Error while scanning subdirs ",e
590 self.session.openWithCallback(self.PlaylistSelected, ChoiceBox, title=_("Please select a playlist..."), list = listpath)
592 def PlaylistSelected(self,path):
594 self.clear_playlist()
595 extension = path[0].rsplit('.',1)[-1]
596 if self.playlistparsers.has_key(extension):
597 playlist = self.playlistparsers[extension]()
598 list = playlist.open(path[1])
600 self.playlist.addFile(x.ref)
601 self.playlist.updateList()
603 def delete_saved_playlist(self):
605 playlistdir = resolveFilename(SCOPE_PLAYLIST)
607 for i in os_listdir(playlistdir):
608 listpath.append((i,playlistdir + i))
610 print "Error while scanning subdirs ",e
611 self.session.openWithCallback(self.DeletePlaylistSelected, ChoiceBox, title=_("Please select a playlist to delete..."), list = listpath)
613 def DeletePlaylistSelected(self,path):
615 self.delname = path[1]
616 self.session.openWithCallback(self.deleteConfirmed, MessageBox, _("Do you really want to delete %s?") % (path[1]))
618 def deleteConfirmed(self, confirmed):
620 os_remove(self.delname)
622 def clear_playlist(self):
624 self.playlist.clear()
625 self.switchToFileList()
627 def copyDirectory(self, directory, recursive = True):
628 print "copyDirectory", directory
629 filelist = FileList(directory, useServiceRef = True, isTop = True)
631 for x in filelist.getFileList():
632 if x[0][1] == True: #isDir
634 self.copyDirectory(x[0][0])
636 self.playlist.addFile(x[0][0])
637 self.playlist.updateList()
640 if self.filelist.getServiceRef().type == 4098: # playlist
641 ServiceRef = self.filelist.getServiceRef()
642 extension = ServiceRef.getPath()[ServiceRef.getPath().rfind('.') + 1:]
643 print "extension:", extension
644 if self.playlistparsers.has_key(extension):
645 playlist = self.playlistparsers[extension]()
646 list = playlist.open(ServiceRef.getPath())
648 self.playlist.addFile(x.ref)
650 self.playlist.addFile(self.filelist.getServiceRef())
651 self.playlist.updateList()
652 if len(self.playlist) == 1:
655 def addPlaylistParser(self, parser, extension):
656 self.playlistparsers[extension] = parser
659 next = self.playlist.getCurrentIndex() + 1
660 if next < len(self.playlist):
661 self.changeEntry(next)
662 elif ( len(self.playlist) > 0 ) and ( self.repeat == True ):
666 def nextMarkOrEntry(self):
667 if not self.jumpPreviousNextMark(lambda x: x):
668 next = self.playlist.getCurrentIndex() + 1
669 if next < len(self.playlist):
670 self.changeEntry(next)
674 def previousMarkOrEntry(self):
675 if not self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True):
676 next = self.playlist.getCurrentIndex() - 1
678 self.changeEntry(next)
680 def deleteEntry(self):
681 self.playlist.deleteFile(self.playlist.getSelectionIndex())
682 self.playlist.updateList()
683 if len(self.playlist) == 0:
684 self.switchToFileList()
686 def changeEntry(self, index):
687 self.playlist.setCurrentPlaying(index)
690 def playServiceRefEntry(self, serviceref):
691 serviceRefList = self.playlist.getServiceRefList()
692 for count in range(len(serviceRefList)):
693 if serviceRefList[count] == serviceref:
694 self.changeEntry(count)
697 def xplayEntry(self):
698 if self.currList == "playlist":
702 self.playlist.clear()
703 sel = self.filelist.getSelection()
705 if sel[1]: # can descent
706 # add directory to playlist
707 self.copyDirectory(sel[0])
709 # add files to playlist
710 self.copyDirectory(os_path.dirname(sel[0].getPath()) + "/", recursive = False)
711 if len(self.playlist) > 0:
715 if len(self.playlist.getServiceRefList()):
716 needsInfoUpdate = False
717 currref = self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()]
718 if self.session.nav.getCurrentlyPlayingServiceReference() is None or currref != self.session.nav.getCurrentlyPlayingServiceReference():
719 self.session.nav.playService(self.playlist.getServiceRefList()[self.playlist.getCurrentIndex()])
720 info = eServiceCenter.getInstance().info(currref)
721 description = info and info.getInfoString(currref, iServiceInformation.sDescription) or ""
722 self["title"].setText(description)
723 # display just playing musik on LCD
724 idx = self.playlist.getCurrentIndex()
725 currref = self.playlist.getServiceRefList()[idx]
726 text = self.getIdentifier(currref)
728 ext = text[-4:].lower()
730 # FIXME: the information if the service contains video (and we should hide our window) should com from the service instead
731 if ext not in [".mp2", ".mp3", ".wav", ".ogg", "flac"] and not self.isAudioCD:
734 needsInfoUpdate = True
735 self.summaries.setText(text,1)
737 # get the next two entries
739 if idx < len(self.playlist):
740 currref = self.playlist.getServiceRefList()[idx]
741 text = self.getIdentifier(currref)
742 self.summaries.setText(text,3)
744 self.summaries.setText(" ",3)
747 if idx < len(self.playlist):
748 currref = self.playlist.getServiceRefList()[idx]
749 text = self.getIdentifier(currref)
750 self.summaries.setText(text,4)
752 self.summaries.setText(" ",4)
754 idx = self.playlist.getCurrentIndex()
755 currref = self.playlist.getServiceRefList()[idx]
756 text = currref.getPath()
757 ext = text[-4:].lower()
758 if ext not in [".mp2", ".mp3", ".wav", ".ogg", "flac"] and not self.isAudioCD:
761 needsInfoUpdate = True
763 self.unPauseService()
764 if needsInfoUpdate == True:
765 self.updateCoverArtPixmap(currref.getPath())
767 pngname = self["coverArt"].default_pixmap
768 self.coverArtFileName = pngname
769 self["coverArt"].instance.setPixmapFromFile(self.coverArtFileName)
770 self.readTitleInformation()
772 def updatedSeekState(self):
773 if self.seekstate == self.SEEK_STATE_PAUSE:
774 self.playlist.pauseFile()
775 elif self.seekstate == self.SEEK_STATE_PLAY:
776 self.playlist.playFile()
777 elif self.isStateForward(self.seekstate):
778 self.playlist.forwardFile()
779 elif self.isStateBackward(self.seekstate):
780 self.playlist.rewindFile()
782 def pauseEntry(self):
784 if self.seekstate == self.SEEK_STATE_PAUSE:
790 self.playlist.stopFile()
791 self.session.nav.playService(None)
792 self.updateMusicInformation(clear=True)
795 def unPauseService(self):
796 self.setSeekState(self.SEEK_STATE_PLAY)
798 def subtitleSelection(self):
799 from Screens.Subtitles import Subtitles
800 self.session.open(Subtitles)
802 class MediaPlayerLCDScreen(Screen):
804 <screen position="0,0" size="132,64" title="LCD Text">
805 <widget name="text1" position="4,0" size="132,35" font="Regular;16"/>
806 <widget name="text3" position="4,36" size="132,14" font="Regular;10"/>
807 <widget name="text4" position="4,49" size="132,14" font="Regular;10"/>
810 def __init__(self, session, parent):
811 Screen.__init__(self, session)
812 self["text1"] = Label("Mediaplayer")
813 self["text3"] = Label("")
814 self["text4"] = Label("")
816 def setText(self, text, line):
817 print "lcd set text:", text, line
819 if text[-4:] == ".mp3":
822 text = text + textleer*10
824 self["text1"].setText(text)
826 self["text3"].setText(text)
828 self["text4"].setText(text)
830 def main(session, **kwargs):
831 session.open(MediaPlayer)
833 def menu(menuid, **kwargs):
834 if menuid == "mainmenu":
835 return [(_("Media player"), main, "media_player", 45)]
838 def filescan_open(list, session, **kwargs):
839 from enigma import eServiceReference
841 mp = session.open(MediaPlayer)
843 mp.savePlaylistOnExit = False
846 if file.mimetype == "video/MP2T":
850 ref = eServiceReference(stype, 0, file.path)
851 mp.playlist.addFile(ref)
854 mp.switchToPlayList()
856 def audioCD_open(list, session, **kwargs):
857 from enigma import eServiceReference
859 mp = session.open(MediaPlayer)
860 mp.cdAudioTrackFiles = []
862 mp.cdAudioTrackFiles.append(file.path)
865 def filescan(**kwargs):
866 from Components.Scanner import Scanner, ScanPath
868 Scanner(mimetypes = ["video/mpeg", "video/MP2T", "video/x-msvideo"],
871 ScanPath(path = "", with_subdirs = False),
874 description = "View Movies...",
875 openfnc = filescan_open,
877 Scanner(mimetypes = ["video/x-vcd"],
880 ScanPath(path = "mpegav", with_subdirs = False),
881 ScanPath(path = "MPEGAV", with_subdirs = False),
884 description = "View Video CD...",
885 openfnc = filescan_open,
887 Scanner(mimetypes = ["audio/mpeg", "audio/x-wav", "application/ogg", "audio/x-flac"],
890 ScanPath(path = "", with_subdirs = False),
893 description = "Play Music...",
894 openfnc = filescan_open,
897 from Plugins.Extensions.CDInfo.plugin import Query
899 Scanner(mimetypes = ["audio/x-cda"],
902 ScanPath(path = "", with_subdirs = False),
905 description = "Play Audio-CD...",
906 openfnc = audioCD_open,
912 from Plugins.Plugin import PluginDescriptor
913 def Plugins(**kwargs):
915 PluginDescriptor(name = "MediaPlayer", description = "Play back media files", where = PluginDescriptor.WHERE_MENU, fnc = menu),
916 PluginDescriptor(name = "MediaPlayer", where = PluginDescriptor.WHERE_FILESCAN, fnc = filescan)