#ifndef __DVPP_RTP_DECODER_H__
#define __DVPP_RTP_DECODER_H__

#include <stdint.h>
#include <atomic>
#include <thread>
#include <queue>
#include <mutex>
#include <chrono>
#include<string>

#include "depend_headers.h"
#include "dvpp_headers.h"
#include "DvppDataMemory.hpp"

#include "FFRecoderTaskManager.h"

#include "VpcUtils.h"

using namespace std;

#define MAX_RTP_BUFFER_SIZE 4194304 // 4M = 4 * 1024 * 1024 = 4194304 字节

class DvppRtpDecoder
{
public:
	DvppRtpDecoder();
	~DvppRtpDecoder();

public:
	std::atomic<char> m_buffer[MAX_RTP_BUFFER_SIZE];
	std::atomic_int   m_bufferSize {0};

public:
    bool Init(FFDecConfig cfg);
    void Close();
    bool start();
    void pause();
    void resume();

    void setDecKeyframe(bool bKeyframe);

    bool isRunning();
    bool isFinished();
    bool isPausing();
    bool getResolution( int &width, int &height );
    bool getOutResolution( int &width, int &height );

    bool isSurport(FFDecConfig& cfg);

    float fps();

    void setName(string nm){
        m_dec_name = nm;
    }

    string getName(){
        return m_dec_name;
    }

    DeviceMemory* snapshot();

    void setPostDecArg(const void* postDecArg);
    void setFinishedDecArg(const void* finishedDecArg);

	DvppDataMemory* GetFrame();

    void doRecode(RecoderInfo& recoderInfo);

    void set_mq_callback(mq_callback_t cb);

	void CacheBuffer(uint8_t* buf, int buf_size);

	int ReadBuffer(uint8_t* buf, int buffsize);

public:
    void doVdppVdecCallBack(acldvppStreamDesc *input, acldvppPicDesc *output, void *pUserData);
    void doProcessReport();

private:
    bool init_dvpp(FFDecConfig cfg);
    void release_ffmpeg();
    void read_thread();
	bool probe();//阻塞式探测国标流并获取解码参数
    
    int sendPkt(aclvdecChannelDesc *vdecChannelDesc, AVPacket* pkt, unsigned long long frame_nb);
    bool sendVdecEos(aclvdecChannelDesc *vdecChannelDesc);
    void release_dvpp();

    int getVdecType(int videoType, int profile);

    void calcOutResolution(int w, int h);

private:
    FFDecConfig m_cfg;
    string m_dec_name;

    const void * m_finishedDecArg {nullptr};
    DECODE_FINISHED_CALLBACK decode_finished_cbk {nullptr};

    bool m_bFinished{false};
    bool m_bRunning{false};
    bool m_bPause{false};

    bool m_bExitReportThd{false};

    // 读取数据
    AVFormatContext *fmt_ctx{nullptr};
    AVIOContext  * ioCtx{nullptr};
	int  mVideoIndex {-1};
    AVPixelFormat pix_fmt;
    AVCodecContext *avctx{nullptr};
    AVBSFContext * h264bsfc{nullptr};

    int frame_width{0};
	int frame_height{0};
    int out_frame_width{0};
	int out_frame_height{0};
    float m_fps{0.0};

    std::thread* m_read_thread{nullptr};

    bool m_dec_keyframe {false};
    bool m_bResize {false};

    // 解码
    int m_dvpp_deviceId {-1};
    int m_dvpp_channel {-1};
    aclrtContext m_context{nullptr};
    acldvppStreamFormat m_enType;

    const void * m_postDecArg {nullptr};
    POST_DECODE_CALLBACK post_decoded_cbk {nullptr};

    int m_vdec_out_size {-1};

    FFRecoderTaskManager m_recoderManager;

    queue<DvppDataMemory*> m_decoded_data_queue;
    mutex m_decoded_data_queue_mtx;

    long long last_ts {0};

    long long m_last_read_ts {0};

    uint64_t m_in_count {0};
    uint64_t m_out_count {0};

    int m_frameSkip {1};

    std::atomic<int> m_DvppCacheCounter{0};
    int m_cache_gop{0};

    VpcUtils m_vpcUtils;

};
#endif //__DVPP_RTP_DECODER_H__