def playVideoGo(video_name, start=0, length=0):
print "Incoming video request"
videofile_path = "video/"+ video_name
# TODO check is file en with mp4 or mov
print "video to play: " + videofile_path
video = OMXPlayer(videofile_path, pause=True)
# set video clip duration
if start > 0:
video.set_position(start)
# set video clip duration
if length == 0:
dur = video.duration()
durint = int(dur)
video.play()
time.sleep(durint)
else:
video.play()
print length
time.sleep(length)
print("Stop playing")
video.quit()
return "Video file played, lol"
def playVideoGo(video_name, start=0, length=0):
print "Incoming video request"
videofile_path = "video/" + video_name
# TODO check is file en with mp4 or mov
print "video to play: " + videofile_path
video = OMXPlayer(videofile_path, pause=True)
# set video clip duration
if start > 0:
video.set_position(start)
# set video clip duration
if length == 0:
dur = video.duration()
durint = int(dur)
video.play()
time.sleep(durint)
else:
video.play()
print length
time.sleep(length)
print("Stop playing")
video.quit()
return "Video file played, lol"
class Controller(object):
def __init__(self):
pass
def check_new_files(self):
'''
check new files from _DIR
'''
self._files = []
for files in os.listdir(_DIR):
if files.endswith(('wmv', 'mp4', 'mov', 'avi')):
self._files.append(os.path.join(_DIR, files))
else:
pass
def play_files(self):
'''
Play all the files sequentially
'''
self.idx = 0
while True:
# Loop over list of files
self.current_file = self._files[self.idx]
self.idx = (self.idx + 1) % len(self._files)
self.next_file = self._files[self.idx]
# Play files one after the other
self.player(self.current_file)
def player(self, current_file):
print(current_file,'\n','\tPlaying')
# Set output window size
self.omx = OMXPlayer(current_file, args=["--win", " 0,0,640,480"])
self.omx.play()
try:
self.omx.set_position(15.0)
while True:
try:
if not(self.omx.playback_status()):
# If file ended.. stop playback
print('\n\tStopped\n')
self.omx.stop()
break
else:
# Print time elapsed
print('\r\t','{0:.2f}'.format(self.omx.position()),
'/', '{0:.2f}'.format(self.omx.duration())+
' seconds', end = ''),
sys.stdout.flush()
except Exception, e:
# dBUS exception for file that
# finished playing. Ignore!
pass
except KeyboardInterrupt, e:
# Catch Ctrl+C and stop playing
# current file
print('Stopping Playback..', e)
self.omx.stop()
def omxplayer_process(queue):
try:
player_num = 0
last_video = None
video = True
while video:
#log.debug("Warte auf Befehle")
video = queue.get()
try:
# block queue
queue.put_nowait(True)
except:
...
log.debug('Play {}'.format(video))
if not last_video == video:
try:
player.quit()
except:
killall_omxplayer()
log.debug('Load new Video: {}'.format(video))
dbus_name = 'org.mpris.MediaPlayer2.omxplayer{}'.format(
player_num)
player = OMXPlayer(video,
args=omxplayer_args,
dbus_name=dbus_name,
pause=True)
player_num += 1
#log.debug(player.volume())
player.set_volume(1.0)
time.sleep(1)
# das erste Video soll nicht abgespielt werden, sondern nur einen Kaltstart vermeiden
if not last_video == None:
player.set_alpha(255)
player.play_sync()
player.pause()
player.set_alpha(0)
player.set_position(0)
log.debug('Video fertig: {}'.format(video))
last_video = video
try:
# clean queue
queue.get_nowait()
except:
...
except KeyboardInterrupt:
...
finally:
killall_omxplayer()
def testVideo(video_id=None):
print "Incoming video request"
vid1 = OMXPlayer(TEST_MEDIA_FILE_1, pause=True)
print("Start playing")
vid1.set_position(70)
dur = vid1.duration()
print dur
vid1.play()
sleep(2)
print("Stop playing")
vid1.pause()
time.sleep(2)
vid1.load(TEST_MEDIA_FILE_2)
vid1.play()
sleep(2)
print("Exit")
vid1.quit()
def testVideo(video_id=None):
print "Incoming video request"
vid1 = OMXPlayer(TEST_MEDIA_FILE_1, pause=True)
print("Start playing")
vid1.set_position(70)
dur = vid1.duration()
print dur
vid1.play()
sleep(2)
print("Stop playing")
vid1.pause()
time.sleep(2)
vid1.load(TEST_MEDIA_FILE_2)
vid1.play()
sleep(2)
print("Exit")
vid1.quit()
class PlayVoidAudio(Thread):
def __init__(self):
Thread.__init__(self)
def terminate(self): # activated by Stop button
self.player.stop()
print('Terminating thread...')
def run(self):
self.player = OMXPlayer(
'/home/pi/donics/MoS_TimingRemix_3Void_CleanStartEnd.mp3')
self.player.pause()
self.player.pause()
self.player.set_position(0.0)
#time.sleep(.1)
print "play"
self.player.play()
class TV(threading.Thread):
def __init__(self):
super(TV, self).__init__()
print("Initializing TV")
self.red_alert = False
self.player = None
self.reset()
#Register Events
signal('SYSTEM_stopping').connect(self.clean_up)
signal('tv.redalert').connect(self.alert)
signal('alert.red.toggle').connect(self.alert)
signal('code_47').connect(self.reset)
def reset(self, sender='anonymous'):
os.system('pkill omxplayer')
self.player = OMXPlayer("http://repo.posttwo.pt/redalert.mp4",
args=['--no-osd', '--no-keys', '-b', '--loop'])
self.player.pause()
def tv_set_pi(self):
subprocess.call("echo 'as' | cec-client -s &", shell=True)
#os.system('echo "as" | cec-client -s')
def tv_set_chrome(self):
subprocess.call("echo 'txn 4f:82:20:00' | cec-client -s &", shell=True)
#os.system('echo "txn 4f:82:20:00" | cec-client -s')
def alert(self, sender='anonymous'):
if not self.red_alert:
self.red_alert = True
self.tv_set_pi()
print("RED ALERT ON")
self.player.set_position(0)
self.player.play()
else:
self.red_alert = False
self.tv_set_chrome()
self.player.pause()
def clean_up(self, sender='anonymous'):
print("TV Cleaning Up")
self.player.quit()
class Player:
def __init__(self, path):
self.path = path
self.player = OMXPlayer(
self.path, args=["--loop", "-o", "local", "--win", "0,0,640,480"])
# self.player.play()
# self.player.set_position(10.0)
# self.player.pause()
def play(self):
self.player.play()
def pause(self):
self.player.pause()
def toggle(self):
self.player.play_pause()
def reset(self):
self.player.pause()
self.player.set_position(0.0)
subprocess.call('sudo pkill omxplayer', shell=True)
GPIO.add_event_detect(force_stop_gpio_i,
GPIO.FALLING,
callback=quit_program,
bouncetime=100)
logger = logging.getLogger('male_zuccini')
logger.info('creating omxplayer objects')
idle_movie_controller = OMXPlayer(filename=idle_video_file,
args=['--loop', '--no-osd'])
after_movie_controller = OMXPlayer(filename=after_video_file,
args=['--no-osd'])
after_movie_controller.pause()
after_movie_controller.set_position(0)
blink_movie_controller = OMXPlayer(filename=blink_video_file,
args=['--loop', '--no-osd'])
logger.info('finished creating omxplayer objects')
def state_idle():
logger.info('starting state_idle')
start_time = time.time()
idle_movie_controller.play()
while running:
if not GPIO.input(male_to_female_i):
start_time = time.time()
time.sleep(0.05)
if (time.time() - start_time) >= DEBOUNCE_TIME_TH:
class Video(object):
currentTime = 0;
startTime = 0;
player = OMXPlayer(dir_path + "/a.mp3", pause=True);
id = "";
listId = "";
state = "";
info = {};
def dispstart(self):
return self.startTime;
def dispcur(self):
return self.currentTime;
def setStartTime(self, time):
self.startTime = time;
def setCurrentTime(self, time):
self.currentTime = time;
def getCurrentTime(self):
now = int(time.time());
self.currentTime = now - self.startTime;
return self.currentTime;
def create(self):
videoToPlay = pafy.new("https://www.youtube.com/watch?v=" + self.info["encrypted_id"]);
bestaudio = videoToPlay.getbestaudio(preftype="m4a", ftypestrict=True);
file_name = dir_path + "/music/" + self.id + ".m4a";
try :
bestaudio.download(file_name);
except:
pass
self.player.quit()
self.player = OMXPlayer(file_name, pause=True);
AudioSegment.from_file(file_name).export(dir_path + "/music/" + self.id + ".mp3", format="mp3");
r = requests.post(addr_serv + "/serv", data=str(self.id));
if r.status_code != 200:
print(r);
print("error post to 2nd server");
else:
print("postb 2nd ok");
def seek(self, timeValue):
self.player.set_position(timeValue);
def play(self):
now = int(time.time());
self.startTime = now - self.currentTime; # calculate the starting point
self.state = "1";
self.player.play();
r = requests.post(addr_serv + "/serv", data=self.state);
if r.status_code != 200:
print(r);
print("error post to 2nd server");
else:
print("postb 2nd ok");
def pause(self):
self.getCurrentTime();
self.state = "2";
self.player.pause();
r = requests.post(addr_serv + "/serv", data=self.state);
if r.status_code != 200:
print(r);
print("error post to 2nd server");
else:
print("postb 2nd ok");
def stop(self): # useless for the moment but mayby later...
self.state = "0";
def volume(self, volume):
self.player.set_volume(-6000 + volume * 60); #-6000/100 car omx va de -6000 a 0 et volume de 0 a 100
class tree_player(object):
"""
control one screen on the "Big Tree display"
toggle between two different movies according to GPIO input signal
"""
def __init__(self, gpio_number, movie_1, movie_2):
self.logger = logging.getLogger('tree_player')
self.logger.info('starting player')
self.logger.info('movie 1: {}'.format(movie_1))
self.logger.info('movie 2: {}'.format(movie_2))
self.logger.info('GPIO: {} (BCM)'.format(gpio_number))
self.stop_gpio = 21
self.logger.info('stop GPIO: {} (BCM)'.format(self.stop_gpio))
self.control_gpio = gpio_number
self.movie_1 = movie_1
self.movie_2 = movie_2
self.current_state = None
self.polling_tries = 0
self.stop_state = 0
self.stop_tries = 0
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.control_gpio, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(self.stop_gpio, GPIO.IN, pull_up_down=GPIO.PUD_UP)
#GPIO.add_event_detect(self.control_gpio, GPIO.BOTH, callback=self.event, bouncetime=300)
#GPIO.add_event_detect(self.stop_gpio, GPIO.FALLING, callback=self.quit, bouncetime=200)
#self.movie_1_controller = omxplayer.OMXPlayer(mediafile=self.movie_1, args=r'--loop -b --no-osd', start_playback=False)
#self.movie_2_controller = omxplayer.OMXPlayer(mediafile=self.movie_2, args=r'--loop -b --no-osd', start_playback=False)
self.movie_1_controller = OMXPlayer(filename=self.movie_1,
args=['--loop', '-b', '--no-osd'])
self.movie_2_controller = OMXPlayer(filename=self.movie_2,
args=['--loop', '-b', '--no-osd'])
sleep(1)
self.running = True
self.button_reader_thread = threading.Thread(target=self.button_reader)
self.button_reader_thread.start()
def button_reader(self):
self.logger.info('button_reader started')
while self.running:
current_state = self.read_current_buttons_state()
if current_state != self.current_state and self.polling_tries == 20:
self.current_state = current_state
self.main_loop()
elif current_state != self.current_state and self.polling_tries < 20:
self.polling_tries += 1
else:
self.polling_tries = 1
stop_state = not GPIO.input(self.stop_gpio)
if stop_state and self.stop_tries == 50:
self.quit()
elif stop_state and self.stop_tries < 50:
self.stop_tries += 1
else:
self.stop_tries = 1
sleep(0.005)
self.logger.info('button_reader ended')
def read_current_buttons_state(self):
"""
read control_gpio state
"""
return GPIO.input(self.control_gpio)
def main_loop(self):
"""
one iteration of main loop,
called when input is changed,
stop one movie, seek to 0 (so next time we start from beginning) and play other movie
:return:
"""
current_state = self.current_state
if current_state:
self.logger.info('state changed to HIGH, show BAD fruit movie')
self.movie_2_controller.pause()
sleep(0.1)
self.movie_2_controller.set_position(0)
sleep(0.1)
self.movie_1_controller.play()
else:
self.logger.info('state changed to LOW, show GOOD fruit movie')
self.movie_1_controller.pause()
sleep(0.1)
self.movie_1_controller.set_position(0)
sleep(0.1)
self.movie_2_controller.play()
sleep(0.3)
def quit(self):
self.logger.info('in quit()')
self.running = False
sleep(0.1)
GPIO.cleanup()
self.logger.info('stopping both movies')
self.movie_1_controller.stop()
self.movie_2_controller.stop()
sleep(0.5)
self.logger.info('closing both players')
try:
self.movie_1_controller.quit()
except Exception as ex:
self.logger.error('while closing player 1, got ex: {}'.format(ex))
try:
self.movie_2_controller.quit()
except Exception as ex:
self.logger.error('while closing player 2, got ex: {}'.format(ex))
sleep(0.5)
self.logger.info('quit function ended')
class Player:
def __init__(self, init_layer=1, init_idleClip=None, init_autoIdle=False, init_volume=0.5):
self.omx = None
self.clip = None
self.isStopping = False
self.layer = init_layer
self.setIdleClip(init_idleClip)
self.autoIdle = init_autoIdle
self.volumeSetting='--vol -6000'
if init_volume == 0:
self.volumeSetting=('--vol ' + str(ceil(2000 * (log10(init_volume)))))
print(self.volumeSetting)
# pre:
# post: returns true if omx is not None
def isPlaying(self):
return self.omx is not None
# pre: expects desired is of type Clip
# post: sets the idle clip to be a looping version of the desired clip
def setIdleClip(self, desired):
if desired is not None:
self.idleClip = Clip(desired.location, True) # TODO: ensure this doesnt pile up clips over time
else:
self.idleClip = None
return self.idleClip
# pre: expects desired to be of type boolean
# post: sets the auto idle option to the desired value
def setAutoIdle(self, desired):
self.autoIdle = desired
return self.autoIdle
def isIdle(self):
return (self.clip == self.idleClip)
def playIdle(self):
self.play(self.idleClip)
# pre:
# post: stops the current clip and plays the desired clip
def play(self, desiredClip):
if (desiredClip is not None):
if self.isPlaying():
self.stop()
self.clip = desiredClip
if (self.clip.isLooping == False):
self.omx = OMXPlayer(self.clip.location, args=['--layer', str(self.layer), '--no-osd', '--no-keys'])
else:
self.omx = OMXPlayer(self.clip.location, args=['--layer', str(self.layer), '--no-osd', '--no-keys', '--loop'])
if (self.idleClip is not desiredClip):
self.omx.exitEvent += lambda a, b: self.clipEndEvent() # will this assign multiple times?
# pre:
# post: starts idling on the idleClip if autoIdle is true, otherwise stops playing the current clip
def endClip(self):
self.stop()
if (self.autoIdle and self.idleClip is not None):
self.play(self.idleClip)
# pre:
# post: stops playing the current clip
def stop(self):
self.isStopping = True
if self.isPlaying():
self.omx.quit()
self.clip = None
self.omx = None
self.isStopping = False
# pre:
# post: resets the current position of the clip to its start
def reset(self):
self.omx.set_position(0)
def clipEndEvent(self):
print("clip end")
self.omx = None
if (self.isStopping is False):
self.play(self.idleClip)
mt_dev = mtc_pos - lastm
print "(%.2f) %.2f %.2f" % (difference, mtc_pos, player_pos)
# av.append(player_pos)
# if len(av) > 10:
# av.pop(0)
# pl_av = sum(av)/len(av)
#
# print "Video: %.2f / %.2f (%.2f) MTC: %.2f" % (player_pos, pl_av, pl_dev, mtc_pos)
#
# # print "%3f %6f" % (pl_dev, mt_dev)
# # print sum(av)/len(av)
#
if difference > 5 or difference < -1:
pause_pos = mtc.getS()+5
player.set_position(pause_pos)
print "seeking to %f" % (pause_pos / 60)
player.pause()
player_pos = player.position()
while mtc.getS() < player_pos: pass
player.play()
# if difference > 0.2:
# player.pause()
# player.play()
if difference > tol and speed == 0:
player.action(1)
speed = -1
elif difference < -tol and speed == 0:
player.action(2)
class Player:
def __init__(self, appli):
self.currVideo = None
self.formatId = 0
self.subtitleId = -1
self.audioStreamId = 0
self.omxProcess = None
self.currTotViewed = 0
self.lastPos = 0
self.appli = appli
self.wasPlaying = False
def LoadVideo(self, video):
if self.isStarted():
self.stop()
self.wasPlaying = False
self.currVideo = video
self.formatId = 0
self.subtitleId = -1
self.audioStreamId = 0
self.currTotViewed = 0
self.lastPos = 0
# Set the format of the video
def setVideoFormat(self, formatId):
if self.currVideo and formatId != self.formatId:
# If the video has this format
if self.currVideo.getFormat(formatId):
oldFormat = self.formatId
self.formatId = formatId
if self.isStarted():
self.wasPlaying = False
oldPos = self.getPosition()
wasPlaying = self.isPlaying()
# Try to play the new format but fallback on the previous one if it fails
if self.tryPlayingFormat(
formatId) or self.tryPlayingFormat(oldFormat):
self.setPosition(oldPos)
if not wasPlaying:
self.playPause()
else:
return False
return True
return False
# Set a different audio stream
def setAudioFormat(self, formatId):
try:
if self.isStarted():
if self.omxProcess.select_audio(formatId):
self.audioStreamId = formatId
return True
else:
return False
else:
return False
except:
self.clearPlayer()
return False
# Set a subtitle track
def setSubtitlesFormat(self, formatId):
try:
if self.isStarted():
if formatId > -1:
self.omxProcess.show_subtitles()
if self.omxProcess.select_subtitle(formatId):
self.subtitleId = formatId
return True
else:
return False
else:
self.subtitleId = -1
return self.omxProcess.hide_subtitles()
else:
return False
except:
self.clearPlayer()
return False
# Tries to play or pause the current video
def playPause(self):
if self.currVideo:
if self.isStarted():
try:
if self.isPlaying():
self.omxProcess.pause()
else:
self.omxProcess.play()
return True
except:
self.clearPlayer()
return False
else:
ok = False
if self.formatId != 0:
ok = self.tryPlayingFormat(self.formatId)
if not ok:
# Try to play formats starting from the highest resolution one
for fid in range(1, len(self.currVideo.getFormatList())):
if self.tryPlayingFormat(fid):
ok = True
break
return ok
return False
def stop(self):
self.wasPlaying = False
try:
if self.omxProcess:
self.omxProcess.quit()
self.omxProcess = None
return True
return False
except:
self.clearPlayer()
return False
# Tries to play a given format of the video
def tryPlayingFormat(self, formatId):
if self.isStarted():
self.stop()
try:
self.formatId = formatId
print('Trying to play ', formatId, 'path:',
self.currVideo.getRessourcePath(formatId))
self.omxProcess = OMXPlayer(
self.currVideo.getRessourcePath(formatId), args=['-b'])
# Wait a bit for loading before disqualifying the format
while self.omxProcess.playback_status() == 'Paused':
sleep(0.01)
if self.isPlaying():
print('isplaying:True')
return True
except Exception as e:
self.clearPlayer()
print(str(e), str(self.currVideo.getFormatList()))
# Handle the case in which the format couldn't be played
self.stop()
self.formatId = 0
return False
def isPlaying(self):
try:
return self.omxProcess and self.omxProcess.is_playing()
except:
self.clearPlayer()
return False
def isStarted(self):
try:
return self.omxProcess and self.omxProcess.can_play()
except:
self.clearPlayer()
return False
def isPaused(self):
return self.isStarted() and not self.isPlaying()
def getPosition(self):
try:
if self.isStarted():
return self.omxProcess.position()
else:
return 0
except:
self.clearPlayer()
return 0
def getDuration(self):
try:
if self.isStarted():
return int(self.omxProcess.duration())
elif self.currVideo:
return self.currVideo.duration
else:
return 1
except:
self.clearPlayer()
return 1
def getSubtitles(self):
subs = {-1: 'None'}
try:
if self.isStarted():
for substr in self.omxProcess.list_subtitles():
idx, lng, name, cdc, actv = substr.split(':')
subs[idx] = lng + (('-' + name) if len(name) > 0 else '')
if actv:
self.subtitleId = idx
return subs
except:
self.clearPlayer()
return subs
def hasSubtitles(self):
try:
return self.isStarted() and len(
self.omxProcess.list_subtitles()) > 0
except:
self.clearPlayer()
return False
def getAudioStreams(self):
auds = {}
try:
if self.isStarted():
for audstr in self.omxProcess.list_audio():
idx, lng, name, cdc, actv = audstr.split(':')
auds[idx] = lng + (('-' + name) if len(name) > 0 else '')
if actv:
self.audioStreamId = idx
return auds
except:
self.clearPlayer()
return auds
def hasAudioStreams(self):
try:
return self.isStarted() and len(self.omxProcess.list_audio()) > 1
except:
self.clearPlayer()
return False
def hasVideoStreams(self):
if self.currVideo:
okFormatList = json.loads(self.currVideo.okFormatsList)
return len(okFormatList) > 2
else:
return False
def getStatus(self):
isPlaying = self.isPlaying()
isPaused = self.isPaused()
currPos = self.getPosition()
dur = self.getDuration()
if isPlaying or isPaused:
self.wasPlaying = True
self.currTotViewed += currPos - self.lastPos
self.lastPos = currPos
with self.appli.threadLock:
if self.currTotViewed / dur > Parameters.get().viewedThreshold:
self.currVideo.viewed = True
self.currVideo.save()
self.appli.updatePart('playlist')
else:
with self.appli.threadLock:
pt = Parameters.get().autoRestartPosThresh
if self.wasPlaying and pt < self.lastPos < self.getDuration() - pt:
self.tryPlayingFormat(self.formatId)
self.setPosition(self.lastPos)
return {
'position': currPos,
'duration': dur,
'isPlaying': isPlaying,
'isPaused': isPaused
}
def setPosition(self, newPos):
try:
# If the video is not started, start it and jump to the position
if self.isStarted() or self.playPause():
self.omxProcess.set_position(newPos)
return True
else:
return False
except:
self.clearPlayer()
return False
def getFormatList(self):
return self.currVideo.getFormatList() if self.currVideo else []
def getFormatListItems(self):
return [(fid, f['name']) for fid, f in enumerate(self.getFormatList())]
def clearPlayer(self):
if self.omxProcess:
try:
self.omxProcess.quit()
except:
pass
self.omxProcess = None
class MediaOmxplayerPlugin(MediaPlugin):
"""
Plugin to control video and media playback using OMXPlayer.
Requires:
* **omxplayer** installed on your system (see your distro instructions)
* **omxplayer-wrapper** (``pip install omxplayer-wrapper``)
"""
def __init__(self, args=None, *argv, timeout: float = 20., **kwargs):
"""
:param args: Arguments that will be passed to the OMXPlayer constructor
(e.g. subtitles, volume, start position, window size etc.) see
https://github.com/popcornmix/omxplayer#synopsis and
https://python-omxplayer-wrapper.readthedocs.io/en/latest/omxplayer/#omxplayer.player.OMXPlayer
:type args: list
:param timeout: How long the plugin should wait for a video to start upon play request (default: 20 seconds).
"""
super().__init__(*argv, **kwargs)
if args is None:
args = []
self.args = args
self.timeout = timeout
self._player = None
self._handlers = {e.value: [] for e in PlayerEvent}
self._play_started = threading.Event()
@action
def play(self, resource=None, subtitles=None, *args, **kwargs):
"""
Play or resume playing a resource.
:param resource: Resource to play. Supported types:
* Local files (format: ``file://<path>/<file>``)
* Remote videos (format: ``https://<url>/<resource>``)
* YouTube videos (format: ``https://www.youtube.com/watch?v=<id>``)
* Torrents (format: Magnet links, Torrent URLs or local Torrent files)
:param subtitles: Subtitles file
"""
if not resource:
if not self._player:
self.logger.warning('No OMXPlayer instances running')
else:
self._player.play()
return self.status()
else:
self._play_started.clear()
self._post_event(MediaPlayRequestEvent, resource=resource)
if subtitles:
args += ('--subtitles', subtitles)
resource = self._get_resource(resource)
if self._player:
try:
self._player.stop()
self._player = None
except Exception as e:
self.logger.exception(e)
self.logger.warning(
'Unable to stop a previously running instance ' +
'of OMXPlayer, trying to play anyway')
from dbus import DBusException
try:
from omxplayer import OMXPlayer
self._player = OMXPlayer(resource, args=self.args)
except DBusException as e:
self.logger.warning(
'DBus connection failed: you will probably not ' +
'be able to control the media')
self.logger.exception(e)
self._post_event(MediaPlayEvent, resource=resource)
self._init_player_handlers()
if not self._play_started.wait(timeout=self.timeout):
self.logger.warning(
f'The player has not sent a play started event within {self.timeout}'
)
return self.status()
@action
def pause(self):
""" Pause the playback """
if self._player:
self._player.play_pause()
return self.status()
@action
def stop(self):
""" Stop the playback (same as quit) """
return self.quit()
@action
def quit(self):
""" Quit the player """
from omxplayer.player import OMXPlayerDeadError
if self._player:
try:
try:
self._player.stop()
except Exception as e:
self.logger.warning(f'Could not stop player: {str(e)}')
self._player.quit()
except OMXPlayerDeadError:
pass
finally:
self._player = None
return {'status': 'stop'}
def get_volume(self) -> float:
"""
:return: The player volume in percentage [0, 100].
"""
if self._player:
return self._player.volume() * 100
@action
def voldown(self, step=10.0):
"""
Decrease the volume.
:param step: Volume decrease step between 0 and 100 (default: 10%).
:type step: float
"""
if self._player:
self.set_volume(max(0, self.get_volume() - step))
return self.status()
@action
def volup(self, step=10.0):
"""
Increase the volume.
:param step: Volume increase step between 0 and 100 (default: 10%).
:type step: float
"""
if self._player:
self.set_volume(min(100, self.get_volume() + step))
return self.status()
@action
def back(self, offset=30):
""" Back by (default: 30) seconds """
if self._player:
self._player.seek(-offset)
return self.status()
@action
def forward(self, offset=30):
""" Forward by (default: 30) seconds """
if self._player:
self._player.seek(offset)
return self.status()
@action
def next(self):
""" Play the next track/video """
if self._player:
self._player.stop()
if self._videos_queue:
video = self._videos_queue.pop(0)
self.play(video)
return self.status()
@action
def hide_subtitles(self):
""" Hide the subtitles """
if self._player:
self._player.hide_subtitles()
return self.status()
@action
def hide_video(self):
""" Hide the video """
if self._player:
self._player.hide_video()
return self.status()
@action
def is_playing(self):
"""
:returns: True if it's playing, False otherwise
"""
return self._player.is_playing()
@action
def load(self, resource, pause=False, **kwargs):
"""
Load a resource/video in the player.
:param resource: URL or filename to load
:type resource: str
:param pause: If set, load the video in paused mode (default: False)
:type pause: bool
"""
if self._player:
self._player.load(resource, pause=pause)
return self.status()
@action
def metadata(self):
""" Get the metadata of the current video """
if self._player:
return self._player.metadata()
return self.status()
@action
def mute(self):
""" Mute the player """
if self._player:
self._player.mute()
return self.status()
@action
def unmute(self):
""" Unmute the player """
if self._player:
self._player.unmute()
return self.status()
@action
def seek(self, position):
"""
Seek to the specified number of seconds from the start.
:param position: Number of seconds from the start
:type position: float
"""
if self._player:
self._player.set_position(position)
return self.status()
@action
def set_position(self, position):
"""
Seek to the specified number of seconds from the start (same as :meth:`.seek`).
:param position: Number of seconds from the start
:type position: float
"""
return self.seek(position)
@action
def set_volume(self, volume):
"""
Set the volume
:param volume: Volume value between 0 and 100
:type volume: float
"""
if self._player:
self._player.set_volume(volume / 100)
return self.status()
@action
def status(self):
"""
Get the current player state.
:returns: A dictionary containing the current state.
Format::
output = {
"duration": Duration in seconds,
"filename": Media filename,
"fullscreen": true or false,
"mute": true or false,
"path": Media path
"pause": true or false,
"position": Position in seconds
"seekable": true or false
"state": play, pause or stop
"title": Media title
"url": Media url
"volume": Volume between 0 and 100
"volume_max": 100,
}
"""
from omxplayer.player import OMXPlayerDeadError
from dbus import DBusException
if not self._player:
return {'state': PlayerState.STOP.value}
try:
state = self._player.playback_status().lower()
except (OMXPlayerDeadError, DBusException) as e:
self.logger.warning(f'Could not retrieve player status: {e}')
if isinstance(e, OMXPlayerDeadError):
self._player = None
return {'state': PlayerState.STOP.value}
if state == 'playing':
state = PlayerState.PLAY.value
elif state == 'stopped':
state = PlayerState.STOP.value
elif state == 'paused':
state = PlayerState.PAUSE.value
return {
'duration':
self._player.duration(),
'filename':
urllib.parse.unquote(self._player.get_source()).split('/')[-1]
if self._player.get_source().startswith('file://') else None,
'fullscreen':
self._player.fullscreen(),
'mute':
self._player._is_muted,
'path':
self._player.get_source(),
'pause':
state == PlayerState.PAUSE.value,
'position':
max(0, self._player.position()),
'seekable':
self._player.can_seek(),
'state':
state,
'title':
urllib.parse.unquote(self._player.get_source()).split('/')[-1]
if self._player.get_source().startswith('file://') else None,
'url':
self._player.get_source(),
'volume':
self.get_volume(),
'volume_max':
100,
}
def add_handler(self, event_type, callback):
if event_type not in self._handlers.keys():
raise AttributeError(
'{} is not a valid PlayerEvent type'.format(event_type))
self._handlers[event_type].append(callback)
@staticmethod
def _post_event(evt_type, **evt):
bus = get_bus()
bus.post(evt_type(player='local', plugin='media.omxplayer', **evt))
def on_play(self):
def _f(player):
if self.volume and not self._play_started.is_set():
self.set_volume(self.volume)
self._play_started.set()
resource = player.get_source()
self._post_event(MediaPlayEvent, resource=resource)
for callback in self._handlers[PlayerEvent.PLAY.value]:
callback(resource)
return _f
def on_pause(self):
def _f(player):
resource = player.get_source()
self._post_event(MediaPauseEvent, resource=resource)
for callback in self._handlers[PlayerEvent.PAUSE.value]:
callback(resource)
return _f
def on_stop(self):
def _f(*_, **__):
self._post_event(MediaStopEvent)
for callback in self._handlers[PlayerEvent.STOP.value]:
callback()
return _f
def on_seek(self):
def _f(player, *_, **__):
self._post_event(MediaSeekEvent, position=player.position())
return _f
def _init_player_handlers(self):
if not self._player:
return
self._player.playEvent += self.on_play()
self._player.pauseEvent += self.on_pause()
self._player.stopEvent += self.on_stop()
self._player.exitEvent += self.on_stop()
self._player.positionEvent += self.on_seek()
self._player.seekEvent += self.on_seek()
def toggle_subtitles(self, *args, **kwargs):
raise NotImplementedError
def set_subtitles(self, filename, *args, **kwargs):
raise NotImplementedError
def remove_subtitles(self, *args, **kwargs):
raise NotImplementedError
#This code is for debugging purposes, incase system freezes it forces close after 30 seconds
timeout = time.time() + 30
while True:
button_quit = GPIO.input(5)
button_lose = GPIO.input(6)
button_win = GPIO.input(13)
button_start = GPIO.input(19)
button_loop = GPIO.input(26)
print('Error Code #002')
player.play()
if (button_loop == False):
print('Loop Trigger by GameMaster')
# cuFunctions.loopvideo(player())
player.set_position(0)
print('Error Code #A01')
while(True):
button_start = GPIO.input(19)#WHY DOES THIS HAVE TO BE HERE? HOLY CRAP
button_quit = GPIO.input(5)
print('Error Code #A02')
if (player.position() > 10):#Seconds until the system loops back to 0
print('Loop Triggered by System')
player.set_position(0)
print('Error Code #A03')
if (button_start == False):#When start pressed, game starts, then break out of loopvideo function
print('Game Start Triggered by GameMaster')
print('Error Code #A04')
player.set_position(600)
time.sleep(1)
break#Break Wroks, use return for function Def
pwm_smoke1.stop()
pwm_smoke2.stop()
pwm_smoke3.stop()
pwm_heat.stop()
action_on = False
#-----------------------------
#Main code
try:
# player-Objekt erzeugen,parametrieren und das Video und Aktoren auf 0 setzen
player = OMXPlayer('/home/pi/Desktop/R_A_vid_v2.mp4',
args=['--win', '0 0 1920 1080', '--no-osd'])
player.set_position(0)
player.play()
action(0, 0, 0, 0, 0)
# stetige Abfrage welche Aktoren angesteuert werden wollen. wenn nichts geschieht, GPIO_Reset wird ausgefuert
# in den jeweiligen Zeitintervallen werden die Aktoren angesteuert
while 1:
while 3 < player.position() < 5 and player.is_playing():
action(25, 100, 0, 0, 0)
print(player.position())
GPIO_reset()
while 21 - 15 < player.position() < 21 and player.is_playing():
action(0, 0, 0, 0, 100)
print(player.position())
GPIO_reset()
#!/usr/bin/env python2
from omxplayer import OMXPlayer
from time import sleep
from smoke_tests import TEST_MEDIA_FILE_1
print(TEST_MEDIA_FILE_1)
vid1 = OMXPlayer(TEST_MEDIA_FILE_1)
print("Start playing")
vid1.set_position(5)
vid1.play()
sleep(2)
print("Stop playing")
vid1.pause()
sleep(2)
print("Exit")
vid1.quit()
