class Video_Player:
def __init__(self, player_id, video_path):
self.player_id = player_id
self.video_path = video_path
self.player = OMXPlayer(video_path,
args=['--loop'],
dbus_name="org.mpris.MediaPlayer2.player" +
player_id)
sleep(2)
#
def load(self, video_path):
self.player.hide_video()
self.video_path = video_path
self.player.load(video_path)
def play(self):
self.player.play()
self.player.show_video()
def pause(self):
self.player.hide_video()
self.player.pause()
def stop(self):
self.player.stop()
def single_video_player_looper(video_clip_path, sleep_minutes, test_mode):
"""
Loops a single video.
Arguments
video_clip_path string
The path of the video clip being played.
sleep_minutes integer or float
Length of time to pause between loops.
test_mode boolean
True of False. If test_mode is True, clip is not
played in full screen mode.
"""
test_mode_length = "720"
test_mode_width = "360"
play_message = "{} - Playing {}".format(current_time(), video_clip_path)
if test_mode is True:
player = OMXPlayer(video_clip_path,
args=[
"--no-osd", "--loop", "--win",
"0, 0, {0}, {1}".format(test_mode_length,
test_mode_width)
])
play_message = "{} in test mode".format(play_message)
else:
player = OMXPlayer(video_clip_path,
args=[
"--no-osd", "--loop", "--orientation", "180",
"--aspect-mode", "fill"
])
print(play_message)
print("{} - {} minute(s) pause between each play".format(
current_time(), sleep_minutes))
try:
player.pause()
while True:
print(play_message)
player.play()
sleep(player.duration())
player.pause()
player.set_position(0.0)
if sleep_minutes > 0:
if sleep_minutes < 1:
sleep_message = "{} seconds".format(
int(60.0 * sleep_minutes))
else:
sleep_message = "{} minute(s)".format(sleep_minutes)
print("{} - Sleeping {} before starting again".format(
current_time(), sleep_message))
sleep(60 * sleep_minutes)
except KeyboardInterrupt:
print("{} - Exiting".format(current_time()))
player.quit()
sys.exit()
def play_film(filename="demo.mp4", duration=0, position=0):
debug("\nfilename:", filename)
debug(" position:", position)
debug(" duration:", duration)
trim_from_end = 0.5
#trim_from_end = 0
player = OMXPlayer(filename)
player.set_position(0.0)
debug(" pre-play pos:", player.position())
player.play()
# check and set position
full_length = player.duration()
# if the position is imposible, set it to 0
if position <= 0 or position > full_length:
position = 0.0
player.set_position(position)
# check and set duration
length_to_end = player.duration()
# if duration is imposible, set it to the length_to_end
if duration == 0 or duration > length_to_end:
wait = length_to_end - trim_from_end
else:
wait = duration
if wait < 0:
wait = 0
debug(" full length: ", full_length)
debug(" length to end: ", length_to_end)
debug(" wait: ", wait)
sleep(wait)
debug(" post sleep pos:", player.position())
player.pause()
player.quit()
debug(" post pause pos:", player.position())
return True
def play_film(filename="demo.mp4", duration=0, position=0):
debug("\nfilename:", filename)
debug(" position:", position)
debug(" duration:", duration)
trim_from_end = 0.5
#trim_from_end = 0
player = OMXPlayer(filename)
player.set_position(0.0)
debug(" pre-play pos:", player.position())
player.play()
# check and set position
full_length = player.duration()
# if the position is imposible, set it to 0
if position <= 0 or position > full_length:
position = 0.0
player.set_position(position)
# check and set duration
length_to_end = player.duration()
# if duration is imposible, set it to the length_to_end
if duration == 0 or duration > length_to_end:
wait = length_to_end - trim_from_end
else:
wait = duration
if wait < 0:
wait = 0
debug(" full length: ", full_length)
debug(" length to end: ", length_to_end)
debug(" wait: ", wait)
sleep(wait)
debug(" post sleep pos:", player.position())
player.pause()
player.quit()
debug(" post pause pos:", player.position())
return True
def playerFactory(filename, logger):
'''
Creates an instance of OMXPlayer the starting state
we desire.
If filename does not exist (or is None), generates a Mock devices
with equivalent functionality (but no media output)
'''
if filename is not None and not os.path.isfile(filename):
logger.warning("Media file: {} DOES NOT EXIST".format(filename))
filename = None # force try to fail quickly below
try:
player = OMXPlayer(filename,
dbus_name='org.mpris.MediaPlayer2.omxplayer1',
args=['-b', '-o', 'both'])
except Exception as e:
player = omxPlayerMock(filename)
player.playEvent += lambda _: logger.debug("Play")
player.pauseEvent += lambda _: logger.debug("Pause")
player.stopEvent += lambda _: logger.debug("Stop")
while True:
try:
player.hide_video()
player.pause()
break
except Exception as e:
logger.exception("Exception in playerFactory")
sys.exit(1)
return player
def init_player_obj():
# Initialize the OMXPlayer and sleep to load in video
prod_args = ['--no-osd', '--vol', str(VIDEO_VOLUME), '-o', VIDEO_AUDIO_SOURCE]
dev_args = ['--win', '0,40,600,400', '--no-osd', '--vol', str(VIDEO_VOLUME), '-o', VIDEO_AUDIO_SOURCE]
player = OMXPlayer(VIDEO_PATH, dev_args, pause=True)
player.pause()
sleep(5)
vid_tree_root = create_beyblade_vid_tree()
player_obj = VidPlayer(player, vid_tree_root)
print("Player ready")
return player_obj
def run(self, filename):
global omxplayer
gpio_control = GPIOControl()
return_code = 0 # OK
try:
omxplayer = OMXPlayer(filename, OMXPLAYER_ARGS, None, None, True)
omxplayer.pause()
print 'Video player is armed!'
print 'Video duration = ' + str(omxplayer.duration())
#while(gpio_control.motion_detected()):
# continue;
gpio_control.start()
#loop_num = int(omxplayer.duration() / duration_sect)
i = duration_sect
last_sect = False
while True:
status = 0
while status != 1:
pos = omxplayer.position()
#print str(pos)
if pos + 0.01 >= i:
if last_sect:
omxplayer.set_position(0)
last_sect = False
i = 0
status = 1
continue
if gpio_control.motion_detected() == 0:
gpio_control.turn_off_relay()
omxplayer.pause()
i += duration_sect
if i + duration_sect >= omxplayer.duration():
last_sect = True
except IOError as e:
return_code = -1
except KeyboardInterrupt:
print 'KeyboardInterrupt'
omxplayer.quit()
print('EXIT')
GPIO.cleanup()
return return_code
def play_video():
player = OMXPlayer('video.mp4',
dbus_name='org.mpris.MediaPlayer2.omxplayer1',
args=['--loop', '--no-osd'])
sleep(2.5)
player.set_position(5)
player.pause()
sleep(2)
player.set_aspect_mode('stretch')
#player.set_fullscreen()
# player.set_video_pos(0, 0, 200, 200)
player.play()
return player
def initPlayer(self, video, dbusName, log):
player = OMXPlayer(video.path, dbus_name=dbusName, args=['--loop'])
player.hide_video()
player.pause()
player.set_position(video.start)
player.set_volume(video.volume)
player.set_aspect_mode(video.aspect)
player.active = False
return player
class Player:
def __init__(self, url):
self.url = url
self.player = None
self.state = True
self.playlist = False
self._play = True
def start(self):
if isinstance(self.url, string_types):
cmd = 'youtube-dl -g -f best {0}'.format(self.url)
yt_dl = subprocess.Popen(cmd,
shell=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
(url, err) = yt_dl.communicate()
if yt_dl.returncode != 0:
sys.stderr.write(err)
print('error')
yurl = url.decode('UTF-8').strip()
self.player = OMXPlayer(yurl, args=['-o', 'hdmi'])
return self.player.duration()
def stop(self):
self.player.stop()
self._play = False
self.player = None
return False
def skip(self):
if self.playlist == True:
self.player.stop()
return True
else:
self.player.stop()
return False
def toggle(self):
#false = not playing // true = playing
if self.state == True:
self.state = False
self.player.pause()
elif self.state == False:
self.state = True
self.player.play()
else:
return False
def is_play(self):
return self.player.can_control()
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()
def initPlayer(self, mediaFile):
logger.info("Creating main omxplayer with file : " + mediaFile.path)
dbusName = 'org.mpris.MediaPlayer2.omxplayer1'
player = OMXPlayer(mediaFile.path,
dbus_name=dbusName,
args=['--no-osd', '-o', self.outputDevice])
player.pause()
self.paused = True
return player
def init_player_obj():
# Initialize the OMXPlayer and sleep to load in video
prod_args = [
'--no-osd', '--vol',
str(VIDEO_VOLUME), '-o', VIDEO_AUDIO_SOURCE
]
dev_args = [
'--win', '0,40,600,400', '--no-osd', '--vol',
str(VIDEO_VOLUME), '-o', VIDEO_AUDIO_SOURCE
]
player = OMXPlayer(VIDEO_PATH, dev_args, pause=True)
player.pause()
sleep(5)
vid_tree_root = create_beyblade_vid_tree()
player_obj = VidPlayer(player, vid_tree_root)
print("Player ready")
return player_obj
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()
#!/usr/bin/env python3
from omxplayer.player import OMXPlayer
from pathlib import Path
from time import sleep
VIDEO_PATH00 = Path("/home/pi/Miac/01.mp4")
player00 = OMXPlayer(VIDEO_PATH00, args='-b')
player00.pause()
player00.hide_video()
sleep(2)
VIDEO_PATH = Path("/home/pi/Miac/03.mp4")
player = OMXPlayer(VIDEO_PATH)
sleep(1)
player.quit()
player.load(VIDEO_PATH)
sleep(2)
player.pause()
print(player.stopEvent)
sleep(2)
player.hide_video()
sleep(2)
player.show_video()
player.quit()
sleep(3)
player00.quit()
# pg.mixer.set_num_channels(12)
#
# mixer = pg.mixer
# channel0 = mixer.Channel(0)
# channel1 = mixer.Channel(1)
# music to play
# office_theme = mixer.Sound("music/office_theme_song.wav")
# agni_kai = mixer.Sound("music/last_agni_kai.wav")
# succession_theme = mixer.Sound("music/succession_theme.wav")
# music to play
office_theme = OMXPlayer(Path('music/office_theme_song.wav'),
dbus_name='org.mpris.MediaPlayer2.omxplayer5',
args='--loop')
office_theme.pause()
agni_kai = OMXPlayer(Path('music/last_agni_kai.wav'),
dbus_name='org.mpris.MediaPlayer2.omxplayer6',
args='--loop')
agni_kai.pause()
succession_theme = OMXPlayer(Path('music/succession_theme.wav'),
dbus_name='org.mpris.MediaPlayer2.omxplayer7',
args='--loop')
succession_theme.pause()
fun_song = OMXPlayer(Path('music/fun_song.wav'),
dbus_name='org.mpris.MediaPlayer2.omxplayer8',
args='--loop')
fun_song.pause()
thrones_theme = OMXPlayer(Path('music/thrones_theme.wav'),
dbus_name='org.mpris.MediaPlayer2.omxplayer9',
args='--loop')
from time import sleep
import logging
logging.basicConfig(level=logging.INFO)
VIDEO_1_PATH = "../tests/media/test_media_1.mp4"
player_log = logging.getLogger("Player 1")
player = OMXPlayer(VIDEO_1_PATH,
dbus_name='org.mpris.MediaPlayer2.omxplayer1')
player.playEvent += lambda _: player_log.info("Play")
player.pauseEvent += lambda _: player_log.info("Pause")
player.stopEvent += lambda _: player_log.info("Stop")
# it takes about this long for omxplayer to warm up and start displaying a picture on a rpi3
sleep(2.5)
player.set_position(5)
player.pause()
sleep(2)
player.set_aspect_mode('stretch')
player.set_video_pos(0, 0, 200, 200)
player.play()
sleep(5)
player.quit()
class VideoPlayer:
def __init__(self):
self.process = None
self.cmd = ""
self.args = ""
self.path = ""
self.player = None
def composeCommand(self):
# split the command and use
# the 'glob' module to expand the * wildchar
#self.cmd = 'omxplayer --loop --no-osd --win "0 0 {} {}" --crop {},{},{},{} {}'.format(SCREENW, SCREENH, CROPX1, CROPY1, CROPX2, CROPY2, videoFileLocation)
self.cmd = 'omxplayer --no-osd'
self.args = shlex.split(self.cmd)
self.args = self.args[:-1] + glob.glob(self.args[-1])
def loadVideo(self, path):
self.path = path
print(self.path)
#~ self.cmd = 'omxplayer --no-osd {}'.format(videoName)
#~ self.args = shlex.split( self.cmd )
#~ self.args = self.args[:-1] + glob.glob( self.args[-1] )
#~ # Open omxplayer
#~ try:
#~ print( " load the video " )
#~ self.process = Popen( self.args, stdin=PIPE, stdout=PIPE )
#~ print("This is the omxplayer process id: ", self.process.pid )
#~ except:
#~ print("something went wrong")
#~ quit()
def play(self):
#~ print("play")
if self.player is None:
self.player = OMXPlayer(self.path,
args=['--no-osd', '--adev', 'local'])
#~ self.player.play()
#~ self.process.stdin.write(b'i')
#~ self.process.stdin.flush()
def stop(self):
#~ print("stop")
if self.player is not None:
self.player.quit()
self.player = None
def pause(self):
#~ print("pause")
self.player.pause()
#self.process.stdin.write(b'p')
#self.process.stdin.flush()
def kill(self):
# quit omxplayer
self.player.stop()
#~ self.process.stdin.write(b'q')
#~ self.process.stdin.flush()
#~ self.process.stdin.close()
def is_ended(self):
if self.player is not None:
#~ print(self.player.position())
# ~ if self.player.position() > 10 or self.player.duration() - self.player.position() < 0.2:
if self.player.duration() - self.player.position() < 1:
return True
else:
return False
def next(self, videoName):
self.stop()
self.loadVideo(videoName)
self.play()
class MusicPlayer():
def __init__(self, playlist, logger):
self.playlist = playlist
self.idx = 0
self.logger = logger
self.omxplayer = None
def get_song_real_url(self, song_url):
try:
htmldoc = urlopen(song_url).read().decode('utf8')
except:
return (None, None, 0, 0)
content = json.loads(htmldoc)
try:
song_link = content['data']['songList'][0]['songLink']
song_name = content['data']['songList'][0]['songName']
song_size = int(content['data']['songList'][0]['size'])
song_time = int(content['data']['songList'][0]['time'])
except:
self.logger.error('get real link failed')
return (None, None, 0, 0)
return song_name, song_link, song_size, song_time
def play(self):
self.logger.debug('MusicPlayer play')
song_url = "http://music.baidu.com/data/music/fmlink?" +\
"type=mp3&rate=320&songIds=%s" % self.playlist[self.idx]['id']
song_name, song_link, song_size, song_time =\
self.get_song_real_url(song_url)
self.play_mp3_by_link(song_link, song_name, song_size, song_time)
def play_mp3_by_link(self, song_link, song_name, song_size, song_time):
if song_link:
self.omxplayer = OMXPlayer(song_link, ['-o', 'both'])
else:
self.omxplayer = None
def pick_next(self):
self.idx += 1
if self.idx > len(self.playlist) - 1:
self.idx = 0
if self.omxplayer and self.omxplayer.can_play():
self.omxplayer.quit()
def pick_previous(self):
self.idx -= 1
if self.idx < 0:
self.idx = 0
if self.omxplayer and self.omxplayer.can_play():
self.omxplayer.quit()
def pause(self):
if self.omxplayer and self.omxplayer.can_pause():
self.omxplayer.pause()
def resume(self):
if self.omxplayer and self.omxplayer.can_play():
self.omxplayer.play()
def is_play_done(self):
try:
return self.omxplayer is None or\
self.omxplayer.can_play() is None
except Exception as e:
self.logger.error(e)
return False
def stop(self):
self.playlist = []
if self.omxplayer:
self.omxplayer.quit()
class OmxPlayer(BasePlayer):
def __init__(self, hplayer, name):
super().__init__(hplayer, name)
self._validExt = [
'mp4', 'm4v', 'mkv', 'avi', 'mov', 'flv', 'mpg', 'wmv', '3gp',
'mp3', 'aac', 'wma', 'wav', 'flac', 'aif', 'aiff', 'm4a', 'ogg',
'opus', 'webm', 'jpg', 'jpeg', 'gif', 'png', 'tif', 'tiff'
]
self._thread = None
self._runflag = threading.Event()
self.player = None
############
## private METHODS
############
# MPV THREAD
def _mpv_thread(self):
self.emit('player-ready')
self.emit('status', self.status())
self.log("player ready")
while self.isRunning():
self._runflag.wait(0.37)
if self._runflag.isSet():
self.update('time', round(self.player.position(), 2))
time.sleep(0.05)
self.isRunning(False)
return
def _onPlay(self, p):
self.update('isPlaying', True)
self.update('isPaused', False)
self.emit('playing')
self._runflag.set()
self.log('play')
def _onPause(self, p):
self.update('isPlaying', False)
self.update('isPaused', True)
self.emit('paused')
self._runflag.clear()
self.log('pause')
def _onExit(self, p, c):
self.player._connection._bus.close()
self.player._connection = None
self.player = None
self._runflag.clear()
self.update('isPlaying', False)
self.update('isPaused', False)
self.emit('end')
self.emit('stopped')
self.log('stop')
##########
## Inherited "abstract" METHODS overloads
##########
#
# Start the player:
# - instantiate mpv subprocess
# - connect IPC socket i/o
#
def _start(self):
# Playback thread
self._thread = threading.Thread(target=self._mpv_thread)
self._thread.start()
#
# Exit the player
# - stop subprocess
# - close IPC socket
#
def _quit(self):
self.isRunning(False)
if self._thread:
# self.log("stopping process thread")
self._thread.join()
self.log("stopped")
def _play(self, path):
self.log("play", path)
if self.player:
self.player.quit()
self.player = OMXPlayer(path,
dbus_name='org.mpris.MediaPlayer2.omxplayer2')
self.player.playEvent += self._onPlay
self.player.pauseEvent += self._onPause
# self.player.stopEvent += self._onStop
self.player.exitEvent += self._onExit
self.player.play()
# self.player.set_video_pos(0,0,100,100)
# self.update('duration', round(self.player.duration(),2))
def _stop(self):
if self.player:
self.player.stop()
def _pause(self):
if self.player:
self.player.pause()
def _resume(self):
if self.player:
self.player.play()
def _seekTo(self, milli):
if self.player:
self.player.set_position(milli / 1000)
# self.log("seek to", milli/1000)
def _skip(self, milli):
if self._status['time'] + milli / 1000 < self._status['duration']:
if self.player:
self.player.seek(milli / 1000)
# self.log("skip", milli/1000)
def _applyVolume(self, volume):
if self.player:
self.player.set_volume(volume / 10.0)
self.log("VOLUME to", volume)
class VideoPlayer(object):
def __init__(self):
self.player = None
self.logger = LogObject('Video Player')
self.args = ['-b']
self.STATUS_MAP = {
'volume': self._videoVolume,
'length': self._videoLength,
'playback': self._playbackStatus,
'position': self._videoPosition
}
self.CONTROL_MAP = {
'playpause': self._playPause,
'stop': self._stop,
'mute': self._mute,
'unmute': self._unmute,
'play': self._play,
'pause': self._pause
}
self.SEEK_MAP = {'relative': self._seek, 'absolute': self._setPosition}
def playUrl(self, url):
if not self.player:
self.player = OMXPlayer(url, args=self.args)
else:
self.player.load(url)
def setVolume(self, volume):
self._checkPlayerExist()
try:
self.player.set_volume(volume)
return self.logger.writeAndReturnLog('VOL0003', {'volume': volume})
except (AttributeError, OMXPlayerDeadError):
self._raisePlayerError('VOL0004')
def sendCommand(self, command):
self._checkPlayerExist()
try:
return self.CONTROL_MAP[command]()
except (AttributeError, OMXPlayerDeadError):
self._raisePlayerError('CTRL0003')
def _stop(self):
self.player.quit()
return self.logger.writeAndReturnLog('CTRL0004')
def _mute(self):
self.player.mute()
return self.logger.writeAndReturnLog('CTRL0006')
def _unmute(self):
self.player.unmute()
return self.logger.writeAndReturnLog('CTRL0007')
def _playPause(self):
self.player.play_pause()
return self.logger.writeAndReturnLog('CTRL0005')
def _play(self):
self.player.play()
return self.logger.writeAndReturnLog('CTRL0008')
def _pause(self):
self.player.pause()
return self.logger.writeAndReturnLog('CTRL0009')
def seek(self, option, time):
self._checkPlayerExist()
try:
return self.SEEK_MAP[option](time)
except (AttributeError, OMXPlayerDeadError):
self._raisePlayerError('SEEK0007')
def _seek(self, seekTime):
self.player.seek(seekTime)
return self.logger.writeAndReturnLog('SEEK0005',
{'position': seekTime})
def _setPosition(self, position):
if position > self._videoLength() or position < 0:
self._raisePlayerError('SEEK0004', {'position': position})
self.player.set_position(position)
return self.logger.writeAndReturnLog('SEEK0006',
{'position': position})
def _checkPlayerExist(self):
if not self.player:
self._raisePlayerError('CTRL0003')
def videoStatus(self, status):
if not self.player:
self._raisePlayerError('STAT0003')
try:
return self.STATUS_MAP[status]()
except (AttributeError, OMXPlayerDeadError):
self._raisePlayerError('STAT0003')
def _videoPosition(self):
return self.player.position()
def _videoLength(self):
return self.player.duration()
def _videoVolume(self):
return self.player.volume()
def _playbackStatus(self):
return self.player.playback_status()
def _raisePlayerError(self, logReference, variablesDict={}):
returnMsg = self.logger.writeAndReturnLog(logReference, variablesDict)
raise PlayerError(returnMsg)
print("--------------")
print(GPIO.input(button))
print("--------------")
VIDEO_PATH = Path("cam_3d.mp4")
BLACK_PATH = Path("black_screen.mp4")
player_log = logging.getLogger("Player 1")
player_action = OMXPlayer(VIDEO_PATH,
dbus_name='org.mpris.MediaPlayer2.omxplayer1')
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()
class VideoPlayer:
def __init__(self,
VIDEO_NAME,
IMAGE_WIDTH,
IMAGE_HEIGHT,
USING_VLC=False,
audioPlayerRef=None,
pygameRef=None):
self.USING_VLC = USING_VLC
self.VIDEO_FILE = VIDEO_NAME
#get a reference to the audio player
self.audioPlayerRef = audioPlayerRef
self.player = None
if self.USING_VLC:
if (pygameRef == None):
print(
"VIDEOPLAYER ERROR: don't have a reference to pygame window!"
)
self.vlcInstance = vlc.Instance()
#tmp (remove comment here) self.media = self.vlcInstance.media_new('/home/pi/code/' + self.VIDEO_FILE)
self.media = self.vlcInstance.media_new(self.VIDEO_FILE)
# Create new instance of vlc player
self.player = self.vlcInstance.media_player_new()
self.player.stop()
# Pass pygame window id to vlc player, so it can render its contents there.
win_id = pygameRef.display.get_wm_info()['window']
self.player.set_xwindow(win_id)
self.player.set_media(self.media)
# TODO: correct the line below
mouse.move(IMAGE_WIDTH, IMAGE_HEIGHT, True, 0)
else:
self.omx_stdin = None
self.omx_process = None
self.tot_sec = None
self.STARTED = False
self.PAUSED = False
if (self.USING_VLC):
print("VIDEOPLAYER: using VLC")
else:
print("VIDEOPLAYER: using OMX")
# info about video
self.info_video = {}
self.chapters = self.get_chapters()
self.curr_chapter = 0
print('VIDEOPLAYER: info video \n\t# chapter:{}\n\t{}'.format(
len(self.chapters), self.chapters))
def start(self):
print("VIDEOPLAYER: Starting video...")
self.STARTED = True
self.PAUSED = False
if self.USING_VLC:
self.player.play()
else:
if self.player:
self.player.quit()
self.player = None
self.player = OMXPlayer(self.VIDEO_FILE, args=['--no-osd'])
time.sleep(1)
def stop(self):
print("VIDEOPLAYER: Stopping video...")
self.STARTED = False
#TODO: is it necessary
#self.PAUSED = True
if self.USING_VLC:
self.player.stop()
else:
self.player.quit()
self.player = None
def pause(self):
print("VIDEOPLAYER: Pausing video...")
# TODO: add some code here??
#self.PAUSED = True #??
def needUpdate(self):
return (self.STARTED and self.player)
def update(self):
#print("VIDEOPLAYER: update")
if self.USING_VLC:
if self.player.get_length() - self.player.get_time(
) < 2000 and not self.PAUSED:
print("VIDEOPLAYER VLC: a due secondi dalla fine")
self.PAUSED = True
self.player.set_pause(1)
else:
if self.player.duration() - self.player.position(
) < 2 and not self.PAUSED:
print('VIDEOPLAYER OMX: a due secondi dalla fine')
self.PAUSED = True
self.player.pause()
#self.printStatus()
def printStatus(self):
print("VIDEOPLAYER: started {}, paused {}".format(
self.STARTED, self.PAUSED))
def changeChapter(self, chapter):
print("VIDEOPLAYER: change chapter")
if chapter != 0:
print("VIDEOPLAYER: chapter != 0")
# in origin era così riga commentata)
#if self.PAUSED == True:
#if self.PAUSED == False:
#print("VIDEOPLAYER: paused is true")
if self.USING_VLC:
self.player.set_pause(0)
else:
if self.player:
self.player.play()
self.PAUSED = False
if self.USING_VLC:
self.handle_chapter_vlc(chapter)
else:
self.handle_chapter_omx(chapter)
"""
if self.USING_VLC:
if self.player.get_length() - self.player.get_time() < 2000 and not self.PAUSED:
self.PAUSED = True
self.player.set_pause(1)
else:
if self.player.duration() - self.player.position() < 2 and not self.PAUSED:
print('...pausing video')
self.PAUSED = True
self.player.pause()
"""
"""
#not using language right now
# return to italian language
if self.audioPlayerRef:
self.audioPlayerRef.switchToITA()
"""
def isPlaying(self):
return self.STARTED
def switch_language(self):
print("Video: switch language...")
if self.audioPlayerRef:
self.audioPlayerRef.switchLanguage()
if self.player:
self.player.set_position(0)
# get all chapters of video file
def get_chapters(self):
buff = sp.check_output([
"ffmpeg", "-i", self.VIDEO_FILE, "-f", 'ffmetadata', "file.txt",
'-y'
],
stderr=sp.STDOUT,
universal_newlines=True)
#print(buff)
self.chapters = []
self.chapters_info = {}
names = []
i = 0
for line in iter(buff.splitlines()):
m = re.match(
r".*Chapter #(\d+:\d+): start (\d+\.\d+), end (\d+\.\d+).*",
line)
if m != None and m.group(1) not in names:
names.append(m.group(1))
self.chapters.append({
"name": i + 1,
"start": float(m.group(2)),
"end": float(m.group(3))
})
i = i + 1
if len(self.chapters) == 2:
self.chapters[len(self.chapters) - 1]['name'] = 3
return self.chapters
# check where i am:
# 0: before chapter 1
# 1: chapter 1
# 2: chapter 2
# 3: chapter 3
# 10 last chapter
def pos2chapter(self, pos):
# ~ print('actual position', pos)
for x in self.chapters:
if pos >= x['start'] / 1000 and pos <= x['end']:
return x['name']
if pos < self.chapters[0]['start']:
return 0
if pos > self.chapters[len(self.chapters) - 1]['end']:
return self.chapters[len(self.chapters) - 1]['name']
# vlc chapter manager
def handle_chapter_vlc(self, c):
print('VIDEOPLAYER VLC: going to', len(self.chapters), c)
if len(self.chapters) == 2:
if c == 3:
print(1)
self.player.set_chapter(1)
if c == 1:
print(2)
self.player.set_chapter(0)
else:
self.player.set_chapter(c - 1)
self.audioPlayerRef.stop()
if c == 1:
self.audioPlayerRef.start()
self.curr_chapter = c
# chapter manager
def handle_chapter_omx(self, c):
self.curr_chapter = self.pos2chapter(self.player.position())
print('VIDEOPLAYER OMX: Handle chapter: from', self.curr_chapter, 'to',
c)
# ~ if c != curr_chapter and c in [f['name'] for f in chapters]:
if c in [f['name'] for f in self.chapters]:
cpt = self.chapters[[
y for y, x in enumerate(self.chapters) if x['name'] == c
][0]]
time.sleep(1)
print('going to', cpt['start'])
self.player.set_position(cpt['start'])
time.sleep(1)
self.audioPlayerRef.stop()
if c == 1:
self.audioPlayerRef.start()
self.curr_chapter = c
def kill(self):
print("Kill video...")
if self.USING_VLC:
self.player.stop()
else:
self.player.quit()
self.player = None
videos.append(video('../shared/matrix.mp4', None, 'fill', 0, 1.0))
videos.append(video('../shared/river.mp4', None, 'fill', 0, 0.5))
videos.append(video('../shared/testcard.mp4', None, 'fill', 0, 0.35))
videos.append(video('../shared/timer.mp4', None, 'fill', 10, 0.35))
player_log = logging.getLogger("Player 1")
# Create player 1
player1 = OMXPlayer(videos[0].path, dbus_name='org.mpris.MediaPlayer2.omxplayer1', args=['--loop'])
player1.playEvent += lambda _: player_log.info("Play")
player1.pauseEvent += lambda _: player_log.info("Pause")
player1.stopEvent += lambda _: player_log.info("Stop")
player1.pause()
player1.hide_video()
player1.set_position(videos[0].start)
player1.set_volume(videos[0].volume)
player1.set_aspect_mode(videos[0].aspect)
# Show player 1
player1.show_video()
player1.play()
sleep(5)
# Load player 1 with video 2
player1.pause()
player1.hide_video()
player1.load(videos[1].path, pause=True)
osrs_t = 1 # Temperature oversampling x 1
mode = 3 # Normal mode
t_sb = 5 # Tstandby 1000ms
filter = 0 # Filter off
spi3w_en = 0 # 3-wire SPI Disable
ctrl_meas_reg = (osrs_t << 5) | mode
config_reg = (t_sb << 5) | (filter << 2) | spi3w_en
writeReg(0xF4, ctrl_meas_reg)
writeReg(0xF5, config_reg)
setup()
get_calib_param()
time.sleep(3)
player_sub = OMXPlayer(VIDEO_PATH_SUB)
time.sleep(3)
player_sub.set_position(0)
player_sub.pause()
if __name__ == '__main__':
try:
while True:
readData()
time.sleep(5)
except KeyboardInterrupt:
pass
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 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)
player2.playEvent += lambda _: print("Play event triggered for 2"
) #player_log.info("Play")
player2.pauseEvent += lambda _: print("Pause event triggered for 2"
) #player_log.info("Pause")
player2.stopEvent += lambda _: print("Stop event triggered for 2"
) #player_log.info("Stop")
time.sleep(2.5)
player2.play()
# it takes about this long for omxplayer to warm up and start displaying a picture on a rpi3
time.sleep(15.5)
player2.set_position(20)
player2.pause()
time.sleep(2)
#player.set_aspect_mode('stretch')
#player.set_video_pos(0, 0, 200, 200)
player2.play()
time.sleep(5)
player2.pause()
player2.load(VIDEO_1_PATH)
player2.play()
#player1.play()
time.sleep(5)
#player1.quit()
class Video(Player):
"""Video player class."""
def __init__(self):
"""Init as Player."""
super(Video, self).__init__()
self.logger = logging.getLogger("oxo")
self.close_player = False
self.stopped = False
@classmethod
def filepath(cls, clip):
"""Return disk location of a clip."""
return os.path.join(DATA_DIR, "clips", clip["filename"])
def run(self):
"""Thread target."""
while not self.stopped:
current_clip = Video.get_next()
if current_clip is None:
self.logger.debug("No clips in database. Waiting...")
sleep(5)
else:
self.logger.debug(
"Starting video player with clip [{}]".format(
current_clip["filename"][:6]))
full_path = self.filepath(current_clip)
if machine() == "armv7l":
player_args = [
'--blank', '-o', 'hdmi', '--loop', '--no-osd',
'--aspect-mode', 'fill', '--win', "'0, 0, 810, 540'"
]
else:
player_args = ['-b', '--loop']
if self.player is None:
self.player = OMXPlayer(full_path, player_args)
else:
self.player.load(full_path, player_args)
self.player.play()
sleep(5)
self.player.pause()
self.logger.debug("Exit video player")
@classmethod
def interact(cls, line, stdin):
"""Enqueue clips continuously through mplayer STDIN."""
start_playback = "Starting playback..."
logger = logging.getLogger("oxo")
if start_playback in line:
nextclip = cls.get_next()
path = cls.filepath(nextclip)
cmd = "loadfile {} 1\n".format(path)
logger.info("Enqueued clip {}".format(nextclip['filename']))
stdin.put(cmd)
@classmethod
def get_next(cls):
"""Select recently added video or a random one from db."""
q = Query()
q_incoming = db.search(q.incoming == True)
if len(q_incoming) > 0:
rv = q_incoming[0]
db.update({"incoming": False}, q.incoming == True)
logger.info("Enqueuing shortlisted clip {}".format(rv["filename"]))
else:
q = Query()
try:
q_clips = db.search(q.type == "clip")
except JSONDecodeError:
rv = None
else:
rv = choice(q_clips) if len(q_clips) > 0 else None
return rv
def stop(self):
"""Quit omxplayer instance."""
self.logger.debug("Stopping {} player...".format(
self.__class__.__name__))
self.stopped = True
if self.running:
self.player.quit()
self.logger.info("{} stopped".format(self.__class__.__name__))
else:
self.logger.debug("{} did not play".format(
self.__class__.__name__))
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
from pathlib import Path
from time import sleep
import logging
#import RPi.GPIO as GPIO
#GPIO.setmode (GPIO.BOARD)
#GPIO.setwarnings (False)
VIDEO_PATH = "/home/pi/Desktop/elephant.mp4"
player_log = logging.getLogger("Player1")
intro = OMXPlayer(VIDEO_PATH, ['-o', 'local'], dbus_name='org.mpris.MediaPlayer2.omxplayer1')
intro.playEvent += lambda _: player_log.info("Play")
intro.pauseEvent += lambda _: player_log.info("Pause")
intro.stopEvent += lambda _: player_log.info("Stop")
sleep(2.5)
intro.set_position(5)
intro.pause()
sleep(1)
intro.set_aspect_mode("letterbox")
intro.set_video_pos(50,100,1000,1000)
intro.play()
sleep(5)
intro.quit()
player_log = logging.getLogger("Player 1")
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
class MusicPlayer(QThreadWithLogging):
def __init__(self):
QThreadWithLogging.__init__(self)
self.playlist = []
self.process = None
self.process_util = None
self.player = None
self.lock = Lock()
self.dbus_increment = 1
if capable_gpio:
gpio.setmode(gpio.BCM)
gpio.setup(18, gpio.OUT)
@pyqtSlot(list)
def push_to_playlist(self, pathes):
self.log(f'lock by push_to_playlist')
with self.lock:
self.log(f'push {pathes}')
self.playlist += pathes
self.log(f'unlock')
@pyqtSlot(result=list)
def get_playlist(self):
self.log(f'lock by push_to_playlist')
with self.lock:
playlist = list(self.playlist)
self.log(f'unlock')
return playlist
@pyqtSlot()
def play_unstoppable_music(self, mp3_path):
self.log(f'begin force playing {mp3_path}')
if capable_gpio:
gpio.output(18, gpio.HIGH)
try:
if is_run_on_posix:
player = OMXPlayer(mp3_path, args='--no-keys -o local',
dbus_name=f'org.mpris.MediaPlayer2.omxplayer{self.dbus_increment}')
self.dbus_increment += 1
while player._process.returncode is None: time.sleep(1)
else:
process = subprocess.Popen(rf'python debug\run_mp3.py "{mp3_path}"')
process.wait()
process.terminate()
except:
self.log(f'failed to force playing {mp3_path}')
self.log(traceback.format_exc())
if capable_gpio:
gpio.output(18, gpio.LOW)
self.log(f'end force playing {mp3_path}')
@pyqtSlot()
def play_music(self, mp3_path):
self.log(f'begin playing {mp3_path}')
if capable_gpio:
gpio.output(18, gpio.HIGH)
try:
if is_run_on_posix:
self.player = OMXPlayer(mp3_path, args='--no-keys -o local',
dbus_name=f'org.mpris.MediaPlayer2.omxplayer{self.dbus_increment}')
self.dbus_increment += 1
while self.player._process.returncode is None: time.sleep(1)
else:
self.process = subprocess.Popen(rf'python debug\run_mp3.py "{mp3_path}"')
self.process_util = psutil.Process(pid=self.process.pid)
self.process.wait()
self.process.terminate()
except:
self.log(f'failed to playing {mp3_path}')
self.log(traceback.format_exc())
if capable_gpio:
gpio.output(18, gpio.LOW)
self.log(f'end playing {mp3_path}')
def run(self):
while not self.isFinished():
if len(self.playlist) > 0:
self.log(f'lock by running')
with self.lock:
try:
self.play_music(self.playlist[0])
except:
self.log(traceback.format_exc())
del self.playlist[0]
self.log('unlock')
@pyqtSlot()
def music_pause(self):
try:
if is_run_on_posix:
self.player.pause()
gpio.output(18, gpio.LOW)
else:
if self.process:
self.process_util.suspend()
except Exception as e:
self.log(f'failed to pause music')
self.log(traceback.format_exc())
@pyqtSlot()
def music_resume(self):
try:
if is_run_on_posix:
self.player.play()
gpio.output(18, gpio.HIGH)
else:
if self.process:
self.process_util.resume()
except Exception as e:
self.log(f'failed to pause music')
self.log(traceback.format_exc())
@pyqtSlot()
def close(self):
try:
if is_run_on_posix:
self.player.quit()
gpio.output(18, gpio.LOW)
else:
self.process.terminate()
except Exception as e:
self.log(f'failed to close music')
self.log(traceback.format_exc())
