def _show_video(self, video_uri, time_window, touch_enabled, text):
pygame.display.flip()
t_start = time.time()
running = True
try:
player = OMXPlayer(video_uri)
player.set_aspect_mode("stretch")
while not player.is_playing():
time.sleep(0.1)
except Exception as e:
raise Exception("Video not loaded. Error is: " + str(e))
while time.time() - t_start < time_window and running:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN and touch_enabled:
running = False
player.quit()
break
try:
if not player.is_playing():
running = False
except Exception as e:
running = False
try:
if player.is_playing():
player.quit()
except Exception as e:
pass
self._show_black()
return {'reaction_time': time.time() - t_start}
class ToonPlayer(object):
"""omxplayer-wrapper throws an exception if it can't find an
active dbus listing. This isn't really what I want so I'll
fix that with my own class and some composition.
-b is here to black out the background terminal.
"""
def __init__(self, source):
self._player = OMXPlayer(source, '-b')
sleep(2)
def play(self, source):
self._player.load(source)
def seek(self, time):
self._player.seek(time)
def active(self):
try:
if self._player.is_playing():
return True
else:
return False
except Exception as ex:
return False
def playFile(path):
global player
global isPlaying
quitPlayer()
print("play {0}".format(path))
isPlaying = True
player = OMXPlayer(path, args=["--video_fifo", "10"])
while not player.is_playing():
wiringpi.delay(50)
def playFile(audioPath):
player = OMXPlayer(audioPath,
dbus_name='org.mpris.MediaPlayer2.omxplayer1')
time.sleep(2.5) # establish player
try:
while player.is_playing():
time.sleep(0.3)
ringSensor.readTrill()
if ringSensor.getNumTouches() >= 3:
print("3 ring sensor touches - stopping")
player.pause()
except:
player.quit()
player.quit()
class videoPlayer:
def __init__(self, videoPath):
self.videoPath = videoPath
self.classPlayer = OMXPlayer(self.videoPath)
sleep(0.2)
self.classPlayer.pause()
def playVideo(self):
self.classPlayer.play()
def end(self):
return self.classPlayer.is_playing()
def length(self):
return self.classPlayer.duration()
def freeze(self):
self.classPlayer.quit()
def text2Speech(self, text):
if text not in self.__TTSCache:
print("Not in cache")
textInput = texttospeech.types.SynthesisInput(text=text)
response = self.__CLIENT.synthesize_speech(textInput,
self.__VOICE,
self.__AUDIO_CONFIG)
f = tempfile.NamedTemporaryFile(suffix=".mp3")
f.write(response.audio_content)
self.__TTSCache[text] = f.name
print("Temp location: ", self.__TTSCache[text])
try:
player = OMXPlayer(self.__TTSCache[text])
while player.is_playing():
pass
except Exception as e:
print("only omxplayer works, but it is buggy as hell")
class Player:
def __init__(self, video_file):
self.player = None
self.path = ''
self.load(video_file)
def load(self, video_file):
print('Player loading {0}'.format(video_file))
#if self.player != None:
# self.player.stop()
# del self.player
self.path = os.path.join(media_dir, video_file)
if self.player is None:
self.player = OMXPlayer(self.path, args=['--loop', '--blank', '-o', 'both'])
else:
self.player.load(self.path)
self.player.stopEvent += lambda _: self._complete()
self.player.pauseEvent += lambda _: self._pauseEvent()
self.player.playEvent += lambda _: self._playEvent()
self.player.positionEvent += lambda _: self._positionEvent()
self.player.seekEvent += lambda _: self._seekEvent()
def _complete(self):
print('Playback finished.')
def _pauseEvent(self):
print('Player pause event.')
def _playEvent(self):
print('Player play event.')
def _positionEvent(self):
print('Player position event.')
def _positionEvent(self):
print('Player seek event.')
def set_pause(self, p):
if p:
self.player.pause()
else:
self.player.play()
def get_pause(self):
if self.player.is_playing():
return False
else:
return True
def toggle_pause(self):
if self.player.is_playing():
self.player.pause()
else:
self.player.play()
def stop(self):
self.player.stop()
def quit(self):
self.player.quit()
def reload(self):
print('Reloading {0}'.format(self.path))
self.load(self.path)
def get_path(self):
return self.path
class Omx():
def __init__(self):
self.url = "None"
self.player = None
self.srt = None
self.dvdplayer = None
self.subs = 0
self.audio_tracks = 0
self.titles = 0
return
def youtube(self):
proc = subprocess.Popen(['youtube-dl', '-g', '-f', 'mp4', self.url],
stdout=subprocess.PIPE)
url = proc.stdout.read()
if url.decode("utf-8") == '':
return False
self.player = OMXPlayer(url.decode("utf-8", "strict")[:-1],
args=['-o', 'hdmi'])
return True
def start_media(self, host, file):
address = "http://" + str(host) + ":8090/" + file
self.player = OMXPlayer(address.replace(" ", "%20"),
args=['-o', 'hdmi'])
i = 0
while not self.player.is_playing():
time.sleep(1)
i += 1
if i >= 40:
break
return False
return True
def start_dvd(self):
self.dvdplayer = mpv.MPV()
self.dvdplayer.fullscreen = True
self.dvdplayer['vo'] = 'rpi'
self.dvdplayer['rpi-osd'] = 'yes'
self.dvdplayer['osd-bar'] = 'yes'
self.dvdplayer['osd-on-seek'] = 'msg-bar'
self.dvdplayer['osd-level'] = '1'
self.dvdplayer['osd-duration'] = '8000'
self.dvdplayer['loop-file'] = 'no'
self.dvdplayer['end'] = '-5'
self.dvdplayer['osd-playing-msg'] = 'Now Playing Your DVD'
self.dvdplayer['dvd-device'] = '/dev/nbd0'
self.dvdplayer.play('dvd://')
self.audio_tracks = 0
self.subs = 0
self.titles = 0
return True
def get_tracks(self):
#Get the amount of audio tracks and subtitles avaible on DVD(May cause issues when more than 1 movie on DVD)
self.subs = 0
self.audio_tracks = 0
print(self.dvdplayer._get_property('disc-titles', 'length'))
for item in self.dvdplayer._get_property("track-list"):
if item['type'] == 'sub':
self.subs += 1
if item['type'] == 'audio':
self.audio_tracks += 1
return
def close_srt(self):
if self.srt and self.srt.poll() is None:
self.srt.terminate()
self.srt.wait()
def pause(self):
if self.player:
time.sleep(1)
self.player.pause()
self.close_srt()
def mirror(self):
self.make_pipe()
self.player = OMXPlayer(NAMED_PIPE,
args=[
'-o', 'hdmi', '--lavfdopts',
'probesize:8000', '--timeout', '0',
'--threshold', '0'
])
with open(NAMED_PIPE, "wb", 0) as output_stream:
self.srt = subprocess.Popen([
"stransmit", "srt://:8090?mode=server&pbkeylen=0", "file://con"
],
stdout=output_stream)
return
def make_pipe(self):
if os.path.exists(NAMED_PIPE):
os.remove(NAMED_PIPE)
os.mkfifo(NAMED_PIPE)
upper = np.array(upper, dtype="uint8")
mask = cv2.inRange(frame, lower, upper)
output = cv2.bitwise_and(frame, frame, mask=mask)
output = cv2.cvtColor(output, cv2.COLOR_BGR2GRAY)
(thresh, output) = cv2.threshold(output, 127, 255, cv2.THRESH_BINARY)
blue_pixels = cv2.countNonZero(output)
textsurface = myfont.render(str(blue_pixels), False, (0, 255, 0))
if debug:
screen.fill([0, 0, 0])
output = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
output = np.rot90(output)
output = pygame.surfarray.make_surface(output)
screen.blit(output, (0, 0))
screen.blit(textsurface, (120, 120))
pygame.display.update()
else:
if blue_pixels > 1000:
if not player.is_playing():
player.play()
else:
player.pause()
for event in pygame.event.get():
if event.type == KEYDOWN:
pygame.quit()
cv2.destroyAllWindows()
sys.exit(0)
class VideoPlayer:
def __init__(self):
self._logger = getLogger("raspberry.videoplayer")
self.is_running = False
self._current_player = None
self._thread = Thread()
self._logger.info("ready")
def start(self, video_list_queue):
self._thread = Thread(target=self._run, args=(video_list_queue, ))
self._thread.start()
def stop(self):
self.is_running = False
self._logger.info("Waiting for all actions to terminate")
if self._current_player:
self._current_player.stop()
self._current_player.quit()
self._thread.join()
self._logger.info("Finished")
def _run(self, video_list_queue):
"""
:type video_list_queue: Queue.Queue
"""
self.is_running = True
pygame.init()
pygame.mouse.set_visible(False)
screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
screen.fill((0, 0, 0))
while self.is_running:
self._logger.info("waiting for a playlist...")
video_list = []
while self.is_running:
try:
video_list = video_list_queue.get(block=True, timeout=5)
self._logger.info("got a playlist!")
break
except Empty:
continue
current_video = 0
while self.is_running:
if self.play_video(video_list[current_video]):
current_video = (current_video + 1) % len(video_list)
else:
# self._logger.info("Removing from the playlist")
current_video = (current_video + 1) % len(video_list)
# del video_list[current_video]
# if len(video_list) > 0:
# current_video = current_video % len(video_list)
# else:
# self._logger.warning("Playlist is empty.")
if len(video_list) == 0 or not video_list_queue.empty():
break
pygame.quit()
def play_video(self, path):
"""
:type path: str
"""
# print "[video player] Playing video %s" % path
try:
self._logger.info("Starting video")
self._current_player = OMXPlayer(path)
test = True
while test:
time.sleep(5)
try:
test = self._current_player.is_playing()
self._logger.debug("Video playing...")
except:
test = False
self._logger.debug("Video finished")
return True
except Exception as e:
self._logger.error("Error playing %s : %s" % (path, str(e)))
return False
player.set_position(feeding)
print("player seeked to " + str(player.position()) + "for feeding")
def flyaway_mode():
player.set_position(flyaway)
print("player seeked to " + str(player.position()) + "for flyaway")
def empty_mode():
player.set_position(empty)
print("player seeked to " + str(player.position()) + "for empty")
try:
while player.is_playing() == False:
player.play()
while GPIO.input(
GPIO_PIR
) == 1: #loop while the motion sensor is setting up and still reading high
print("Waiting for PIR to settle ...")
time.sleep(2)
print(" Ready")
while True:
if int(
player.position()
) > player_length: #check once for error here, in case the cue is missed and this overruns the player length
from ffprobe import FFProbe
from omxplayer.player import OMXPlayer
from time import sleep
import logging
logging.basicConfig(level=logging.INFO)
VIDEO_1_PATH = "app/static/videos/Iowa_Launch.mp4"
sleep(5)
player_log = logging.getLogger("Player 1")
player = OMXPlayer(VIDEO_1_PATH)
sleep(5)
player.play()
print
print "Player is playing : ", player.is_playing()
print "Player can play : ", player.can_play()
sleep(10)
player.quit()
player.set_position(feeding)
print("player seeked to " + str(player.position()) + "for feeding")
def flyaway_mode():
player.set_position(flyaway)
print("player seeked to " + str(player.position()) + "for flyaway")
def empty_mode():
player.set_position(empty)
print("player seeked to " + str(player.position()) + "for empty")
try:
if player.is_playing() == False:
player.play()
while GPIO.input(
GPIO_PIR
) == 1: #loop while the motion sensor is setting up and still reading high
print("Waiting for PIR to settle ...")
time.sleep(2)
print(" Ready")
while True:
if int(
player.position()
) > player_length: #check once for error here, in case the cue is missed and this overruns the player length
player_stop = OMXPlayer(BLACK_PATH,
dbus_name='org.mpris.MediaPlayer2.omxplayer2')
# it takes about this long for omxplayer to warm up and start displaying a picture on a rpi3
player_action.pause()
sleep(2.5)
player_stop.pause()
try:
while True:
# Button was pressed
if ( GPIO.input(button) == GPIO.LOW ):
sleep(1)
try:
if (player_action.is_playing() == True):
player_action.stop()
sleep(1)
player_action = OMXPlayer(VIDEO_PATH, dbus_name='org.mpris.MediaPlayer2.omxplayer1')
else:
player_action.play()
sleep(1)
except:
sleep(1)
except KeyboardInterrupt:
try:
player_action.quit()
class MoviePlayer(metaclass=EventDispatcher):
# Evemts
MOVIE_STOP_EVENT = "MoviePlayer:Stop"
MOVIE_START_EVENT = "MoviePlayer:Start"
MOVIE_TRIGER_EVENT = "MoviePlayer:Trigger"
MOVIE_PLAY_EVENT = "MoviePlayer:Play"
MOVIE_EXIT_EVENT = "MoviePlayer:Exit"
player = None
isPlaying = False
_triggers = []
def __init__(self, volume=4):
self.volume = volume
def play(self, url, loop=False):
self.path = Path(url)
self._triggers = []
if (self.player == None):
#, '--vol', '0'
props = ['--no-osd', '--no-keys']
if (loop):
props.append('--loop')
self.player = OMXPlayer(self.path, args=props)
# self.player.pauseEvent += lambda _: player_log.info("Pause")
# self.player.playEvent += lambda _: player_log.info("Play")
self.player.exitEvent += lambda _, exit_code: self.handleExit(
exit_code)
else:
self.player.load(self.path)
self.isPlaying = True
def handleExit(self, eve):
self.isPlaying = False
self.emit_event(MoviePlayer.MOVIE_EXIT_EVENT)
def addTriggers(self, triggers):
self._triggers = []
if (len(triggers) > 0):
for trigger in triggers:
self._triggers.append(
Trigger(trigger["time"], trigger["actions"]))
def update(self):
try:
if (self.isPlaying == True and self.player != None
and len(self._triggers) > 0
and self.player.is_playing() == True):
frame = self.player.position()
for t in self._triggers:
if (frame >= t.frame):
self._triggers.remove(t)
self.emit_event(MoviePlayer.MOVIE_TRIGER_EVENT,
t.actions)
except:
pass
def pause(self):
self.isPlaying = False
def stop(self):
self.isPlaying = False
self._triggers = []
try:
self.player.stop()
self.player = None
except ValueError:
print("Oops! That was no valid number. Try again...")
def destroy(self):
self.player.quit()
self.player = None
self._triggers = []
) #0 + next video in array 10 seconds
current_video = next_video_to_play
next_video_to_play += 1
if (
next_video_to_play >= number_of_videos
): # -1 number of videos because the last one plays with the sensor state
print('revert to default')
current_video = 0
next_video_to_play = 1
player.seek(-player.position())
#if the player pos is greater than the video stamp plus the length of the video then revert to default content
if (player.position() >=
(video_timestamps[current_video] + video_lengths[current_video])):
print('default content')
player.seek(-player.position())
current_video = video_timestamps[0]
current_video = 0
#if the videos are all complete after the last button press then play default supermodels video
last_button_state = local_button_state
# Cleanup
print("Cleanup")
button_thread.join() #exit thread
if (player.is_playing()):
player.stop()
GPIO.cleanup()
