AudioPlayer.h

Go to the documentation of this file.

#pragma once
 
#include "AudioToolsConfig.h"
#include "AudioTools/AudioCodecs/AudioCodecs.h"
#include "AudioTools/CoreAudio/AudioBasic/Debouncer.h"
#include "AudioTools/CoreAudio/AudioLogger.h"
#include "AudioTools/CoreAudio/AudioMetaData/MetaData.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "AudioTools/CoreAudio/AudioTypes.h"
#include "AudioTools/CoreAudio/BaseConverter.h"
#include "AudioTools/CoreAudio/Buffers.h"
#include "AudioTools/CoreAudio/Fade.h"
#include "AudioTools/CoreAudio/StreamCopy.h"
#include "AudioTools/CoreAudio/Analysis/VolumeStream.h"
#include "AudioTools/Disk/AudioSource.h"
 
namespace audio_tools {
 
class AudioPlayer : public AudioInfoSupport, public VolumeSupport {
 public:
  AudioPlayer() { TRACED(); }
 
  AudioPlayer(AudioSource& source, AudioOutput& output, AudioDecoder& decoder) {
    TRACED();
    this->p_source = &source;
    this->p_decoder = &decoder;
    setOutput(output);
    // notification for audio configuration
    decoder.addNotifyAudioChange(*this);
  }
 
  AudioPlayer(AudioSource& source, Print& output, AudioDecoder& decoder,
              AudioInfoSupport* notify = nullptr) {
    TRACED();
    this->p_source = &source;
    this->p_decoder = &decoder;
    setOutput(output);
    addNotifyAudioChange(notify);
  }
 
  AudioPlayer(AudioSource& source, AudioStream& output, AudioDecoder& decoder) {
    TRACED();
    this->p_source = &source;
    this->p_decoder = &decoder;
    setOutput(output);
    // notification for audio configuration
    decoder.addNotifyAudioChange(*this);
  }
 
  AudioPlayer(AudioPlayer const&) = delete;
 
  AudioPlayer& operator=(AudioPlayer const&) = delete;
 
  void setOutput(AudioOutput& output) {
    if (p_decoder->isResultPCM()) {
      this->fade.setOutput(output);
      this->volume_out.setOutput(fade);
      out_decoding.setOutput(&volume_out);
      out_decoding.setDecoder(p_decoder);
    } else {
      out_decoding.setOutput(&output);
      out_decoding.setDecoder(p_decoder);
    }
    this->p_final_print = &output;
    this->p_final_stream = nullptr;
  }
 
  void setOutput(Print& output) {
    if (p_decoder->isResultPCM()) {
      this->fade.setOutput(output);
      this->volume_out.setOutput(fade);
      out_decoding.setOutput(&volume_out);
      out_decoding.setDecoder(p_decoder);
    } else {
      out_decoding.setOutput(&output);
      out_decoding.setDecoder(p_decoder);
    }
    this->p_final_print = nullptr;
    this->p_final_stream = nullptr;
  }
 
  void setOutput(AudioStream& output) {
    if (p_decoder->isResultPCM()) {
      this->fade.setOutput(output);
      this->volume_out.setOutput(fade);
      out_decoding.setOutput(&volume_out);
      out_decoding.setDecoder(p_decoder);
    } else {
      out_decoding.setOutput(&output);
      out_decoding.setDecoder(p_decoder);
    }
    this->p_final_print = nullptr;
    this->p_final_stream = &output;
  }
 
  void setBufferSize(int size) { copier.resize(size); }
 
  bool begin(int index = 0, bool isActive = true) {
    TRACED();
    bool result = false;
    // initilaize volume
    if (current_volume == -1.0f) {
      setVolume(1.0f);
    } else {
      setVolume(current_volume);
    }
 
    // take definition from source
    autonext = p_source->isAutoNext();
 
    // initial audio info for fade from output when not defined yet
    setupFade();
 
    // start dependent objects
    out_decoding.begin();
 
    if (!p_source->begin()) {
      LOGE("Could not start audio source");
      return false;
    }
    if (!meta_out.begin()) {
      LOGE("Could not start metadata output");
      return false;
    }
    if (!volume_out.begin()) {
      LOGE("Could not start volume control");
      return false;
    }
 
    if (index >= 0) {
      setStream(p_source->selectStream(index));
      if (p_input_stream != nullptr) {
        if (meta_active) {
          copier.setCallbackOnWrite(decodeMetaData, this);
        }
        copier.begin(out_decoding, *p_input_stream);
        timeout = millis() + p_source->timeoutAutoNext();
        active = isActive;
        result = true;
      } else {
        LOGW("-> begin: no data found");
        active = false;
        result = false;
      }
    } else {
      LOGW("-> begin: no stream selected");
      active = isActive;
      result = false;
    }
    return result;
  }
 
