RTSPFormat.h

#pragma once
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "AudioTools/CoreAudio/AudioTypes.h"
#include "RTSPPlatform.h"
#include "stdint.h"
 
#define DEFAULT_PCM_FRAGMENT_SIZE 640
 
namespace audio_tools {
 
class RTSPFormat {
 public:
  // Provides the format information: see see
  // https://en.wikipedia.org/wiki/RTP_payload_formats
  virtual const char *format(char *buffer, int len) = 0;
 
  // Data convertsion e.g. to network format. len is in samples
  virtual int convert(void *data, int sampleCount) { return sampleCount; }
 
  // Initialize with AudioInfo like data
  virtual void begin(AudioInfo info) { cfg = info; }
  // Provide a default config (must be overridden by concrete subclass)
  virtual AudioInfo defaultConfig() = 0;
  // Access current AudioInfo
  virtual AudioInfo audioInfo() { return cfg; }
  // Name accessors
  virtual const char *name() { return name_str; }
  void setName(const char *name) { name_str = name; }
 
  void setFragmentSize(int fragmentSize) { fragment_size = fragmentSize; }
 
  virtual int fragmentSize() { return fragment_size; }
 
  virtual int timestampIncrement() {
    int sample_size_bytes = cfg.bits_per_sample / 8;
    int samples_per_fragment =
        fragmentSize() / (sample_size_bytes * cfg.channels);
    return samples_per_fragment;
  }
 
  void setTimerPeriodUs(int period) { timer_period_us = period; }
 
  virtual int timerPeriodUs() { return timer_period_us; }
 
  virtual int rtpPayloadType() { return 96; }
 
  virtual int readHeader(uint8_t *data) { return 0; }
 
  virtual void setUseRfc2250Header(bool /*enable*/) {}
  virtual bool useRfc2250Header() const { return false; }
 
 protected:
  const char *STD_URL_PRE_SUFFIX = "trackID";
  // for sample rate 16000
  int fragment_size = DEFAULT_PCM_FRAGMENT_SIZE;
  int timer_period_us = 10000;
  AudioInfo cfg{16000, 1, 16};
  const char *name_str = "RTSPAudioTools";
};
 
class RTSPFormatPCM : public RTSPFormat {
 public:
  RTSPFormatPCM(AudioInfo info, int fragmentSize = DEFAULT_PCM_FRAGMENT_SIZE) {
    cfg = info;
    setFragmentSize(fragmentSize);
    setTimerPeriodUs(getTimerPeriod(fragmentSize));
  }
 
  RTSPFormatPCM() {
    AudioInfo tmp(16000, 1, 16);  // Default: 16kHz mono 16-bit
    cfg = tmp;
    setFragmentSize(DEFAULT_PCM_FRAGMENT_SIZE);
    setTimerPeriodUs(getTimerPeriod(DEFAULT_PCM_FRAGMENT_SIZE));
  }
 
  void begin(AudioInfo info) {
    this->cfg = info;
    setTimerPeriodUs(getTimerPeriod(this->fragment_size));
  }
 
  const char *format(char *buffer, int len) override {
    snprintf(buffer, len,
             "s=Microphone\r\n"      // Stream Name
             "c=IN IP4 0.0.0.0\r\n"  // Connection Information
             "t=0 0\r\n"  // start / stop - 0 -> unbounded and permanent session
             "m=audio 0 RTP/AVP %d\r\n"  // UDP sessions with format 10 or 11
             "a=rtpmap:%s\r\n"
             "a=rate:%i\r\n",  // provide sample rate
             rtpPayloadType(), payloadFormat(), sampleRate());
    LOGI("ftsp format: %s", buffer);
    return (const char *)buffer;
  }
 
  int convert(void *data, int samples) {
    // convert to network format (big endian)
    int16_t *pt_16 = (int16_t *)data;
    for (int j = 0; j < samples / 2; j++) {
      pt_16[j] = htons(pt_16[j]);
    }
    return samples;
  }
 
  AudioInfo info() { return cfg; }
 
  AudioInfo defaultConfig() override { return AudioInfo(16000, 1, 16); }
 
  int rtpPayloadType() override {
    int result = 0;
    switch (channels()) {
      case 1:
        result = 11;
        break;
      case 2:
        result = 10;
        break;
      default:
        LOGE("unsupported audio type");
        break;
    }
    return result;
  }
 
