actually exit dvd player on pressing exit key in exit choicebox
[enigma2.git] / lib / python / Plugins / Extensions / DVDPlayer / plugin.py
index 2169cc8c5566510b351f47b9da93d1c358f0bcd3..593d4d2e30060fd0eabbedb0060136d19dd0da2a 100644 (file)
@@ -1,22 +1,19 @@
 from os import path as os_path, remove as os_remove, listdir as os_listdir, system
-from time import strftime
-from enigma import eTimer, iPlayableService, eServiceCenter, iServiceInformation, eServiceReference, iServiceKeys
+from enigma import eTimer, iPlayableService, iServiceInformation, eServiceReference, iServiceKeys
 from Screens.Screen import Screen
 from Screens.MessageBox import MessageBox
 from Screens.ChoiceBox import ChoiceBox
-from Screens.InputBox import InputBox
 from Screens.HelpMenu import HelpableScreen
 from Screens.InfoBarGenerics import InfoBarSeek, InfoBarPVRState, InfoBarCueSheetSupport, InfoBarShowHide, InfoBarNotifications
 from Components.ActionMap import ActionMap, NumberActionMap, HelpableActionMap
 from Components.Label import Label
 from Components.FileList import FileList
+from Components.MenuList import MenuList
 from Components.ServiceEventTracker import ServiceEventTracker, InfoBarBase
 from Components.config import config
-from Components.ProgressBar import ProgressBar
-from ServiceReference import ServiceReference
 from Tools.Directories import pathExists, fileExists
+from Components.Harddisk import harddiskmanager
 
-import random
 import servicedvd # load c++ part of dvd player plugin
 
 lastpath = ""
@@ -26,19 +23,23 @@ class FileBrowser(Screen):
        <screen name="FileBrowser" position="100,100" size="520,376" title="DVD File Browser" >
                <widget name="filelist" position="0,0" size="520,376" scrollbarMode="showOnDemand" />
        </screen>"""
-       def __init__(self, session):
+       def __init__(self, session, dvd_filelist = [ ]):
                Screen.__init__(self, session)
-               global lastpath
-               if lastpath is not None:
-                       currDir = lastpath + "/"
+
+               self.dvd_filelist = dvd_filelist
+               if len(dvd_filelist):   
+                       self["filelist"] = MenuList(self.dvd_filelist)
                else:
-                       currDir = "/media/dvd/"
-               if not pathExists(currDir):
-                       currDir = "/"
-               #else:
-                       #print system("mount "+currDir)
-               self.filelist = FileList(currDir, matchingPattern = "(?i)^.*\.(iso)", useServiceRef = True)
-               self["filelist"] = self.filelist
+                       global lastpath
+                       if lastpath is not None:
+                               currDir = lastpath + "/"
+                       else:
+                               currDir = "/media/dvd/"
+                       if not pathExists(currDir):
+                               currDir = "/"
+
+                       self.filelist = FileList(currDir, matchingPattern = "(?i)^.*\.(iso)", useServiceRef = True)
+                       self["filelist"] = self.filelist
 
                self["FilelistActions"] = ActionMap(["OkCancelActions"],
                        {
@@ -47,21 +48,36 @@ class FileBrowser(Screen):
                        })
 
        def ok(self):
-               global lastpath
-               filename = self["filelist"].getFilename()
-               if filename is not None:
-                       lastpath = filename[0:filename.rfind("/")]
-                       if filename.upper().endswith("VIDEO_TS/"):
-                               print "dvd structure found, trying to open..."
-                               self.close(filename[0:-9])
-               if self["filelist"].canDescent(): # isDir
-                       self["filelist"].descent()
+               if len(self.dvd_filelist):
+                       print "OK " + self["filelist"].getCurrent()
+                       self.close(self["filelist"].getCurrent())
                else:
-                       self.close(filename)
+                       global lastpath
+                       filename = self["filelist"].getFilename()
+                       if filename is not None:
+                               if filename.upper().endswith("VIDEO_TS/"):
+                                       print "dvd structure found, trying to open..."
+                                       dvdpath = filename[0:-9]
+                                       lastpath = (dvdpath.rstrip("/").rsplit("/",1))[0]
+                                       print "lastpath video_ts/=", lastpath
+                                       self.close(dvdpath)
+                                       return
+                       if self["filelist"].canDescent(): # isDir
+                               self["filelist"].descent()
+                               pathname = self["filelist"].getCurrentDirectory() or ""
+                               if fileExists(pathname+"VIDEO_TS.IFO"):
+                                       print "dvd structure found, trying to open..."
+                                       lastpath = (pathname.rstrip("/").rsplit("/",1))[0]
+                                       print "lastpath video_ts.ifo=", lastpath
+                                       self.close(pathname)
+                       else:
+                               lastpath = filename[0:filename.rfind("/")]
+                               print "lastpath directory=", lastpath
+                               self.close(filename)
 
        def exit(self):
                self.close(None)
-               
+
 class DVDSummary(Screen):
        skin = """
        <screen position="0,0" size="132,64">