  void end() {
    TRACED();
    active = false;
    eof_called = false;
    out_decoding.end();
    meta_out.end();
    // remove any data in the decoder
    if (p_decoder != nullptr) {
      LOGI("reset codec");
      p_decoder->end();
      p_decoder->begin();
    }
  }
 
  AudioSource& audioSource() { return *p_source; }
 
  void setAudioSource(AudioSource& source) { this->p_source = &source; }
 
  void setDecoder(AudioDecoder& decoder) {
    this->p_decoder = &decoder;
    out_decoding.setDecoder(p_decoder);
  }
 
  void addNotifyAudioChange(AudioInfoSupport* notify) {
    this->p_final_notify = notify;
    // notification for audio configuration
    if (p_decoder != nullptr) {
      p_decoder->addNotifyAudioChange(*this);
    }
  }
 
  void setAudioInfo(AudioInfo info) override {
    TRACED();
    LOGI("sample_rate: %d", (int)info.sample_rate);
    LOGI("bits_per_sample: %d", (int)info.bits_per_sample);
    LOGI("channels: %d", (int)info.channels);
    this->info = info;
    // notifiy volume
    volume_out.setAudioInfo(info);
    fade.setAudioInfo(info);
    // notifiy final ouput: e.g. i2s
    if (p_final_print != nullptr) p_final_print->setAudioInfo(info);
    if (p_final_stream != nullptr) p_final_stream->setAudioInfo(info);
    if (p_final_notify != nullptr) p_final_notify->setAudioInfo(info);
  };
 
  AudioInfo audioInfo() override { return info; }
 
  void play() {
    TRACED();
    setActive(true);
  }
 
  bool playPath(const char* path) {
    TRACED();
    if (!setPath(path)) {
      LOGW("Could not open file: %s", path);
      return false;
    }
 
    LOGI("Playing %s", path);
    // start if inactive
    play();
    // process all data
    copyAll();
 
    LOGI("%s has finished playing", path);
    return true;
  }
 
  bool playFile(const char* path) { return playPath(path); }
 
  void stop() {
    TRACED();
    setActive(false);
  }
 
  void clearBuffers(bool drainSource = false) {
    TRACED();
    if (drainSource && p_input_stream != nullptr) {
      // Snapshot once: a live source keeps receiving new bytes
      // continuously, so re-checking available() after every read could
      // never terminate - only discard what had already piled up up to
      // this point. Anything that arrives during the drain is fresh
      // ("now") data anyway, so leaving it for normal playback after
      // resuming is correct, not a bug.
      int remaining = p_input_stream->available();
      uint8_t tmp[256];
      while (remaining > 0) {
        int to_read = min(remaining, (int)sizeof(tmp));
        int got = p_input_stream->readBytes(tmp, to_read);
        if (got <= 0) break;  // stream stalled - stop rather than spin
        remaining -= got;
      }
    }
    if (p_decoder != nullptr) {
      p_decoder->end();
      p_decoder->begin();
    }
  }
 
  bool next(int offset = 1) {
    TRACED();
    writeEnd();
    stream_increment = offset >= 0 ? 1 : -1;
    active = setStream(p_source->nextStream(offset));
    return active;
  }
 
  bool setIndex(int idx) {
    TRACED();
    writeEnd();
    stream_increment = 1;
    active = setStream(p_source->selectStream(idx));
    return active;
  }
 
  bool setPath(const char* path) {
    TRACED();
    writeEnd();
    stream_increment = 1;
    active = setStream(p_source->selectStream(path));
    return active;
  }
 
  bool previous(int offset = 1) {
    TRACED();
    writeEnd();
    stream_increment = -1;
    active = setStream(p_source->previousStream(abs(offset)));
    return active;
  }
 
