#ifndef COMMONFFMPEGFUNC_HPP
#define COMMONFFMPEGFUNC_HPP

#include <basic/debug/Debug.h>

#ifdef __cplusplus
extern "C" {
#endif

#include <libavcodec/avcodec.h>
#include <libavdevice/avdevice.h>
#include <libavformat/avformat.h>
#include <libavfilter/avfilter.h>
#include <libavutil/avutil.h>
#include <libswscale/swscale.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>


#ifdef __cplusplus
}
#endif

class CommonFFmpeg
{
public:
    CommonFFmpeg():m_pInFmtCtx(nullptr),m_pInVideoStream(nullptr),m_pDict(nullptr){}
    ~CommonFFmpeg(){}

public:
    void init()
    {
        av_register_all();
        avformat_network_init();
    }
    int rtspInputOpen(const char* rtsp)
    {
        av_dict_set(&m_pDict, "rtsp_transport", "tcp", 0);
        int ret = avformat_open_input(&m_pInFmtCtx, rtsp, NULL, &m_pDict);
        if (ret!=0)
        {
            fprintf(stderr, "could not open input file, ret: %d,info: %x\n",ret,AVERROR(ret));
            return ret;
        }
        ret = avformat_find_stream_info(m_pInFmtCtx, NULL);
        if (ret<0)
        {
            fprintf(stderr, "could not find stream info\n");
            return ret;
        }

        /* find first video stream */
        for (unsigned i=0; i<m_pInFmtCtx->nb_streams; i++)
        {
            if (m_pInFmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
            {
                m_pInVideoStream = m_pInFmtCtx->streams[i];
                break;
            }
        }
        if (m_pInVideoStream == NULL)
        {
            fprintf(stderr, "didn't find any video stream\n");
            return -1;
        }
        return 0;
    }
    void rtspInputClose()
    {
        if(m_pInFmtCtx!=nullptr)
            avformat_close_input(&m_pInFmtCtx);
        if(m_pDict!=nullptr)
            av_dict_free(&m_pDict);
    }

    void* rtspCreatePkg()
    {
        //g_pkg.lock();
        mutex().lock();
        AVPacket* pkt = nullptr;
        try{pkt=new AVPacket();av_init_packet(pkt);}
        catch (...){if(pkt!=nullptr){delete pkt;pkt=nullptr;}}
        //g_pkg.unlock();
        mutex().unlock();
        return pkt;
    }
    void rtspDestroyPkg(void* packet)
    {
        mutex().lock();
        if(packet!=nullptr)
        {
            AVPacket* pkg = static_cast<AVPacket*>(packet);
            av_free_packet(pkg);
            delete pkg;
            pkg = nullptr;
        }
        mutex().unlock();
    }

    int rtspReadPkg(void* packet)
    {
        mutex().lock();
        int ret = -1;
        if(packet!=nullptr)
        {
            AVPacket* pkg = static_cast<AVPacket*>(packet);
            ret = av_read_frame(m_pInFmtCtx, pkg);
        }
        mutex().unlock();
        return ret;
    }

    void* getRtspStream()
    {
        return (void*)m_pInVideoStream;
    }

    int fileOutOpen(const char* filename,void* inStream)
    {
        AVStream* pInstream = (AVStream*)inStream;
        if(pInstream==nullptr)
        {DBG("instream is null");return -1;}
        int ret = avformat_alloc_output_context2(&m_pOutFmtCtx, NULL, NULL, filename);
        if(ret<0)
        {
            fprintf(stderr, "avformat_alloc_output_context2 failed, errorCode: %d\n",AVERROR(ret));
            return -1;
        }
        /*
        * since all input files are supposed to be identical (framerate, dimension, color format, ...)
        * we can safely set output codec values from first input file
        */
        m_pOutVideo_stream = avformat_new_stream(m_pOutFmtCtx, NULL);
        {
            AVCodecContext *c;
            c = m_pOutVideo_stream->codec;
            c->bit_rate = 400000;
            c->codec_id = pInstream->codec->codec_id;
            c->codec_type = pInstream->codec->codec_type;
            c->time_base.num = pInstream->time_base.num;
            c->time_base.den = pInstream->time_base.den;
            fprintf(stderr, "time_base.num = %d time_base.den = %d\n", c->time_base.num, c->time_base.den);
            c->width = pInstream->codec->width;
            c->height = pInstream->codec->height;
            c->pix_fmt = pInstream->codec->pix_fmt;
            printf("%d %d %d", c->width, c->height, c->pix_fmt);
            c->flags = pInstream->codec->flags;
            c->flags |= CODEC_FLAG_GLOBAL_HEADER;
            c->me_range = pInstream->codec->me_range;
            c->max_qdiff = pInstream->codec->max_qdiff;

            c->qmin = pInstream->codec->qmin;
            c->qmax = pInstream->codec->qmax;

            c->qcompress = pInstream->codec->qcompress;
        }
        ret =avio_open(&m_pOutFmtCtx->pb, filename, AVIO_FLAG_WRITE);
        if(ret<0)
        {
            fprintf(stderr, "could not find stream info, errorCode: %d\n",AVERROR(ret));
            return -1;
        }

        avformat_write_header(m_pOutFmtCtx, NULL);
    }

    void fileOutClose()
    {
        av_write_trailer(m_pOutFmtCtx);
        avio_close(m_pOutFmtCtx->pb);
        avcodec_close(m_pOutFmtCtx->streams[0]->codec);
        av_freep(&m_pOutFmtCtx->streams[0]->codec);
        av_freep(&m_pOutFmtCtx->streams[0]);

        av_free(m_pOutFmtCtx);
        m_pOutFmtCtx = nullptr;
    }

    int fileWritePkg(void* packet)
    {
        mutex().lock();
        int ret = -1;
        if(packet!=nullptr)
        {
            AVPacket* pkg = static_cast<AVPacket*>(packet);
            //av_interleaved_write_frame(thisPtr->m_pOutFmtCtx, &i_pkt);
            ret = av_write_frame(m_pOutFmtCtx, pkg);
        }
        mutex().unlock();
        return ret;
    }

    bool isKeyFrame(void* packet)
    {
        bool ret = false;
        if(packet!=nullptr)
        {
            AVPacket* pkg = static_cast<AVPacket*>(packet);
            if(pkg->flags&AV_PKT_FLAG_KEY) ret = true;
        }
        return ret;
    }

    long int getPkgDts(void* packet)
    {
        long int ret = 0;
        if(packet!=nullptr)
        {
            AVPacket* pkg = static_cast<AVPacket*>(packet);
            ret = pkg->dts;
        }
        return ret;
    }
    long int getPkgPts(void* packet)
    {
        long int ret = 0;
        if(packet!=nullptr)
        {
            AVPacket* pkg = static_cast<AVPacket*>(packet);
            ret = pkg->pts;
        }
        return ret;
    }

    void conversion(void* packet,const long int& firstKeyPts,const long int& firstKeyDts,void* inVideoStream)
    {
        mutex().lock();
        if((packet!=nullptr)&&(inVideoStream!=nullptr))
        {
            AVStream* inStream = (AVStream*)inVideoStream;
            AVPacket* pkg = static_cast<AVPacket*>(packet);
            pkg->pts -= firstKeyPts;
            pkg->dts -= firstKeyDts;
            pkg->pts = av_rescale_q_rnd(pkg->pts, inStream->time_base,
                                         m_pOutVideo_stream->time_base,
                                         (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
            pkg->dts = av_rescale_q_rnd(pkg->dts, inStream->time_base,
                                         m_pOutVideo_stream->time_base,
                                         (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
            pkg->duration = av_rescale_q(pkg->duration, inStream->time_base,
                                          m_pOutVideo_stream->time_base);
            pkg->pos = -1;
        }
        mutex().unlock();
    }

private:
    AVFormatContext * m_pInFmtCtx;
    AVStream *m_pInVideoStream;
    AVDictionary *m_pDict;

    AVFormatContext *m_pOutFmtCtx;
    AVStream *m_pOutVideo_stream;
    //static std::mutex g_pkg;
    inline static int& n() { static int tn = 0; return tn;}

    inline static std::mutex& mutex(){static std::mutex mtx;return mtx;}

};
#endif
//std::mutex CommonFFmpeg::g_pkg;