@@ -147,10 +163,9 @@ class ChapterZap(Screen):
                self.Timer.callback.append(self.keyOK)
                self.Timer.start(3000, True)
 
-class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarPVRState, InfoBarShowHide, HelpableScreen):
-#InfoBarCueSheetSupport, 
+class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarPVRState, InfoBarShowHide, HelpableScreen, InfoBarCueSheetSupport):
 #      ALLOW_SUSPEND = True
-#      ENABLE_RESUME_SUPPORT = True
+       ENABLE_RESUME_SUPPORT = True
        
        skin = """
        <screen name="DVDPlayer" flags="wfNoBorder" position="0,380" size="720,160" title="InfoBar" backgroundColor="transparent" >
@@ -219,11 +234,11 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
                config.seek.stepwise_repeat.value = self.saved_config_seek_stepwise_repeat
                config.seek.on_pause.value = self.saved_config_seek_on_pause
 
-       def __init__(self, session, args = None):
+       def __init__(self, session, dvd_device = None, dvd_filelist = [ ], args = None):
                Screen.__init__(self, session)
                InfoBarBase.__init__(self)
                InfoBarNotifications.__init__(self)
-#              InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
+               InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
                InfoBarShowHide.__init__(self)
                HelpableScreen.__init__(self)
                self.save_infobar_seek_config()
@@ -234,9 +249,11 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
 
                self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
                self.session.nav.stopService()
-               self["audioLabel"] = Label("1")
+               self["audioLabel"] = Label("n/a")
                self["subtitleLabel"] = Label("")
                self["chapterLabel"] = Label("")
+               self.last_audioTuple = None
+               self.last_subtitleTuple = None
                self.totalChapters = 0
                self.currentChapter = 0
                self.totalTitles = 0
@@ -244,6 +261,7 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
+                               iPlayableService.evStopped: self.__serviceStopped,
                                iPlayableService.evUser: self.__timeUpdated,
                                iPlayableService.evUser+1: self.__statePlay,
                                iPlayableService.evUser+2: self.__statePause,
@@ -254,18 +272,17 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
                                iPlayableService.evUser+7: self.__osdSubtitleInfoAvail,
                                iPlayableService.evUser+8: self.__chapterUpdated,
                                iPlayableService.evUser+9: self.__titleUpdated,
-                               #iPlayableService.evUser+10: self.__initializeDVDinfo,
                                iPlayableService.evUser+11: self.__menuOpened,
                                iPlayableService.evUser+12: self.__menuClosed
                        })
 
-               self["DVDPlayerDirectionActions"] = HelpableActionMap(self, "DirectionActions",
+               self["DVDPlayerDirectionActions"] = ActionMap(["DirectionActions"],
                        {
                                #MENU KEY DOWN ACTIONS
-                               "left": (self.keyLeft, _("DVD left key")),
-                               "right": (self.keyRight, _("DVD right key")),
-                               "up": (self.keyUp, _("DVD up key")),
-                               "down": (self.keyDown, _("DVD down key")),
+                               "left": self.keyLeft,
+                               "right": self.keyRight,
+                               "up": self.keyUp,
+                               "down": self.keyDown,
 
                                #MENU KEY REPEATED ACTIONS
                                "leftRepeated": self.doNothing,
@@ -278,13 +295,13 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
                                "rightUp": self.doNothing,
                                "upUp": self.doNothing,
                                "downUp": self.doNothing,
-                       }, -2)
+                       })
 
-               self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+               self["OkCancelActions"] = ActionMap(["OkCancelActions"],
                        {
-                               "ok": (self.keyOk, _("DVD ENTER key")),
+                               "ok": self.keyOk,
                                "cancel": self.keyCancel,
-                       }, -2)
+                       })
 
                self["DVDPlayerPlaybackActions"] = HelpableActionMap(self, "DVDPlayerActions",
                        {
@@ -299,7 +316,7 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
                                "dvdAudioMenu": (self.enterDVDAudioMenu, _("(show optional DVD audio menu)")),
                                "nextAudioTrack": (self.nextAudioTrack, _("switch to the next audio track")),
                                "nextSubtitleTrack": (self.nextSubtitleTrack, _("switch to the next subtitle language")),
-                               "seekBeginning": (self.seekBeginning, _("Jump to video title 1 (play movie from start)")),
+                               "seekBeginning": self.seekBeginning,
                        }, -2)
                        
                self["NumberActions"] = NumberActionMap( [ "NumberActions"],
@@ -317,10 +334,34 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
                        })
 
                self.onClose.append(self.__onClose)
+               self.physicalDVD = False
+               self.dvd_device = None
+               if dvd_device:
+                               self.dvd_device = dvd_device
+                               self.physicalDVD = True
+               else:
+                       devicepath = harddiskmanager.getAutofsMountpoint(harddiskmanager.getCD())
+                       if pathExists(devicepath):
+                               from Components.Scanner import scanDevice
+                               res = scanDevice(devicepath)
+                               list = [ (r.description, r, res[r], self.session) for r in res ]
+                               if list:
+                                       (desc, scanner, files, session) = list[0]
+                                       for file in files:
+                                               print file
+                                               if file.mimetype == "video/x-dvd":
+                                                       self.dvd_device = devicepath
+                                                       print "physical dvd found:", self.dvd_device
+                                                       self.physicalDVD = True                 
+
+               self.dvd_filelist = dvd_filelist
                self.onFirstExecBegin.append(self.showFileBrowser)
                self.service = None
                self.in_menu = False
-               
+               self.old_aspect = open("/proc/stb/video/aspect", "r").read()
+               self.old_policy = open("/proc/stb/video/policy", "r").read()
+               self.old_wss = open("/proc/stb/denc/0/wss", "r").read()
+
        def keyNumberGlobal(self, number):
                print "You pressed number " + str(number)
                self.session.openWithCallback(self.numberEntered, ChapterZap, number)
@@ -330,8 +371,25 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
                if retval > 0:
                        self.zapToNumber(retval)
 
+       def getServiceInterface(self, iface):
+               service = self.service
+               if service:
+                       attr = getattr(service, iface, None)
+                       if callable(attr):
+                               return attr()
+               return None
+
+       def __serviceStopped(self):
+               self.dvdScreen.hide()
+               subs = self.getServiceInterface("subtitle")
+               if subs:
+                       subs.disableSubtitles(self.session.current_dialog.instance)
+
        def serviceStarted(self): #override InfoBarShowHide function
-               pass
+               self.dvdScreen.show()
+               subs = self.getServiceInterface("subtitle")
+               if subs:
+                       subs.enableSubtitles(self.dvdScreen.instance, None)
 
        def doEofInternal(self, playing):
                if self.in_menu:
@@ -389,113 +447,133 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
                print "StringAvail"
 
        def __osdAudioInfoAvail(self):
-               audioString = self.service.info().getInfoString(iPlayableService.evUser+6)
-               print "AudioInfoAvail "+audioString
-               self["audioLabel"].setText(audioString)
-               if not self.in_menu:
-                       self.doShow()
+               info = self.getServiceInterface("info")
+               audioTuple = info and info.getInfoObject(iServiceInformation.sUser+6)
+               print "AudioInfoAvail ", repr(audioTuple)
+               if audioTuple:
+                       audioString = "%d: %s (%s)" % (audioTuple[0],audioTuple[1],audioTuple[2])
+                       self["audioLabel"].setText(audioString)
+                       if audioTuple != self.last_audioTuple and not self.in_menu:
+                               self.doShow()
+               self.last_audioTuple = audioTuple
 
        def __osdSubtitleInfoAvail(self):
-               subtitleString = self.service.info().getInfoString(iPlayableService.evUser+7)
-               print "SubtitleInfoAvail "+subtitleString
-               self["subtitleLabel"].setText(subtitleString)
-               if not self.in_menu:
-                       self.doShow()
+               info = self.getServiceInterface("info")
+               subtitleTuple = info and info.getInfoObject(iServiceInformation.sUser+7)
+               print "SubtitleInfoAvail ", repr(subtitleTuple)
+               if subtitleTuple:
+                       subtitleString = ""
+                       if subtitleTuple[0] is not 0:
+                               subtitleString = "%d: %s" % (subtitleTuple[0],subtitleTuple[1])
+                       self["subtitleLabel"].setText(subtitleString)
+                       if subtitleTuple != self.last_subtitleTuple and not self.in_menu:
+                               self.doShow()
+               self.last_subtitleTuple = subtitleTuple
 
        def __chapterUpdated(self):
-               self.currentChapter = self.service.info().getInfo(iPlayableService.evUser+8)
-               self.totalChapters = self.service.info().getInfo(iPlayableService.evUser+80)
-               self.setChapterLabel()
-               print "__chapterUpdated: %d/%d" % (self.currentChapter, self.totalChapters)
+               info = self.getServiceInterface("info")
+               if info:
+                       self.currentChapter = info.getInfo(iServiceInformation.sCurrentChapter)
+                       self.totalChapters = info.getInfo(iServiceInformation.sTotalChapters)
+                       self.setChapterLabel()
+                       print "__chapterUpdated: %d/%d" % (self.currentChapter, self.totalChapters)
 
        def __titleUpdated(self):
-               self.currentTitle = self.service.info().getInfo(iPlayableService.evUser+9)
-               self.totalTitles = self.service.info().getInfo(iPlayableService.evUser+90)
-               self.setChapterLabel()
-               print "__titleUpdated: %d/%d" % (self.currentTitle, self.totalTitles)
-               if not self.in_menu:
-                       self.doShow()
+               info = self.getServiceInterface("info")
+               if info:
+                       self.currentTitle = info.getInfo(iServiceInformation.sCurrentTitle)
+                       self.totalTitles = info.getInfo(iServiceInformation.sTotalTitles)
+                       self.setChapterLabel()
+                       print "__titleUpdated: %d/%d" % (self.currentTitle, self.totalTitles)
+                       if not self.in_menu:
+                               self.doShow()
                
-       #def __initializeDVDinfo(self):
-               #self.__osdAudioInfoAvail()
-               #self.__osdSubtitleInfoAvail()
-
        def askLeavePlayer(self):
-               self.session.openWithCallback(self.exitCB, ChoiceBox, title=_("Leave DVD Player?"), list=[(_("Exit"), "exit"), (_("Return to file browser"), "browser"), (_("Continue playing"), "play")])
+               choices = [(_("Continue playing"), "play"), (_("Exit"), "exit")]
+               if not self.physicalDVD:
+                       choices.insert(1,(_("Return to file browser"), "browser"))
+               self.session.openWithCallback(self.exitCB, ChoiceBox, title=_("Leave DVD Player?"), list = choices)
+
+       def sendKey(self, key):
+               keys = self.getServiceInterface("keys")
+               if keys:
+                       keys.keyPressed(key)
+               return keys
 
        def nextAudioTrack(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUser)
+               self.sendKey(iServiceKeys.keyUser)
 
        def nextSubtitleTrack(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUser+1)
+               self.sendKey(iServiceKeys.keyUser+1)
 
        def enterDVDAudioMenu(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUser+2)
+               self.sendKey(iServiceKeys.keyUser+2)
 
        def nextChapter(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUser+3)
+               self.sendKey(iServiceKeys.keyUser+3)
 
        def prevChapter(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUser+4)
+               self.sendKey(iServiceKeys.keyUser+4)
 
        def nextTitle(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUser+5)
+               self.sendKey(iServiceKeys.keyUser+5)
 
        def prevTitle(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUser+6)
+               self.sendKey(iServiceKeys.keyUser+6)
 
        def enterDVDMenu(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUser+7)
-                       
+               self.sendKey(iServiceKeys.keyUser+7)
+
        def seekBeginning(self):
                if self.service:
                        seekable = self.getSeek()
-                       if seekable is not None:
+                       if seekable:
                                seekable.seekTo(0)
-                               
+
        def zapToNumber(self, number):
                if self.service:
                        seekable = self.getSeek()
-                       if seekable is not None:
+                       if seekable:
                                print "seek to chapter %d" % number
                                seekable.seekChapter(number)
 
 #      MENU ACTIONS
        def keyRight(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyRight)
+               self.sendKey(iServiceKeys.keyRight)
 
        def keyLeft(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyLeft)
+               self.sendKey(iServiceKeys.keyLeft)
 
        def keyUp(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyUp)
+               self.sendKey(iServiceKeys.keyUp)
 
        def keyDown(self):
-               if self.service:
-                       self.service.keys().keyPressed(iServiceKeys.keyDown)
+               self.sendKey(iServiceKeys.keyDown)
 
        def keyOk(self):
-               if self.service:
-                       if not self.in_menu:
-                               self.toggleInfo()
-                       self.service.keys().keyPressed(iServiceKeys.keyOk)
+               if self.sendKey(iServiceKeys.keyOk) and not self.in_menu:
+                       self.toggleInfo()
 
        def keyCancel(self):
                self.askLeavePlayer()
 
        def showFileBrowser(self):
-               self.session.openWithCallback(self.FileBrowserClosed, FileBrowser)
+               if self.physicalDVD and len(self.dvd_filelist) == 0:
+                       if self.dvd_device == harddiskmanager.getAutofsMountpoint(harddiskmanager.getCD()):
+                               self.session.openWithCallback(self.DVDdriveCB, MessageBox, text=_("Do you want to play DVD in drive?"), timeout=5 )
+                       else:
+                               self.DVDdriveCB(True)
+               elif len(self.dvd_filelist) == 1:
+                       self.FileBrowserClosed(self.dvd_filelist[0])
+               else:
+                       self.session.openWithCallback(self.FileBrowserClosed, FileBrowser, self.dvd_filelist)
+       
+       def DVDdriveCB(self, answer):
+               if answer == True:
+                       self.FileBrowserClosed(self.dvd_device)
+               else:
+                       self.session.openWithCallback(self.FileBrowserClosed, FileBrowser)
+                       self.physicalDVD = False
 
        def FileBrowserClosed(self, val):
                curref = self.session.nav.getCurrentlyPlayingServiceReference()
@@ -510,54 +588,44 @@ class DVDPlayer(Screen, InfoBarBase, InfoBarNotifications, InfoBarSeek, InfoBarP
                                self.service = self.session.nav.getCurrentService()
                                print "self.service", self.service
                                print "cur_dlg", self.session.current_dialog
-                               self.dvdScreen.show()
-                               self.service.subtitle().enableSubtitles(self.dvdScreen.instance, None)
 
        def exitCB(self, answer):
-               if answer is not None:
-                       if answer[1] == "exit":
-                               if self.service:
-                                       self.dvdScreen.hide()
-                                       self.service.subtitle().disableSubtitles(self.session.current_dialog.instance)
-                                       self.service = None
-                               self.close()
-                       if answer[1] == "browser":
+               if not answer or answer and answer[1] == "exit":
+                       if self.service:
+                               self.service = None
+                       self.close()
+               if answer and answer[1] == "browser":
                                #TODO check here if a paused dvd playback is already running... then re-start it...
                                #else
-                               self.showFileBrowser()
-                       else:
-                               pass
+                       if self.service:
+                               self.service = None
+                       self.showFileBrowser()
 
        def __onClose(self):
+               for i in (("/proc/stb/video/aspect", self.old_aspect), ("/proc/stb/video/policy", self.old_policy), ("/proc/stb/denc/0/wss", self.old_wss)):
+                       try:
+                               open(i[0], "w").write(i[1])
+                       except IOError:
+                               print "restore", i[0], "failed"
                self.restore_infobar_seek_config()
                self.session.nav.playService(self.oldService)
 
-#      def playLastCB(self, answer): # overwrite infobar cuesheet function
-#              print "playLastCB", answer, self.resume_point
-#              pos = self.resume_point
-#              title = self.resume_point % 90000
-#              pos -= title
-#              chapter = title % 256
-#              title /= 256
-#              print "pos", pos, "title", title, "chapter", chapter
-#              if self.service:
-#                      seek = self.service.seek()
-#                      if title != 1:
-#                              seek.seekTitle(title)
-#                              self.resume_state = 1
-#                      elif chapter != 1:
-#                              seek.seekChapter(chapter)
-#                              self.resume_state = 2
-#                      else:
-#                              seek.seekTo(pos)
-#              self.hideAfterResume()
+       def playLastCB(self, answer): # overwrite infobar cuesheet function
+               print "playLastCB", answer, self.resume_point
+               if self.service:
+                       if answer == True:
+                               seekable = self.getSeek()
+                               if seekable:
+                                       seekable.seekTo(self.resume_point)
+                       pause = self.service.pause()
+                       pause.unpause()
+               self.hideAfterResume()
 
        def showAfterCuesheetOperation(self):
                if not self.in_menu:
                        self.show()
 
        def createSummary(self):
-               print "DVDCreateSummary"
                return DVDSummary
 
 #override some InfoBarSeek functions
@@ -576,5 +644,46 @@ def menu(menuid, **kwargs):
        return []
 
 from Plugins.Plugin import PluginDescriptor
+
+def filescan_open(list, session, **kwargs):
+       if len(list) == 1 and list[0].mimetype == "video/x-dvd":
+               splitted = list[0].path.split('/')
+               print "splitted", splitted
+               if len(splitted) > 2:
+                       if splitted[1] == 'autofs':
+                               session.open(DVDPlayer, dvd_device="/dev/%s" %(splitted[2]))
+                               return
+                       else:
+                               print "splitted[0]", splitted[1]
+       else:
+               dvd_filelist = []
+               for x in list:
+                       if x.mimetype == "video/x-dvd-iso":
+                               dvd_filelist.append(x.path)
+                       if x.mimetype == "video/x-dvd":
+                               dvd_filelist.append(x.path.rsplit('/',1)[0])                    
+               session.open(DVDPlayer, dvd_filelist=dvd_filelist)
+
+def filescan(**kwargs):
+       from Components.Scanner import Scanner, ScanPath
+
+       # Overwrite checkFile to only detect local
+       class LocalScanner(Scanner):
+               def checkFile(self, file):
+                       return fileExists(file.path)
+
+       return [
+               LocalScanner(mimetypes = ["video/x-dvd","video/x-dvd-iso"],
+                       paths_to_scan =
+                               [
+                                       ScanPath(path = "video_ts", with_subdirs = False),
+                                       ScanPath(path = "", with_subdirs = False),
+                               ],
+                       name = "DVD",
+                       description = "Play DVD",
+                       openfnc = filescan_open,
+               )]              
+
 def Plugins(**kwargs):
-       return [PluginDescriptor(name = "DVDPlayer", description = "Play DVDs", where = PluginDescriptor.WHERE_MENU, fnc = menu)]
+       return [PluginDescriptor(name = "DVDPlayer", description = "Play DVDs", where = PluginDescriptor.WHERE_MENU, fnc = menu),
+                       PluginDescriptor(where = PluginDescriptor.WHERE_FILESCAN, fnc = filescan)]