  bool setStream(Stream* input) {
    end();
    out_decoding.begin();
    p_input_stream = input;
    eof_called = false;  // reset EOF state for new stream
    if (p_input_stream != nullptr) {
      LOGD("open selected stream");
      meta_out.begin();
      copier.begin(out_decoding, *p_input_stream);
    }
    // execute callback if defined
    if (on_stream_change_callback != nullptr)
      on_stream_change_callback(p_input_stream, p_reference);
    return p_input_stream != nullptr;
  }
 
  Stream* getStream() { return p_input_stream; }
 
  bool isActive() { return active; }
 
  operator bool() { return isActive(); }
 
  void setActive(bool isActive) {
    if (is_auto_fade) {
      if (isActive) {
        fade.setFadeInActive(true);
      } else {
        fade.setFadeOutActive(true);
        copier.copy();
        writeSilence(2048);
      }
    }
    active = isActive;
  }
 
  bool setVolume(float volume) override {
    bool result = true;
    if (volume >= 0.0f && volume <= 1.0f) {
      if (abs(volume - current_volume) > 0.01f) {
        LOGI("setVolume(%f)", volume);
        volume_out.setVolume(volume);
        current_volume = volume;
      }
    } else {
      LOGE("setVolume value '%f' out of range (0.0 -1.0)", volume);
      result = false;
    }
    return result;
  }
 
  bool setVolume(float volume, int channel) {
    return volume_out.setVolume(volume, channel);
  }
 
  float volume() override { return current_volume; }
 
  float volume(int channel) { return volume_out.volume(channel); }
 
  void setAutoNext(bool next) { autonext = next; }
 
  void setDelayIfOutputFull(int delayMs) { delay_if_full = delayMs; }
 
  size_t copy() { return copy(copier.bufferSize()); }
 
  size_t copyAll() {
    size_t result = 0;
    size_t step = copy();
    while (step > 0) {
      result += step;
      step = copy();
    }
    return result;
  }
 
  size_t copy(size_t bytes) {
    size_t result = 0;
    if (active) {
      if (delay_if_full != 0 && ((p_final_print != nullptr &&
                                  p_final_print->availableForWrite() == 0) ||
                                 (p_final_stream != nullptr &&
                                  p_final_stream->availableForWrite() == 0))) {
        // not ready to do anything - so we wait a bit
        delay(delay_if_full);
        LOGD("copy: %d -> 0", (int)bytes);
        return 0;
      }
 
      // handle sound
      result = copier.copyBytes(bytes);
      if (result > 0 || timeout == 0) {
        // reset timeout if we had any data
        timeout = millis() + p_source->timeoutAutoNext();
      }
 
      // move to next stream after timeout
      moveToNextFileOnTimeout();
 
      // return silence when there was no data
      if (result < bytes && silence_on_inactive) {
        writeSilence(bytes - result);
      }
 
    } else {
      // e.g. A2DP should still receive data to keep the connection open
      if (silence_on_inactive) {
        writeSilence(bytes);
      }
    }
    LOGD("copy: %d -> %d", (int)bytes, (int)result);
    return result;
  }
 
  void setVolumeControl(VolumeControl& vc) { volume_out.setVolumeControl(vc); }
 
  StreamCopy& getStreamCopy() { return copier; }
 
  void setSilenceOnInactive(bool active) { silence_on_inactive = active; }
 
  bool isSilenceOnInactive() { return silence_on_inactive; }
 
  void writeSilence(size_t bytes) {
    TRACEI();
    if (p_final_print != nullptr) {
      p_final_print->writeSilence(bytes);
    } else if (p_final_stream != nullptr) {
      p_final_stream->writeSilence(bytes);
    }
  }
 
  VolumeStream& getVolumeStream() { return volume_out; }
 
  void setAutoFade(bool active) { is_auto_fade = active; }
 
  bool isAutoFade() { return is_auto_fade; }
 
  void setMetaDataSize(int size) { meta_out.resize(size); }
 
  void setReference(void* ref) { p_reference = ref; }
 
  void setMetadataCallback(void (*callback)(MetaDataType type, const char* str,
                                            int len),
                           ID3TypeSelection sel = SELECT_ID3) {
    TRACEI();
    // setup metadata.
    if (p_source->setMetadataCallback(callback)) {
      // metadata is handled by source
      LOGI("Using ICY Metadata");
      meta_active = false;
    } else {
      // metadata is handled here
      meta_out.setCallback(callback);
      meta_out.setFilter(sel);
      meta_active = true;
    }
  }
 
