RTSPAudioSource.h

#pragma once
 
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "IAudioSource.h"
#include "RTSPFormat.h"
#include "RTSPPlatform.h"
 
 
namespace audio_tools {
 
class RTSPAudioSource : public IAudioSource {
 public:
  RTSPAudioSource() = default;
 
  virtual ~RTSPAudioSource() {
    TRACEI();
    stop();                // Ensure we're properly stopped
    m_magic = 0xDEADFACE;  // Invalidate magic number
  }
 
  RTSPAudioSource(AudioStream &stream) { setInput(stream); }
 
  RTSPAudioSource(Stream &stream, AudioInfo info) { setInput(stream, info); }
 
  RTSPAudioSource(Stream &stream, RTSPFormat &format) {
    setInput(stream);
    setFormat(format);
  }
 
  void setInput(AudioStream &stream) {
    p_stream = &stream;
    p_audiostream = &stream;
  }
 
  void setInput(Stream &stream, AudioInfo info) {
    p_stream = &stream;
    p_audiostream = nullptr;
    setAudioInfo(info);
  }
 
  void setInput(Stream &stream) {
    p_stream = &stream;
    p_audiostream = nullptr;
  }
 
  void setAudioInfo(AudioInfo info) {
    TRACEI();
    default_format.begin(info);
    if (p_audiostream) {
      p_audiostream->setAudioInfo(info);
    }
  }
 
  int readBytes(void *dest, int byteCount) override {
    // Validate object integrity
    if (m_magic != MAGIC_NUMBER) {
      LOGE("RTSPAudioSource: invalid magic number 0x%08x, object corrupted",
           m_magic);
      return 0;
    }
 
    // Validate parameters
    if (dest == nullptr || byteCount <= 0) {
      LOGW("RTSPAudioSource: invalid parameters dest=%p byteCount=%d", dest,
           byteCount);
      return 0;
    }
 
    time_of_last_read = millis();
 
    int result = 0;
    LOGD("readDataTo: %d", byteCount);
    if (started && p_stream) {
      result = p_stream->readBytes((uint8_t *)dest, byteCount);
    }
    return result;
  }
 
  void start() override {
    TRACEI();
 
    // Validate object integrity
    if (m_magic != MAGIC_NUMBER) {
      LOGE("RTSPAudioSource: start called on corrupted object, magic=0x%08x",
           m_magic);
      return;
    }
 
    IAudioSource::start();
    if (p_audiostream) {
      p_audiostream->begin();
    }
    started = true;
  }
 
  void stop() override {
    TRACEI();
 
    // Validate object integrity (allow stop even if corrupted for cleanup)
    if (m_magic != MAGIC_NUMBER) {
      LOGW(
          "RTSPAudioSource: stop called on corrupted object, magic=0x%08x, "
          "proceeding anyway",
          m_magic);
    }
 
    IAudioSource::stop();
    started = false;
    if (p_audiostream) {
      p_audiostream->end();
    }
  }
 
  void setFragmentSize(int fragmentSize) {
    getFormat().setFragmentSize(fragmentSize);
  }
 
  void setTimerPeriod(int period) { getFormat().setTimerPeriodUs(period); }
 
  bool isActive() {
    if (!started) return false;
    if (timeout > 0) {
      return millis() - time_of_last_read < timeout;
    }
    return true;
  }
 
  bool isStarted() { return started; }
 
  void setFormat(RTSPFormat &format) { p_format = &format; }
 
  RTSPFormat &getFormat() override { return *p_format; }
 
  void setTimeout(uint16_t to) { timeout = to; }
 
 protected:
  const uint32_t MAGIC_NUMBER =
      0xFEEDFACE;                   // Magic number for object validation
  uint32_t m_magic = MAGIC_NUMBER;  // Object validity marker
  Stream *p_stream = nullptr;
  AudioStream *p_audiostream = nullptr;
  uint32_t time_of_last_read = 0;
  bool started = false;
  RTSPFormatPCM default_format;            // Used for AudioStream sources
  RTSPFormat *p_format = &default_format;  // kept internally as pointer;
                                           // externally exposed as reference
  uint16_t timeout = 0;
};
 
}  // namespace audio_tools