pmkuipers/mediaserver
1
0
Fork 0
forked from Mediacore/mediaserver
Code Pull requests Activity

Compare commits

base: pmkuipers:master
Branches Tags
pmkuipers:master
Mediacore:master
..
compare: Mediacore:master
Branches Tags
Mediacore:master
pmkuipers:master

No commits in common. "master" and "master" have entirely different histories.
master ... master

3 changed files with 1 additions and 369 deletions
Show stats Expand all files Collapse all files

2
mediaserver/basicplayer.py
View file

@ -134,7 +134,7 @@ class BasicPlayer(GObject.GObject):
self.pipeline = Gst.ElementFactory.make("playbin", None) self.pipeline = Gst.ElementFactory.make("playbin", None)
self.videosink = Gst.ElementFactory.make("glimagesink", None) self.videosink = Gst.ElementFactory.make("glimagesink", None)
self.videosink.set_window_handle(self.window_handle) self.videosink.set_window_handle(self.window_handle)
self.alsasink = Gst.ElementFactory.make("fakesink", None) self.alsasink = Gst.ElementFactory.make("alsasink", None)
# set output device # set output device
#devicename = self.config["Devices.Output"].getStr('name') #devicename = self.config["Devices.Output"].getStr('name')

356
mediaserver/mediaclient.py
View file

