MediaStream.hpp

//
// Created by xiong on 2021/8/6.
//
 
#ifndef EMX_MediaStream_HPP
#define EMX_MediaStream_HPP
 
#include <functional>
#include "core/EmxMsg.hpp"
#include "media/common/MediaRingBuffer.hpp"
#include "media/common/MediaTypedef.hpp"
 
namespace Emx {
    class MediaStream {
    public:
        MediaStream() {}
 
        virtual ~MediaStream() {}
 
        using OnGetFrameCallback = std::function<void(Emx::ErrCodeE e, MediaFrame &frame)>;
 
        using OnGetFrameInfoCallback = std::function<void(MediaFrame &)>;
 
        class Channel {
        public:
 
            void Add(MediaFrame::TypeE type, int32_t chn) {
                array.emplace_back(type, chn);
            }
 
            struct Item {
                Item(MediaFrame::TypeE t, int32_t c) : type(t), chn(c), inited(false) {}
 
                MediaFrame::TypeE type; 
                int32_t chn; 
                uint32_t waitSeq; 
                bool inited; 
            };
 
            Item *GetChnItem(MediaFrame::TypeE t, int32_t c) {
                for (auto &e : array) {
                    if (e.type == t && e.chn == c)
                        return &e;
                }
                return nullptr;
            }
 
            std::vector<Item> array; 
        };
 
        ErrCodeE GetFrameByInfo(MediaFrame &frame);
 
    protected:
        void OnMsgRecv(uint32_t topic, const char *data, int32_t size);
 
        ErrCodeE CheckFrame(ErrCodeE errPop, MediaFrame &frame);
 
    protected:
        OnGetFrameCallback m_cbFrame;
        OnGetFrameInfoCallback m_cbFrameInfo;
        MediaRingBufferReader m_ring;
        std::string m_data;
        Channel m_chn;
    };
 
//    //!@brief MediaFrame异步数据接收
//    class MediaStreamAsync : public MediaStream {
//    public:
//        MediaStreamAsync(EuvLoop &loop) : MediaStream(), m_loop(loop) {}
//
//        virtual ~MediaStreamAsync() {}
//
//        /**
//         * @brief 开始接收
//         * @param chn [in] 需要接收的通道
//         * @param cb [in] 接收到MediaFrame帧数据的回调函数
//         * @param cbInfo [in] 仅接收到MediaFrame帧信息的回调函数(未去接收实际帧数据),可选参数
//         * @return ErrCodeE
//         */
//        ErrCodeE Start(Channel &chn, OnGetFrameCallback cb, OnGetFrameInfoCallback cbInfo = nullptr);
//
//        //!@brief 停止MediaFrame异步数据接收
//        void Stop();
//
//        //!@brief 暂停接收消息数据
//        void RecvFramePause() { m_sub.PauseRecv(); }
//
//        //!@brief 恢复接收消息数据
//        void RecvFrameResume() { m_sub.ResumeRecv(); }
//
//        //!@brief 是否正在接收消息数据
//        bool IsReceivingFrame() { return m_sub.IsReceiving(); }
//
//    private:
//        EuvLoop &m_loop;
//        MsgTopicSubscriberAsync m_sub;
//        char m_buffer[256];
//    };
 
    class MediaStreamAsync : public MediaStream {
    public:
        MediaStreamAsync() : MediaStream() {}
 
        virtual ~MediaStreamAsync() {}
 
        ErrCodeE Start(EuvLoop &loop, char *buffer, int size,
                       Channel &chn, OnGetFrameCallback cb, OnGetFrameInfoCallback cbInfo = nullptr);
 
        void Stop();
 
        void RecvFramePause() { m_sub.PauseRecv(); }
 
        void RecvFrameResume() { m_sub.ResumeRecv(); }
 
        bool IsReceivingFrame() { return m_sub.IsReceiving(); }
 
    private:
        MsgTopicSubscriberAsync m_sub;
    };
 
    class MediaStreamSync : public MediaStream {
    public:
        MediaStreamSync() : MediaStream() {}
 
        ErrCodeE Open(Channel &chn, int32_t timeoutMs);
 
        void Close();
 
        ErrCodeE GetFrame(MediaFrame &frame, int32_t timeoutMs);
 
        ErrCodeE GetFrameInfo(MediaFrame &frame, int32_t timeoutMs);
 
    private:
        MsgTopicSubscriberSync m_sub;
    };
}
 
#endif //EMX_MediaStream_HPP