 protected:
  char payload_fromat[30];
 
  int sampleRate() { return cfg.sample_rate; }
  int channels() { return cfg.channels; }
  int bytesPerSample() { return cfg.bits_per_sample / 8; }
  
  int getTimerPeriod(int fragmentSize) {
    // Calculate how many samples are in the fragment
    int samples_per_fragment = timestampIncrement();
    // Calculate how long it takes to play these samples at the given sample
    // rate
    int timer_period =
        (samples_per_fragment * 1000000) / cfg.sample_rate;  // microseconds
    return timer_period;
  }
 
 
  // see https://en.wikipedia.org/wiki/RTP_payload_formats
  // 11 L16/%i/%i
  const char *payloadFormat() {
    switch (channels()) {
      case 1:
        snprintf(payload_fromat, 30, "%d L16/%i/%i", rtpPayloadType(),
                 sampleRate(), channels());
        break;
      case 2:
        snprintf(payload_fromat, 30, "%d L16/%i/%i", rtpPayloadType(),
                 sampleRate(), channels());
        break;
      default:
        LOGE("unsupported audio type");
        break;
    }
    return payload_fromat;
  }
};
 
class RTSPFormatOpus : public RTSPFormat {
 public:
  RTSPFormatOpus() {
    setTimerPeriodUs(20000);  // 20ms standard for Opus
  }
 
  RTSPFormatOpus(AudioEncoder &encoder) {
    p_encoder = &encoder;
    setTimerPeriodUs(encoder.frameDurationUs());  // Convert ms to us
  }
 
  // Provides the Opus format information:
  //  m=audio 54312 RTP/AVP 101
  //  a=rtpmap:101 opus/48000/2
  //  a=fmtp:101 stereo=1; sprop-stereo=1
  const char *format(char *buffer, int len) override {
    TRACEI();
    snprintf(buffer, len,
             "s=%s\r\n"              // Stream Name
             "c=IN IP4 0.0.0.0\r\n"  // Connection Information
             "t=0 0\r\n"  // start / stop - 0 -> unbounded and permanent session
             "m=audio 0 RTP/AVP 101\r\n"  // UDP sessions with format 101=opus
             "a=rtpmap:101 opus/%d/2\r\n"
             "a=fmtp:101 stereo=1; sprop-stereo=%d\r\n",
             name(), cfg.sample_rate, cfg.channels == 2);
    return (const char *)buffer;
  }
  AudioInfo defaultConfig() {
    AudioInfo cfg(48000, 2, 16);
    return cfg;
  }
 
  void begin(AudioInfo info) override {
    RTSPFormat::begin(info);
    // Update timer period based on encoder configuration if available
    if (p_encoder != nullptr) {
      // p_encoder->setAudioInfo(info);
      setTimerPeriodUs(p_encoder->frameDurationUs());  // Convert ms to us
    }
  }
 
 protected:
  AudioEncoder *p_encoder = nullptr;
};
 
class RTSPFormatAbtX : public RTSPFormat {
 public:
  RTSPFormatAbtX() {
    setTimerPeriodUs(20000);  // Default 20ms, will be recalculated in begin()
  }
 
  // Provides the SBC format information:
  //    m=audio 5004 RTP/AVP 98
  //    a=rtpmap:98 aptx/44100/2
  //    a=fmtp:98 variant=standard; bitresolution=16;
  const char *format(char *buffer, int len) override {
    TRACEI();
    snprintf(buffer, len,
             "s=%s\r\n"              // Stream Name
             "c=IN IP4 0.0.0.0\r\n"  // Connection Information
             "t=0 0\r\n"  // start / stop - 0 -> unbounded and permanent session
             "m=audio 0 RTP/AVP 98\r\n"  // UDP sessions with format 98=aptx
             "a=rtpmap:98 aptx/%d/%d\r\n"
             "a=fmtp:98 variant=standard; bitresolution=%d\r\n",
             name(), cfg.sample_rate, cfg.channels, cfg.bits_per_sample);
    return (const char *)buffer;
  }
  AudioInfo defaultConfig() {
    AudioInfo cfg(44100, 2, 16);
    return cfg;
  }
 
