MediaServerOsd.hpp

//
// Created by xiong on 2023/8/16.
//
 
#ifndef EMX_MediaServerOsd_HPP
#define EMX_MediaServerOsd_HPP
 
#include "MediaServerBase.hpp"
#include "core/euv/EuvTimer.hpp"
#include "media/common/MediaInfOsd.hpp"
#include "media/common/MediaRegion.hpp"
#include <list>
#include <thread>
#include <vector>
#include <mutex>
 
class OutlineOsd;
 
namespace Emx {
    class MediaServerOsdChn : public MediaInfOsd, public MediaServerModuleChnBase {
    public:
        explicit MediaServerOsdChn(int32_t chn) : MediaServerModuleChnBase(MediaModE::Osd, chn), m_timeRecord(0) {}
 
        ~MediaServerOsdChn() override = default;
 
        ErrCodeE LoadParam() override;
 
        ErrCodeE SaveParam() override;
 
        void *GetParam() override { return &m_param; }
 
        void *GetNewParam() override { return &m_paramNew; }
 
        void *GetRunningParam() override { return &m_paramRunning; }
 
        ErrCodeE SetOsdContent(OsdContent *pInfo) override { return ErrCodeE::Success; }
 
        ErrCodeE OnRecvReqChn(uint32_t method, const char *data, int32_t size, std::string &out) override;
 
        int GetParamSize() override { return -1; }
 
        ErrCodeE GetParamDefaultData(std::string &data) override;
 
        void NewParamInCome(const char *data, int size) override;
 
        bool ParamChanged() override;
 
        void GetParamData(std::string &data) override;
 
        void GetRunningParamData(std::string &data) override;
 
        void UpdateParam() override;
 
        void UpdateRunningParam() override {};
 
        ErrCodeE OnServerCreate() override;
 
        void OnServerDestroy() override;
 
        ErrCodeE OnParamChanged() override;
 
    protected:
        virtual Size GetChnPicSize() = 0;
 
        struct RegionInfo {
            MediaInfOsd::TypeE type; 
            int x;                   
            int y;                   
            int w;                   
            int h;                   
            int layer;               
            bool show;               
            int id;                  
            uint16_t flickerInterval;
            uint8_t isFlicker;       
            uint8_t autoSwitchColor; 
        };
        struct SwitchColorRect {
            uint16_t x;
            uint16_t y;
            uint16_t w;
            uint16_t h;
        };
 
        virtual void RegionCreateAll(std::list<RegionInfo> &region) {}
 
        virtual void RegionDestroyAll(const std::list<RegionInfo> &region) {};
 
        virtual void SetBitMap(int id, uint8_t *pix, int w, int h,
                std::vector<SwitchColorRect> *switchColorRectList = nullptr) = 0;
 
        virtual ErrCodeE ImageToCanvas(int id, const std::string &data) = 0;
 
        virtual void Pause() {}
 
        virtual void Resume() {}
 
    private:
        void CreateAll();
 
        void DestroyAll();
 
        void PreproccessAll();
 
        void ResourceFreeAll();
 
        void ThreadWrite();
 
        OutlineOsd *CreateOutline(int fontSize, uint32_t color, const char *font);
 
        void DestroyOutline(OutlineOsd *outline);
 
        void GetTime(time_t time, char *formatString, char weekFormat[7][16], int maxSize, char *content);
 
        void CalcCoordinate(Margin &margin, int regionWidth, int regionHeight, int backgroundWidth,
                int backgroundHeight, int &x, int &y);
 
        void SetRunningParam(Param *param);
 
        void ParamPush();
 
        bool ParamPop();
        void ThreadRun();
        void ThreadStop();
        void TimeUpdata();
        void TextUpdata();
 
        void ContentPush(OsdContent &info);
 
    protected:
        Param *m_pParam;
        Param m_param;
        Param m_paramNew;
        Param m_paramRunning;
        Param m_paramTread;
 
    private:
        Size m_chnPicSize;
 
        struct OutlineOsdCfg {
            OutlineOsd *outline;
            int fontSize;
            char font[32];
            int refCnt;
            uint32_t color;
        };
        std::list<OutlineOsdCfg *> m_outline;
 
        struct OsdItem {
            OutlineOsd *outline;
            ParamItem *item;    
            RegionInfo *region; 
            std::vector<SwitchColorRect> switchColorRect;
            int index;          
        };
 
        std::list<OsdItem> m_osdTime;  
        std::list<OsdItem> m_osdText;  
        std::list<OsdItem> m_osdImage; 
        std::list<RegionInfo> m_region;
 
        EuvTimer m_timer;                      
        time_t m_timeRecord;                   
        bool m_threadRunning = false;          
        bool m_craeteFlag = false;             
        std::thread m_thread;                  
        std::vector<Param> m_paramQueue;       
        std::mutex m_paramMtx;                 
        std::vector<OsdContent> m_contentQueue;
        std::string m_cacheChar;               
        int m_thickness;                       
 
    private:
        int TextWrapLineSize(ParamText &paramText, RegionInfo &region, OutlineOsd *outline);
        int TextWrapLine(OsdItem &text);
    };
 
    class MediaServerOsd : public MediaServerModuleBase {
    public:
        MediaServerOsd() : MediaServerModuleBase(MediaModE::Osd, "osd") {}
    };
}// namespace Emx
 
#endif//EMX_MediaServerOsd_HPP