SIDPlayer.h

#pragma once
#include "AudioTools.h"
#include "SIDAudioSource.h"
#include "SIDStream.h"
#include "SIDConfig.h"
 
namespace audio_tools {
 
class SIDPlayer : public AudioInfoSupport {
public:
  SIDPlayer(AudioSource &source, AudioOutput &output, SizeSource &sizeSource) {
    static CodecNOP nop;
    p_size_source = &sizeSource;
    player.setAudioSource(source);
    player.setOutput(output);
    p_info = &output;
    p_out = &output;
  }
  
  SIDPlayer(AudioSource &source, AudioStream &output, SizeSource &sizeSource) {
    static CodecNOP nop;
    p_size_source = &sizeSource;
    player.setAudioSource(source);
    player.setOutput(output);
    p_info = &output;
    p_out = &output;
  }
 
  bool begin(int index = 0, bool isActive = true) {
    TRACEI();
    // get update audio info from destination
    setAudioInfo(p_info->audioInfo());
    info.logInfo();
    player.setAudioInfo(info);
    // setup sid stream
    auto cfg = sid.defaultConfig();
    cfg.copyFrom(info);
    sid.begin(cfg);
 
    // make sure we have valid audio data
    assert(cfg.channels>0);
    assert(cfg.sample_rate>0);
    assert(cfg.bits_per_sample==16);
 
    // setup player
    player.setAutoNext(false);
    bool result = player.begin(index, isActive);
 
    return result;
  }
  void end() {
    player.end();
    sid.end();
  }
 
  void setAudioInfo(AudioInfo info) override {
    TRACED();
    this->info = info;
  };
 
  AudioInfo audioInfo() override { return info; }
 
  void play() { player.play(); }
 
  void stop() { player.stop(); }
 
  bool previous(int offset = 1) {
    state = Initial;
    return player.previous(offset);
  }
 
  bool next(int offset = 1) {
    state = Initial;
    return player.next(offset);
  }
 
  bool nextTune(int offset = 1) {
    int tune =sid.getStreamConfigdata().subtune;
    tune = (++tune) % sid.getMetadata().total_tunes;
    sid.setTune(tune);
    return true;
  }
 
  bool setIndex(int idx) {
    state = Initial;
    return player.setIndex(idx);
  }
 
  bool setPath(const char *path) {
    state = Initial;
    return player.setPath(path);
  }
 
  Stream *getStream() { return player.getStream(); }
 
  bool isActive() { return player.isActive(); }
 
  operator bool() { return isActive(); }
 
  void setActive(bool isActive) { player.setActive(isActive); }
 
  void setVolume(float volume) { player.setVolume(volume); }
 
  float volume() { return player.volume(); }
 
  void setSilenceOnInactive(bool active) {
    player.setSilenceOnInactive(active);
  }
 
  bool isSilenceOnInactive() { return player.isSilenceOnInactive(); }
 
  void setTimeout(size_t timeout) { timeout_sec = timeout; }
 
  void copy() {
    TRACED();
    if (!isActive()) {
      if (isSilenceOnInactive()) {
        player.writeSilence(DEFAULT_BUFFER_SIZE);
      }
      return;
    }
 
    if (state == Initial) {
      loadSID();
      setIsPlayingTimeout();  
      setSIDAsInput();
 
    } else {
      // play sid file
      player.copy();
      // We can set a timeout for each song
      if (isPlayingTimedOut()) {
        moveNextOnEnd();
      }
    }
  }
 
protected:
  AudioPlayer player;
  SIDStream sid;
  Print *p_out;
  AudioInfoSupport *p_info;
  AudioInfo info;
  Vector<uint8_t> sid_data{0};
  SizeSource *p_size_source = nullptr;
  enum proces_state_enum { Initial, Playing };
  proces_state_enum state = Initial;
  size_t timeout_sec = 0;
  size_t playing_timout_ms = 0;
 
  Print *getOutput() { return player.getVolumeOutput(); }
 
  void loadSID() {
    TRACEI();
    Stream *p_stream = getStream();
    // allocate memory
    int size = p_size_source->size();
    sid_data.resize(size);
    p_stream->readBytes(sid_data.data(), size);
    LOGI("setSID size: %d", size);
    if (size<MAX_FILE_SIZE){
      sid.setSID(sid_data.data(), size, 0);
      state = Playing;
    } else {
      LOGE("Song is too big!");
      next(1);
    }
 
    if (MEMORY_ALLOCATION_LOGIC!=4){
      // release memory again
      sid_data.resize(0);
    }
  }
 
  void setIsPlayingTimeout() {
    if (timeout_sec > 0) {
      playing_timout_ms = millis() + (timeout_sec * 1000);
    }
  }
 
  bool isPlayingTimedOut() {
    return (playing_timout_ms == 0) ? false : millis() > playing_timout_ms;
  }
 
  void moveNextOnEnd() {
    TRACEI();
    // move to next play
    next(1);
  }
 
  void setSIDAsInput(){
    StreamCopy *p_copy = &player.getStreamCopy();
    p_copy->begin(*getOutput(), sid);
    player.setActive(true);
  }
};
 
} // namespace audio_tools