  void begin(AudioInfo info) override {
    RTSPFormat::begin(info);
    // Calculate fragment-based timing for AptX
    if (fragmentSize() > 0 && cfg.sample_rate > 0 && cfg.channels > 0) {
      int bytesPerSample = (cfg.bits_per_sample + 7) / 8;
      int samplesPerFragment = fragmentSize() / (cfg.channels * bytesPerSample);
      int period = (samplesPerFragment * 1000000) / cfg.sample_rate;
      setTimerPeriodUs(period);
    }
  }
};
 
class RTSPFormatGSM : public RTSPFormat {
 public:
  RTSPFormatGSM() {
    setTimerPeriodUs(20000);  // 20ms standard for GSM (160 samples at 8kHz)
  }
 
  const char *format(char *buffer, int len) override {
    TRACEI();
    assert(cfg.sample_rate == 8000);
    assert(cfg.channels == 1);
 
    snprintf(buffer, len,
             "s=%s\r\n"              // Stream Name
             "c=IN IP4 0.0.0.0\r\n"  // Connection Information
             "t=0 0\r\n"  // start / stop - 0 -> unbounded and permanent session
             "m=audio 0 RTP/AVP 3\r\n"  // UDP sessions with format 3=GSM
             ,
             name());
    return (const char *)buffer;
  }
 
  AudioInfo defaultConfig() {
    AudioInfo cfg(8000, 1, 16);
    return cfg;
  }
};
 
class RTSPFormatG711 : public RTSPFormat {
 public:
  RTSPFormatG711(bool isUlaw) {
    setTimerPeriodUs(20000);  // 20ms standard for G.711 (160 samples at 8kHz)
    setIsULaw(isUlaw);
  }
 
  const char *format(char *buffer, int len) override {
    TRACEI();
    assert(cfg.sample_rate == 8000);
    assert(cfg.channels == 1);
 
    snprintf(
        buffer, len,
        "s=%s\r\n"              // Stream Name
        "c=IN IP4 0.0.0.0\r\n"  // Connection Information
        "t=0 0\r\n"  // start / stop - 0 -> unbounded and permanent session
        "m=audio 0 RTP/AVP %d\r\n"  // UDP sessions with format 0=G711 μ-Law
        ,
        name(), getFormat());
    return (const char *)buffer;
  }
 
  void setIsULaw(bool flag) { is_ulaw = flag; }
 
  AudioInfo defaultConfig() {
    AudioInfo cfg(8000, 1, 16);
    return cfg;
  }
 
 protected:
  bool is_ulaw = true;
  uint8_t getFormat() { return is_ulaw ? 0 : 8; }
};
 
class RTSPFormatPCM8 : public RTSPFormat {
 public:
  RTSPFormatPCM8() {
    setTimerPeriodUs(20000);  // Default 20ms, will be recalculated in begin()
  }
 
  const char *format(char *buffer, int len) override {
    TRACEI();
    snprintf(buffer, len,
             "s=%s\r\n"              // Stream Name
             "c=IN IP4 0.0.0.0\r\n"  // Connection Information
             "t=0 0\r\n"  // start / stop - 0 -> unbounded and permanent session
             "m=audio 0 RTP/AVP 96\r\n"  // UDP sessions with format 96=dynamic
             "a=rtpmap:96 l8/%d/%d\r\n",
             name(), cfg.sample_rate, cfg.channels);
    return (const char *)buffer;
  }
  AudioInfo defaultConfig() {
    AudioInfo cfg(16000, 2, 8);
    return cfg;
  }
 
  void begin(AudioInfo info) override {
    RTSPFormat::begin(info);
    // Calculate fragment-based timing for L8 (8-bit PCM)
    if (fragmentSize() > 0 && cfg.sample_rate > 0 && cfg.channels > 0) {
      int bytesPerSample = 1;  // 8-bit = 1 byte per sample
      int samplesPerFragment = fragmentSize() / cfg.channels;
      int period = (samplesPerFragment * 1000000) / cfg.sample_rate;
      setTimerPeriodUs(period);
    }
  }
};
 
template <class AudioEncoder>
class RTSPFormatADPCM : public RTSPFormat {
 public:
  RTSPFormatADPCM() {
    setTimerPeriodUs(20000);  // Default 20ms, will be recalculated in begin()
  }
 
