RTSPOutput.h

Go to the documentation of this file.

/*
 * Author: Phil Schatzmann
 *
 * Based on Micro-RTSP library:
 * https://github.com/geeksville/Micro-RTSP
 * https://github.com/Tomp0801/Micro-RTSP-Audio
 *
 */
#pragma once
 
#include "AudioTools/CoreAudio/AudioPlayer.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "RTSPMediaSource.h"
#include "RTSPMediaStreamer.h"
#include "RTSPFormat.h"
#include "RTSPVideoEncoder.h"
 
namespace audio_tools {

template <typename Platform>
class RTSPOutput : public AudioOutput {
 public:
  RTSPOutput(RTSPFormat &format, AudioEncoder &encoder) {
    setFormat(format);
    rtsp_streamer.setMediaSource(&rtsp_source);
    p_encoder = &encoder;
  }

  RTSPOutput(RTSPFormat &format, RTSPVideoEncoder &encoder) {
    setFormat(format);
    p_encoder = &encoder;
    p_video_encoder = &encoder;
    encoder.setFormat(format);
  }
 
  void setFormat(RTSPFormat &format) {
    TRACEI();
    p_format = &format;
    rtsp_source.setFormat(format);
  }

  RTSPOutput() = default;

  RTSPMediaStreamer<Platform> &streamer() { return rtsp_streamer; }

  bool begin(AudioInfo info) {
    cfg = info;
    return begin();
  }

 
  bool begin() {
    TRACEI();
    if (p_encoder == nullptr) {
      LOGE("encoder is null");
      return false;
    }
    if (p_format == nullptr) {
      LOGE("format is null");
      return false;
    }
 
    if (p_video_encoder != nullptr) {
      // Packetized (video) path: the encoder owns fragmentation, framing
      // and the RTP marker bit; the streamer only forwards its already
      // ready-to-send fragments.
      p_encoder->begin();
      rtsp_streamer.setMediaSource(p_video_encoder);
      return true;
    }
 
    // setup the RTSPMediaStreamer
    cfg.logInfo();
 
    p_encoder->setOutput(memory_stream);
    p_encoder->setAudioInfo(cfg);
    p_encoder->begin();
    // setup the RTSPSourceFromAudioStream
    rtsp_source.setInput(memory_stream);
    rtsp_source.setFormat(*p_format);
    rtsp_source.setAudioInfo(cfg);
    rtsp_source.start();
 
    memory_stream.setConsumeOnRead(true);
    memory_stream.begin();
 
    // Initialize format with audio info (PCM or codec-specific)
    p_format->begin(cfg);
 
    return true;
  }

  void end() {
    if (p_video_encoder != nullptr) {
      p_video_encoder->stop();
      return;
    }
    rtsp_source.stop();
    memory_stream.end();
  }

  int availableForWrite() {
    if (p_video_encoder != nullptr) {
      // Video frames are pushed on capture, not rate-limited by an
      // intermediate buffer; report "ready" whenever the encoder is started.
      return (bool)(*p_video_encoder) ? 0x7FFFFFFF : 0;
    }
    return rtsp_source.isStarted() ? memory_stream.availableForWrite() : 0;
  }

  size_t write(const uint8_t *data, size_t len) override {
    TRACED();
    size_t result = p_encoder->write(data, len);
    return result;
  }

  operator bool() {
    if (p_video_encoder != nullptr) return (bool)(*p_video_encoder);
    return rtsp_source.isActive() && memory_stream.availableForWrite() > 0;
  }
 
 protected:
  // Core Components
  CopyEncoder copy_encoder;           
  RTSPMediaSource rtsp_source;        
  DynamicMemoryStream memory_stream{false, 1024, 10};  
  AudioEncoder *p_encoder =
      &copy_encoder;            
  RTSPVideoEncoder *p_video_encoder =
      nullptr;                  
  RTSPFormatPCM pcm;            
  RTSPFormat *p_format = &pcm;  
  RTSPMediaStreamer<Platform>
      rtsp_streamer;  
};
 
}  // namespace audio_tools