def __init__(self, session, service, cutlistat):
self.service = service
#self.backup = []
self.cutlistat = cutlistat
self.cut_list = []
Cutlist.__init__(self)
MoviePlayer.__init__(self, session, service)
self.skinName = "MoviePlayer"
self["custom_actions"] = HelpableActionMap(self, "CutlistPlayerActions",
{
"left": (self.left, _("Move Cutlist to the left")),
"right": (self.right, _("Move Cutlist to the right")),
"ok": (self.switch, _("Switch between Marker and Cut-In/Out")),
"exit": (self.cancel, _("Exit without saving")),
#"up": (self["list"].pageUp, _("Page up")),
#"down": (self["list"].pageDown, _("Page up")),
#"red": (self.ok, _("Download Single Cutlist")),
"green": (self.save, _("Save new cutlist")),
#"yellow": (self.bestdownload, _("Page up")),
#"blue": (self.remove, _("Remove Marker")),
}, -3)
self["Service"] = CutlistService(session.nav, self)
def __init__(self, session,openmovie,opensubtitle, rootID, LastPlayedService, URLlinkName = '', movieTitle='', LastPosition = 0):
self.session = session
#if '://' not in uri: uri = 'file://' + uri
fileRef = eServiceReference(int(rootID),0,openmovie)
fileRef.setName (movieTitle)
self.Ask_on_movie_stop = False
#try:
if config.usage.on_movie_stop.value == "ask":
self.Ask_on_movie_stop = True
config.usage.on_movie_stop.value = "quit"
config.usage.on_movie_stop.save()
#except:
# pass
self.Ask_on_movie_eof = False
try:
if config.usage.on_movie_eof.value == "ask":
self.Ask_on_movie_eof = True
config.usage.on_movie_eof.value = "quit"
config.usage.on_movie_eof.save()
except:
pass
systemMoviePlayer.__init__(self, self.session, fileRef)
self.skinName = "MoviePlayer"
systemMoviePlayer.skinName = "MoviePlayer"
if self.Ask_on_movie_stop == True:
config.usage.on_movie_stop.value = "ask"
config.usage.on_movie_stop.save()
if self.Ask_on_movie_eof == True:
config.usage.on_movie_eof.value = "ask"
config.usage.on_movie_eof.save()
def closeScreen(self):
# When exiting, restore the previous service/playback if a channel has been previewed.
currentService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
if currentService and currentService.toString(
) != self.__originalPlayingService.toString():
# service has changed from the original
if self.epgConfig.preview_mode.value:
# In preview mode, the original service or movie playback is restored
if self.__originalPlayingService.isPlayback():
# Restart movie playback at the resume point stored earlier
from Screens.InfoBar import MoviePlayer
if MoviePlayer.instance:
MoviePlayer.instance.forceNextResume()
self.session.nav.playService(self.__originalPlayingService)
else:
# In non-preview mode, stick with the now playing service; this means closing the movieplayer
# if it's open, and setting the infobar's lastservice
from Screens.InfoBar import MoviePlayer
MoviePlayer.ensureClosed(currentService)
self.zapFunc(None, False)
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
self.closeEventViewDialog()
self.close()
def __init__(self, session, service):
CutListSupport.__init__(self, service)
MoviePlayer.__init__(self, session, service)
MoviePreview.__init__(self, session)
SelectionEventInfo.__init__(self)
self.skinName = ["MoviePlayerExtended", "MoviePlayer"]
global PlayerInstance
PlayerInstance = self
self["EPGActions"] = HelpableActionMap(
self, "InfobarEPGActions", {
"showEventInfo": (self.openInfoView, _("Show event details")),
"showEventInfoPlugin":
(self.openServiceList, _("Open servicelist"))
})
if config.AdvancedMovieSelection.exitkey.value and config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(
self, "WizardActions",
{"back": (self.leavePlayer, _("Leave movie player"))})
if config.AdvancedMovieSelection.exitkey.value and not config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(
self, "WizardActions",
{"back": (self.close, _("Leave movie player"))})
if config.AdvancedMovieSelection.use_original_movieplayer_summary.value == True:
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={iPlayableService.evUpdatedInfo: self.__updateInfo})
self.firstime = True
self.onExecBegin.append(self.__onExecBegin)
def keyOK(self): sel = self["config"].getCurrent()[1] if sel == self.positionEntry: if self.length: if self.dvd: # seekTo() doesn't work for DVD Player oldPosition = self.seek.getPlayPosition()[1] newPosition = int(float(self.length[1]) / 100.0 * self.percent) if newPosition > oldPosition: pts = newPosition - oldPosition else: pts = -1*(oldPosition - newPosition) DVDPlayer.doSeekRelative(self.infobarInstance, pts) else: self.seek.seekTo(int(float(self.length[1]) / 100.0 * self.percent)) self.exit() elif sel == self.minuteInput: pts = self.minuteInput.value * 60 * 90000 if self.fwd == False: pts = -1*pts if self.dvd: DVDPlayer.doSeekRelative(self.infobarInstance, pts) elif self.vdb: VideoDBPlayer.doSeekRelative(self.infobarInstance, pts) else: MoviePlayer.doSeekRelative(self.infobarInstance, pts) self.exit()
def __init__(self, session, sref, playlist, playlistName, playlistCB): self.onPlayService = [] self.sref = sref MoviePlayer.__init__(self, session, sref) InfoBarPlaylist.__init__(self, playlist, playlistCB, playlistName) # SubsSupport.__init__(self, subPath=subtitles, alreadyPlaying=True) self.skinName = "MoviePlayer"
def __init__(self, session, playlist, notifyNextEntry=None, flags=None):
self.session = session
self.flags = flags
self.playlist = self.fixParts(playlist)
self.progressTimer = eTimer()
self.progressTimer.callback.append(self.progressUpdate)
self.progressTimer.start(1000)
self.notifyNextEntry = notifyNextEntry
if isinstance(self.playlist, list):
self.isPlaylist = True
self.current = 0
firstPath = self.playlist[0][0]
firstName = self.playlist[0][1]
if firstPath.endswith(".ts"):
type = 1
elif firstPath.endswith(".m2ts"):
type = 3
else:
type = 4097
ref = eServiceReference(type, 0, firstPath)
self.currentPlayingFile = firstPath
ref.setName(firstName)
self.playing = True
MoviePlayer.__init__(self, session, ref)
else:
self.isPlaylist = False
self.playing = True
self.currentPlayingFile = self.playlist
MoviePlayer.__init__(self, session, self.playlist)
self.skinName = "MoviePlayer"
def evEOF(self, needToClose=False):
# see if there are more to play
if (self.playcount + 1) < len(self.playlist):
self.playcount += 1
service = self.playlist[self.playcount]
self.currentlyPlaying = service
if os.path.exists(service.getPath()):
self.recordings.viewedToggle(
service,
True) # rename .cutsr to .cuts if user has toggled it
self.session.nav.playService(service)
self.currentlyPlaying = service
self.setSeekState(InfoBarSeek.SEEK_STATE_PLAY)
self.doSeek(0)
DelayedFunction(200, self.setAudioTrack)
DelayedFunction(1000, self.setSubtitleState, True)
else:
self.session.open(
MessageBox,
_("Skipping movie, the file does not exist.\n\n") +
service.getPath(), MessageBox.TYPE_ERROR, 10)
self.evEOF(needToClose)
else:
if 0:
MoviePlayer.handleLeave(self, config.usage.on_movie_eof.value)
else:
if needToClose or config.usage.on_movie_eof.value != "pause": # ask, movielist, quit or pause
global gClosedByDeleteleavePlayer
gClosedByDelete = needToClose
self.leavePlayer(False)
def __init__(self, session, sref, playlist, playlistName, playlistCB): self.onPlayService = [] self.sref = sref MoviePlayer.__init__(self, session, sref) InfoBarPlaylist.__init__(self, playlist, playlistCB, playlistName) # SubsSupport.__init__(self, subPath=subtitles, alreadyPlaying=True) self.skinName = "MoviePlayer"
def zapExit(self):
selectedService = self["list"].getCurrent()[1]
from Screens.InfoBar import MoviePlayer
MoviePlayer.ensureClosed(selectedService)
self.zapSelectedService()
self.closeEventViewDialog()
self.close()
def __init__(self, session, service):
CutListSupport.__init__(self, service)
MoviePlayer.__init__(self, session, service)
MoviePreview.__init__(self, session)
SelectionEventInfo.__init__(self)
self.skinName = ["MoviePlayerExtended", "MoviePlayer"]
global PlayerInstance
PlayerInstance = self
self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
"showEventInfo": (self.openInfoView, _("Show event details")),
"showEventInfoPlugin": (self.openServiceList, _("Open servicelist"))
})
if config.AdvancedMovieSelection.exitkey.value and config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(self, "WizardActions",
{
"back": (self.leavePlayer, _("Leave movie player"))
})
if config.AdvancedMovieSelection.exitkey.value and not config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(self, "WizardActions",
{
"back": (self.close, _("Leave movie player"))
})
if config.AdvancedMovieSelection.use_original_movieplayer_summary.value == True:
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUpdatedInfo: self.__updateInfo
})
self.firstime = True
self.onExecBegin.append(self.__onExecBegin)
def __init__(self, session, playlist, notifyNextEntry=None, flags=None):
self.session = session
self.flags = flags
self.playlist = self.fixParts(playlist)
self.progressTimer = eTimer()
self.progressTimer.callback.append(self.progressUpdate)
self.progressTimer.start(1000)
self.notifyNextEntry = notifyNextEntry
if isinstance(self.playlist, list):
self.isPlaylist = True
self.current = 0
firstPath = self.playlist[0][0]
firstName = self.playlist[0][1]
if firstPath.endswith(".ts"):
type = 1
elif firstPath.endswith(".m2ts"):
type = 3
else:
type = 4097
ref = eServiceReference(type, 0, firstPath)
self.currentPlayingFile = firstPath
ref.setName(firstName)
self.playing = True
MoviePlayer.__init__(self, session, ref)
else:
self.isPlaylist = False
self.playing = True
self.currentPlayingFile = self.playlist
MoviePlayer.__init__(self, session, self.playlist)
self.skinName = "MoviePlayer"
def keyOK(self):
sel = self["config"].getCurrent()[1]
if sel == self.positionEntry:
if self.length:
if self.dvd: # seekTo() doesn't work for DVD Player
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(
float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
DVDPlayer.doSeekRelative(self.infobarInstance, pts)
else:
self.seek.seekTo(
int(float(self.length[1]) / 100.0 * self.percent))
self.exit()
elif sel == self.minuteInput:
pts = self.minuteInput.value * 60 * 90000
if self.fwd == False:
pts = -1 * pts
if self.dvd:
DVDPlayer.doSeekRelative(self.infobarInstance, pts)
elif self.vdb:
VideoDBPlayer.doSeekRelative(self.infobarInstance, pts)
else:
MoviePlayer.doSeekRelative(self.infobarInstance, pts)
self.exit()
def __init__(self, session, service, cur, playnext): MoviePlayer.__init__(self, session, service) self.skinName = ['BlurayPlayer', 'MoviePlayer'] self.servicelist = InfoBar.instance and InfoBar.instance.servicelist self.cur = cur self.playnext = playnext self.chapters = [] self.onLayoutFinish.append(self.LayoutFinish)
def __init__(self, session, service, backend, start=None):
MoviePlayer.__init__(self, session, service)
self.backend = backend
backend.window=self
session.nav.getCurrentService().streamed().setBufferSize(config.plugins.airplayer.bufferSize.value)
self.AutoPlay = True
self.start=start;
start_new_thread(self.seekWatcher,(self,))
def __init__(self, session, service, slist=None, lastservice=None):
self.session = session
OrgMoviePlayer.__init__(self,
session,
service,
slist=None,
lastservice=None)
self.skinName = "MoviePlayer"
OrgMoviePlayer.WithoutStopClose = True
def __init__(self, session, service, backend, start=None):
MoviePlayer.__init__(self, session, service)
self.backend = backend
backend.window = self
session.nav.getCurrentService().streamed().setBufferSize(
config.plugins.airplayer.bufferSize.value)
self.AutoPlay = True
self.start = start
start_new_thread(self.seekWatcher, (self, ))
def __init__(self, session, sref, playlist, playlistName, playlistCB): self.onPlayService = [] self.sref = sref MoviePlayer.__init__(self, session, sref) onStartShow = repeat = len(playlist) > 1 autoPlay = False InfoBarPlaylist.__init__(self, playlist, playlistCB, playlistName, autoPlay=autoPlay, repeat=repeat, onStartShow=onStartShow, showProtocol=True) # SubsSupport.__init__(self, subPath=subtitles, alreadyPlaying=True) self.skinName = "MoviePlayer"
def __init__(self, session, sref, playlist, playlistName, playlistCB): self.onPlayService = [] self.sref = sref MoviePlayer.__init__(self, session, sref) onStartShow = repeat = len(playlist) > 1 autoPlay = False InfoBarPlaylist.__init__(self, playlist, playlistCB, playlistName, autoPlay=autoPlay, repeat=repeat, onStartShow=onStartShow, showProtocol=True) # SubsSupport.__init__(self, subPath=subtitles, alreadyPlaying=True) self.skinName = "MoviePlayer"
def __init__(self, session, uri, title):
self.session = session
self.WithoutStopClose = True
#if '://' not in uri: uri = 'file://' + uri
fileRef = eServiceReference(4097,0,uri)
fileRef.setName (title)
standardMoviePlayer.__init__(self, self.session, fileRef)
self.skinName = "MoviePlayer"
standardMoviePlayer.skinName = "MoviePlayer"
def __init__(self, session, uri, title):
self.session = session
self.WithoutStopClose = True
#if '://' not in uri: uri = 'file://' + uri
fileRef = eServiceReference(4097,0,uri)
fileRef.setName (title)
standardMoviePlayer.__init__(self, self.session, fileRef)
self.skinName = "MoviePlayer"
standardMoviePlayer.skinName = "MoviePlayer"
def __init__(self, session, service):
MoviePlayer.__init__(self, session, service)
self.skinName = 'MoviePlayer'
self.servicelist = InfoBar.instance and InfoBar.instance.servicelist
self.started = False
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evSeekableStatusChanged:
self.TorrPlayerseekableStatusChanged
})
def openMoviePlayerEventView(self):
already_open = False
if True and not already_open:
already_open = True
service = self.session.nav.getCurrentService()
filename = service.info().getName()
url = self.session.nav.getCurrentlyPlayingServiceReference().getPath()
if re.match('.*?http://', url, re.S):
self.session.open(MediaInfo)
else:
MoviePlayer.originalOpenEventView(self)
else:
MoviePlayer.originalOpenEventView(self)
def openMoviePlayerEventView(self):
already_open = False
if True and not already_open:
already_open = True
service = self.session.nav.getCurrentService()
filename = service.info().getName()
url = self.session.nav.getCurrentlyPlayingServiceReference().getPath()
if re.match('.*?http://', url, re.S):
self.session.open(MediaInfo)
else:
MoviePlayer.originalOpenEventView(self)
else:
MoviePlayer.originalOpenEventView(self)
def __init__(self, session, service):
MoviePlayer.__init__(self, session, service)
self.skinName = 'MoviePlayer'
self.servicelist = InfoBar.instance and InfoBar.instance.servicelist
self["actions"] = HelpableActionMap(self, "MoviePlayerActions", {
"leavePlayer": (self.leavePlayer, _("leave YT-Trailer player..."))
})
self["vcsActions"] = HelpableActionMap(
self, "ColorActions", {"blue": (self.showVCS, _("show VCS..."))})
if config.plugins.tmbd_yttrailer.close_player_with_exit.value:
self["closeactions"] = HelpableActionMap(
self, "WizardActions",
{"back": (self.close, _("leave YT-Trailer player..."))})
self.setTitle(_("YT-Trailer Player"))
def __init__(self, session, service, cur, playnext):
MoviePlayer.__init__(self, session, service)
self.skinName = ['BlurayPlayer', 'MoviePlayer']
self.servicelist = InfoBar.instance and InfoBar.instance.servicelist
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evSeekableStatusChanged:
self.blurayseekableStatusChanged
})
self.cur = cur
self.playnext = playnext
self.chapters = []
self.onLayoutFinish.append(self.LayoutFinish)
def __init__(self, session, playlist, recordings):
# MoviePlayer.__init__ will start playback for the given service!!
MoviePlayer.__init__(self, session,
session.nav.getCurrentlyPlayingServiceReference())
self.skinName = "MoviePlayer"
self["actions"] = HelpableActionMap(
self, "PluginPlayerActions", {
"bInfo": (self.openEventView, _("show event details")),
"leavePlayer": (self.leavePlayer, _("Stop playback")),
"bRADIO": (self.btnRadio, _("Open extensions menu"))
})
self.playInit(playlist, recordings)
self.onShown.append(self.onDialogShow)
def zap(self):
currentService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
if currentService and currentService.isPlayback():
# in movie playback, so store the resume point before zapping
from Screens.InfoBarGenerics import setResumePoint
setResumePoint(self.session)
self.zapSelectedService(True)
self.refreshTimer.start(1)
if not self.currch or self.currch == self.prevch:
# Zapping the same service for a second time, record it with the zap history and exit
from Screens.InfoBar import MoviePlayer
MoviePlayer.ensureClosed(currentService)
self.zapFunc(None, False)
self.closeEventViewDialog()
self.close()
def doEofInternal(self, playing): # Override method in MoviePlayer
if not self.endless_loop:
return MoviePlayer.doEofInternal(self, playing)
if not self.execing:
return
if not playing:
return
self.leavePlayerConfirmed([True, "restart"])
def doEofInternal(self, playing): # Override method in MoviePlayer
if not self.endless_loop:
return MoviePlayer.doEofInternal(self, playing)
if not self.execing:
return
if not playing:
return
self.leavePlayerConfirmed([True, "restart"])
def __init__(self, session, service):
CutListSupport.__init__(self, service)
MoviePlayer.__init__(self, session, service)
PlayerBase.__init__(self, session)
self.skinName = ["MoviePlayerExtended", "MoviePlayer"]
if config.AdvancedMovieSelection.exitkey.value and config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(
self, "WizardActions",
{"back": (self.leavePlayer, _("Leave movie player"))})
if config.AdvancedMovieSelection.exitkey.value and not config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(
self, "WizardActions",
{"back": (self.close, _("Leave movie player"))})
if config.AdvancedMovieSelection.use_original_movieplayer_summary.value == True:
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={iPlayableService.evUpdatedInfo: self.__updateInfo})
self.firstime = True
self.onExecBegin.append(self.__onExecBegin)
def __init__(self,
session,
openmovie,
opensubtitle,
rootID,
LastPlayedService,
URLlinkName='',
movieTitle='',
LastPosition=0):
self.session = session
#if '://' not in uri: uri = 'file://' + uri
fileRef = eServiceReference(int(rootID), 0, openmovie)
fileRef.setName(movieTitle)
self.Ask_on_movie_stop = False
#try:
if config.usage.on_movie_stop.value == "ask":
self.Ask_on_movie_stop = True
config.usage.on_movie_stop.value = "quit"
config.usage.on_movie_stop.save()
#except:
# pass
self.Ask_on_movie_eof = False
try:
if config.usage.on_movie_eof.value == "ask":
self.Ask_on_movie_eof = True
config.usage.on_movie_eof.value = "quit"
config.usage.on_movie_eof.save()
except:
pass
systemMoviePlayer.__init__(self, self.session, fileRef)
self.skinName = "MoviePlayer"
systemMoviePlayer.skinName = "MoviePlayer"
if self.Ask_on_movie_stop == True:
config.usage.on_movie_stop.value = "ask"
config.usage.on_movie_stop.save()
if self.Ask_on_movie_eof == True:
config.usage.on_movie_eof.value = "ask"
config.usage.on_movie_eof.save()
def __init__(self, session, service):
CutListSupport.__init__(self, service)
MoviePlayer.__init__(self, session, service)
PlayerBase.__init__(self, session)
self.skinName = ["MoviePlayerExtended", "MoviePlayer"]
if config.AdvancedMovieSelection.exitkey.value and config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(self, "WizardActions",
{
"back": (self.leavePlayer, _("Leave movie player"))
})
if config.AdvancedMovieSelection.exitkey.value and not config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(self, "WizardActions",
{
"back": (self.close, _("Leave movie player"))
})
if config.AdvancedMovieSelection.use_original_movieplayer_summary.value == True:
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUpdatedInfo: self.__updateInfo
})
self.firstime = True
self.onExecBegin.append(self.__onExecBegin)
def __init__(self, session, playerData, resume=False):
'''
'''
printl("", self, "S")
self.session = session
self.startNewServiceOnPlay = False
self.resume = resume
self.resumeStamp = int(playerData['resumeStamp']) / 1000 #plex stores seconds * 1000
self.server = str(playerData['server'])
self.id = str(playerData['id'])
self.url = str(playerData['playUrl'])
printl("Checking for usable gstreamer service (built-in)... ",self, "I")
if self.isValidServiceId(self.ENIGMA_SERVICEGS_ID):
printl("found usable gstreamer service (builtin) ...", self, "I")
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICEGS_ID
#STOP_BEFORE_UNPAUSE = False
else:
printl("no usable gstreamer service (built-in) found ...", self, "I")
#todo hier eine meldung mit dem hinweis auf systemcheck
#session.open(MessageBox, _("Please try Systemcheck to install gstreamer!"), MessageBox.TYPE_INFO)
#MoviePlayer.__init__(self, session, service)
printl("self.ENIGMA_SERVICE_ID = " + str(self.ENIGMA_SERVICE_ID), self, "I")
sref = eServiceReference(self.ENIGMA_SERVICE_ID, 0, self.url)
sref.setName("DreamPlex")
#MoviePlayer.__init__(self, session, service)
MoviePlayer.__init__(self, session, sref)
self.skinName = "DPS_PlexPlayer"
self.service = sref
self.bufferslider = Slider(0, 100)
self["bufferslider"] = self.bufferslider
self["bufferslider"].setValue(0)
self["label_bitrate"] = StaticText("Bitrate: N/A")
self["label_speed"] = StaticText("DL-Speed: N/A")
self["label_buffer"] = StaticText("Buffer")
self["label_update"] = StaticText("")
self.bufferSeconds = 0
self.bufferPercent = 0
self.bufferSecondsLeft = 0
self.bitrate = 0
self.endReached = False
self.buffersize = 1
self.localCache = False
self.dlactive = False
self.url = self.service.getPath()
self.localsize = 0
self["actions"] = ActionMap(["InfobarInstantRecord", "MoviePlayerActions"],
{
"instantRecord": self.keyStartLocalCache,
"leavePlayer": self.leavePlayer,
}, -2)
self.useBufferControl = config.plugins.dreamplex.useBufferControl.value
if config.plugins.dreamplex.setBufferSize.value:
bufferSize = int(config.plugins.dreamplex.bufferSize.value) * 1024 * 1024
session.nav.getCurrentService().streamed().setBufferSize(bufferSize)
service1 = self.session.nav.getCurrentService()
self.seek = service1 and service1.seek()
if self.seek != None:
rLen = self.getPlayLength()
rPos = self.getPlayPosition()
printl("rLen: " + str(rLen), self, "I")
printl("rPos: " + str(rPos), self, "I")
if self.resume == True and self.resumeStamp != None and self.resumeStamp > 0.0:
start_new_thread(self.seekWatcher,(self,))
start_new_thread(self.bitRateWatcher,(self,))
#start_new_thread(self.checkForUpdate,(self,))
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUser+10: self.__evAudioDecodeError,
iPlayableService.evUser+11: self.__evVideoDecodeError,
iPlayableService.evUser+12: self.__evPluginError,
iPlayableService.evBuffering: self.__evUpdatedBufferInfo,
iPlayableService.evEOF: self.__evEOF,
})
printl("", self, "C")
def __init__(self, session, service):
MoviePlayer.__init__(self, session, service)
self.skinName = ["ServiceAppPlayer", "MoviePlayer"]
self.servicelist = InfoBar.instance and InfoBar.instance.servicelist
def __init__(self, session, service): self.session = session MoviePlayer.__init__(self, session, service) self.skinName = "MoviePlayer" MoviePlayer.WithoutStopClose = True
def __init__(self, session, service, languages, codecs): MoviePlayer.__init__(self, session, service) self.skinName = ['BlurayPlayer', 'MoviePlayer'] self.servicelist = InfoBar.instance and InfoBar.instance.servicelist self.languages = languages self.codecs = codecs
def __init__(self, session, service, slist = None, lastservice = None): self.session = session self.WithoutStopClose = False MP_parent.__init__(self, session, service, slist, lastservice)
def __init__(self, session, service): MoviePlayer.__init__(self, session, service) self.skinName = "MoviePlayer"
def __init__(self, session, service):
MoviePlayer.__init__(self, session, service)
self.skinName = "MoviePlayer"
def __init__(self, session, service): MoviePlayer.__init__(self, session, service) self.skinName = ["ServiceAppPlayer", "MoviePlayer"] self.servicelist = InfoBar.instance and InfoBar.instance.servicelist
def createSummary(self):
if config.AdvancedMovieSelection.use_original_movieplayer_summary.value == True:
return MoviePlayerExtended_summary
return MoviePlayer.createSummary(self)
def __init__(self, session, service): self.session = session self.WithoutStopClose = False MP_parent.__init__(self, self.session, service)
def __init__(self, session, service, slist = None, lastservice = None): MP_parent.__init__(self, session, service, slist, lastservice)
def __init__(self, session, playerData, resume=False):
'''
'''
printl("", self, "S")
self.session = session
self.startNewServiceOnPlay = False
self.resume = resume
self.resumeStamp = int(
playerData['resumeStamp']) / 1000 #plex stores seconds * 1000
self.server = str(playerData['server'])
self.id = str(playerData['id'])
self.url = str(playerData['playUrl'])
printl("Checking for usable gstreamer service (built-in)... ", self,
"I")
if self.isValidServiceId(self.ENIGMA_SERVICEGS_ID):
printl("found usable gstreamer service (builtin) ...", self, "I")
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICEGS_ID
#STOP_BEFORE_UNPAUSE = False
else:
printl("no usable gstreamer service (built-in) found ...", self,
"I")
#todo hier eine meldung mit dem hinweis auf systemcheck
#session.open(MessageBox, _("Please try Systemcheck to install gstreamer!"), MessageBox.TYPE_INFO)
#MoviePlayer.__init__(self, session, service)
printl("self.ENIGMA_SERVICE_ID = " + str(self.ENIGMA_SERVICE_ID), self,
"I")
sref = eServiceReference(self.ENIGMA_SERVICE_ID, 0, self.url)
sref.setName("DreamPlex")
#MoviePlayer.__init__(self, session, service)
MoviePlayer.__init__(self, session, sref)
self.skinName = "DPS_PlexPlayer"
self.service = sref
self.bufferslider = Slider(0, 100)
self["bufferslider"] = self.bufferslider
self["bufferslider"].setValue(0)
self["label_bitrate"] = StaticText("Bitrate: N/A")
self["label_speed"] = StaticText("DL-Speed: N/A")
self["label_buffer"] = StaticText("Buffer")
self["label_update"] = StaticText("")
self.bufferSeconds = 0
self.bufferPercent = 0
self.bufferSecondsLeft = 0
self.bitrate = 0
self.endReached = False
self.buffersize = 1
self.localCache = False
self.dlactive = False
self.url = self.service.getPath()
self.localsize = 0
self["actions"] = ActionMap(
["InfobarInstantRecord", "MoviePlayerActions"], {
"instantRecord": self.keyStartLocalCache,
"leavePlayer": self.leavePlayer,
}, -2)
self.useBufferControl = config.plugins.dreamplex.useBufferControl.value
if config.plugins.dreamplex.setBufferSize.value:
bufferSize = int(
config.plugins.dreamplex.bufferSize.value) * 1024 * 1024
session.nav.getCurrentService().streamed().setBufferSize(
bufferSize)
service1 = self.session.nav.getCurrentService()
self.seek = service1 and service1.seek()
if self.seek != None:
rLen = self.getPlayLength()
rPos = self.getPlayPosition()
printl("rLen: " + str(rLen), self, "I")
printl("rPos: " + str(rPos), self, "I")
if self.resume == True and self.resumeStamp != None and self.resumeStamp > 0.0:
start_new_thread(self.seekWatcher, (self, ))
start_new_thread(self.bitRateWatcher, (self, ))
#start_new_thread(self.checkForUpdate,(self,))
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evUser + 10: self.__evAudioDecodeError,
iPlayableService.evUser + 11: self.__evVideoDecodeError,
iPlayableService.evUser + 12: self.__evPluginError,
iPlayableService.evBuffering: self.__evUpdatedBufferInfo,
iPlayableService.evEOF: self.__evEOF,
})
printl("", self, "C")
def __init__(self, session, service): self.session = session MoviePlayer.__init__(self, session, service) self.skinName = "MoviePlayer" MoviePlayer.WithoutStopClose = True
def __init__(self, session, service): self.session = session MP_parent.__init__(self, self.session, service)
def doEofInternal(self, *args, **kwargs):
if (args and args[0]) or kwargs.get('playing', False):
self.e2iplayerEOF = True
standardMoviePlayer.doEofInternal(self, *args, **kwargs)
def __init__(self, session, playerData, resume=False):
printl("", self, "S")
self.session = session
self.videoData = playerData['videoData']
self.mediaData = playerData['mediaData']
# go through the data out of the function call
self.resume = resume
self.resumeStamp = int(playerData['resumeStamp']) / 1000 # plex stores seconds * 1000
self.server = str(playerData['server'])
self.id = str(playerData['id'])
self.multiUserServer = playerData['multiUserServer']
self.url = str(playerData['playUrl'])
self.transcodingSession = str(playerData['transcodingSession'])
self.playbackType = str(playerData['playbackType'])
self.connectionType = str(playerData['connectionType'])
self.universalTranscoder = playerData['universalTranscoder']
self.localAuth = playerData['localAuth']
# lets prepare all additional data for a better experience :-)
self.title = str(self.videoData['title'])
self.tagline = str(self.videoData['tagline'])
self.summary = str(self.videoData['summary'])
self.year = str(self.videoData['year'])
self.studio = str(self.videoData['studio'])
self.duration = str(self.videoData['duration'])
self.contentRating = str(self.videoData['contentRating'])
self.audioCodec = str(self.mediaData['audioCodec'])
self.videoCodec = str(self.mediaData['videoCodec'])
self.videoResolution = str(self.mediaData['videoResolution'])
self.videoFrameRate = str(self.mediaData['videoFrameRate'])
# check for playable services
printl( "Checking for usable gstreamer service (builtin)... ",self, "I")
# lets built the sref for the movieplayer out of the gathered information
if self.url[:4] == "http": #this means we are in streaming mode so we will use sref 4097
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICEGS_ID
elif self.url[-3:] == ".ts" or self.url[-4:] == ".iso": # seems like we have a real ts file ot a iso file so we will use sref 1
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICETS_ID
elif self.url[-5:] == ".m2ts":
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVIDEM2_ID
else: # if we have a real file but no ts but for eg mkv we will use sref 4097
if self.isValidServiceId(self.ENIGMA_SERVICEGS_ID):
printl("we are able to stream over 4097", self, "I")
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICEGS_ID
else:
# todo add errorhandler
raise Exception
printl("self.ENIGMA_SERVICE_ID = " + str(self.ENIGMA_SERVICE_ID), self, "I")
sref = eServiceReference(self.ENIGMA_SERVICE_ID, 0, self.url)
sref.setName(self.title)
# lets call the movieplayer
MoviePlayer.__init__(self, session, sref)
self.skinName = "DPS_PlexPlayer"
self.service = sref
self.bufferslider = Slider(0, 100)
self["bufferslider"] = self.bufferslider
if self.playbackType == "2":
self["bufferslider"].setValue(100)
else:
self["bufferslider"].setValue(1)
self["mediaTitle"] = StaticText(self.title)
self["label_update"] = StaticText()
self.bufferSeconds = 0
self.bufferPercent = 0
self.bufferSecondsLeft = 0
self.bitrate = 0
self.endReached = False
self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions", "InfobarSeekActions", "MediaPlayerActions"],
{
"ok": self.ok,
"cancel": self.hide,
"keyTV": self.leavePlayer,
"stop": self.leavePlayer,
"leavePlayer": self.hide,
"next": self.seekManual,
"previous": self.seekManual,
"stopRunningRecords": self.leavePlayer
}, -2)
# it will stop up/down/movielist buttons opening standard movielist whilst playing movie in plex
if self.has_key('MovieListActions'):
self["MovieListActions"].setEnabled(False)
service1 = self.session.nav.getCurrentService()
self.seek = service1 and service1.seek()
# if self.seek != None:
# rLen = self.getPlayLength()
# rPos = self.getPlayPosition()
# printl("rLen: " + str(rLen), self, "I")
# printl("rPos: " + str(rPos), self, "I")
#=======================================================================
if self.resume == True and self.resumeStamp is not None and self.resumeStamp > 0.0:
seekwatcherThread = threading.Thread(target=self.seekWatcher,args=(self,))
seekwatcherThread.start()
if self.multiUserServer:
printl("we are a multiuser server", self, "D")
if self.connectionType == "2" or (self.connectionType == "0" and self.localAuth):
printl("we are configured for multiuser", self, "D")
self.multiUser = True
if self.multiUser:
self.timelinewatcherthread_stop = threading.Event()
self.timelinewatcherthread_wait = threading.Event()
self.timelinewatcherthread_stop.clear()
self.timelinewatcherthread_wait.clear()
self.timelinewatcherThread = threading.Thread(target=self.timelineWatcher,name="TimeLineWatcherThread", args=(self.timelinewatcherthread_stop, self.timelinewatcherthread_wait,))
self.timelinewatcherThread.daemon = True
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUser+10: self.__evAudioDecodeError,
iPlayableService.evUser+11: self.__evVideoDecodeError,
iPlayableService.evUser+12: self.__evPluginError,
iPlayableService.evBuffering: self.__evUpdatedBufferInfo,
iPlayableService.evEOF: self.__evEOF,
})
if self.playbackType == "2":
self.bufferFull()
printl("", self, "C")
def close(self, *args, **kwargs):
if self.e2iplayerEOF:
standardMoviePlayer.close(self, *args, **kwargs)
else:
standardMoviePlayer.close(self, 'key_exit')
def createSummary(self):
if config.AdvancedMovieSelection.use_original_movieplayer_summary.value == True:
return MoviePlayerExtended_summary
return MoviePlayer.createSummary(self)
def __init__(self, session, service): self.session = session self.WithoutStopClose = False MP_parent.__init__(self, self.session, service)
def __init__(self, session, playerData, resume=False):
'''
'''
printl("", self, "S")
self.session = session
self.startNewServiceOnPlay = False
self.videoData = playerData['videoData']
self.mediaData = playerData['mediaData']
# go through the data out of the function call
self.resume = resume
self.resumeStamp = int(playerData['resumeStamp']) / 1000 # plex stores seconds * 1000
self.server = str(playerData['server'])
self.id = str(playerData['id'])
self.url = str(playerData['playUrl'])
self.transcodingSession = str(playerData['transcodingSession'])
# lets prepare all additional data for a better experience :-)
self.title = str(self.videoData['title'])
self.tagline = str(self.videoData['tagline'])
self.summary = str(self.videoData['summary'])
self.year = str(self.videoData['year'])
self.studio = str(self.videoData['studio'])
self.duration = str(self.videoData['duration'])
self.contentRating = str(self.videoData['contentRating'])
self.audioCodec = str(self.mediaData['audioCodec'])
self.videoCodec = str(self.mediaData['videoCodec'])
self.videoResolution = str(self.mediaData['videoResolution'])
self.videoFrameRate = str(self.mediaData['videoFrameRate'])
# check for playable services
printl( "Checking for usable gstreamer service (builtin)... ",self, "I")
gstreamer = False
if self.isValidServiceId(self.ENIGMA_SERVICEGS_ID):
printl("we are able to stream over 4097", self, "I")
gstreamer = True
# lets built the sref for the movieplayer out of the gathered information
if self.url[:4] == "http": #this means we are in streaming mode so we will use sref 4097
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICEGS_ID
elif self.url[-3:] == ".ts" or self.url[-4:] == ".iso": # seems like we have a real ts file ot a iso file so we will use sref 1
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICETS_ID
elif self.url[-5:] == ".m2ts":
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVIDEM2_ID
else: # if we have a real file but no ts but for eg mkv we will also use sref 4097
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICEGS_ID
printl("self.ENIGMA_SERVICE_ID = " + str(self.ENIGMA_SERVICE_ID), self, "I")
sref = eServiceReference(self.ENIGMA_SERVICE_ID, 0, self.url)
sref.setName("DreamPlex")
# lets call the movieplayer
MoviePlayer.__init__(self, session, sref)
self.skinName = "DPS_PlexPlayer"
self.service = sref
self.bufferslider = Slider(0, 100)
self["bufferslider"] = self.bufferslider
self["bufferslider"].setValue(0)
self["label_buffer"] = StaticText(self.title)
self["label_update"] = StaticText("")
self.bufferSeconds = 0
self.bufferPercent = 0
self.bufferSecondsLeft = 0
self.bitrate = 0
self.endReached = False
self.buffersize = 1
self.localCache = False
self.dlactive = False
#self.url = self.service.getPath()
self.localsize = 0
self["actions"] = ActionMap(["InfobarInstantRecord", "MoviePlayerActions"],
{
"leavePlayer": self.leavePlayer,
}, -2)
self.useBufferControl = config.plugins.dreamplex.useBufferControl.value
service1 = self.session.nav.getCurrentService()
self.seek = service1 and service1.seek()
if self.seek != None:
rLen = self.getPlayLength()
rPos = self.getPlayPosition()
printl("rLen: " + str(rLen), self, "I")
printl("rPos: " + str(rPos), self, "I")
if self.resume == True and self.resumeStamp != None and self.resumeStamp > 0.0:
start_new_thread(self.seekWatcher,(self,))
if config.plugins.dreamplex.autoLanguage.value:
start_new_thread(self.audioTrackWatcher,(self,))
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUser+10: self.__evAudioDecodeError,
iPlayableService.evUser+11: self.__evVideoDecodeError,
iPlayableService.evUser+12: self.__evPluginError,
iPlayableService.evBuffering: self.__evUpdatedBufferInfo,
iPlayableService.evEOF: self.__evEOF,
})
printl("", self, "C")
def __init__(self, session, service, slist=None, lastservice=None):
MP_parent.__init__(self, session, service, slist, lastservice)
def __init__(self, session, service, current): MoviePlayer.__init__(self, session, service) self.skinName = 'MoviePlayer' self.current = current self.servicelist = InfoBar.instance and InfoBar.instance.servicelist
def __init__(self, session, service): self.session = session self.WithoutStopClose = False Movie_Audio_Player.__init__(self, self.session, service)
def __init__(self, session, playerData, resume=False):
'''
'''
printl("", self, "S")
self.session = session
self.startNewServiceOnPlay = False
self.videoData = playerData['videoData']
self.mediaData = playerData['mediaData']
# go through the data out of the function call
self.resume = resume
self.resumeStamp = int(360)#int(playerData['resumeStamp']) / 1000 # plex stores seconds * 1000
self.server = str(playerData['server'])
self.id = str(playerData['id'])
self.servermultiuser = playerData['servermultiuser']
self.playbacktype = playerData['playbackType']
self.url = str(playerData['playUrl'])
self.transcodingSession = str(playerData['transcodingSession'])
self.playbackType = str(playerData['playbackType'])
# lets prepare all additional data for a better experience :-)
self.title = str(self.videoData['title'])
self.tagline = str(self.videoData['tagline'])
self.summary = str(self.videoData['summary'])
self.year = str(self.videoData['year'])
self.studio = str(self.videoData['studio'])
self.duration = str(self.videoData['duration'])
self.contentRating = str(self.videoData['contentRating'])
self.audioCodec = str(self.mediaData['audioCodec'])
self.videoCodec = str(self.mediaData['videoCodec'])
self.videoResolution = str(self.mediaData['videoResolution'])
self.videoFrameRate = str(self.mediaData['videoFrameRate'])
# check for playable services
printl( "Checking for usable gstreamer service (builtin)... ",self, "I")
gstreamer = False
if self.isValidServiceId(self.ENIGMA_SERVICEGS_ID):
printl("we are able to stream over 4097", self, "I")
gstreamer = True
# lets built the sref for the movieplayer out of the gathered information
if self.url[:4] == "http": #this means we are in streaming mode so we will use sref 4097
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICEGS_ID
elif self.url[-3:] == ".ts" or self.url[-4:] == ".iso": # seems like we have a real ts file ot a iso file so we will use sref 1
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICETS_ID
elif self.url[-5:] == ".m2ts":
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVIDEM2_ID
else: # if we have a real file but no ts but for eg mkv we will also use sref 4097
self.ENIGMA_SERVICE_ID = self.ENIGMA_SERVICEGS_ID
printl("self.ENIGMA_SERVICE_ID = " + str(self.ENIGMA_SERVICE_ID), self, "I")
sref = eServiceReference(self.ENIGMA_SERVICE_ID, 0, self.url)
sref.setName("DreamPlex")
# lets call the movieplayer
MoviePlayer.__init__(self, session, sref)
self.skinName = "DPS_PlexPlayer"
self.service = sref
self.bufferslider = Slider(0, 100)
self["bufferslider"] = self.bufferslider
self["bufferslider"].setValue(0)
self["mediaTitle"] = StaticText(self.title)
self["label_update"] = StaticText("")
self.bufferSeconds = 0
self.bufferPercent = 0
self.bufferSecondsLeft = 0
self.bitrate = 0
self.endReached = False
self["actions"] = ActionMap(["OkCancelActions", "TvRadioActions", "InfobarSeekActions", "MediaPlayerActions"],
{
"ok": self.ok,
"cancel": self.hide,
"keyTV": self.leavePlayer,
"stop": self.leavePlayer,
"leavePlayer": self.hide,
"next": self.seekManual,
"seekFwd": self.seekManual,
"seekBack": self.seekManual,
"seekFwdDown": self.seekManual,
"seekBackDown": self.seekManual,
"seekFwdManual": self.seekManual,
"seekBackManual": self.seekManual,
"previous": self.seekManual
}, -2)
service1 = self.session.nav.getCurrentService()
self.seek = service1 and service1.seek()
# if self.seek != None:
# rLen = self.getPlayLength()
# rPos = self.getPlayPosition()
# printl("rLen: " + str(rLen), self, "I")
# printl("rPos: " + str(rPos), self, "I")
#=======================================================================
if self.resume == True and self.resumeStamp != None and self.resumeStamp > 0.0:
seekwatcherThread = threading.Thread(target=self.seekWatcher,args=(self,))
seekwatcherThread.start()
asda = 123
test123 = 123123
asdasd = 123
if self.playbackType == "1": # TRANSCODED
self.useBufferControl = True
if self.servermultiuser == True:
self.timelinewatcherthread_stop = threading.Event()
self.timelinewatcherthread_wait = threading.Event()
self.timelinewatcherthread_stop.clear()
self.timelinewatcherthread_wait.clear()
self.timelinewatcherThread = threading.Thread(target=self.timelineWatcher,name="TimeLineWatcherThread", args=(self.timelinewatcherthread_stop, self.timelinewatcherthread_wait,))
self.timelinewatcherThread.daemon = True
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUser+10: self.__evAudioDecodeError,
iPlayableService.evUser+11: self.__evVideoDecodeError,
iPlayableService.evUser+12: self.__evPluginError,
iPlayableService.evBuffering: self.__evUpdatedBufferInfo,
iPlayableService.evEOF: self.__evEOF,
})
printl("using buffer control: " + str(self.useBufferControl),self, "D")
else: # all other types
self.useBufferControl = False
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUser+10: self.__evAudioDecodeError,
iPlayableService.evUser+11: self.__evVideoDecodeError,
iPlayableService.evUser+12: self.__evPluginError,
iPlayableService.evEOF: self.__evEOF,
})
#if config.plugins.dreamplex.autoLanguage.value:
#start_new_thread(self.audioTrackWatcher,(self,))
printl("", self, "C")
def keyOK(self):
sel = self["config"].getCurrent()[1]
if sel == self.positionEntry:
if self.length:
if self.old_dvd: # seekTo() doesn't work for DVD Player
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
DVDPlayer2.doSeekRelative(self.infobarInstance, pts)
elif self.media_player:
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
MediaPlayer.doSeekRelative(self.infobarInstance, pts)
elif self.dvd_pli:
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
DVDPlayer.doSeekRelative(self.infobarInstance, pts)
elif self.ytube:
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
YouTubePlayer.doSeekRelative(self.infobarInstance, pts)
elif self.tmbd_trailer:
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
tmbdTrailerPlayer.doSeekRelative(self.infobarInstance, pts)
elif self.vod:
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
nVODplayer.doSeekRelative(self.infobarInstance, pts)
elif self.yamp_player:
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
YampScreen.doSeekRelative(self.infobarInstance, pts)
elif self.seasondream:
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
Player.doSeekRelative(self.infobarInstance, pts)
elif self.cutlisteditor:
oldPosition = self.seek.getPlayPosition()[1]
newPosition = int(float(self.length[1]) / 100.0 * self.percent)
if newPosition > oldPosition:
pts = newPosition - oldPosition
else:
pts = -1 * (oldPosition - newPosition)
CutListEditor.doSeekRelative(self.infobarInstance, pts)
elif self.movie:
self.seek.seekTo(int(float(self.length[1]) / 100.0 * self.percent))
elif self.timeshift:
self.seek.seekTo(int(float(self.length[1]) / 100.0 * self.percent))
else:
pass
self.exit()
elif sel == self.minuteInput:
pts = self.minuteInput.value * 60 * 90000
if self.fwd == False:
pts = -1 * pts
if self.old_dvd:
DVDPlayer2.doSeekRelative(self.infobarInstance, pts)
elif self.media_player:
MediaPlayer.doSeekRelative(self.infobarInstance, pts)
elif self.dvd_pli:
DVDPlayer.doSeekRelative(self.infobarInstance, pts)
elif self.ytube:
YouTubePlayer.doSeekRelative(self.infobarInstance, pts)
elif self.tmbd_trailer:
tmbdTrailerPlayer.doSeekRelative(self.infobarInstance, pts)
elif self.vod:
nVODplayer.doSeekRelative(self.infobarInstance, pts)
elif self.yamp_player:
YampScreen.doSeekRelative(self.infobarInstance, pts)
elif self.seasondream:
Player.doSeekRelative(self.infobarInstance, pts)
elif self.cutlisteditor:
CutListEditor.doSeekRelative(self.infobarInstance, pts)
elif self.movie:
MoviePlayer.doSeekRelative(self.infobarInstance, pts)
elif self.timeshift:
InfoBar.doSeekRelative(self.infobarInstance, pts)
else:
pass
self.exit()
def __init__(self, session, service):
self.session = session
self.WithoutStopClose = False
Movie_Audio_Player.__init__(self, self.session, service)
def __init__(self, session, service, slist = None, lastservice = None): self.session = session OrgMoviePlayer.__init__(self, session, service, slist = None, lastservice = None) self.skinName = "MoviePlayer" OrgMoviePlayer.WithoutStopClose = True
