Comments and reordering.
This commit is contained in:
Matthew Stratford
parent
c538ce3a46
commit
325f62ed37
1 changed files with 379 additions and 282 deletions
661
player.py
661
player.py
|
|
@ -13,11 +13,11 @@
|
|||
October, November 2020
|
||||
"""
|
||||
|
||||
# This is the player. Reliability is critical here, so we're catching
|
||||
# literally every exception possible and handling it.
|
||||
# This is the player. It does everything regarding playing sound.
|
||||
# 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.
|
||||
# It is key that whenever the clients tells us to do something
|
||||
# that we respond with something, FAIL or OKAY. They don't like to be kept waiting/ignored.
|
||||
|
||||
# Stop the Pygame Hello message.
|
||||
import os
|
||||
|
|
@ -70,6 +70,7 @@ class Player:
|
|||
tracklist_start_timer: Optional[Timer] = None
|
||||
tracklist_end_timer: Optional[Timer] = None
|
||||
|
||||
# The default state that should be set if there is no previous state info.
|
||||
__default_state = {
|
||||
"initialised": False,
|
||||
"loaded_item": None,
|
||||
|
|
@ -92,8 +93,12 @@ class Player:
|
|||
"tracklist_id": None,
|
||||
}
|
||||
|
||||
# These tell the StateManager which variables we don't care about really accurate history for.
|
||||
# This means that the internal running state of the player will have quickly updating info (multiple times a sec)
|
||||
# But we will rate limit (a few secs) saving updates to these variables to the state JSON file.
|
||||
__rate_limited_params = ["pos", "pos_offset", "pos_true", "remaining"]
|
||||
|
||||
# Checks if the mixer is init'd. It will throw an exception if not.
|
||||
@property
|
||||
def isInit(self):
|
||||
try:
|
||||
|
|
@ -106,7 +111,7 @@ class Player:
|
|||
@property
|
||||
def isPlaying(self) -> bool:
|
||||
if self.isInit:
|
||||
return (not self.isPaused) and bool(mixer.music.get_busy())
|
||||
return not self.isPaused and mixer.music.get_busy()
|
||||
return False
|
||||
|
||||
@property
|
||||
|
|
@ -117,6 +122,9 @@ class Player:
|
|||
def isLoaded(self):
|
||||
return self.state.get()["loaded"]
|
||||
|
||||
# Checks if a file has been loaded
|
||||
# This should be run with a long test before client requests for status etc.
|
||||
# Short tests are used in other logic in the player, without fussing over full playback tests.
|
||||
def _checkIsLoaded(self, short_test: bool = False):
|
||||
|
||||
loaded = True
|
||||
|
|
@ -124,12 +132,10 @@ class Player:
|
|||
if not self.state.get()["loaded_item"] or not self.isInit:
|
||||
loaded = False
|
||||
elif not self.isPlaying:
|
||||
# If we don't want to do any testing if it's really loaded, fine.
|
||||
# Because this function can be called very often, only some (less frequent) checks will initiate a full trial of loading success, for efficiency.
|
||||
if not short_test:
|
||||
|
||||
# Because Pygame/SDL is annoying
|
||||
# We're not playing now, so we can quickly test run
|
||||
# If that works, we're loaded.
|
||||
# If that works, we're truely loaded.
|
||||
try:
|
||||
mixer.music.set_volume(0)
|
||||
mixer.music.play(0)
|
||||
|
|
@ -150,9 +156,9 @@ class Player:
|
|||
self.state.update("loaded", loaded)
|
||||
return loaded
|
||||
|
||||
# Is the player at a cue marker point?
|
||||
@property
|
||||
def isCued(self):
|
||||
# Don't mess with playback, we only care about if it's supposed to be loaded.
|
||||
if not self.isLoaded:
|
||||
return False
|
||||
return (
|
||||
|
|
@ -160,11 +166,14 @@ class Player:
|
|||
and not self.isPlaying
|
||||
)
|
||||
|
||||
# Returns the state of the player as a nice friendly JSON dump.
|
||||
@property
|
||||
def status(self):
|
||||
# Get a copy of the server state.
|
||||
state = self.state.state
|
||||
|
||||
# Not the biggest fan of this, but maybe I'll get a better solution for this later
|
||||
# Convert objects to a nice JSON friendly dicts.
|
||||
state["loaded_item"] = (
|
||||
state["loaded_item"].__dict__ if state["loaded_item"] else None
|
||||
)
|
||||
|
|
@ -175,242 +184,9 @@ class Player:
|
|||
|
||||
# Audio Playout Related Methods
|
||||
|
||||
def play(self, pos: float = 0):
|
||||
self.logger.log.info("Playing from pos: " + str(pos))
|
||||
if not self.isLoaded:
|
||||
self.logger.log.warning("Player is not loaded.")
|
||||
return False
|
||||
try:
|
||||
mixer.music.play(0, pos)
|
||||
self.state.update("pos_offset", pos)
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to play at pos: " + str(pos))
|
||||
return False
|
||||
self.state.update("paused", False)
|
||||
self._potentially_tracklist()
|
||||
self.stopped_manually = False
|
||||
return True
|
||||
|
||||
def pause(self):
|
||||
try:
|
||||
mixer.music.stop()
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to pause.")
|
||||
return False
|
||||
|
||||
self.stopped_manually = True
|
||||
self.state.update("paused", True)
|
||||
return True
|
||||
|
||||
def unpause(self):
|
||||
if not self.isPlaying:
|
||||
state = self.state.get()
|
||||
position: float = state["pos_true"]
|
||||
if not self.play(position):
|
||||
self.logger.log.exception(
|
||||
"Failed to unpause from pos: " + str(position)
|
||||
)
|
||||
return False
|
||||
|
||||
self.state.update("paused", False)
|
||||
|
||||
# Increment Played count
|
||||
loaded_item = state["loaded_item"]
|
||||
if loaded_item:
|
||||
loaded_item.play_count_increment()
|
||||
self.state.update("loaded_item", loaded_item)
|
||||
|
||||
return True
|
||||
return False
|
||||
|
||||
def stop(self, user_initiated: bool = False):
|
||||
try:
|
||||
mixer.music.stop()
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to stop playing.")
|
||||
return False
|
||||
self.state.update("paused", False)
|
||||
|
||||
if user_initiated:
|
||||
self._potentially_end_tracklist()
|
||||
|
||||
self.stopped_manually = True
|
||||
|
||||
if not self.state.get()["loaded_item"]:
|
||||
self.logger.log.warning("Tried to stop without a loaded item.")
|
||||
return True
|
||||
|
||||
# This lets users toggle (using the stop button) between cue point and 0.
|
||||
if user_initiated and not self.isCued:
|
||||
# if there's a cue point ant we're not at it, go there.
|
||||
self.seek(self.state.get()["loaded_item"].cue)
|
||||
else:
|
||||
# Otherwise, let's go to 0.
|
||||
self.seek(0)
|
||||
|
||||
return True
|
||||
|
||||
def seek(self, pos: float) -> bool:
|
||||
self.logger.log.info("Seeking to pos:" + str(pos))
|
||||
if self.isPlaying:
|
||||
try:
|
||||
self.play(pos)
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to seek to pos: " + str(pos))
|
||||
return False
|
||||
return True
|
||||
else:
|
||||
self.logger.log.debug(
|
||||
"Not playing during seek, setting pos state for next play."
|
||||
)
|
||||
self.stopped_manually = True # Don't trigger _ended() on seeking.
|
||||
if pos > 0:
|
||||
self.state.update("paused", True)
|
||||
self._updateState(pos=pos)
|
||||
return True
|
||||
|
||||
def set_auto_advance(self, message: bool) -> bool:
|
||||
self.state.update("auto_advance", message)
|
||||
return True
|
||||
|
||||
def set_repeat(self, message: str) -> bool:
|
||||
if message in ["all", "one", "none"]:
|
||||
self.state.update("repeat", message)
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def set_play_on_load(self, message: bool) -> bool:
|
||||
self.state.update("play_on_load", message)
|
||||
return True
|
||||
|
||||
# Show Plan Related Methods
|
||||
def get_plan(self, message: int):
|
||||
plan = sync(self.api.get_showplan(message))
|
||||
self.clear_channel_plan()
|
||||
channel = self.state.get()["channel"]
|
||||
self.logger.log.debug(plan)
|
||||
if not isinstance(plan, dict):
|
||||
return False
|
||||
if str(channel) in plan.keys():
|
||||
for plan_item in plan[str(channel)]:
|
||||
try:
|
||||
self.add_to_plan(plan_item)
|
||||
except Exception as e:
|
||||
self.logger.log.critical(
|
||||
"Failed to add item to show plan: {}".format(e)
|
||||
)
|
||||
continue
|
||||
|
||||
return True
|
||||
|
||||
def _check_ghosts(self, item: PlanItem):
|
||||
if isinstance(item.timeslotitemid, str) and item.timeslotitemid.startswith("I"):
|
||||
# Kinda a bodge for the moment, each "Ghost" (item which is not saved in the database showplan yet)
|
||||
# needs to have a unique temporary item.
|
||||
# To do this, we'll start with the channel number the item was originally added to
|
||||
# (to stop items somehow simultaneously added to different channels from having the same id)
|
||||
# And chuck in the unix epoch in ns for good measure.
|
||||
item.timeslotitemid = "GHOST-{}-{}".format(
|
||||
self.state.get()["channel"], time.time_ns()
|
||||
)
|
||||
return item
|
||||
|
||||
# TODO Allow just moving an item inside the channel instead of removing and adding.
|
||||
def add_to_plan(self, new_item: Dict[str, Any]) -> bool:
|
||||
new_item_obj = PlanItem(new_item)
|
||||
new_item_obj = self._check_ghosts(new_item_obj)
|
||||
plan_copy: List[PlanItem] = copy.copy(self.state.get()["show_plan"])
|
||||
# Shift any plan items after the new position down one to make space.
|
||||
for item in plan_copy:
|
||||
if item.weight >= new_item_obj.weight:
|
||||
item.weight += 1
|
||||
|
||||
plan_copy += [new_item_obj] # Add the new item.
|
||||
|
||||
self._fix_and_update_weights(plan_copy)
|
||||
|
||||
loaded_item = self.state.get()["loaded_item"]
|
||||
if loaded_item:
|
||||
|
||||
# Right. So this may be confusing.
|
||||
# So... If the user has just moved the loaded item in the channel (by removing above and readding)
|
||||
# Then we want to re-associate the loaded_item object reference with the new one.
|
||||
# The loaded item object before this change is now an orphan, which was
|
||||
# kept around while the loaded item was potentially moved to another
|
||||
# channel.
|
||||
if loaded_item.timeslotitemid == new_item_obj.timeslotitemid:
|
||||
self.state.update("loaded_item", new_item_obj)
|
||||
|
||||
# NOPE NOPE NOPE
|
||||
# THIS IS AN EXAMPLE OF WHAT NOT TO DO!
|
||||
# ONCE AGAIN, THE LOADED ITEM IS THE SAME OBJECT INSTANCE AS THE ONE IN
|
||||
# THE SHOW PLAN (AS LONG AS IT HASN'T BEEN RE/MOVED)
|
||||
|
||||
# loaded_item.weight = new_item_obj.weight
|
||||
|
||||
# Bump the loaded_item's weight if we just added a new item above it.
|
||||
# elif loaded_item.weight >= new_item_obj.weight:
|
||||
# loaded_item.weight += 1
|
||||
|
||||
# Else, new weight stays the same.
|
||||
# else:
|
||||
# return True
|
||||
|
||||
# self.state.update("loaded_item", loaded_item)
|
||||
|
||||
return True
|
||||
|
||||
def remove_from_plan(self, weight: int) -> bool:
|
||||
plan_copy: List[PlanItem] = copy.copy(self.state.get()["show_plan"])
|
||||
found: Optional[PlanItem] = None
|
||||
|
||||
before = []
|
||||
for item in plan_copy:
|
||||
before += (item.weight, item.name)
|
||||
|
||||
self.logger.log.debug(
|
||||
"Weights before removing weight {}:\n{}".format(weight, before)
|
||||
)
|
||||
|
||||
for i in plan_copy:
|
||||
if i.weight == weight:
|
||||
found = i
|
||||
plan_copy.remove(i)
|
||||
|
||||
if found:
|
||||
self._fix_and_update_weights(plan_copy)
|
||||
|
||||
# If we removed the loaded item from this channel, update it's weight
|
||||
# So we know how/not to autoadvance.
|
||||
loaded_item = self.state.get()["loaded_item"]
|
||||
if loaded_item == found:
|
||||
# Loaded_item is actually the same PlanItem instance as in the show_plan.
|
||||
# So if it's still in the show plan, we'll have corrected it's weight already.
|
||||
# If it was removed above, fix_weights won't have done anything
|
||||
# So we'll want to update the weight.
|
||||
|
||||
# We're removing the loaded item from the channel.
|
||||
# if loaded_item.weight == weight:
|
||||
loaded_item.weight = -1
|
||||
|
||||
# If loaded_item wasn't the same instance, we'd want to do the below.
|
||||
|
||||
# We removed an item above it. Shift it up.
|
||||
# elif loaded_item.weight > weight:
|
||||
# loaded_item.weight -= 1
|
||||
# Else, new weight stays the same.
|
||||
# else:
|
||||
# return True
|
||||
|
||||
self.state.update("loaded_item", loaded_item)
|
||||
return True
|
||||
return False
|
||||
|
||||
def clear_channel_plan(self) -> bool:
|
||||
self.state.update("show_plan", [])
|
||||
return True
|
||||
|
||||
# Loads a plan item into the player, ready for playing.
|
||||
# This includes some retry logic to try and double-down on ensuring it plays successfully.
|
||||
def load(self, weight: int):
|
||||
if not self.isPlaying:
|
||||
# If we have something loaded already, unload it first.
|
||||
|
|
@ -424,7 +200,7 @@ class Player:
|
|||
"Resetting output (in case of sound output gone silent somehow) to "
|
||||
+ str(loaded_state["output"])
|
||||
)
|
||||
self.output(loaded_state["output"])
|
||||
self.set_output(loaded_state["output"])
|
||||
|
||||
showplan = loaded_state["show_plan"]
|
||||
|
||||
|
|
@ -516,12 +292,6 @@ class Player:
|
|||
)
|
||||
continue # Try loading again.
|
||||
|
||||
if not self.isLoaded:
|
||||
self.logger.log.error(
|
||||
"Pygame loaded file without error, but never actually loaded."
|
||||
)
|
||||
continue # Try loading again.
|
||||
|
||||
try:
|
||||
if loaded_item.filename.endswith(".mp3"):
|
||||
song = MP3(loaded_item.filename)
|
||||
|
|
@ -541,8 +311,16 @@ class Player:
|
|||
# Everything worked, we made it!
|
||||
# Write the loaded item again once more, to confirm the filename if we've reattempted.
|
||||
self.state.update("loaded_item", loaded_item)
|
||||
self._checkIsLoaded()
|
||||
|
||||
# Now just double check that pygame could actually play it (silently)
|
||||
self._checkIsLoaded()
|
||||
if not self.isLoaded:
|
||||
self.logger.log.error(
|
||||
"Pygame loaded file without error, but never actually loaded."
|
||||
)
|
||||
continue # Try loading again.
|
||||
|
||||
# If the track has a cue point, let's jump to that, ready.
|
||||
if loaded_item.cue > 0:
|
||||
self.seek(loaded_item.cue)
|
||||
else:
|
||||
|
|
@ -560,6 +338,8 @@ class Player:
|
|||
|
||||
return False
|
||||
|
||||
# Remove the currently loaded item from the player.
|
||||
# Not much reason to do this, but if it makes you happy.
|
||||
def unload(self):
|
||||
if not self.isPlaying:
|
||||
try:
|
||||
|
|
@ -570,22 +350,122 @@ class Player:
|
|||
self.logger.log.exception("Failed to unload channel.")
|
||||
return False
|
||||
|
||||
self._potentially_end_tracklist()
|
||||
#self._potentially_end_tracklist()
|
||||
# If we unloaded successfully, reset the tracklist_id, ready for the next item.
|
||||
if not self.isLoaded:
|
||||
self.state.update("tracklist_id", None)
|
||||
|
||||
# If we successfully unloaded, this will return true, for success!
|
||||
return not self.isLoaded
|
||||
|
||||
def quit(self):
|
||||
try:
|
||||
mixer.quit()
|
||||
self.state.update("paused", False)
|
||||
self.logger.log.info("Quit mixer.")
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to quit mixer.")
|
||||
|
||||
def output(self, name: Optional[str] = None):
|
||||
# Starts playing the loaded item, from a given position (secs)
|
||||
def play(self, pos: float = 0):
|
||||
self.logger.log.info("Playing from pos: " + str(pos))
|
||||
if not self.isLoaded:
|
||||
self.logger.log.warning("Player is not loaded.")
|
||||
return False
|
||||
try:
|
||||
mixer.music.play(0, pos)
|
||||
self.state.update("pos_offset", pos)
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to play at pos: " + str(pos))
|
||||
return False
|
||||
self.state.update("paused", False)
|
||||
self._potentially_tracklist()
|
||||
self.stopped_manually = False
|
||||
return True
|
||||
|
||||
# Pauses the player
|
||||
def pause(self):
|
||||
# Because the player's position is stored by a event from pygame while playing only,
|
||||
# the current playback position state will remain, in case we unpause later.
|
||||
try:
|
||||
mixer.music.stop()
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to pause.")
|
||||
return False
|
||||
|
||||
self.stopped_manually = True
|
||||
self.state.update("paused", True)
|
||||
return True
|
||||
|
||||
# Plays the player, from the playback position it was already at.
|
||||
def unpause(self):
|
||||
if not self.isPlaying:
|
||||
state = self.state.get()
|
||||
position: float = state["pos_true"]
|
||||
if not self.play(position):
|
||||
self.logger.log.exception(
|
||||
"Failed to unpause from pos: " + str(position)
|
||||
)
|
||||
return False
|
||||
|
||||
self.state.update("paused", False)
|
||||
|
||||
# Increment Played count
|
||||
loaded_item = state["loaded_item"]
|
||||
if loaded_item:
|
||||
loaded_item.play_count_increment()
|
||||
self.state.update("loaded_item", loaded_item)
|
||||
|
||||
return True
|
||||
return False
|
||||
|
||||
# Stop the player.
|
||||
def stop(self, user_initiated: bool = False):
|
||||
try:
|
||||
mixer.music.stop()
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to stop playing.")
|
||||
return False
|
||||
self.state.update("paused", False)
|
||||
|
||||
# When it wasn't _ended() calling this, end the tracklist.
|
||||
# _ended() already calls this, but user stops won't have.
|
||||
if user_initiated:
|
||||
self._potentially_end_tracklist()
|
||||
self.stopped_manually = True
|
||||
|
||||
if not self.state.get()["loaded_item"]:
|
||||
self.logger.log.warning("Tried to stop without a loaded item.")
|
||||
return True
|
||||
|
||||
# This lets users toggle (using the stop button) between cue point and 0.
|
||||
|
||||
if user_initiated and not self.isCued:
|
||||
# if there's a cue point ant we're not at it, go there.
|
||||
self.seek(self.state.get()["loaded_item"].cue)
|
||||
else:
|
||||
# Otherwise, let's go to 0.
|
||||
self.seek(0)
|
||||
|
||||
return True
|
||||
|
||||
# Move the audio position (secs) of the player
|
||||
def seek(self, pos: float) -> bool:
|
||||
self.logger.log.info("Seeking to pos:" + str(pos))
|
||||
if self.isPlaying:
|
||||
# If we're playing, just start playing directly from that position
|
||||
try:
|
||||
self.play(pos)
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to seek to pos: " + str(pos))
|
||||
return False
|
||||
return True
|
||||
else:
|
||||
# If we're not actually playing at the moment, set the player to be paused at the new position
|
||||
self.logger.log.debug(
|
||||
"Not playing during seek, setting pos state for next play."
|
||||
)
|
||||
self.stopped_manually = True # Don't trigger _ended() on seeking.
|
||||
if pos > 0:
|
||||
self.state.update("paused", True)
|
||||
self._updateState(pos=pos)
|
||||
return True
|
||||
|
||||
# Set the output device name and initialise the pygame audio mixer.
|
||||
def set_output(self, name: Optional[str] = None):
|
||||
wasPlaying = self.isPlaying
|
||||
|
||||
state = self.state.get()
|
||||
|
|
@ -593,12 +473,19 @@ class Player:
|
|||
|
||||
name = None if (not name or name.lower() == "none") else name
|
||||
|
||||
# Stop the mixer if it's already init'd.
|
||||
self.quit()
|
||||
self.state.update("output", name)
|
||||
try:
|
||||
# Setup the mixer.
|
||||
# Sample rate of 44100Hz (44.1KHz) (matching the MP3's and typical CD/online source material)
|
||||
# 16 bits per sample
|
||||
# 2 channels (stereo)
|
||||
# sample buffer of 1024 samples
|
||||
if name:
|
||||
mixer.init(44100, -16, 2, 1024, devicename=name)
|
||||
else:
|
||||
# Use the default system output
|
||||
mixer.init(44100, -16, 2, 1024)
|
||||
except Exception:
|
||||
self.logger.log.exception(
|
||||
|
|
@ -606,6 +493,7 @@ class Player:
|
|||
)
|
||||
return False
|
||||
|
||||
# If we had something loaded before, load it back in and play it.
|
||||
loadedItem = state["loaded_item"]
|
||||
if loadedItem:
|
||||
self.logger.log.info("Reloading after output change.")
|
||||
|
|
@ -616,11 +504,193 @@ class Player:
|
|||
|
||||
return True
|
||||
|
||||
# Timeslotitemid can be a ghost (un-submitted item), so may be "IXXX"
|
||||
# De-initialises the pygame mixer.
|
||||
def quit(self):
|
||||
try:
|
||||
mixer.quit()
|
||||
self.state.update("paused", False)
|
||||
self.logger.log.info("Quit mixer.")
|
||||
except Exception:
|
||||
self.logger.log.exception("Failed to quit mixer.")
|
||||
|
||||
|
||||
# Sets whether auto advance is on or off
|
||||
# Auto advance is where the next item in the list is selected after the current item is finished playing.
|
||||
def set_auto_advance(self, message: bool) -> bool:
|
||||
self.state.update("auto_advance", message)
|
||||
return True
|
||||
|
||||
# As you'd expect, all rotates around all of the items in the channel plan, and loops to the first from the last.
|
||||
# One plays the same item over and over again
|
||||
def set_repeat(self, message: str) -> bool:
|
||||
if message in ["all", "one", "none"]:
|
||||
self.state.update("repeat", message)
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
# Set whether the player should play the item as soon as it's been selected.
|
||||
def set_play_on_load(self, message: bool) -> bool:
|
||||
self.state.update("play_on_load", message)
|
||||
return True
|
||||
|
||||
|
||||
# Show Plan Related Methods
|
||||
|
||||
def _check_ghosts(self, item: PlanItem):
|
||||
# Webstudio returns intermediate "I" objects when dragging in from the media sidebar.
|
||||
if isinstance(item.timeslotitemid, str) and item.timeslotitemid.startswith("I"):
|
||||
# Kinda a bodge for the moment, each "Ghost" (item which is not saved in the database showplan yet)
|
||||
# needs to have a unique temporary item.
|
||||
# To do this, we'll start with the channel number the item was originally added to
|
||||
# (to stop items somehow simultaneously added to different channels from having the same id)
|
||||
# And chuck in the unix epoch in ns for good measure.
|
||||
item.timeslotitemid = "GHOST-{}-{}".format(
|
||||
self.state.get()["channel"], time.time_ns()
|
||||
)
|
||||
return item
|
||||
|
||||
# Pull in from the API the show plan items for this player channel.
|
||||
def get_plan(self, show_plan_id: int):
|
||||
# Call the API
|
||||
# sync turns the asyncronous API into syncronous.
|
||||
plan = sync(self.api.get_showplan(show_plan_id))
|
||||
|
||||
# Empty the channel plan so we can put the updated items in.
|
||||
self.clear_channel_plan()
|
||||
channel = self.state.get()["channel"]
|
||||
self.logger.log.debug(plan)
|
||||
# If there isn't a show plan for the required show, return failure without filling in the plan.
|
||||
if not isinstance(plan, dict):
|
||||
return False
|
||||
|
||||
# Add the items, if this channel has any.
|
||||
if str(channel) in plan.keys():
|
||||
plan_items = plan[str(channel)]
|
||||
try:
|
||||
self.add_to_plan(plan_items)
|
||||
except Exception as e:
|
||||
self.logger.log.error(
|
||||
"Failed to add items to show plan: {}".format(e)
|
||||
)
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
# Add a list of new show plan items to the channel.
|
||||
# These will be in dict format, we'll validate them and turn them into proper plan objects.
|
||||
# TODO Allow just moving an item inside the channel instead of removing and adding.
|
||||
def add_to_plan(self, new_items: List[Dict[str, Any]]) -> bool:
|
||||
plan_copy: List[PlanItem] = copy.copy(self.state.get()["show_plan"])
|
||||
|
||||
for new_item in new_items:
|
||||
new_item_obj = PlanItem(new_item)
|
||||
new_item_obj = self._check_ghosts(new_item_obj)
|
||||
|
||||
# Shift any plan items after the new position down one to make space.
|
||||
for item in plan_copy:
|
||||
if item.weight >= new_item_obj.weight:
|
||||
item.weight += 1
|
||||
|
||||
plan_copy += [new_item_obj] # Add the new item.
|
||||
|
||||
loaded_item = self.state.get()["loaded_item"]
|
||||
if loaded_item:
|
||||
|
||||
# Right. So this may be confusing.
|
||||
# So... If the user has just moved the loaded item in the channel (by removing above and readding)
|
||||
# Then we want to re-associate the loaded_item object reference with the new one.
|
||||
# The loaded item object before this change is now an orphan, which was
|
||||
# kept around while the loaded item was potentially moved to another
|
||||
# channel.
|
||||
if loaded_item.timeslotitemid == new_item_obj.timeslotitemid:
|
||||
self.state.update("loaded_item", new_item_obj)
|
||||
|
||||
# NOPE NOPE NOPE
|
||||
# THIS IS AN EXAMPLE OF WHAT NOT TO DO!
|
||||
# ONCE AGAIN, THE LOADED ITEM IS THE SAME OBJECT INSTANCE AS THE ONE IN
|
||||
# THE SHOW PLAN (AS LONG AS IT HASN'T BEEN RE/MOVED)
|
||||
|
||||
# loaded_item.weight = new_item_obj.weight
|
||||
|
||||
# Bump the loaded_item's weight if we just added a new item above it.
|
||||
# elif loaded_item.weight >= new_item_obj.weight:
|
||||
# loaded_item.weight += 1
|
||||
|
||||
# Else, new weight stays the same.
|
||||
# else:
|
||||
# return True
|
||||
|
||||
# self.state.update("loaded_item", loaded_item)
|
||||
|
||||
# Just in case somehow we've ended up with items with the same weights (or gaps)
|
||||
# We'll correct them.
|
||||
# This function also orders and saves the updated plan copy we've given it.
|
||||
self._fix_and_update_weights(plan_copy)
|
||||
|
||||
return True
|
||||
|
||||
# Removes an item from the show plan with the given weight (index)
|
||||
def remove_from_plan(self, weight: int) -> bool:
|
||||
plan_copy: List[PlanItem] = copy.copy(self.state.get()["show_plan"])
|
||||
found: Optional[PlanItem] = None
|
||||
|
||||
# Give some helpful debug
|
||||
before = []
|
||||
for item in plan_copy:
|
||||
before += (item.weight, item.name)
|
||||
|
||||
self.logger.log.debug(
|
||||
"Weights before removing weight {}:\n{}".format(weight, before)
|
||||
)
|
||||
|
||||
# Look for the item with the correct weight
|
||||
for i in plan_copy:
|
||||
if i.weight == weight:
|
||||
found = i
|
||||
plan_copy.remove(i)
|
||||
|
||||
if found:
|
||||
self._fix_and_update_weights(plan_copy)
|
||||
|
||||
# If we removed the loaded item from this channel, update it's weight
|
||||
# So we know how/not to autoadvance.
|
||||
loaded_item = self.state.get()["loaded_item"]
|
||||
if loaded_item == found:
|
||||
# Loaded_item is actually the same PlanItem instance as in the show_plan.
|
||||
# So if it's still in the show plan, we'll have corrected it's weight already.
|
||||
# If it was removed above, fix_weights won't have done anything
|
||||
# So we'll want to update the weight.
|
||||
|
||||
# We're removing the loaded item from the channel.
|
||||
# if loaded_item.weight == weight:
|
||||
loaded_item.weight = -1
|
||||
|
||||
# If loaded_item wasn't the same instance, we'd want to do the below.
|
||||
|
||||
# We removed an item above it. Shift it up.
|
||||
# elif loaded_item.weight > weight:
|
||||
# loaded_item.weight -= 1
|
||||
# Else, new weight stays the same.
|
||||
# else:
|
||||
# return True
|
||||
|
||||
self.state.update("loaded_item", loaded_item)
|
||||
return True
|
||||
return False
|
||||
|
||||
# Empties the channel's plan.
|
||||
def clear_channel_plan(self) -> bool:
|
||||
self.state.update("show_plan", [])
|
||||
return True
|
||||
|
||||
# PlanItems can have markers. These are essentially bookmarked positions in the audio.
|
||||
# Timeslotitemid can be a ghost (un-submitted item), so may be "IXXX", hence str.
|
||||
def set_marker(self, timeslotitemid: str, marker_str: str):
|
||||
set_loaded = False
|
||||
success = True
|
||||
try:
|
||||
# Take a string representation of the marker (from clients)
|
||||
marker = Marker(marker_str)
|
||||
except Exception as e:
|
||||
self.logger.log.error(
|
||||
|
|
@ -630,6 +700,7 @@ class Player:
|
|||
)
|
||||
return False
|
||||
|
||||
# Allow setting a marker for the currently loaded item.
|
||||
if timeslotitemid == "-1":
|
||||
set_loaded = True
|
||||
if not self.isLoaded:
|
||||
|
|
@ -641,6 +712,9 @@ class Player:
|
|||
):
|
||||
set_loaded = True
|
||||
|
||||
# Loop over the show plan items. When you find the timeslotitemid the marker is for, update it.
|
||||
# This is instead of weight, since the client asking doesn't know the weight of the item (or which channel it is)
|
||||
# So all channels will look and update if necessary.
|
||||
plan_copy: List[PlanItem] = copy.copy(self.state.get()["show_plan"])
|
||||
for i in range(len(self.state.get()["show_plan"])):
|
||||
|
||||
|
|
@ -659,6 +733,7 @@ class Player:
|
|||
)
|
||||
success = False
|
||||
|
||||
# If the item to update was the loaded item, update it.
|
||||
if set_loaded:
|
||||
try:
|
||||
self.state.update(
|
||||
|
|
@ -675,6 +750,8 @@ class Player:
|
|||
|
||||
return success
|
||||
|
||||
# This marks an item as played, or not.
|
||||
# A weight of -1 will affect all items in the channel
|
||||
def set_played(self, weight: int, played: bool):
|
||||
plan: List[PlanItem] = self.state.get()["show_plan"]
|
||||
if weight == -1:
|
||||
|
|
@ -698,17 +775,20 @@ class Player:
|
|||
# If we're going to live (potentially from not live/PFL), potentially tracklist if it's playing.
|
||||
if live:
|
||||
self._potentially_tracklist()
|
||||
# If the fader is now not live, don't bother stopping the tracklist, incase it's faded up again during the same playback.
|
||||
return True
|
||||
|
||||
# Helper functions
|
||||
|
||||
# This essentially allows the tracklist end API call to happen in a separate thread, to avoid hanging playout/loading.
|
||||
# This essentially allows the tracklist start API call to happen in a separate thread, to avoid hanging playout/loading.
|
||||
def _potentially_tracklist(self):
|
||||
mode = self.state.get()["tracklist_mode"]
|
||||
|
||||
time: int = -1
|
||||
if mode in ["on", "fader-live"]:
|
||||
time = 1 # Let's do it pretty quickly.
|
||||
if mode == "on":
|
||||
time = 0 # Let's do it pretty quickly.
|
||||
if mode == "fader-live":
|
||||
time = 4 # Give presenter a bit of a grace period in case they accidentally fade up the wrong one.
|
||||
elif mode == "delayed":
|
||||
# Let's do it in a bit, once we're sure it's been playing. (Useful if we've got no idea if it's live or cueing.)
|
||||
time = TRACKLISTING_DELAYED_S
|
||||
|
|
@ -735,7 +815,7 @@ class Player:
|
|||
self.tracklist_start_timer.cancel()
|
||||
self.tracklist_start_timer = None
|
||||
|
||||
# Decrement Played count on track we didn't play much of.
|
||||
# Decrement Played count on track we didn't play enough of to tracklist.
|
||||
state = self.state.get()
|
||||
loaded_item = state["loaded_item"]
|
||||
if loaded_item and loaded_item.type == "central":
|
||||
|
|
@ -748,9 +828,6 @@ class Player:
|
|||
self.logger.log.info("No tracklist to end.")
|
||||
return
|
||||
|
||||
self.logger.log.info(
|
||||
"Setting timer for ending tracklist_id '{}'".format(tracklist_id)
|
||||
)
|
||||
if tracklist_id:
|
||||
self.logger.log.info(
|
||||
"Attempting to end tracklist_id '{}'".format(tracklist_id)
|
||||
|
|
@ -770,6 +847,7 @@ class Player:
|
|||
"Failed to potentially end tracklist, no tracklist started."
|
||||
)
|
||||
|
||||
# The actual function that will register with the API an item being played.
|
||||
def _tracklist_start(self):
|
||||
state = self.state.get()
|
||||
loaded_item = state["loaded_item"]
|
||||
|
|
@ -811,6 +889,7 @@ class Player:
|
|||
# No matter what we end up doing, we need to kill this timer so future ones can run.
|
||||
self.tracklist_start_timer = None
|
||||
|
||||
# The actual function that will register with the API an item being finished playing.
|
||||
def _tracklist_end(self, tracklist_id):
|
||||
|
||||
if tracklist_id:
|
||||
|
|
@ -823,8 +902,10 @@ class Player:
|
|||
"Tracklist_id to _tracklist_end() missing. Failed to end tracklist."
|
||||
)
|
||||
|
||||
# No matter what we end up doing, we need to kill this timer so future ones can run.
|
||||
self.tracklist_end_timer = None
|
||||
|
||||
# When an item has ended (the pygame mixer has told us that it has stopped playing)
|
||||
def _ended(self):
|
||||
self._potentially_end_tracklist()
|
||||
|
||||
|
|
@ -844,7 +925,7 @@ class Player:
|
|||
# Just make sure that if we stop and do nothing, we end up at 0.
|
||||
self.state.update("pos", 0)
|
||||
|
||||
# Repeat 1
|
||||
# Repeat 1? Spin that record again!
|
||||
# TODO ENUM
|
||||
if state["repeat"] == "one":
|
||||
self.play()
|
||||
|
|
@ -882,10 +963,12 @@ class Player:
|
|||
self.stop()
|
||||
self._retAll("STOPPED") # Tell clients that we've stopped playing.
|
||||
|
||||
# This runs every main loop, to update anything that changes often / automatically.
|
||||
def _updateState(self, pos: Optional[float] = None):
|
||||
|
||||
self.state.update("initialised", self.isInit)
|
||||
if self.isInit:
|
||||
# Is pygame still happy?
|
||||
isInit = self.isInit
|
||||
self.state.update("initialised", isInit)
|
||||
if isInit:
|
||||
if pos is not None:
|
||||
# Seeking sets the position like this when not playing.
|
||||
self.state.update("pos", pos) # Reset back to 0 if stopped.
|
||||
|
|
@ -919,6 +1002,8 @@ class Player:
|
|||
self.state.get()["pos_true"])),
|
||||
)
|
||||
|
||||
# Sends the current playback position to clients, so they can update their UI frequently.
|
||||
# Run on every main loop, but rate limited.
|
||||
def _ping_times(self):
|
||||
|
||||
UPDATES_FREQ_SECS = 0.2
|
||||
|
|
@ -929,10 +1014,12 @@ class Player:
|
|||
self.last_time_update = time.time()
|
||||
self._retAll("POS:" + str(self.state.get()["pos_true"]))
|
||||
|
||||
# Broadcast a message to all other modules of the BAPSicle server.
|
||||
def _retAll(self, msg):
|
||||
if self.out_q:
|
||||
self.out_q.put("ALL:" + msg)
|
||||
|
||||
# Send a response back to an incoming command, with the original content and a success or failure.
|
||||
def _retMsg(
|
||||
self, msg: Any, okay_str: bool = False, custom_prefix: Optional[str] = None
|
||||
):
|
||||
|
|
@ -961,12 +1048,13 @@ class Player:
|
|||
"Message return Queue is missing!!!! Can't send message."
|
||||
)
|
||||
|
||||
# Send the current status to all other modules/clients. Used for updating all client UIs when one of them causes a change etc.
|
||||
def _send_status(self):
|
||||
# TODO This is hacky
|
||||
self._retMsg(str(self.status), okay_str=True,
|
||||
custom_prefix="ALL:STATUS:")
|
||||
|
||||
def _fix_and_update_weights(self, plan):
|
||||
# Takes an input show plan, checks and corrects duplicate / gaps in weights, and stores it.
|
||||
def _fix_and_update_weights(self, plan: List[PlanItem]):
|
||||
def _sort_weight(e: PlanItem):
|
||||
return e.weight
|
||||
|
||||
|
|
@ -994,6 +1082,7 @@ class Player:
|
|||
self.logger.log.debug("Weights after sorting:\n{}".format(fixed))
|
||||
self.state.update("show_plan", plan)
|
||||
|
||||
# Player start up. This is called from the BAPSicle server.py.
|
||||
def __init__(
|
||||
self,
|
||||
channel: int,
|
||||
|
|
@ -1023,28 +1112,30 @@ class Player:
|
|||
|
||||
self.state.update("start_time", datetime.now().timestamp())
|
||||
|
||||
# When the state changes, use _send_status() to tell all clients.
|
||||
self.state.add_callback(self._send_status)
|
||||
|
||||
self.state.update("channel", channel)
|
||||
# tracklist mode is shared between all players, so grab that from the server config.
|
||||
self.state.update("tracklist_mode", server_state.get()[
|
||||
"tracklist_mode"])
|
||||
self.state.update(
|
||||
"live", True
|
||||
) # Channel is live until controller says it isn't.
|
||||
) # Channel Fader is live until controller says it isn't.
|
||||
|
||||
# Just in case there's any weights somehow messed up, let's fix them.
|
||||
plan_copy: List[PlanItem] = copy.copy(self.state.get()["show_plan"])
|
||||
self._fix_and_update_weights(plan_copy)
|
||||
|
||||
loaded_state = copy.copy(self.state.state)
|
||||
loaded_state = self.state.state
|
||||
|
||||
if loaded_state["output"]:
|
||||
self.logger.log.info("Setting output to: " +
|
||||
str(loaded_state["output"]))
|
||||
self.output(loaded_state["output"])
|
||||
self.set_output(loaded_state["output"])
|
||||
else:
|
||||
self.logger.log.info("Using default output device.")
|
||||
self.output()
|
||||
self.set_output()
|
||||
|
||||
loaded_item = loaded_state["loaded_item"]
|
||||
if loaded_item:
|
||||
|
|
@ -1072,11 +1163,15 @@ class Player:
|
|||
else:
|
||||
self.logger.log.info("No file was previously loaded to resume.")
|
||||
|
||||
# The main loop. This keeps running till something tells it to stop.
|
||||
try:
|
||||
while self.running:
|
||||
# Update the state for playback position changes etc
|
||||
self._updateState()
|
||||
# If we need to, tell clients of the position updates
|
||||
self._ping_times()
|
||||
try:
|
||||
# Try and get a new command message from clients
|
||||
message = in_q.get_nowait()
|
||||
source = message.split(":")[0]
|
||||
if source not in VALID_MESSAGE_SOURCES:
|
||||
|
|
@ -1115,8 +1210,9 @@ class Player:
|
|||
# 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]))
|
||||
self._retMsg(self.set_output(split[1]))
|
||||
|
||||
# Only process these commands if we're properly initialised.
|
||||
elif self.isInit:
|
||||
message_types: Dict[
|
||||
str, Callable[..., Any]
|
||||
|
|
@ -1194,6 +1290,7 @@ class Player:
|
|||
|
||||
message_type: str = self.last_msg.split(":")[0]
|
||||
|
||||
# From the list above, work out which command type we have, and run it's handling function.
|
||||
if message_type in message_types.keys():
|
||||
message_types[message_type]()
|
||||
|
||||
|
|
@ -1205,7 +1302,7 @@ class Player:
|
|||
else:
|
||||
self._retMsg("Unknown Command")
|
||||
else:
|
||||
|
||||
# We're not initialised, return a failed status if they asked for one, or just say the command failed
|
||||
if self.last_msg == "STATUS":
|
||||
self._retMsg(self.status)
|
||||
else:
|
||||
|
|
|
|||
Loading…
Reference in a new issue