  RTSPFormatADPCM(AudioEncoder &encoder) {
    p_encoder = &encoder;
    encoder.begin();
    setTimerPeriodUs(encoder.frameDurationUs());  // Convert ms to us
    setFragmentSize(encoder.blockSize());
  }
 
  int timerPeriodUs() {
    if (p_encoder != nullptr) return p_encoder->frameDurationUs();
    return RTSPFormat::timerPeriodUs();
  }
 
  // Provides the IMA ADPCM format information
  // See RFC 3551 for details
  const char *format(char *buffer, int len) override {
    TRACEI();
    // Only certain sample rates are valid for DVI4 (IMA ADPCM)
    int sr = cfg.sample_rate;
    int payload_type = 5;  // default to 8000 Hz
    switch (sr) {
      case 8000:
        payload_type = 5;
        break;
      case 16000:
        payload_type = 6;
        break;
      case 11025:
        payload_type = 16;
        break;
      case 22050:
        payload_type = 17;
        break;
      default:
        LOGE("Unsupported sample rate for IMA ADPCM: %d", sr);
        sr = 8000;
        payload_type = 5;
        break;
    }
    snprintf(buffer, len,
             "s=%s\r\n"
             "c=IN IP4 0.0.0.0\r\n"
             "t=0 0\r\n"
             "m=audio 0 RTP/AVP %d\r\n"
             "a=rtpmap:%d DVI4/%d\r\n",
             name(), payload_type, payload_type, sr);
    return (const char *)buffer;
  }
  AudioInfo defaultConfig() {
    AudioInfo cfg(22050, 1, 16);  // 4 bits per sample for IMA ADPCM
    return cfg;
  }
 
  void begin(AudioInfo info) override {
    RTSPFormat::begin(info);
    if (p_encoder != nullptr) {
      ((AudioInfoSupport *)p_encoder)->setAudioInfo(info);
      setTimerPeriodUs(p_encoder->frameDurationUs());  // Convert ms to us
    } else {
      // Calculate timing for ADPCM (4 bits per sample = 0.5 bytes per sample)
      if (fragmentSize() > 0 && cfg.sample_rate > 0) {
        int samplesPerFragment =
            fragmentSize() * 2;  // 2 samples per byte for 4-bit ADPCM
        int period = (samplesPerFragment * 1000000) / cfg.sample_rate;
        setTimerPeriodUs(period);
      }
    }
  }
 
  AudioInfo audioInfo() override {
    if (p_encoder != nullptr)
      return ((AudioInfoSupport *)p_encoder)->audioInfo();
    return RTSPFormat::audioInfo();
  }
 
 protected:
  AudioEncoder *p_encoder = nullptr;
};
 
class RTSPFormatMP3 : public RTSPFormat {
 public:
  RTSPFormatMP3() {
    setTimerPeriodUs(26122);  // ~26ms for MP3 frames (1152 samples at 44.1kHz)
    setFragmentSize(2884);    // Trigger read that is big enough
  }
 
  RTSPFormatMP3(AudioEncoder &encoder) {
    setEncoder(encoder);
    setFragmentSize(2884);  // Trigger read that is big enough
    setTimerPeriodUs(encoder.frameDurationUs());  // Convert ms to us
  }
 
  void setEncoder(AudioEncoder &encoder) { p_encoder = &encoder; }
 
  int timerPeriodUs() {
    if (p_encoder != nullptr) return p_encoder->frameDurationUs();
    return RTSPFormat::timerPeriodUs();
  }
 
  virtual int timestampIncrement() {
    if (p_encoder != nullptr) return p_encoder->samplesPerFrame();
    // MP3 frame size is typically 1152 samples
    return 1152;
  }
 
  AudioInfo audioInfo() {
    if (p_encoder != nullptr)
      return ((AudioInfoSupport *)p_encoder)->audioInfo();
    return RTSPFormat::audioInfo();
  }
 
