red5pro.h

/*
 * Copyright (c) 2022 Infrared5, Inc.
 * License information: https://account.red5.net/assets/LICENSE.txt
 *
 */

#pragma once

#include <climits>
#include <cstring>
#include <vector>
#include <string>
#include <memory>

#include "r5common.h"
#include "r5codec.h"
#include "r5source.h"
#include <functional>

namespace r5::core {

using namespace r5::common;

std::string R5_SDK_CORE_EXPORT GetVersion();

enum class StatusType {
    Connected, 
    Disconnected, 
    ConnectionError, 
    ConnectionTimeout, 
    ConnectionClose, 
    StartStreaming, 
    StopStreaming, 
    NetStatus, 
    AudioMute, 
    AudioUnmute, 
    VideoMute, 
    VideoUnmute, 
    LicenseError, 
    LicenseValid, 
    BufferFlushStart, 
    BufferFlushEmpty, 
    VideoRenderStart, 
    AbrLevelChange, 
    SrtpKeyGenError, 
    SrtpKeyHandleError, 
    HardwareDecodeError, 
    ConnectionRejectedError, 
};

enum class RecordType {
    Live, 
    Record, 
    Append 
};
enum class ProtocolType {
    Rtsp, 
    Srtp, 
    NullSrtp, 
    WebRTC 
};
enum class NetworkTransport {
    Tcp, 
    Udp 
};
enum class AudioFormat {
    Aac, 
    Opus, 
    L16 
};
typedef std::pair<std::string, std::string> MetadataRecord;
typedef struct Metadata
{
    std::string name; 
    uint32_t timestamp; 
    std::vector<MetadataRecord> records; 
} Metadata;
class IMediaDescEnumerator
{
public:
    virtual int GetNumberMediaDescs() = 0;
    virtual int GetMediaDesc(int idx, MediaTransform &desc) = 0;
    virtual int GetCurrentMediaDesc(MediaTransform &desc) = 0;
    virtual int SetCurrentMediaDesc(const MediaTransform &desc) = 0;
};
typedef std::shared_ptr<IMediaDescEnumerator> IMediaDescEnumeratorPtr;
class IMediaSink
{
public:
    virtual int SinkSample(const MediaSample &outSample) = 0;
};
typedef std::shared_ptr<IMediaSink> IMediaSinkPtr;
class ISingleSource
{
public:
    virtual int Init(MediaDesc &desc) = 0;
    virtual int GetData(MediaSample &outSample) = 0;
    virtual int Release() = 0;
};
typedef std::shared_ptr<ISingleSource> ISingleSourcePtr;
class IDemuxingSource
{
public:
    virtual int Init(std::vector<MediaDesc> &descs) = 0;
    virtual int GetData(int idx, MediaSample &outSample) = 0;
    virtual int Release() = 0;
};
typedef std::shared_ptr<IDemuxingSource> IDemuxingSourcePtr;
class ITransform
{
public:
    virtual int Init(MediaTransform &desc) = 0;
    virtual int PutData(MediaSample &inSample) = 0;
    virtual int GetData(MediaSample &outSample) = 0;
    virtual int Release() = 0;
};
typedef std::shared_ptr<ITransform> ITransformPtr;
class ISingleRenderer
{
public:
    virtual int Init(MediaDesc &desc) = 0;
    virtual int PutData(const MediaSample &inSample) = 0;
    virtual int Release() = 0;
};
typedef std::shared_ptr<ISingleRenderer> ISingleRendererPtr;
class IMuxingRenderer
{
public:
    virtual int Init(std::vector<MediaDesc> &descs) = 0;
    virtual int PutData(int idx, const MediaSample &inSample) = 0;
    virtual int Release() = 0;
};

typedef std::shared_ptr<IMuxingRenderer> IMuxingRendererPtr;

class IMediaStream
{
public:
    virtual DataType GetType() = 0;
    virtual int SetEncoderSettings(EncoderSettings set) = 0;
    virtual int AddTransform(ITransformPtr tfm) = 0;
    virtual int AddSink(IMediaSinkPtr sink) = 0;
};

typedef std::shared_ptr<IMediaStream> IMediaStreamPtr;

class ICallbackHandler
{
public:
    virtual int InitHandler() = 0;
    virtual int OnStatus(StatusType statusType, const std::string &statusMessage) = 0;
    virtual int OnReceiveMetadata(Metadata &metadata) = 0;
    virtual int ReleaseHandler() = 0;
};
typedef std::shared_ptr<ICallbackHandler> ICallbackHandlerPtr;
class IClient
{
public:
    virtual std::vector<IMediaStreamPtr> AddStreams(IDemuxingSourcePtr src) = 0;
    virtual IMediaStreamPtr AddStream(ISingleSourcePtr src) = 0;
    virtual IMediaStreamPtr AddStream(ISingleRendererPtr rdr) = 0;
    virtual int SetCallbackHandler(ICallbackHandlerPtr handler) = 0;
    virtual int SetLogger(std::shared_ptr<ILogger>) = 0;
    virtual int Connect() = 0;
    virtual int Disconnect() = 0;
    virtual bool IsRunning() = 0;
    virtual int SendMetadata(const Metadata &metadata) = 0;
    virtual uint64_t GetBytesSent(DataType type) = 0;
    virtual uint64_t GetBytesReceived(DataType type) = 0;
};
typedef std::shared_ptr<IClient> IClientPtr;
typedef struct ServerDescription
{
    std::string host; 
    int port; 
    std::string contextName; 
    std::string streamName; 
    NetworkTransport transport = NetworkTransport::Tcp; 
    ProtocolType protocolType = ProtocolType::Rtsp; 
    RecordType recordType = RecordType::Live; 

    std::string username; 
    std::string password; 
} ServerDescription;

class R5_SDK_CORE_EXPORT Red5Pro
{
public:
    static void SetLicenseKey(const std::string &licenseKey);
    static ILoggerPtr GetDefaultLogger();
    static int SetDefaultLogger(ILoggerPtr logger);
    static void SetDefaultLogLevel(LogLevel level);
    static void SetPreferredAudioFormat(AudioFormat fmt);

    static ITransformPtr CreateEncoderForCodec(CodecPtr codec, EncoderSettings set);
    static ITransformPtr CreateDecoderForCodec(CodecPtr codec);
    static IDemuxingSourcePtr OpenMediaFile(std::string fname, int numberOfRepeat, ILoggerPtr logger = nullptr);
    static IClientPtr CreateClient(const ServerDescription &desc);
};
}