RTSPMediaCallbackSource.h

Go to the documentation of this file.

/*
 * Author: Phil Schatzmann
 * RTSP Media Callback Source for custom media data providers
 */
 
#pragma once
 
#include "IMediaSource.h"
#include "RTSPFormat.h"
 
namespace audio_tools {
 
class RTSPMediaCallbackSource : public IMediaSource {
 public:
  typedef int (*read_callback_t)(uint8_t* buffer, int maxBytes, void* userData);
 
  typedef void (*lifecycle_callback_t)(void* userData);
 
  typedef int (*packet_size_callback_t)(void* userData);
  
  RTSPMediaCallbackSource() {
    read_callback = nullptr;
    start_callback = nullptr;
    stop_callback = nullptr;
    packet_size_callback = nullptr;
    user_data = nullptr;
    p_format = &default_format;
    is_active = false;
  }
  
  RTSPMediaCallbackSource(read_callback_t callback, void* userData = nullptr) 
    : RTSPMediaCallbackSource() {
    setReadCallback(callback, userData);
  }
  
  RTSPMediaCallbackSource(RTSPFormat& format, read_callback_t callback, void* userData = nullptr) 
    : RTSPMediaCallbackSource(callback, userData) {
    setFormat(format);
  }
  
  virtual ~RTSPMediaCallbackSource() {
    stop();
  }
  
  void setReadCallback(read_callback_t callback, void* userData = nullptr) {
    read_callback = callback;
    user_data = userData;
  }
  
  void setStartCallback(lifecycle_callback_t callback) {
    start_callback = callback;
  }
  
  void setStopCallback(lifecycle_callback_t callback) {
    stop_callback = callback;
  }
 
  void setPacketSizeCallback(packet_size_callback_t callback) {
    packet_size_callback = callback;
  }
  
  void setFormat(RTSPFormat& format) {
    p_format = &format;
  }
  
  RTSPFormat& getFormat() override {
    return *p_format;
  }
  
  int readBytes(void* dest, int maxBytes) override {
    if (!is_active || read_callback == nullptr) {
      return 0;
    }
    
    if (dest == nullptr || maxBytes <= 0) {
      LOGW("RTSPMediaCallbackSource: invalid parameters");
      return 0;
    }
    
    // Call user-provided callback
    int result = read_callback((uint8_t*)dest, maxBytes, user_data);
    
    // Log result for debugging
    if (result > 0) {
      LOGD("RTSPMediaCallbackSource: read %d bytes", result);
    } else if (result < 0) {
      LOGW("RTSPMediaCallbackSource: callback returned error %d", result);
    }
    
    return result;
  }
 
  int packetSize() override {
    if (packet_size_callback == nullptr) return -1;
    if (!is_active) return 0;
    return packet_size_callback(user_data);
  }
 
  void start() override {
    LOGI("RTSPMediaCallbackSource: starting");
    
    if (read_callback == nullptr) {
      LOGE("RTSPMediaCallbackSource: no read callback configured");
      return;
    }
    
    IMediaSource::start();
    is_active = true;
    
    // Call optional start callback
    if (start_callback != nullptr) {
      start_callback(user_data);
    }
    
    LOGI("RTSPMediaCallbackSource: started successfully");
  }
  
  void stop() override {
    LOGI("RTSPMediaCallbackSource: stopping");
    
    is_active = false;
    IMediaSource::stop();
    
    // Call optional stop callback
    if (stop_callback != nullptr) {
      stop_callback(user_data);
    }
    
    LOGI("RTSPMediaCallbackSource: stopped");
  }
  
  bool isActive() const {
    return is_active && read_callback != nullptr;
  }
  
  void* getUserData() const {
    return user_data;
  }
  
 protected:
  read_callback_t read_callback;
  lifecycle_callback_t start_callback;
  lifecycle_callback_t stop_callback;
  packet_size_callback_t packet_size_callback;
  void* user_data;
  RTSPFormat* p_format;
  RTSPFormatPCM default_format;
  bool is_active;
};
 
namespace RTSPCallbacks {
  using ReadCallback = RTSPMediaCallbackSource::read_callback_t;
  using LifecycleCallback = RTSPMediaCallbackSource::lifecycle_callback_t;
  using PacketSizeCallback = RTSPMediaCallbackSource::packet_size_callback_t;
}
 
} // namespace audio_tools