  // Provides the MP3 format information:
  //   m=audio 0 RTP/AVP 14
  //   a=rtpmap:14 MPA/90000[/ch]
  // See RFC 3551 for details: MP3 RTP clock is always 90kHz
  const char *format(char *buffer, int len) override {
    TRACEI();
    int payload_type = rtpPayloadType();  // RTP/AVP 14 = MPEG audio (MP3)
    int ch = cfg.channels;
    if (ch <= 0) ch = 1;
    // Include channels when not mono for clarity
    int ptime_ms =
        (cfg.sample_rate > 0) ? (int)((1152 * 1000) / cfg.sample_rate) : 26;
    if (ptime_ms < 10) ptime_ms = 10;  // clamp to a reasonable minimum
    if (ch == 1) {
      snprintf(buffer, len,
               "m=audio 0 RTP/AVP %d\r\n"
               "a=rtpmap:%d MPA/90000\r\n"
               "a=fmtp:%d layer=3\r\n"
               "a=ptime:%d\r\n",
               payload_type, payload_type, payload_type, ptime_ms);
    } else {
      snprintf(buffer, len,
               "m=audio 0 RTP/AVP %d\r\n"
               "a=rtpmap:%d MPA/90000/%d\r\n"
               "a=fmtp:%d layer=3\r\n"
               "a=ptime:%d\r\n",
               payload_type, payload_type, ch, payload_type, ptime_ms);
    }
    return (const char *)buffer;
  }
 
  int rtpPayloadType() override { return 14; }
 
  AudioInfo defaultConfig() {
    AudioInfo cfg(44100, 2, 16);  // Typical MP3 config
    return cfg;
  }
 
  void begin(AudioInfo info) override {
    RTSPFormat::begin(info);
    // MP3 frame size is typically 1152 samples
    int samplesPerFrame = 1152;
    if (cfg.sample_rate > 0) {
      int period = (samplesPerFrame * 1000000) / cfg.sample_rate;
      setTimerPeriodUs(period);
    }
  }
 
  int readHeader(unsigned char *buffer) override {
    // Some clients (e.g., FFmpeg/ffplay) expect the optional RFC2250 4-byte
    // MPEG audio header for payload type 14, while others (e.g., VLC) expect
    // raw frames. Make this behavior configurable.
    if (use_rfc2250_header_) {
      memset(buffer, 0, 4);
      return 4;
    }
    (void)buffer;
    return 0;
  }
 
 protected:
  AudioEncoder *p_encoder = nullptr;
  bool use_rfc2250_header_ = false;
 
 public:
  // Enable/disable RFC2250 4-byte MPEG audio header in RTP payload
  void setUseRfc2250Header(bool enable) { use_rfc2250_header_ = enable; }
  bool useRfc2250Header() const override { return use_rfc2250_header_; }
};
 
class RTSPFormatAAC : public RTSPFormat {
 public:
  RTSPFormatAAC() {
    setTimerPeriodUs(23219);  // ~23ms for AAC frames (1024 samples at 44.1kHz)
  }
 
  // Provides the AAC format information:
  //   m=audio 0 RTP/AVP 96
  //   a=rtpmap:96 MPEG4-GENERIC/44100/2
  //   a=fmtp:96 streamtype=5; profile-level-id=1; mode=AAC-hbr; ...
  // For simplicity, only basic SDP lines are provided here
  const char *format(char *buffer, int len) override {
    TRACEI();
    int payload_type = 96;  // Dynamic payload type for AAC
    int sr = cfg.sample_rate;
    int ch = cfg.channels;
    snprintf(buffer, len,
             "s=%s\r\n"
             "c=IN IP4 0.0.0.0\r\n"
             "t=0 0\r\n"
             "m=audio 0 RTP/AVP %d\r\n"
             "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
             "a=fmtp:%d streamtype=5; profile-level-id=1; mode=AAC-hbr;\r\n",
             name(), payload_type, payload_type, sr, ch, payload_type);
    return (const char *)buffer;
  }
  AudioInfo defaultConfig() {
    AudioInfo cfg(44100, 2, 16);  // Typical AAC config
    return cfg;
  }
 
  void begin(AudioInfo info) override {
    RTSPFormat::begin(info);
    // AAC frame size is typically 1024 samples
    int samplesPerFrame = 1024;
    if (cfg.sample_rate > 0) {
      int period = (samplesPerFrame * 1000000) / cfg.sample_rate;
      setTimerPeriodUs(period);
    }
  }
};
 
}  // namespace audio_tools