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 playVideos(vN):
global playing
global player
global player1
global first
print("Dentro funcion video >> " + str(vN))
vid = "/home/pi/Desktop/videocoto/videos/" + str(vN) + ".mp4"
print("Toca reproducir ahora: " + vid)
if playing == 0:
print("Not Playing: " + str(playing))
VIDEO_PATH = Path(vid)
if slave == False:
player = OMXPlayer(VIDEO_PATH, args=omx_arg, dbus_name=bus[0])
if slave == True:
player = OMXPlayer(VIDEO_PATH,
args=omx_arg_pasive,
dbus_name=bus[0])
player.seek(0)
player.play()
if first == 1:
player1.stop()
first = 1
playing = 1
elif playing == 1:
print("Is Playing: " + str(playing))
VIDEO_PATH = Path(vid)
if slave == False:
player1 = OMXPlayer(VIDEO_PATH, args=omx_arg, dbus_name=bus[1])
if slave == True:
player1 = OMXPlayer(VIDEO_PATH,
args=omx_arg_pasive,
dbus_name=bus[1])
player1.seek(0)
player1.play()
player.stop()
playing = 0
else:
print(key)
player.quit()
player = OMXPlayer(VIDEO_PATH2)
elif key == "play":
print(key)
player.play()
elif key == "quit":
print(key)
player.quit()
elif key == "pause":
print(key)
player.pause()
elif key == "next":
print(key)
player.seek(5.0)
elif key == "previous":
print(key)
player.seek(-5.0)
elif key == "base":
print(key)
hsock.send(b'base')
elif key == "dir":
print(key)
hsock.send(b'dir')
except KeyboardInterrupt:
print("disconnected")
sock.close()
hsock.close()
print("all done")
sleep(5)
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)
import RPi.GPIO as GPIO #for taking signal from GPIO
import subprocess
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(27, GPIO.OUT)
GPIO_PIR = 7
VIDEO_PATH = Path("siskin_full.mp4")
player = OMXPlayer(VIDEO_PATH)
positionEvent = 3
while True:
key = input()
currtime = player.position()
if (currtime > 3):
player.seek(-300)
print(currtime)
if key == 'h':
player.seek(300)
#player.loop()
sleep(5)
#player.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)
button_thread.start()
while running:
time.sleep(0.0005)
if (current_video == 0):
try:
button_lock.acquire() # DOM: acquire, not aquire
local_button_state = button_state
finally:
button_lock.release()
if ((current_video == 0) and (local_button_state == True)):
player.seek(-player.position() + video_timestamps[next_video_to_play]
) #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')
class PlaybackController(object):
def __init__(self):
self.player = None
self.queue = []
self.current_playbackitem = None
self.volume = 0.6
def __str__(self):
if self.current_playbackitem:
return f"{self.get_status()} {self.current_playbackitem.get_title()}. {len(self.queue)} items in queue."
else:
return f"{self.get_status()}. {len(self.queue)} items in queue."
def get_title(self):
if self.current_playbackitem:
return self.current_playbackitem.get_title()
else:
return "Not playing anything."
def _on_omxplayer_exit(self, player, exit_status):
log.info("OMXPlayer exit: {}".format(exit_status))
self.player = None
if exit_status == 0:
self.current_playbackitem = None
self._new_player()
def _new_player(self):
"""Creates a new player by popping from queue."""
log.info("Creating new OMXplayer.")
if self.player is not None:
self.player.quit()
if self.current_playbackitem is None:
if len(self.queue) == 0:
raise ValueError("Nothing to play.")
else:
self.current_playbackitem = self.queue.pop(0)
log.info("Creating player for video: {}".format(
self.current_playbackitem))
self.player = OMXPlayer(self.current_playbackitem.get_direct_url())
self.player.set_volume(self.volume)
self.player.exitEvent.subscribe(self._on_omxplayer_exit)
def add_single_url(self, url):
n_item = PlaybackItem(url)
if n_item is not None:
self.queue.append(n_item)
return True
raise ValueError("Could not get URL")
def playlist(self, url):
log.info("Adding every videos from playlist to queue.")
ydl = youtube_dl.YoutubeDL({
'logger': log,
'extract_flat': 'in_playlist',
'ignoreerrors': True,
})
with ydl: # Downloading youtub-dl infos
result = ydl.extract_info(url, download=False)
for i in result['entries']:
logger.info("queuing video")
if i != result['entries'][0]:
try:
if "://" not in i['url']:
self.add_single_url("https://youtube.com/?v=" +
i['url'])
else:
self.add_single_url(i['url'])
except Exception as e:
log.error("Could not enqueue " + i['url'])
log.error(e)
def play(self):
if self.get_status() == "Playing":
log.debug("Playback already playing.")
return
if self.player is None and len(self.queue) > 0:
self._new_player()
else:
log.error("Nothing to play!")
def stop(self):
if self.player is not None:
self.player.stop()
self.player = None
def playpause(self):
if self.player is None:
log.error("No player running.")
if len(self.queue) > 0:
self.play()
else:
self.player.play_pause()
def pause(self):
if self.get_status() == "Paused":
log.debug("Playback is already paused.")
return
def seek(self, seconds):
if self.player is None:
raise Exception("Player is not running")
self.player.seek(seconds)
def change_volume(self, increment):
self.volume += increment
if self.volume < 0.0:
self.volume = 0.0
elif self.volume > 1.0:
self.volume = 1.0
if self.player is not None:
self.player.set_volume(self.volume)
def get_volume(self):
if self.player is not None:
return self.player.volume()
else:
return self.volume
def get_status(self):
if self.player is None:
return "Stopped"
try:
return self.player.playback_status()
except OMXPlayerDeadError:
log.error("OMXPlayer is dead.")
self.player = None
return "Stopped"
def next_video(self):
self.stop()
self.current_playbackitem = None
self._new_player()
def shutdown(self):
self.stop()
