OnTrackInterface.hpp

#ifndef _PRIVMXLIB_ENDPOINT_STREAM_ONTRACKINTERFACE_HPP
#define _PRIVMXLIB_ENDPOINT_STREAM_ONTRACKINTERFACE_HPP
 
#include <functional>
#include <memory>
#include <optional>
#include <privmx/endpoint/stream/Types.hpp>
#include <string>
#include <vector>
 
namespace privmx {
namespace endpoint {
namespace stream {

enum TrackAction {
    REMOVED,

    ADDED
};

enum DataType {
    VIDEO,

    AUDIO,

    PLAIN
};

struct Track {
    DataType kind;

    std::vector<std::string> streamIds;

    std::string trackId;

    bool muted;

    std::function<void(bool)> updateMute;
};

struct Data {
    Data(DataType _type, const std::vector<std::string>& _streamIds, const std::string& _track)
        : type(_type), streamIds(_streamIds), track(_track) {}

    virtual ~Data() = default;

    DataType type;

    const std::vector<std::string> streamIds;

    const std::string track;
};

class Frame {
public:
    virtual int ConvertToRGBA(uint8_t* dst_argb, int dst_stride_argb, int dest_width, int dest_height) = 0;
};

struct VideoData : public Data {
    VideoData(
        const std::vector<std::string>& _streamIds,
        const std::string& _track,
        const int64_t _w,
        const int64_t _h,
        std::shared_ptr<Frame> _frameData
    )
        : Data(DataType::VIDEO, _streamIds, _track), w(_w), h(_h), frameData(_frameData) {}

    const int64_t w;

    const int64_t h;

    std::shared_ptr<Frame> frameData;
};

struct AudioData : public Data {
    AudioData(
        const std::vector<std::string>& _streamIds,
        const std::string& _track,
        const void* _audio_data,
        int _bits_per_sample,
        int _sample_rate,
        size_t _number_of_channels,
        size_t _number_of_frames
    )
        : Data(DataType::AUDIO, _streamIds, _track), audio_data(_audio_data), bits_per_sample(_bits_per_sample),
          sample_rate(_sample_rate), number_of_channels(_number_of_channels), number_of_frames(_number_of_frames) {}

    const void* audio_data;

    int bits_per_sample;

    int sample_rate;

    size_t number_of_channels;

    size_t number_of_frames;
};

struct PlainData : public Data {
    PlainData(
        const std::vector<std::string>& _streamIds,
        const std::string& _track,
        const core::Buffer& _data,
        const uint64_t& _seq,
        bool _binary,
        const uint64_t& _statusCode
    )
        : Data(DataType::PLAIN, _streamIds, _track), data(_data), seq(_seq), binary(_binary), statusCode(_statusCode) {}

    core::Buffer data;

    uint64_t seq;

    bool binary;

    uint64_t statusCode;
};

class OnTrackInterface {
public:
    virtual void OnRemoteTrack(Track tack, TrackAction action) = 0;

    virtual void OnData(std::shared_ptr<Data> data) = 0;
 
protected:
    virtual ~OnTrackInterface() = default;
};
 
} // namespace stream
} // namespace endpoint
} // namespace privmx
 
#endif // _PRIVMXLIB_ENDPOINT_STREAM_ONTRACKINTERFACE_HPP