  void setOnStreamChangeCallback(void (*callback)(Stream* stream_ptr,
                                                  void* reference)) {
    on_stream_change_callback = callback;
    if (p_input_stream != nullptr) callback(p_input_stream, p_reference);
  }
 
  void setOnEOFCallback(void (*callback)(AudioPlayer& player)) {
    on_eof_callback = callback;
  }
 
  bool setMuted(bool muted) {
    if (muted) {
      if (current_volume > 0.0f) {
        muted_volume = current_volume;
        setVolume(0.0f);
      }
    } else {
      if (muted_volume > 0.0f) {
        setVolume(muted_volume);
        muted_volume = 0.0f;
      }
    }
    return true;
  }
 
  bool isMuted() { return current_volume == 0.0f; }
 
 protected:
  bool active = false;
  bool autonext = true;
  bool silence_on_inactive = false;
  AudioSource* p_source = nullptr;
  VolumeStream volume_out;  // Volume control
  FadeStream fade;          // Phase in / Phase Out to avoid popping noise
  MetaDataID3 meta_out;     // Metadata parser
  EncodedAudioOutput out_decoding;  // Decoding stream
  CopyDecoder no_decoder{true};
  AudioDecoder* p_decoder = &no_decoder;
  Stream* p_input_stream = nullptr;
  AudioOutput* p_final_print = nullptr;
  AudioStream* p_final_stream = nullptr;
  AudioInfoSupport* p_final_notify = nullptr;
  StreamCopy copier;  // copies sound into i2s
  AudioInfo info;
  bool meta_active = false;
  uint32_t timeout = 0;
  int stream_increment = 1;      // +1 moves forward; -1 moves backward
  float current_volume = -1.0f;  // illegal value which will trigger an update
  float muted_volume = 0.0f;
  int delay_if_full = 100;
  bool is_auto_fade = true;
  void* p_reference = nullptr;
  void (*on_stream_change_callback)(Stream* stream_ptr,
                                    void* reference) = nullptr;
  // EOF callback and guard (invoked once when current stream reaches end)
  void (*on_eof_callback)(AudioPlayer& player) = nullptr;
  bool eof_called = false;
 
  void setupFade() {
    if (p_final_print != nullptr) {
      fade.setAudioInfo(p_final_print->audioInfo());
    } else if (p_final_stream != nullptr) {
      fade.setAudioInfo(p_final_stream->audioInfo());
    }
  }
 
  void moveToNextFileOnTimeout() {
    if (p_final_stream != nullptr && p_final_stream->availableForWrite() == 0)
      return;
    if (p_input_stream == nullptr || millis() > timeout) {
      if (is_auto_fade) fade.setFadeInActive(true);
 
      // EOF callback: trigger once per stream
      if (!eof_called) {
        eof_called = true;
        if (on_eof_callback != nullptr) {
          on_eof_callback(*this);
        }
      }
 
      if (autonext) {
        LOGI("-> timeout - moving by %d", stream_increment);
        // open next stream
        if (!next(stream_increment)) {
          LOGD("stream is null");
        }
      } else {
        active = false;
      }
      timeout = millis() + p_source->timeoutAutoNext();
    }
  }
 
  void writeEnd() {
    // end silently
    TRACEI();
    if (is_auto_fade) {
      fade.setFadeOutActive(true);
      copier.copy();
      // start by fading in
      fade.setFadeInActive(true);
    }
    // restart the decoder to make sure it does not contain any audio when we
    // continue
    p_decoder->begin();
    eof_called = false;  // prepare for next stream
    // Discard whatever of the just-faded-out stream is still sitting in the
    // output's own buffer (e.g. an I2S DMA buffer) but not yet physically
    // played. Without this, opening the next stream below can block for a
    // while (file/network I/O), during which that leftover old-stream audio
    // keeps playing out on its own - heard as a chunk of the previous track
    // after the switch instead of a clean cut to the new one. No-op for
    // outputs that don't support it.
    if (p_final_print != nullptr) {
      p_final_print->flush();
    } else if (p_final_stream != nullptr) {
      p_final_stream->flush();
    }
  }
 
  static void decodeMetaData(void* obj, void* data, size_t len) {
    LOGD("%s, %zu", LOG_METHOD, len);
    AudioPlayer* p = (AudioPlayer*)obj;
    if (p->meta_active) {
      p->meta_out.write((const uint8_t*)data, len);
    }
  }
};
 
}  // namespace audio_tools