BAPSicle/player.py

419 lines
12 KiB
Python
Raw Normal View History

2020-11-01 02:35:14 +00:00
"""
BAPSicle Server
Next-gen audio playout server for University Radio York playout,
based on WebStudio interface.
Audio Player
Authors:
Matthew Stratford
Michael Grace
Date:
October, November 2020
"""
# This is the player. Reliability is critical here, so we're catching
# literally every exception possible and handling it.
# It is key that whenever the parent server tells us to do something
# that we respond with something, FAIL or OKAY. The server doesn't like to be kept waiting.
2020-10-29 21:23:37 +00:00
from queue import Empty
import multiprocessing
import setproctitle
import copy
import json
import time
2020-11-01 02:35:14 +00:00
from typing import Callable, Dict, List
2020-10-29 21:23:37 +00:00
from pygame import mixer
2020-10-25 01:23:24 +00:00
from state_manager import StateManager
2020-11-01 02:35:14 +00:00
from plan import PlanObject
2020-10-25 01:23:24 +00:00
from mutagen.mp3 import MP3
import os
os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
2020-10-23 20:10:32 +00:00
2020-10-24 20:31:52 +00:00
class Player():
state = None
running = False
2020-10-30 00:32:34 +00:00
out_q = None
last_msg = None
2020-10-24 20:31:52 +00:00
__default_state = {
2020-10-30 00:32:34 +00:00
"initialised": False,
2020-11-01 02:35:14 +00:00
"loaded_item": None,
2020-10-24 20:31:52 +00:00
"channel": -1,
"playing": False,
"paused": False,
2020-10-29 22:25:17 +00:00
"loaded": False,
2020-10-24 20:31:52 +00:00
"pos": 0,
"pos_offset": 0,
"pos_true": 0,
2020-10-24 20:31:52 +00:00
"remaining": 0,
"length": 0,
"loop": False,
2020-11-01 02:35:14 +00:00
"output": None,
"show_plan": []
2020-10-24 20:31:52 +00:00
}
2020-10-29 22:25:17 +00:00
@property
2020-10-24 20:31:52 +00:00
def isInit(self):
try:
2020-10-25 01:23:24 +00:00
mixer.music.get_busy()
2020-10-24 20:31:52 +00:00
except:
return False
2020-10-29 22:25:17 +00:00
return True
2020-10-24 20:31:52 +00:00
2020-10-29 21:23:37 +00:00
@property
2020-10-24 20:31:52 +00:00
def isPlaying(self):
2020-10-29 22:25:17 +00:00
if self.isInit:
return (not self.isPaused) and bool(mixer.music.get_busy())
2020-10-29 22:25:17 +00:00
return False
2020-10-24 20:31:52 +00:00
@property
def isPaused(self):
return self.state.state["paused"]
2020-10-29 21:23:37 +00:00
@property
def isLoaded(self):
2020-11-01 02:35:14 +00:00
if not self.state.state["loaded_item"]:
2020-10-29 22:25:17 +00:00
return False
if self.isPlaying:
return True
2020-10-30 00:32:34 +00:00
# Because Pygame/SDL is annoying
# We're not playing now, so we can quickly test run
# If that works, we're loaded.
2020-10-29 22:25:17 +00:00
try:
2020-10-30 00:32:34 +00:00
position = self.state.state["pos"]
mixer.music.set_volume(0)
mixer.music.play(0)
2020-10-29 22:25:17 +00:00
except:
2020-10-30 00:32:34 +00:00
try:
mixer.music.set_volume(1)
except:
pass
2020-10-29 22:25:17 +00:00
return False
2020-10-30 00:32:34 +00:00
if position > 0:
self.pause()
2020-10-30 00:32:34 +00:00
else:
self.stop()
2020-10-30 00:32:34 +00:00
mixer.music.set_volume(1)
return True
2020-10-29 22:25:17 +00:00
2020-10-30 00:32:34 +00:00
@property
def status(self):
2020-11-01 02:35:14 +00:00
state = copy.copy(self.state.state)
# Not the biggest fan of this, but maybe I'll get a better solution for this later
state["loaded_item"] = state["loaded_item"].__dict__() if state["loaded_item"] else None
state["show_plan"] = [repr.__dict__() for repr in state["show_plan"]]
res = json.dumps(state)
2020-10-30 00:32:34 +00:00
return res
2020-10-29 21:23:37 +00:00
def play(self, pos=0):
# if not self.isPlaying:
try:
mixer.music.play(0, pos)
self.state.update("pos_offset", pos)
except:
return False
self.state.update("paused", False)
return True
# return False
2020-10-24 20:31:52 +00:00
def pause(self):
# if self.isPlaying:
2020-10-29 22:25:17 +00:00
try:
mixer.music.pause()
except:
return False
self.state.update("paused", True)
return True
# return False
2020-10-24 20:31:52 +00:00
def unpause(self):
2020-10-29 22:25:17 +00:00
if not self.isPlaying:
try:
self.play(self.state.state["pos_true"])
2020-10-29 22:25:17 +00:00
except:
return False
self.state.update("paused", False)
2020-10-29 22:25:17 +00:00
return True
return False
2020-10-24 20:31:52 +00:00
def stop(self):
# if self.isPlaying or self.isPaused:
try:
mixer.music.stop()
2020-11-01 02:35:14 +00:00
except Exception as e:
print("Couldn't Stop Player:", e)
return False
self.state.update("pos", 0)
self.state.update("pos_offset", 0)
self.state.update("pos_true", 0)
self.state.update("paused", False)
return True
# return False
2020-10-24 20:31:52 +00:00
def seek(self, pos):
2020-10-29 22:25:17 +00:00
if self.isPlaying:
try:
self.play(pos)
2020-10-29 22:25:17 +00:00
except:
return False
return True
else:
self.state.update("paused", True)
self._updateState(pos=pos)
return True
2020-10-24 20:31:52 +00:00
2020-11-01 02:35:14 +00:00
def add_to_plan(self, new_item: Dict[str, any]) -> bool:
self.state.update("show_plan", self.state.state["show_plan"] + [PlanObject(new_item)])
return True
def load(self, timeslotitemid: int):
2020-10-29 22:25:17 +00:00
if not self.isPlaying:
self.unload()
2020-10-29 22:25:17 +00:00
2020-11-01 02:35:14 +00:00
updated: bool = False
for i in range(len(self.state.state["show_plan"])):
if self.state.state["show_plan"][i].timeslotitemid == timeslotitemid:
self.state.update("loaded_item", self.state.state["show_plan"][i])
updated = True
break
if not updated:
print("Failed to find timeslotitemid:", timeslotitemid)
return False
filename: str = self.state.state["loaded_item"].filename
2020-10-29 22:25:17 +00:00
try:
mixer.music.load(filename)
except:
# We couldn't load that file.
print("Couldn't load file:", filename)
return False
try:
if ".mp3" in filename:
song = MP3(filename)
self.state.update("length", song.info.length)
else:
self.state.update("length", mixer.Sound(filename).get_length()/1000)
except:
return False
return True
def unload(self):
if not self.isPlaying:
try:
mixer.music.unload()
self.state.update("paused", False)
2020-11-01 02:35:14 +00:00
self.state.update("loaded_item", None)
2020-10-29 22:25:17 +00:00
except:
return False
return not self.isLoaded
2020-10-24 20:31:52 +00:00
def quit(self):
2020-10-25 01:23:24 +00:00
mixer.quit()
self.state.update("paused", False)
2020-10-24 20:31:52 +00:00
def output(self, name=None):
self.quit()
2020-10-30 00:32:34 +00:00
self.state.update("output", name)
2020-11-01 02:35:14 +00:00
self.state.update("loaded_item", None)
2020-10-24 20:31:52 +00:00
try:
if name:
2020-10-25 01:23:24 +00:00
mixer.init(44100, -16, 1, 1024, devicename=name)
2020-10-24 20:31:52 +00:00
else:
2020-10-25 01:23:24 +00:00
mixer.init(44100, -16, 1, 1024)
2020-10-24 20:31:52 +00:00
except:
2020-10-30 00:32:34 +00:00
return False
2020-10-24 20:31:52 +00:00
2020-10-30 00:32:34 +00:00
return True
2020-10-24 20:31:52 +00:00
2020-10-30 00:32:34 +00:00
def _updateState(self, pos=None):
self.state.update("initialised", self.isInit)
if self.isInit:
# TODO: get_pos returns the time since the player started playing
# This is NOT the same as the position through the song.
if self.isPlaying:
# Get one last update in, incase we're about to pause/stop it.
self.state.update("pos", max(0, mixer.music.get_pos()/1000))
2020-10-30 00:32:34 +00:00
self.state.update("playing", self.isPlaying)
self.state.update("loaded", self.isLoaded)
2020-10-30 00:32:34 +00:00
if (pos):
self.state.update("pos", max(0, pos))
self.state.update("pos_true", self.state.state["pos"] + self.state.state["pos_offset"])
self.state.update("remaining", self.state.state["length"] - self.state.state["pos_true"])
2020-10-30 00:32:34 +00:00
def _retMsg(self, msg, okay_str=False):
response = self.last_msg + ":"
if msg == True:
response += "OKAY"
elif isinstance(msg, str):
if okay_str:
response += "OKAY:" + msg
else:
response += "FAIL:" + msg
2020-10-24 20:31:52 +00:00
else:
2020-10-30 00:32:34 +00:00
response += "FAIL"
if self.out_q:
self.out_q.put(response)
2020-10-24 20:31:52 +00:00
def __init__(self, channel, in_q, out_q):
self.running = True
2020-10-30 00:32:34 +00:00
self.out_q = out_q
2020-10-25 01:23:24 +00:00
setproctitle.setproctitle("BAPSicle - Player " + str(channel))
2020-10-24 20:31:52 +00:00
self.state = StateManager("channel" + str(channel), self.__default_state)
self.state.update("channel", channel)
loaded_state = copy.copy(self.state.state)
if loaded_state["output"]:
print("Setting output to: " + loaded_state["output"])
self.output(loaded_state["output"])
else:
2020-10-29 21:23:37 +00:00
print("Using default output device.")
2020-10-24 20:31:52 +00:00
self.output()
2020-11-01 02:35:14 +00:00
if loaded_state["loaded_item"]:
print("Loading filename: " + loaded_state["loaded_item"["filename"]])
self.load(loaded_state["loaded_item"["timeslotitemid"]])
2020-10-24 20:31:52 +00:00
if loaded_state["pos_true"] != 0:
print("Seeking to pos_true: " + str(loaded_state["pos_true"]))
self.seek(loaded_state["pos_true"])
2020-10-24 20:31:52 +00:00
2020-10-29 21:23:37 +00:00
if loaded_state["playing"] == True:
print("Resuming.")
self.unpause()
else:
print("No file was previously loaded.")
2020-10-24 20:31:52 +00:00
while self.running:
2020-10-30 00:32:34 +00:00
time.sleep(0.1)
self._updateState()
2020-10-29 21:23:37 +00:00
try:
try:
2020-10-30 00:32:34 +00:00
self.last_msg = in_q.get_nowait()
2020-10-29 21:23:37 +00:00
except Empty:
# The incomming message queue was empty,
# skip message processing
pass
else:
2020-10-30 00:32:34 +00:00
2020-10-29 21:23:37 +00:00
# We got a message.
2020-10-29 22:25:17 +00:00
2020-10-30 00:32:34 +00:00
# Output re-inits the mixer, so we can do this any time.
if (self.last_msg.startswith("OUTPUT")):
split = self.last_msg.split(":")
self._retMsg(self.output(split[1]))
elif self.isInit:
2020-10-29 21:23:37 +00:00
2020-10-30 00:32:34 +00:00
if (self.last_msg == 'LOADED?'):
self._retMsg(self.isLoaded)
2020-10-29 21:23:37 +00:00
continue
2020-11-01 02:35:14 +00:00
elif (self.last_msg.startswith("ADD")):
split = self.last_msg.split(":")
self._retMsg(self.add_to_plan(json.loads(":".join(split[1:]))))
2020-10-30 00:32:34 +00:00
elif (self.last_msg == 'PLAY'):
2020-11-01 02:35:14 +00:00
self._retMsg(self.play())
2020-10-30 00:32:34 +00:00
elif (self.last_msg == 'PAUSE'):
2020-11-01 02:35:14 +00:00
self._retMsg(self.pause())
2020-10-30 00:32:34 +00:00
elif (self.last_msg == 'UNPAUSE'):
2020-11-01 02:35:14 +00:00
self._retMsg(self.unpause())
2020-10-30 00:32:34 +00:00
elif (self.last_msg == 'STOP'):
2020-11-01 02:35:14 +00:00
self._retMsg(self.stop())
2020-10-30 00:32:34 +00:00
elif (self.last_msg == 'QUIT'):
2020-10-29 21:23:37 +00:00
self.running = False
2020-10-30 00:32:34 +00:00
continue
elif (self.last_msg.startswith("SEEK")):
split = self.last_msg.split(":")
self._retMsg(self.seek(float(split[1])))
elif (self.last_msg.startswith("LOAD")):
split = self.last_msg.split(":")
2020-11-01 02:35:14 +00:00
self._retMsg(self.load(int(split[1])))
2020-10-30 00:32:34 +00:00
elif (self.last_msg == 'UNLOAD'):
2020-11-01 02:35:14 +00:00
self._retMsg(self.unload())
2020-10-30 00:32:34 +00:00
elif (self.last_msg == 'STATUS'):
2020-11-01 02:35:14 +00:00
self._retMsg(self.status, True)
2020-10-30 00:32:34 +00:00
else:
self._retMsg("Unknown Command")
else:
if (self.last_msg == 'STATUS'):
self._retMsg(self.status)
else:
self._retMsg(False)
2020-10-29 21:23:37 +00:00
# Catch the player being killed externally.
except KeyboardInterrupt:
break
except SystemExit:
break
except:
raise
2020-10-24 20:31:52 +00:00
print("Quiting player ", channel)
2020-10-29 21:23:37 +00:00
self.quit()
2020-10-30 00:32:34 +00:00
self._retMsg("EXIT")
2020-10-29 21:23:37 +00:00
def showOutput(in_q, out_q):
print("Starting showOutput().")
while True:
time.sleep(0.01)
last_msg = out_q.get()
print(last_msg)
2020-10-29 21:23:37 +00:00
if __name__ == "__main__":
in_q = multiprocessing.Queue()
out_q = multiprocessing.Queue()
outputProcess = multiprocessing.Process(
target=showOutput,
args=(in_q, out_q),
).start()
playerProcess = multiprocessing.Process(
target=Player,
args=(-1, in_q, out_q),
).start()
# Do some testing
2020-10-29 22:25:17 +00:00
in_q.put("LOADED?")
in_q.put("PLAY")
2020-11-01 02:35:14 +00:00
in_q.put("LOAD:dev/test.mp3") # I mean, this won't work now, this can get sorted :)
2020-10-29 22:25:17 +00:00
in_q.put("LOADED?")
in_q.put("PLAY")
2020-10-29 21:23:37 +00:00
print("Entering infinite loop.")
while True:
pass