AudioPlayerThreadSafe.h

#pragma once
 
#include "AudioTools/CoreAudio/AudioPlayer.h"
 
namespace audio_tools {
 
enum class AudioPlayerCommandType {
  Begin,
  End,
  Next,
  SetIndex,
  SetPath,
  SetVolume,
  SetMuted,
  SetActive
};
 
struct AudioPlayerCommand {
  AudioPlayerCommandType type;
  int index = 0;         // begin/setIndex
  bool isActive = true;  // begin/setActive
  int offset = 1;        // next
  float volume = 0.0f;   // setVolume
  bool muted = false;    // setMuted
};
 
template <template <class> class QueueT>
class AudioPlayerThreadSafe {
 public:
  AudioPlayerThreadSafe(AudioPlayer& p, QueueT<AudioPlayerCommand>& queue)
      : player(p), queue(queue) {}
 
  // Control API: enqueue only; applied in copy()
  bool begin(int index = 0, bool isActive = true) {
    AudioPlayerCommand c{AudioPlayerCommandType::Begin};
    c.index = index;
    c.isActive = isActive;
    return enqueue(c);
  }
 
  void end() {
    AudioPlayerCommand c{AudioPlayerCommandType::End};
    enqueue(c);
  }
 
  bool next(int offset = 1) {
    AudioPlayerCommand c{AudioPlayerCommandType::Next};
    c.offset = offset;
    return enqueue(c);
  }
 
  bool setIndex(int idx) {
    AudioPlayerCommand c{AudioPlayerCommandType::SetIndex};
    c.index = idx;
    return enqueue(c);
  }
 
  bool setPath(const char* path) {
    AudioPlayerCommand c{AudioPlayerCommandType::SetPath};
    this->path = path;
    return enqueue(c);
  }
 
  size_t copy() {
    if (queue.size() > 0) processCommands();
    return player.copy();
  }
 
  size_t copy(size_t bytes) {
    if (queue.size() > 0) processCommands();
    return player.copy(bytes);
  }
 
  void setActive(bool active) {
    AudioPlayerCommand c{AudioPlayerCommandType::SetActive};
    c.isActive = active;
    enqueue(c);
  }
 
  bool setVolume(float v) {
    AudioPlayerCommand c{AudioPlayerCommandType::SetVolume};
    c.volume = v;
    return enqueue(c);
  }
 
  bool setMuted(bool muted) {
    AudioPlayerCommand c{AudioPlayerCommandType::SetMuted};
    c.muted = muted;
    return enqueue(c);
  }
 
 private:
  AudioPlayer& player;
  // Internal command queue
  QueueT<AudioPlayerCommand>& queue;
  Str path;
 
  // Drain command queue and apply to underlying player
  void processCommands() {
    AudioPlayerCommand cmd;
    // Attempt non-blocking dequeue loop; requires queue configured non-blocking
    while (dequeue(cmd)) {
      switch (cmd.type) {
        case AudioPlayerCommandType::Begin:
          player.begin(cmd.index, cmd.isActive);
          break;
        case AudioPlayerCommandType::End:
          player.end();
          break;
        case AudioPlayerCommandType::Next:
          player.next(cmd.offset);
          break;
        case AudioPlayerCommandType::SetIndex:
          player.setIndex(cmd.index);
          break;
        case AudioPlayerCommandType::SetPath:
          player.setPath(path.c_str());
          break;
        case AudioPlayerCommandType::SetVolume:
          player.setVolume(cmd.volume);
          break;
        case AudioPlayerCommandType::SetMuted:
          player.setMuted(cmd.muted);
          break;
        case AudioPlayerCommandType::SetActive:
          player.setActive(cmd.isActive);
          break;
      }
      if (queue.size() == 0) break;
    }
  }
 
  // Queue facade wrappers to allow both internal/external queues
  bool enqueue(AudioPlayerCommand& c) { return queue.enqueue(c); }
 
  bool dequeue(AudioPlayerCommand& c) { return queue.dequeue(c); }
};
 
}  // namespace audio_tools