def play():
print('Starting player...')
cinemagraphs_path = os.path.join('cinemagraphs', 'processed')
cinemagraphs = os.listdir(cinemagraphs_path)
shuffle(cinemagraphs)
global current_player
current_player = None
for i, cinemagraph in enumerate(cinemagraphs):
path_str = os.path.join(cinemagraphs_path, cinemagraph)
path = Path(path_str)
dbus_name = 'org.mpris.MediaPlayer2.omxplayer{}'.format(i)
print('Now playing "{}".'.format(path_str))
previous_player = current_player
current_player = OMXPlayer(path,
args=['--loop', '--no-osd', '-b'],
dbus_name=dbus_name)
current_player.set_video_pos(0, 0, 1024, 600)
if previous_player is not None:
previous_player.quit()
for alpha_fade_in in range(0, 255):
current_player.set_alpha(alpha_fade_in)
sleep(0.01)
sleep(600)
for alpha_fade_out in reversed(range(0, 255)):
current_player.set_alpha(alpha_fade_out)
sleep(0.02)
current_player.quit()
class VideoPlayerScreen(Screen):
slider = ObjectProperty()
minimized = BooleanProperty(True)
video_path = StringProperty() # 20200308tagesthemen.mp4
def is_playing(self):
if hasattr(self, 'player'):
try:
return self.player.is_playing()
except OMXPlayerDeadError:
self.leave_player()
return False
else:
return False
def set_play_pause_bttn(self, *args):
print(self.ids)
if self.is_playing():
self.ids.play_pause_image.source = 'atlas://data/images/defaulttheme/media-playback-pause'
else:
self.ids.play_pause_image.source = 'atlas://data/images/defaulttheme/media-playback-start'
def play(self):
VIDEO_PATH = Path("videos/" + self.video_path)
print(VIDEO_PATH)
self.player = OMXPlayer(VIDEO_PATH,
args=['-o', 'alsa', '--layer', '100000'])
self.player.set_video_pos(0, 0, 800, 480)
self.set_slider()
self.change_size()
Clock.schedule_interval(self.set_slider, 3)
Clock.schedule_interval(self.set_play_pause_bttn, 1)
def player_stop(self):
Clock.unschedule(self.set_play_pause_bttn)
Clock.unschedule(self.set_slider)
if self.is_playing():
self.player.stop()
@staticmethod
def leave_player():
App.get_running_app().root.current = 'base'
def play_pause(self):
self.player.play_pause()
def quit(self, gg, **kwargs):
self.player.quit()
App.get_running_app().stop()
def set_slider(self, *args):
try:
pos = self.player.position() # in seconds as int
duration = self.player.duration() # in seconds as float
self.slider.value_normalized = pos / duration
except OMXPlayerDeadError:
self.leave_player()
def set_videopos(self, *args):
pos = self.player.position() # in seconds as int
duration = self.player.duration() # in seconds as float
if abs(pos / duration - self.slider.value_normalized) > 0.05:
self.player.set_position(self.slider.value_normalized * duration)
def change_size(self):
if self.minimized:
self.player.set_alpha(255)
else:
self.player.set_alpha(100)
self.minimized = not self.minimized
try:
player = OMXPlayer("/home/pi/Projects/MuzeApp/media.mp4",
args=[
'--loop', '-o', 'both', '--no-osd', '--win',
'0 0 ' + m_width + ' ' + m_height
],
dbus_name='org.mpris.MediaPlayer2.omxplayer1' +
str(random.randint(0, 99)))
except Exception as e:
print(e)
player.playEvent += lambda _: player_log.info("Play")
player.pauseEvent += lambda _: player_log.info("Pause")
player.stopEvent += lambda _: player_log.info("Stop")
time.sleep(5)
player.pause()
player.set_alpha(0)
#GPIO Mode (BOARD / BCM)
GPIO.setmode(GPIO.BCM)
#set GPIO Pins
GPIO_TRIGGER = 23
GPIO_ECHO = 24
#set GPIO direction (IN / OUT)
GPIO.setup(GPIO_TRIGGER, GPIO.OUT)
GPIO.setup(GPIO_ECHO, GPIO.IN)
measurements = []
lostDetectionCounterMax = lostInTime * 1000 / delay #Iteration counts for deactivation
is_playing = False
class VideoPlayer:
def __init__(self, root, message_handler, data, name):
self.root = root
self.message_handler = message_handler
self.data = data
self.omx_player = None
self.name = name
self.omx_running = False
self.status = 'EMPTY'
self.total_length = 0.0
self.bankslot_number = '*-*'
self.start = -1.0
self.end = -1.0
self.rate = 1
self.crop_length = 0.0
self.location = ''
self.load_attempts = 0
self.alpha = 0
def try_load(self, layer):
load_attempts = 0
while (load_attempts < 2):
load_attempts = load_attempts + 1
if self.load(layer):
print('load success')
return True
else:
print('load failed')
self.message_handler.set_message('ERROR', 'failed to load')
self.status = 'ERROR'
return False
def load(self, layer):
#try:
self.get_context_for_player()
is_dev_mode, first_screen_arg, second_screen_arg = self.set_screen_size_for_dev_mode(
)
arguments = [
'--no-osd', '--layer',
str(layer), '--adev', 'local', '--alpha', '0', first_screen_arg,
second_screen_arg
]
if not is_dev_mode:
arguments.append('--blank=0x{}'.format(
self.data.get_background_colour()))
self.status = 'LOADING'
print('the location is {}'.format(self.location))
if self.location == '':
self.status = 'EMPTY'
return True
self.omx_player = OMXPlayer(self.location,
args=arguments,
dbus_name=self.name)
self.omx_running = True
self.total_length = self.omx_player.duration(
) # <-- uneeded once self.duration stores float
if (self.end is -1):
self.end = self.total_length
if (self.start is -1):
self.start = 0
self.crop_length = self.end - self.start
print('{}: the duration is {}'.format(self.name, self.total_length))
if self.start > 0.9:
self.set_position(self.start - 0.9)
if 'show' in self.data.settings['sampler']['ON_LOAD']['value']:
self.set_alpha_value(255)
else:
self.set_alpha_value(0)
self.pause_at_start()
return True
#except (ValueError, SystemError) as e:
# print(e)
#self.message_handler.set_message('ERROR', 'load attempt fail')
#return False
def pause_at_start(self):
position = self.get_position()
start_threshold = round(self.start - 0.02, 2)
if position > start_threshold:
if self.status == 'LOADING':
self.status = 'LOADED'
self.omx_player.pause()
elif self.omx_running:
self.root.after(5, self.pause_at_start)
def start_video(self):
if 'show' in self.data.settings['sampler']['ON_START']['value']:
self.set_alpha_value(255)
else:
self.set_alpha_value(0)
if 'play' in self.data.settings['sampler']['ON_START']['value']:
self.status = 'PLAYING'
self.omx_player.play()
else:
self.status = 'START'
self.pause_at_end()
def pause_at_end(self):
position = self.get_position()
end_threshold = self.end - 0.2
if (position > end_threshold):
self.status = 'FINISHED'
self.omx_player.pause()
print('its paused at end!')
elif (self.omx_running):
self.root.after(5, self.pause_at_end)
def reload(self, layer):
self.exit()
self.omx_running = False
self.try_load(layer)
def is_loaded(self):
return self.status is 'LOADED'
def is_finished(self):
return self.status is 'FINISHED'
def get_position(self):
try:
return self.omx_player.position()
except:
print('{}: error get_position'.format(self.name))
return -1
def get_context_for_player(self):
next_context = self.data.get_next_context()
self.location = next_context['location']
#self.total_length = next_context['length']
self.start = next_context['start']
self.end = next_context['end']
self.bankslot_number = next_context['bankslot_number']
self.rate = next_context['rate']
def toggle_pause(self):
self.omx_player.play_pause()
self.status = self.omx_player.playback_status().upper()
def toggle_show(self):
if self.alpha > 127:
self.show_toggle_on = False
self.set_alpha_value(0)
else:
self.show_toggle_on = True
self.set_alpha_value(255)
def set_alpha_value(self, amount):
self.omx_player.set_alpha(amount)
self.alpha = amount
def seek(self, amount):
position = self.get_position()
after_seek_position = position + amount
if after_seek_position > self.start and after_seek_position < self.end:
self.set_position(after_seek_position)
#self.player.seek(amount)
else:
self.message_handler.set_message('INFO',
'can not seek outside range')
def change_rate(self, amount):
new_rate = self.rate + amount
if (new_rate > self.omx_player.minimum_rate()
and new_rate < self.omx_player.maximum_rate()):
updated_speed = self.omx_player.set_rate(new_rate)
self.rate = new_rate
print('max rate {} , min rate {} '.format(
self.omx_player.maximum_rate(),
self.omx_player.minimum_rate()))
return new_rate
else:
self.message_handler.set_message(
'INFO', 'can not set speed outside of range')
return self.rate
def set_position(self, position):
self.omx_player.set_position(position)
def exit(self):
try:
self.omx_player.quit()
self.status = 'EMPTY'
self.omx_running = False
except:
pass
def set_screen_size_for_dev_mode(self):
## only dev mode is needed now that auto handles all modes... can be removed probably ...
if self.data.settings['other']['DEV_MODE_RESET']['value'] == 'on':
return True, '--win', '50,350,550,750'
else:
aspect_mode = self.data.settings['video']['SCREEN_MODE']['value']
return False, '--aspect-mode', aspect_mode
class VideoPlayerScreen(Screen):
slider = ObjectProperty()
minimized = BooleanProperty(False)
@staticmethod
def clearbckgrnd():
Window.clearcolor = (0, 0, 0, 0)
@staticmethod
def addbckgrnd():
Window.clearcolor = (0, 0, 0, 1)
def play(self):
VIDEO_PATH = Path("../videos/20200308tagesthemen.mp4")
self.player = OMXPlayer(VIDEO_PATH,
args=['-o', 'alsa', '--layer', '10000'])
#self.player = OMXPlayer('/home/pi/Documents/Radio/videos/20200223tagesthemen.mp4')
self.player.set_video_pos(0, 0, 800, 480)
#self.player.hide_video()
#self.player.show_video()
self.player.set_alpha(100)
self.set_slider()
#Clock.schedule_once(self.quit, 20)
Clock.schedule_interval(self.set_slider, 3)
def playpause(self):
self.player.play_pause()
def quit(self, gg, **kwargs):
self.player.quit()
App.get_running_app().stop()
def set_slider(self, *args):
pos = self.player.position() # in seconds as int
duration = self.player.duration() # in seconds as float
#return pos/duration
self.slider.value_normalized = pos / duration
#return 0.5
def set_videopos(self, *args):
pos = self.player.position() # in seconds as int
duration = self.player.duration() # in seconds as float
if abs(pos / duration - self.slider.value_normalized) > 0.05:
self.player.set_position(self.slider.value_normalized * duration)
def change_size(self):
# pass
#width 800
#height 480
# check if crop as alternative
if self.minimized:
# self.player.set_video_pos(2,2,798,478)
self.player.set_alpha(255)
else:
# self.player.set_video_pos(2,2,798,418)
self.player.set_alpha(100)
self.minimized = not self.minimized
import os
from omxplayer.player import OMXPlayer
# from pathlib import Path
from time import sleep
import sys
# VIDEO_PATH = Path("./vid.mp4")
player = OMXPlayer("./vid.mp4", args=[])
player.set_alpha(125)
try:
sleep(5)
player.pause()
player.action(2)
sleep(1)
player.pause()
player.action(2)
player.play()
sleep(1)
player.action(2)
sleep(1)
player.action(2)
sleep(1)
except KeyboardInterrupt:
player.quit()
sys.exit()
# os.system('mkfifo t cat t | omxplayer --no-osd -b vid.mp4 &')
# os.system('echo p > t rm t')
player1 = None
player2 = None
video_playlist = [
VideoFile(1, "/media/pi/TOSHIBA1/Apocalyptic.mp4"),
VideoFile(2, "/media/pi/TOSHIBA1/ledtime.mp4")
]
player_log = logging.getLogger("Player")
player1 = OMXPlayer(video_playlist[0].path,
args='--win 0,0,1920,1080 --layer 2',
bus_address_finder=None,
Connection=None,
dbus_name='orb.mpris.MediaPlayer2.omxplayer1',
pause=True)
player1.set_alpha(200)
player2 = OMXPlayer(video_playlist[1].path,
args='--win 0,0,1920,1080 --layer 1',
bus_address_finder=None,
Connection=None,
dbus_name='orb.mpris.MediaPlayer2.omxplayer2',
pause=True)
player1.play()
sleep(player1.duration() - 1)
alpha1 = 200
player2.pause()
for x in range(6):
sleep(0.1)
values = sorted(values, reverse=True)
r = sum(values[:int(num_samples * 0.2)]) / int(num_samples * 0.2)
#print (' Average audio intensity is r', int(r))
time.sleep(.1)
stream.close()
p.terminate()
return r
if (__name__ == '__main__'):
VIDEO_PATH = "/home/pi/Desktop/rasto.mp4"
player = OMXPlayer(VIDEO_PATH, args=['--no-osd', '--loop', '-b'])
player.set_aspect_mode('fill')
player.set_alpha(0)
while (True):
r = audio_int() # To measure your mic levels
if r > 5000:
alpha = alpha + 10
if alpha > 255:
alpha = 255
else:
alpha = alpha - 10
if alpha < 0:
alpha = 0
print(alpha)
player.set_alpha(alpha)
import time
import gaugette.gpio
import gaugette.rotary_encoder
import os
from omxplayer.player import OMXPlayer
# from pathlib import Path
import sys
player = OMXPlayer("./vid.mp4", args=[])
player.set_alpha(50)
player.set_rate(0.5)
rate = 0.5
print(player.minimum_rate())
print(player.rate())
A_PIN = 1
B_PIN = 16
gpio = gaugette.gpio.GPIO()
encoder = gaugette.rotary_encoder.RotaryEncoder(gpio, A_PIN, B_PIN)
encoder.start()
#FIXME: weird issue where, while only comparing to delta of 1, decrease function somehow manages to decrease speed below 0.25 - possibly a timing issue?
try:
while True:
delta = encoder.get_cycles()
print(delta)
time.sleep(0.1)
except KeyboardInterrupt:
player.quit()
sys.exit()
class ScreenController:
video_playlist = []
player1 = None
player2 = None
index = None
number_of_cycles = 0
currentIndex = None
nextIndex = None
def __init__(self):
self.video_playlist = [VideoFile(1, "/media/pi/TOSHIBA1/Apocalyptic.mp4"), VideoFile(2, "/media/pi/TOSHIBA1/ledtime.mp4"), VideoFile(3, "/media/pi/TOSHIBA1/DiscoLightsVidevo.mov")]
self.index = 0
self.currentIndex = 0
self.nextIndex = self.currentIndex+1
self.player_log = logging.getLogger("Player")
def setup_player_one(self):
self.player1 = OMXPlayer(self.video_playlist[self.index].path, args='--win 0,0,1920,1080 --layer 2', dbus_name='orb.mpris.MediaPlayer2.omxplayer1', pause = True)
self.player1.playEvent += lambda _: self.player_log.info(" 1 Play")
self.player1.pauseEvent += lambda _: self.player_log.info("1 Pause")
self.player1.stopEvent += lambda _: self.player_log.info("1 Stop")
def setup_player_two(self):
self.player2 = OMXPlayer(self.video_playlist[self.index + 1].path, args='--win 0,0,1920,1080 --layer 1', dbus_name='orb.mpris.MediaPlayer2.omxplayer2', pause = True)
self.player2.playEvent += lambda _: self.player_log.info(" 2 Play")
self.player2.pauseEvent += lambda _: self.player_log.info("2 Pause")
self.player2.stopEvent += lambda _: self.player_log.info("2 Stop")
def start_playlist(self):
self.setup_player_one();
self.setup_player_two();
self.play_videos(True);
def play_videos(self, init = False):
# Load players with appropiate indexes
self.player1.load(self.video_playlist[self.currentIndex].path, True)
self.player2.load(self.video_playlist[self.nextIndex].path, True)
self.player1.set_alpha(255)
self.player2.set_alpha(255)
# Play for total duration - 1 second
self.player1.play()
sleep(self.player1.duration()-1)
# Fade player
self.fade_player_out(self.player1)
# Play for total duration - 1 second
self.player2.play()
sleep(self.player2.duration()-1)
# Set new current and next index
self.reset_indexes()
# Recursively call play videos
self.number_of_cycles = self.number_of_cycles + 1
if(self.number_of_cycles < 2):
self.play_videos(False)
# Fade player
self.fade_player_out(self.player2)
def reset_indexes(self):
if self.nextIndex + 1 >= len(self.video_playlist):
self.currentIndex = 0
else :
self.currentIndex = self.nextIndex + 1
if self.currentIndex + 1 >= len(self.video_playlist):
self.nextIndex = 0
else:
self.nextIndex = self.currentIndex + 1
print('AFTER CURRENT')
print(self.currentIndex)
print('AFTER NEXT')
print(self.nextIndex)
def fade_player_out(self, player):
alpha = 200
for x in range(6):
sleep(0.1)
alpha = alpha - 20
player.set_alpha(alpha)
alpha = 200
def get_remaining_seconds(self, player):
remaining_seconds = player.duration() - player.position()
return remaining_seconds
def is_nearly_finished(self, player):
amountPlayed = 0
if player.position() > 0:
amountPlayed = player.position();
percentPlayed = amountPlayed/player.duration()
print(percentPlayed)
if(percentPlayed > 0.9):
return True;
else:
return False;
import time
import gaugette.gpio
import gaugette.rotary_encoder
import os
from omxplayer.player import OMXPlayer
# from pathlib import Path
import sys
player = OMXPlayer("./output.mov", args=[])
player.set_alpha(150)
player.set_rate(0.5)
rate = 0.5
print(player.minimum_rate())
print(player.rate())
A_PIN = 1
B_PIN = 16
gpio = gaugette.gpio.GPIO()
encoder = gaugette.rotary_encoder.RotaryEncoder(gpio, A_PIN, B_PIN)
encoder.start()
#FIXME: weird issue where, while only comparing to delta of 1, decrease function somehow manages to decrease speed below 0.25 - possibly a timing issue?
try:
while True:
delta = encoder.get_cycles()
if delta != 0:
print "rotate %d" % delta
print "rate: " + str(rate)
if delta >= 5 and rate <= 1:
player.action(2)
rate = rate + 0.125
else:
class ScreenMovie(LcarsScreen):
def setup(self, all_sprites):
############ Start base screen #############
### BASE_ui
all_sprites.add(LcarsBackgroundImage(), layer=0)
self.ui_screen_base = all_sprites.get_sprites_from_layer(0)
all_sprites.add(LcarsTab(colours.COM2, 3, (50, 80)), layer=1)
all_sprites.add(LcarsImageBlock(colours.BLUE5,
pos=(50, 115),
rectSize=(1688, 38)),
layer=1)
all_sprites.add(LcarsTab(colours.COM2, 4, (50, 1810)), layer=1)
all_sprites.add(LcarsTab(colours.COM2, 1, (953, 50)), layer=1)
all_sprites.add(LcarsImageBlock(colours.BLUE5,
pos=(953, 1361),
rectSize=(443, 77)),
layer=1)
all_sprites.add(LcarsBlockSmall(
colours.BLUE6, (953, 116),
"REWIND",
self.rewHandler,
textSize=.75,
fontFace="assets/OpenSansCondensed-Bold.ttf"),
layer=2)
all_sprites.add(LcarsBlockSmall(
colours.BLUE6, (953, 365),
"PLAY",
self.playHandler,
textSize=.75,
fontFace="assets/OpenSansCondensed-Bold.ttf"),
layer=2)
all_sprites.add(LcarsBlockSmall(
colours.BLUE6, (953, 614),
"F F",
self.ffHandler,
textSize=.75,
fontFace="assets/OpenSansCondensed-Bold.ttf"),
layer=2)
all_sprites.add(LcarsBlockSmall(
colours.BLUE6, (953, 863),
"STOP",
self.stopHandler,
textSize=.75,
fontFace="assets/OpenSansCondensed-Bold.ttf"),
layer=2)
all_sprites.add(LcarsBlockSmall(
colours.BLUE6, (953, 1112),
"BASE",
self.mainHandler,
textSize=.75,
fontFace="assets/OpenSansCondensed-Bold.ttf"),
layer=2)
all_sprites.add(LcarsImageBlock(colours.BLUE5,
pos=(953, 1361),
rectSize=(443, 77)),
layer=1)
all_sprites.add(LcarsTab(colours.COM2, 2, (953, 1810)), layer=1)
self.fileList = LcarsTextBlock(colours.BLUE6, (94, 365),
self.dirlist(),
rectSize=(1694, 781))
all_sprites.add(self.fileList, layer=3)
all_sprites.add(LcarsImageBlock(colours.BLUE2,
pos=(94, 116),
text="01-3906",
rectSize=(243, 100)),
layer=3)
all_sprites.add(LcarsImageBlock(colours.BLUE3,
pos=(200, 116),
text="96-4783",
rectSize=(243, 500)),
layer=3)
all_sprites.add(LcarsImageBlock(colours.BLUE4,
pos=(706, 116),
text="32-6487",
rectSize=(243, 163)),
layer=3)
all_sprites.add(LcarsElbow(colours.BLUE5, 0, (875, 116)), layer=3)
all_sprites.add(LcarsImageBlock(colours.BLUE4,
pos=(904, 398),
rectSize=(1074, 43)),
layer=3)
all_sprites.add(LcarsImageBlock(colours.BLUE3,
pos=(875, 1478),
rectSize=(44, 72)),
layer=3)
all_sprites.add(LcarsElbow(colours.BLUE5, 3, (875, 1528)), layer=3)
self.file_address = LcarsText(
colours.BLACK, (900, 450),
"NO MEDIA SELECTED",
textSize=.75,
fontFace="assets/OpenSansCondensed-Bold.ttf")
all_sprites.add(self.file_address, layer=3)
self.list_block = all_sprites.get_sprites_from_layer(3)
#self.VIDEO_1_PATH = "./assets/video/LittleShopofHorrors1960Color.mp4"
### sound effects
self.beep1 = Sound("assets/audio/panel/201.wav")
self.lastClockUpdate = 0
#Sound("assets/audio/panel/220.wav").play()
############ End base screen #############
def dirlist(self, dirPath='./assets/video'):
#os.scandir(dirPath)
file_names = []
for item in os.scandir(dirPath):
if item.is_file() or item.is_dir():
file_names.append(item.name)
return file_names
def update(self, screenSurface, fpsClock):
if pygame.time.get_ticks() - self.lastClockUpdate > 500:
if self.fileList.visible == True:
if self.fileList.get_state() == None:
self.file_address.setText("NO MEDIA SELECTED")
else:
self.file_address.setText(self.fileList.get_state())
self.lastClockUpdate = pygame.time.get_ticks()
LcarsScreen.update(self, screenSurface, fpsClock)
def handleEvents(self, event, fpsClock):
if event.type == pygame.MOUSEBUTTONDOWN:
self.beep1.play()
if event.type == pygame.MOUSEBUTTONUP:
return False
def playHandler(self, item, event, clock):
try:
self.player.play_pause()
except:
try:
self.VIDEO_1_PATH = './assets/video/' + self.fileList.get_state(
)
self.player = OMXPlayer(
self.VIDEO_1_PATH,
dbus_name='org.mpris.MediaPlayer2.omxplayer1')
self.player.set_aspect_mode('stretch')
self.player.set_video_pos(116, 94, 1804, 947)
self.player.set_alpha(255)
self.showhide(self.list_block)
except:
pass
def rewHandler(self, item, event, clock):
try:
self.player.action(omxkey.REWIND)
except:
pass
def showhide(self, listofitems):
for items in listofitems:
items.visible = not items.visible
def stopHandler(self, item, event, clock):
try:
self.player.stop()
self.showhide(self.list_block)
except:
pass
def ffHandler(self, item, event, clock):
try:
self.player.action(omxkey.FAST_FORWARD)
except:
pass
###### Screen Handling #####
def mainHandler(self, item, event, clock):
try:
self.player.stop()
except:
pass
from screens.base import ScreenBase
self.loadScreen(ScreenBase())
def logoutHandler(self, item, event, clock):
from screens.authorize import ScreenAuthorize
self.loadScreen(ScreenAuthorize())
def libraryHandler(self, item, event, clock):
from screens.library import ScreenLibrary
self.loadScreen(ScreenLibrary())
