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, 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,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, 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 __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, 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, 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, service, slist = None, lastservice = None): self.session = session self.WithoutStopClose = False MP_parent.__init__(self, session, service, slist, lastservice)
def __init__(self, session, service, slist = None, lastservice = None): MP_parent.__init__(self, session, service, slist, lastservice)
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.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, 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, 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 __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):
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): MoviePlayer.__init__(self, session, service) self.skinName = "MoviePlayer"
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 __init__(self, session, service, backend, start = None, lastservice = None):
self.backend = backend
self.startNewServiceOnPlay = False
self.start = start
self.service = service
self.session = session
self.useProxy = False
self.url = self.service.getPath()
self.proxyReady = False
self.proxyError = False
self['useProxy'] = Boolean(False)
self['premiumUser'] = Boolean(False)
self.azBoxLastService = None
self.proxyCaching = False
print '[AirPlayMoviePlayer] MoviePlayer play url: ', self.url
if self.url[:7] == 'http://' or self.url[:8] == 'https://':
print '[AirPlayMoviePlayer] found http(s) link'
if self.checkProxyUsable() and config.plugins.airplayer.useProxyIfPossible.value:
print '[AirPlayMoviePlayer] using proxy'
self.service = None
self.startNewServiceOnPlay = True
self.proxyCaching = True
self.useProxy = True
self['useProxy'] = Boolean(True)
if 'm3u8' in self.url and self.useProxy == False:
Notifications.AddNotification(MessageBox, _('You are trying to play an m3u8 stream. Playing m3u8 streams requires a Premium-Key to use the embedded proxy or a very new version of GStreamer and the gst-fragmented plugin. Otherwise the playback might not work!'), type=MessageBox.TYPE_INFO, timeout=10)
if self.backend.ENIGMA_SERVICE_ID == self.backend.ENIGMA_SERVICEAZ_ID:
self.azBoxLastService = lastservice or self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
open('/proc/player', 'w').write('0')
open('/proc/player', 'w').write('2')
MoviePlayer.__init__(self, session, self.service)
if self.backend.ENIGMA_SERVICE_ID == self.backend.ENIGMA_SERVICEAZ_ID:
self.lastservice = self.azBoxLastService
backend.MovieWindow = self
self.skinName = 'AirPlayerMoviePlayer'
if lastservice is not None:
self.lastservice = lastservice
self.bufferslider = Slider(0, 100)
self.bufferslider.setValue(0)
self['bufferslider'] = self.bufferslider
self['bufferslider'].setValue(0)
self['label_speed'] = StaticText('DL-Speed: N/A')
self['label_update'] = StaticText('')
self['label_cache'] = StaticText('Cache: N/A')
self.endReached = False
self.localCache = False
self.dlactive = False
self.localsize = 0
self.proxyProcess = None
self.liveStream = False
self.m3u8Stream = False
self['actions'] = ActionMap(['InfobarInstantRecord', 'MoviePlayerActions'], {'instantRecord': self.keyStartLocalCache,
'leavePlayer': self.leavePlayer}, -2)
if config.plugins.airplayer.setSeekOnStart.value and self.start != None and self.start > 0.0:
start_new_thread(self.seekWatcher, (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.evEOF: self.__evEOF})
if self.useProxy:
start_new_thread(self.proxyWatcher, (self,))
self.backend.updateEventInfo('loading')
self.onHide.append(self.lockInfoBar)
self.proxyCaching = True
self.checkProxyTimer = eTimer()
self.checkProxyTimer.timeout.get().append(self.checkProxyStatus)
self.checkProxyTimer.start(500, True)
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, slist = None, lastservice = None): MP_parent.__init__(self, session, service, slist, lastservice)
def __init__(self, session, service):
self.session = session
self.WithoutStopClose = True
MP_parent.__init__(self, self.session, service)
def __init__(self, session, service): MoviePlayer.__init__(self, session, service) self.skinName = "MoviePlayer"
def __init__(self, session, service): self.session = session MP_parent.__init__(self, self.session, service)
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 OrgMoviePlayer.__init__(self, session, service, slist = None, lastservice = None) self.skinName = "MoviePlayer" OrgMoviePlayer.WithoutStopClose = True
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,
backend,
start=None,
lastservice=None):
self.backend = backend
self.startNewServiceOnPlay = False
self.start = start
self.service = service
self.session = session
self.useProxy = False
self.url = self.service.getPath()
self.proxyReady = False
self.proxyError = False
self['useProxy'] = Boolean(False)
self['premiumUser'] = Boolean(True)
self.azBoxLastService = None
self.proxyCaching = False
self.alreadyUsedTsServiceAsBackup = False
print('[AirPlayMoviePlayer] MoviePlayer play url: ', self.url)
if self.url[:7] == 'http://' or self.url[:8] == 'https://':
print('[AirPlayMoviePlayer] found http(s) link')
if self.checkProxyUsable(
) and config.plugins.airplayer.useProxyIfPossible.value:
print('[AirPlayMoviePlayer] using proxy')
self.service = None
self.startNewServiceOnPlay = True
self.proxyCaching = True
self.useProxy = True
self['useProxy'] = Boolean(True)
if self.backend.ENIGMA_SERVICE_ID == self.backend.ENIGMA_SERVICEAZ_ID:
self.azBoxLastService = lastservice or self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
open('/proc/player', 'w').write('0')
open('/proc/player', 'w').write('2')
MoviePlayer.__init__(self, session, self.service)
if self.backend.ENIGMA_SERVICE_ID == self.backend.ENIGMA_SERVICEAZ_ID:
self.lastservice = self.azBoxLastService
backend.MovieWindow = self
self.skinName = 'AirPlayerMoviePlayer'
if lastservice is not None:
self.lastservice = lastservice
self.bufferslider = Slider(0, 100)
self.bufferslider.setValue(0)
self['bufferslider'] = self.bufferslider
self['bufferslider'].setValue(0)
self['label_speed'] = StaticText('DL-Speed: N/A')
self['label_cache'] = StaticText('Cache: N/A')
self.endReached = False
self.localCache = False
self.dlactive = False
self.localsize = 0
self.proxyProcess = None
self.liveStream = False
self.m3u8Stream = False
self['actions'] = ActionMap(
['InfobarInstantRecord', 'MoviePlayerActions'], {
'instantRecord': self.keyStartLocalCache,
'leavePlayer': self.leavePlayer
}, -2)
if config.plugins.airplayer.setSeekOnStart.value and self.start != None and self.start > 0.0:
start_new_thread(self.seekWatcher, (self, ))
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 self.useProxy:
start_new_thread(self.proxyWatcher, (self, ))
self.backend.updateEventInfo('loading')
self.onHide.append(self.lockInfoBar)
self.proxyCaching = True
self.checkProxyTimer = eTimer()
self.checkProxyTimer.timeout.get().append(self.checkProxyStatus)
self.checkProxyTimer.start(500, True)
return