@ -1,356 +0,0 @@
import dbus
import dbus.service
import dbus.mainloop.glib
from . import dbus_smartobject
from . import event
import os
import gi
from gi.repository import GLib
from gi.repository import GObject
class MediaClient(dbus_smartobject.DBusSmartObject):
def __init__(self,quickfolder=None):
if not quickfolder is None:
self._quickfolder = quickfolder
else:
self._quickfolder = os.path.dirname(os.getcwd())
self.Playing = False
self.Paused = False
self.Stopped = True
self.Buffering = False
self.status_url = None
self.status_position = 0
self.status_reloading = False
# initialize the events
self.OnLoading = event.Event()
self.OnReady = event.Event()
self.OnPlaying = event.Event()
self.OnPaused = event.Event()
self.OnReconnectReady = event.Event()
self.OnReconnectPlaying = event.Event()
self.OnReconnectPaused = event.Event()
self.OnStopped = event.Event()
self.OnFinished = event.Event()
self.OnFinishing = event.Event()
self.OnLoadFail = event.Event()
self.OnRunFail = event.Event()
self.OnConnect = event.Event()
self.OnReconnect = event.Event()
self.OnDisconnect = event.Event()
self.OnBuffering = event.Event()
# init base object
dbus_smartobject.DBusSmartObject.__init__( self,
service='nl.miqra.MediaCore.Media',
path='/nl/miqra/MediaCore/Media',
interface='nl.miqra.MediaCore.Media',
systembus=True)
self.statusticker()
def init_busobject(self,busobject):
# this is what gives us the multi media keys.
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnLoading', self._onLoading)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnReady', self._onReady)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnPlaying', self._onPlaying)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnPaused', self._onPaused)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnStopped', self._onStopped)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnFinished', self._onFinished)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnFinishing', self._onFinishing)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnLoadFail', self._onLoadFail)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnRunFail', self._onRunFail)
# connect_to_signal registers our callback function.
busobject.connect_to_signal('OnBuffering', self._onBuffering)
def on_connection_lost(self):
self.OnDisconnect()
def on_connection_made(self):
self.OnConnect()
def on_connection_regained(self):
if self.status_url is not None:
self.status_reloading = True
self.LoadUrl(self.status_url)
def statusticker(self):
if self.connected():
if not self.status_reloading and (self.Playing or self.Paused):
self.status_position = self.Position()
#print "backed up position: {0}".format(self.status_position)
GObject.timeout_add(1000, self.statusticker)
#callback function
def _onLoading(self,url):
""" gets called when a source has been requested for playback
"""
self.OnLoading(url)
def _onBuffering(self,pct):
""" gets called when a source has been requested for playback
"""
if pct < 100:
self.Buffering = True
else:
self.Buffering = False
self.OnBuffering(pct)
def _onReady(self,url,tags):
""" gets called when a source is ready for playback
"""
if not self.status_reloading:
self.Playing = False
self.Paused = False
self.Stopped = True
self.status_url = url
self.OnReady(url,tags)
else:
if self.Playing or self.Paused:
self.Play()
else:
self.status_reloading = False
self.OnReconnectReady()
def _onPlaying(self):
""" gets called when a playback has started
"""
if not self.status_reloading:
self.Playing = True
self.Paused = False
self.Stopped = False
self.OnPlaying()
else:
self.Seek(self.status_position)
if self.Paused:
self.Pause()
else:
self.status_reloading = False
self.OnReconnectPlaying()
pass
def _onPaused(self):
""" gets called when a playback is paused
"""
if not self.status_reloading:
self.Playing = False
self.Paused = True
self.Stopped = False
self.OnPaused()
else:
self.status_reloading = False
self.OnReconnectPaused()
def _onStopped(self):
""" gets called when playback has stopped
"""
self.Playing = False
self.Paused = False
self.Stopped = True
self.status_position = 0
self.OnStopped()
def _onFinished(self):
""" gets called when playback has completed
"""
self.Playing = False
self.Paused = False
self.Stopped = True
self.status_position = 0
self.OnFinished()
def _onFinishing(self):
self.OnFinishing()
def _onLoadFail(self,reason):
""" gets called when loading a source for playback fails
"""
self.OnLoadFail(reason)
def _onRunFail(self,reason):
""" gets called when playback fails
"""
self.OnRunFail(reason)
def QuickPlay(self, file, duration = None):
""" Directly play back a local file
"""
path = file
# check if the file exists, if not, try to find it in the base folder for quickplay or else as a subfolder of the __main__ folder
if not os.path.isfile(path):
path = os.path.join(self._quickfolder,file)
if not os.path.isfile(path):
path = os.path.join(os.getcwd(),file)
try:
if duration is None or duration <= 0:
self.call("QuickPlay",file)
else:
self.call("QuickPlayFor",file,duration)
except dbus_smartobject.NoConnectionError:
print("Could not call QuickPlay function because of no connection")
pass
def QuickPlayUrl(self, url, duration = None):
""" Directly play back a URL
"""
try:
if duration is None or duration <= 0:
self.call("QuickPlayUrl",url)
else:
self.call("QuickPlayUrlFor",url,duration)
except dbus_smartobject.NoConnectionError:
print("Could not call QuickPlayUrl function because of no connection")
pass
def QuickLoop(self, file):
""" Directly play back a local file
"""
path = file
# check if the file exists, if not, try to find it in the base folder for quickplay or else as a subfolder of the __main__ folder
if not os.path.isfile(path):
path = os.path.join(self._quickfolder,file)
if not os.path.isfile(path):
path = os.path.join(os.getcwd(),file)
try:
self.call("QuickLoop",file)
except dbus_smartobject.NoConnectionError:
print("Could not call QuickPlay function because of no connection")
pass
def QuickLoopUrl(self, url):
""" Directly play back a URL
"""
try:
self.call("QuickLoopUrl",url)
except dbus_smartobject.NoConnectionError:
print("Could not call QuickPlayUrl function because of no connection")
pass
def LoadFile(self, file):
""" Load a local file for playback
"""
try:
self.call("LoadFile",file)
except dbus_smartobject.NoConnectionError:
print("Could not call LoadFile because of no connection")
pass
def LoadUrl(self, url):
""" Load an url for playback
"""
try:
self.call("LoadUrl",url)
except dbus_smartobject.NoConnectionError:
print("Could not call LoadUrl because of no connection")
pass
def PlayFor(self, duration):
""" Starts playback for [duration] seconds
"""
try:
self.call("PlayFor",duration)
except dbus_smartobject.NoConnectionError:
print("Could not call PlayFor because of no connection")
pass
def Play(self):
""" Starts/resumes playback
"""
try:
self.call("Play")
except dbus_smartobject.NoConnectionError:
print("Could not call Play because of no connection")
pass
def Loop(self):
""" Starts/resumes playback
"""
try:
self.call("Loop")
except dbus_smartobject.NoConnectionError:
print("Could not call Loop because of no connection")
pass
def Pause(self):
""" Pauses playback
"""
try:
self.call("Pause")
except dbus_smartobject.NoConnectionError:
print("Could not call Pause because of no connection")
pass
def Stop(self):
""" Stops playback
"""
try:
self.call("Stop")
except dbus_smartobject.NoConnectionError:
print("Could not call Stop because of no connection")
pass
def Length(self):
""" returns length of currently loaded source
"""
try:
return self.call("Length")
except dbus_smartobject.NoConnectionError:
print("Could not call Length because of no connection")
return 0
def Position(self):
""" returns current position in the source
"""
try:
return self.call("Position")
except dbus_smartobject.NoConnectionError:
print("Could not call Position because of no connection")
return 0
def Seek(self,position):
""" jump to new position in the source
"""
try:
self.call("Seek",position)
self.status_position = position
except dbus_smartobject.NoConnectionError:
print("Could not call because of no connection")
pass

12
playvideo.py
View file

@ -1,12 +0,0 @@
#!/usr/bin/python3
import os, sys
from mediaserver import client
player = client.MediaClient()
file = sys.argv[1]
print(f"Requesting playback of {file}")
player.QuickPlay(file)