r5data.h

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

#pragma once

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

#include "r5common.h"

namespace r5::common {
enum class VideoFmt : int {
    Unknown = 0, 
    Yuv420, 
    Yuy2, 
    Nv12, 
    Rgba, 
    Argb, 
    Bgra, 
    Abgr, 
    H264, 
    Unsupported, 
};
enum class AudioFmt : int {
    Unknown = 0, 
    FltP, 
    S16P, 
    Flt, 
    S16, 
    Aac, 
    Opus, 
    Unsupported, 
};
enum class DataType {
    Unknown = -1, 
    Audio = 0, 
    Video = 1, 
    Rtsp, 
    DataTypeCount 
};
inline bool IsEncodedVideoFormat(VideoFmt fmt)
{
    return fmt == VideoFmt::H264;
}
inline bool IsRawVideoFormat(VideoFmt fmt)
{
    return !(fmt == VideoFmt::Unknown || fmt == VideoFmt::Unsupported) && !IsEncodedVideoFormat(fmt);
}

inline bool IsEncodedAudioFormat(AudioFmt fmt)
{
    return fmt == AudioFmt::Aac || fmt == AudioFmt::Opus;
}

inline bool IsRawAudioFormat(AudioFmt fmt)
{
    return !(fmt == AudioFmt::Unknown || fmt == AudioFmt::Unsupported) && !IsEncodedAudioFormat(fmt);
}

typedef struct VideoDesc
{
    union {
        VideoFmt fmt = VideoFmt::Unknown; 
        int fmtFull; 
    };
    int width = 0; 
    int height = 0; 
    int fps = 0; 
} VideoDesc;
typedef struct AudioDesc
{
    union {
        AudioFmt fmt = AudioFmt::Unknown; 
        int fmtFull; 
    };
    int numChannels = 0; 
    int sampleRate = 0; 
} AudioDesc;
typedef struct MediaDesc
{
    MediaDesc(DataType t = DataType::Unknown) : type(t)
    {
        video.fmt = VideoFmt::Unknown;
        video.width = 0;
        video.height = 0;
        video.fps = 0;
    }
    MediaDesc(const MediaDesc &other)
    {
        type = other.type;
        if (type == DataType::Audio)
            audio = other.audio;
        else if (type == DataType::Video)
            video = other.video;
    }
    MediaDesc &operator=(MediaDesc other)
    {
        type = other.type;
        if (type == DataType::Audio)
            audio = other.audio;
        else if (type == DataType::Video)
            video = other.video;
        return *this;
    }
    MediaDesc(VideoFmt fmt, int32_t w = 0, int32_t h = 0, int32_t fps = 0) : type(DataType::Video)
    {
        video.fmt = fmt;
        video.width = w;
        video.height = h;
        video.fps = fps;
    }
    MediaDesc(AudioFmt fmt, int32_t ch = 0, int32_t sr = 0) : type(DataType::Audio)
    {
        audio.fmt = fmt;
        audio.numChannels = ch;
        audio.sampleRate = sr;
    }

    DataType type; 

    union {
        struct VideoDesc video; 
        struct AudioDesc audio; 
    };
} MediaDesc;
inline bool operator==(const MediaDesc &lhs, const MediaDesc &rhs)
{
    if (lhs.type == DataType::Unknown || rhs.type == DataType::Unknown)
        return false; // Unknown types not identical
    if (lhs.type != rhs.type)
        return false;

    if (lhs.type == DataType::Audio) {
        if (lhs.audio.fmt == AudioFmt::Unknown || rhs.audio.fmt == AudioFmt::Unknown || lhs.audio.fmt == rhs.audio.fmt)
            return true;
        else
            return false;
    } else if (lhs.type == DataType::Video) {
        if (lhs.video.fmt == VideoFmt::Unknown || rhs.video.fmt == VideoFmt::Unknown || lhs.video.fmt == rhs.video.fmt)
            return true;
        else
            return false;
    }
    return false;
}
inline bool operator!=(const MediaDesc &lhs, const MediaDesc &rhs)
{
    bool eq = lhs == rhs;
    return !eq;
}
typedef struct MediaTransform
{

    MediaTransform(DataType t = DataType::Unknown) : in(t), out(t) {}
    MediaTransform(const MediaTransform &other)
    {
        in = other.in;
        out = other.out;
        friendlyName = other.friendlyName;
    }
    MediaTransform &operator=(MediaTransform other)
    {
        in = other.in;
        out = other.out;
        friendlyName = other.friendlyName;
        return *this;
    }
    MediaTransform(VideoFmt fmtIn, VideoFmt fmtOut, std::string name = "") : in(fmtIn), out(fmtOut), friendlyName(name) {}
    MediaTransform(AudioFmt fmtIn, AudioFmt fmtOut, std::string name = "") : in(fmtIn), out(fmtOut), friendlyName(name) {}
    MediaTransform(MediaDesc descIn, MediaDesc descOut, std::string name = "") : in(descIn), out(descOut), friendlyName(name)
    {
        if (in.type == DataType::Audio) {
            if (in.audio.numChannels != 0 && out.audio.numChannels == 0)
                out.audio.numChannels = in.audio.numChannels;
            else if (in.audio.numChannels == 0 && out.audio.numChannels != 0)
                in.audio.numChannels = out.audio.numChannels;

            if (in.audio.sampleRate != 0 && out.audio.sampleRate == 0)
                out.audio.sampleRate = in.audio.sampleRate;
            else if (in.audio.sampleRate == 0 && out.audio.sampleRate != 0)
                in.audio.sampleRate = out.audio.sampleRate;
        } else if (in.type == DataType::Video) {
            if (in.video.width != 0 && out.video.width == 0)
                out.video.width = in.video.width;
            else if (in.video.width == 0 && out.video.width != 0)
                in.video.width = out.video.width;

            if (in.video.height != 0 && out.video.height == 0)
                out.video.height = in.video.height;
            else if (in.video.height == 0 && out.video.height != 0)
                in.video.height = out.video.height;
        }
    }

    MediaDesc in; 
    MediaDesc out; 
    std::string friendlyName; 
} MediaTransform;
template<typename T, typename U>
inline std::unique_ptr<T[]> reinterpret_unique_pointer_cast(std::unique_ptr<U[]> &&old)
{
    return std::unique_ptr<T[]>(reinterpret_cast<T *>(old.release()));
}
typedef struct MediaSample
{
    MediaSample()
    {
        timestamp = 0;
        size = 0;
        buffer = nullptr;
    }
    MediaSample(MediaDesc mediaType, uint32_t dataSize, uint32_t ts)
    {
        buffer = std::make_unique<uint8_t[]>(dataSize);
        size = dataSize;
        type = mediaType;
        timestamp = ts;
    }
    MediaSample(MediaDesc mediaType, uint8_t *data, uint32_t dataSize, uint32_t ts)
    {
        buffer = std::make_unique<uint8_t[]>(dataSize);
        memcpy(buffer.get(), data, dataSize);
        size = dataSize;
        type = mediaType;
        timestamp = ts;
    }
    MediaSample(MediaDesc mediaType, char *data, uint32_t dataSize, uint32_t ts)
    {
        buffer = std::make_unique<uint8_t[]>(dataSize);
        memcpy(buffer.get(), data, dataSize);
        size = dataSize;
        type = mediaType;
        timestamp = ts;
    }
    MediaSample(MediaDesc mediaType, std::unique_ptr<uint8_t[]> data, uint32_t dataSize, uint32_t ts)
    {
        buffer = std::move(data);
        size = dataSize;
        type = mediaType;
        timestamp = ts;
    }
    MediaSample(MediaDesc mediaType, std::unique_ptr<char[]> data, uint32_t dataSize, uint32_t ts)
    {
        buffer = reinterpret_unique_pointer_cast<uint8_t>(std::move(data));
        size = dataSize;
        type = mediaType;
        timestamp = ts;
    }
    ~MediaSample() {}
    MediaSample(MediaSample &other)
    {
        type = other.type;
        timestamp = other.timestamp;
        size = other.size;
        buffer = std::move(other.buffer);
    }
    MediaSample &operator=(MediaSample &other)
    {
        type = other.type;
        timestamp = other.timestamp;
        size = other.size;
        buffer = std::move(other.buffer);

        return *this;
    }
    MediaSample(const MediaSample &other)
    {
        type = other.type;
        timestamp = other.timestamp;
        size = other.size;
        buffer = std::make_unique<uint8_t[]>(size);
        memcpy(buffer.get(), other.buffer.get(), size);
    }
    MediaSample &operator=(const MediaSample &other)
    {
        type = other.type;
        timestamp = other.timestamp;
        size = other.size;
        buffer = std::make_unique<uint8_t[]>(size);
        memcpy(buffer.get(), other.buffer.get(), size);

        return *this;
    }

    MediaDesc type; 
    uint32_t timestamp; 
    uint32_t size; 
    std::unique_ptr<uint8_t[]> buffer; 
} MediaSample;
typedef struct ProvisionDesc
{
    int width; 
    int height; 
    int fps; 
    int bitrate; 
} ProvisionDesc;
int R5_SDK_CORE_EXPORT parseProvisions(const std::string &jsonData, std::vector<ProvisionDesc> &provisions);
int R5_SDK_CORE_EXPORT writeProvisions(const std::vector<ProvisionDesc> &provisions, std::string &jsonData);
}