/**
 * 叶海辉
 * QQ群121376426
 * http://blog.yundiantech.com/
 */

#include "VideoPlayerHK.h"

#include "Audio/PcmVolumeControl.h"
#include "parser/parser_callback.h"

#include <stdio.h>

#include <QDebug>

VideoPlayerHK::VideoPlayerHK()
{
    mVideoType = NORMALVIDEO;
    parseCB = nullptr;
    initPlayer();
}

VideoPlayerHK::~VideoPlayerHK()
{

}

bool VideoPlayerHK::startPlay(const std::string &filePath, int videoType)
{
    if (mPlayerState != VideoPlayer_Stop)
    {
        return false;
    }

    mIsQuit = false;
    mIsPause = false;

    if (!filePath.empty())
        mFilePath = filePath;
    mVideoType = videoType;

    //启动新的线程实现读取视频文件
    std::thread([&](VideoPlayerHK *pointer)
    {
        pointer->readVideoFile();

    }, this).detach();
//    readVideoFile();

    parseCB = new parser_callback(&mVideoPacktList, &mAudioPacktList,
                                  mConditon_Video, mConditon_Audio);
    run_player(mFilePath.c_str(), mVideoType, parseCB);

    return true;

}

int64_t VideoPlayerHK::getTotalTime()
{
    return 1;
}

void VideoPlayerHK::readVideoFile()
{
    ///SDL初始化需要放入子线程中，否则有些电脑会有问题。
    if (SDL_Init(SDL_INIT_AUDIO))
    {
        doOpenSdlFailed(-100);
        fprintf(stderr, "Could not initialize SDL - %s. \n", SDL_GetError());
        return;
    }

    mIsReadThreadFinished = false;
    mIsReadFinished = false;

    pFormatCtx = nullptr;
    pCodecCtx = nullptr;
    pCodec = nullptr;

    aCodecCtx = nullptr;
    aCodec = nullptr;
    aFrame = nullptr;

    mAudioStream = new AVStream;
    mVideoStream = new AVStream;

    audio_clock = 0;
    video_clock = 0;

    doTotalTimeChanged(getTotalTime());

    ///创建一个线程专门用来解码视频
    std::thread([&](VideoPlayerHK *pointer)
    {
        pointer->decodeVideoThread();

    }, this).detach();

    //audio decoder
    // find the audio decoder
    int codecId = AV_CODEC_ID_AMR_NB;
    aCodec = avcodec_find_decoder((AVCodecID)codecId);
    if (!aCodec) {
        fprintf(stderr, "Codec not found\n");
        return;
    }

    aCodecCtx = avcodec_alloc_context3(aCodec);
    if (!aCodecCtx) {
        fprintf(stderr, "Could not allocate audio codec context\n");
        return;
    }

    aCodecCtx->codec = aCodec;
    aCodecCtx->sample_fmt = AV_SAMPLE_FMT_FLT;
    aCodecCtx->bit_rate = 6000;
    aCodecCtx->sample_rate = 8000;
    aCodecCtx->channels = 1;
    aCodecCtx->channel_layout = AV_CH_LAYOUT_MONO;
    aCodecCtx->codec_type = AVMEDIA_TYPE_AUDIO;

    if (aCodec == NULL)
    {
        fprintf(stderr, "ACodec not found.\n");
    }
    else
    {
        //open it
        ///打开音频解码器
        if (avcodec_open2(aCodecCtx, aCodec, nullptr) < 0)
        {
            fprintf(stderr, "Could not open audio codec.\n");
            doOpenVideoFileFailed();
            goto end;
        }

        ///解码音频相关
        aFrame = av_frame_alloc();


        //重采样设置选项-----------------------------------------------------------start
        aFrame_ReSample = nullptr;

        //frame->16bit 44100 PCM 统一音频采样格式与采样率
        swrCtx = nullptr;

        //输入的声道布局
        int in_ch_layout;

        //输出的声道布局
        int out_ch_layout = av_get_default_channel_layout(audio_tgt_channels); ///AV_CH_LAYOUT_STEREO

        out_ch_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;

        /// 这里音频播放使用了固定的参数
        /// 强制将音频重采样成44100 双声道  AV_SAMPLE_FMT_S16
        /// SDL播放中也是用了同样的播放参数
        //重采样设置选项----------------
        //输入的采样格式
        in_sample_fmt = aCodecCtx->sample_fmt;
        //输出的采样格式 16bit PCM
        out_sample_fmt = AV_SAMPLE_FMT_S16;
        //输入的采样率
        in_sample_rate = aCodecCtx->sample_rate;
        //输入的声道布局
        in_ch_layout = aCodecCtx->channel_layout;

        //输出的采样率
        out_sample_rate = 44100;
        //输出的声道布局

        audio_tgt_channels = 2; ///av_get_channel_layout_nb_channels(out_ch_layout);
        out_ch_layout = av_get_default_channel_layout(audio_tgt_channels); ///AV_CH_LAYOUT_STEREO

        out_ch_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;

        /// 2019-5-13添加
        /// wav/wmv 文件获取到的aCodecCtx->channel_layout为0会导致后面的初始化失败，因此这里需要加个判断。
        if (in_ch_layout <= 0)
        {
            in_ch_layout = av_get_default_channel_layout(aCodecCtx->channels);
        }

        swrCtx = swr_alloc_set_opts(nullptr, out_ch_layout, out_sample_fmt, out_sample_rate,
                                             in_ch_layout, in_sample_fmt, in_sample_rate, 0, nullptr);

        /** Open the resampler with the specified parameters. */
        int ret = swr_init(swrCtx);
        if (ret < 0)
        {
            char buff[128]={0};
            av_strerror(ret, buff, 128);

            fprintf(stderr, "Could not open resample context %s\n", buff);
            swr_free(&swrCtx);
            swrCtx = nullptr;
            doOpenVideoFileFailed();
            goto end;
        }

        //存储pcm数据
        int out_linesize = out_sample_rate * audio_tgt_channels;

//        out_linesize = av_samples_get_buffer_size(NULL, audio_tgt_channels, av_get_bytes_per_sample(out_sample_fmt), out_sample_fmt, 1);
        out_linesize = AVCODEC_MAX_AUDIO_FRAME_SIZE;


//            mAudioStream = pFormatCtx->streams[audioStream];

        ///打开SDL播放声音
        int code = openSDL();

        if (code == 0)
        {
            SDL_LockAudioDevice(mAudioID);
            SDL_PauseAudioDevice(mAudioID,0);
            SDL_UnlockAudioDevice(mAudioID);

            mIsAudioThreadFinished = false;
        }
        else
        {
            doOpenSdlFailed(code);
        }
    }


    mPlayerState = VideoPlayer_Playing;
    doPlayerStateChanged(VideoPlayer_Playing, mVideoStream != nullptr, mAudioStream != nullptr);

    mVideoStartTime = av_gettime();
    fprintf(stderr, "%s mIsQuit=%d mIsPause=%d \n", __FUNCTION__, mIsQuit, mIsPause);

    ///文件读取结束 跳出循环的情况
    ///等待播放完毕
    while (!mIsQuit)
    {
        mSleep(100);
    }

end:

    parseCB->quit();
    clearAudioQuene();
    clearVideoQuene();

    if (mPlayerState != VideoPlayer_Stop) //不是外部调用的stop 是正常播放结束
    {
        stop();
    }

    while((mVideoStream != nullptr && !mIsVideoThreadFinished) || (mAudioStream != nullptr && !mIsAudioThreadFinished))
    {
        mSleep(10);
    } //确保视频线程结束后 再销毁队列

    closeSDL();

    if (swrCtx != nullptr)
    {
        swr_free(&swrCtx);
        swrCtx = nullptr;
    }

    if (aFrame != nullptr)
    {
        av_frame_free(&aFrame);
        aFrame = nullptr;
    }

    if (aFrame_ReSample != nullptr)
    {
        av_frame_free(&aFrame_ReSample);
        aFrame_ReSample = nullptr;
    }

    if (aCodecCtx != nullptr)
    {
        avcodec_close(aCodecCtx);
        aCodecCtx = nullptr;
    }

    if (pCodecCtx != nullptr)
    {
        avcodec_close(pCodecCtx);
        pCodecCtx = nullptr;
    }

//    avformat_close_input(&pFormatCtx);
//    avformat_free_context(pFormatCtx);

    SDL_Quit();

    doPlayerStateChanged(VideoPlayer_Stop, mVideoStream != nullptr, mAudioStream != nullptr);

    mIsReadThreadFinished = true;

fprintf(stderr, "%s finished \n", __FUNCTION__);
}

void VideoPlayerHK::decodeVideoThread()
{
    fprintf(stderr, "%s start \n", __FUNCTION__);

    mIsVideoThreadFinished = false;

    int videoWidth  = 0;
    int videoHeight =  0;

    double video_pts = 0; //当前视频的pts
    double audio_pts = 0; //音频pts

    ///解码视频相关
    AVFrame *pFrame = nullptr;
    AVFrame *pFrameYUV = nullptr;
    uint8_t *yuv420pBuffer = nullptr; //解码后的yuv数据
    struct SwsContext *imgConvertCtx = nullptr;  //用于解码后的视频格式转换

//    AVCodecContext *pCodecCtx = mVideoStream->codec; //视频解码器
    //debug add decoder
    // find the MPEG-1 video decoder
    pCodec = avcodec_find_decoder(AV_CODEC_ID_H264);
    if (!pCodec) {
        fprintf(stderr, "Codec not found\n");
        return;
    }

    pCodecCtx = avcodec_alloc_context3(pCodec);
    if (!pCodecCtx) {
        fprintf(stderr, "Could not allocate video codec context\n");
        return;
    }

    auto parser = av_parser_init(pCodec->id);
    if (!parser) {
        fprintf(stderr, "parser not found\n");
        return;
    }

    ///打开视频解码器
    if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
    {
        fprintf(stderr, "Could not open video codec.\n");
        doOpenVideoFileFailed();
        return;
    }

//    FILE *fp_v = fopen("./pkts.h264", "wb");

    pFrame = av_frame_alloc();

    auto pkt = av_packet_alloc();

    while(1)
    {
        if (mIsQuit)
        {
            clearVideoQuene(); //清空队列
            break;
        }

        if (mIsPause == true) //判断暂停
        {
            mSleep(10);
            continue;
        }

        mConditon_Video->Lock();

        static int emptyTimes = 0;
        if (mVideoPacktList.size() <= 0)
        {
            mConditon_Video->Unlock();
            if (mIsReadFinished)
            {
                //队列里面没有数据了且读取完毕了
                break;
            }
            else
            {
                emptyTimes++;
                if (emptyTimes >= 50){
                    //队列里面没有数据了且读取完毕了
                    break;
                }
                mSleep(1); //队列只是暂时没有数据而已
                continue;
            }
        }
        emptyTimes = 0;

        AVPacket pkt1 = mVideoPacktList.front();
        mVideoPacktList.pop_front();

        mConditon_Video->Unlock();

//        fwrite(pkt1.data, 1, pkt1.size, fp_v);
        AVPacket *packet = &pkt1;

        //收到这个数据 说明刚刚执行过跳转 现在需要把解码器的数据 清除一下
        if(strcmp((char*)packet->data, FLUSH_DATA) == 0)
        {
            fprintf(stderr, "strcmp((char*)packet->data, FLUSH_DATA) == 0\n");
            avcodec_flush_buffers(pCodecCtx);
            av_packet_unref(packet);
            continue;
        }

        while(packet->size> 0) {
            int ret = av_parser_parse2(parser, pCodecCtx, &pkt->data, &pkt->size,
                                   packet->data, packet->size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
            if (ret < 0) {
                fprintf(stderr, "Error while parsing\n");
                break;
            }
            packet->data += ret;
            packet->size -= ret;

            if (pkt->size) {
                auto ret = avcodec_send_packet(pCodecCtx, pkt);
                if (ret != 0)
                {
                   qDebug("input AVPacket to decoder failed!, error:%d\n", ret);
                   av_packet_unref(pkt);
                   continue;
                }

                while (0 == avcodec_receive_frame(pCodecCtx, pFrame))
                {
                    if (pkt->dts == AV_NOPTS_VALUE &&
                            pFrame->opaque&& *(uint64_t*) pFrame->opaque != AV_NOPTS_VALUE)
                    {
                        video_pts = *(uint64_t *) pFrame->opaque;
                    }
                    else if (pkt->dts != AV_NOPTS_VALUE)
                    {
                        video_pts = pkt->dts;
                    }
                    else
                    {
                        video_pts = 0;
                    }

//                    printf("timebase:%d, %d\n", pCodecCtx->time_base.num, pCodecCtx->time_base.den);
                    AVRational timebase = {1, 1200000};
                    video_pts *= av_q2d(timebase);//mVideoStream->time_base);
                    video_clock = video_pts;
                    //OUTPUT("%s %f \n", __FUNCTION__, video_pts);
                    if (seek_flag_video)
                    {
                        //发生了跳转 则跳过关键帧到目的时间的这几帧
                       if (video_pts < seek_time)
                       {
                           av_packet_unref(pkt);
                           continue;
                       }
                       else
                       {
                           seek_flag_video = 0;
                       }
                    }

                    ///音视频同步，实现的原理就是，判断是否到显示此帧图像的时间了，没到则休眠5ms，然后继续判断
                    while(1)
                    {
                        if (mIsQuit)
                        {
                            break;
                        }

                        if (mAudioStream != NULL && !mIsAudioThreadFinished)
                        {
                            if (mIsReadFinished && mAudioPacktList.size() <= 0)
                            {//读取完了 且音频数据也播放完了 就剩下视频数据了  直接显示出来了 不用同步了
                                break;
                            }

                            ///有音频的情况下，将视频同步到音频
                            ///跟音频的pts做对比，比视频快则做延时
                            audio_pts = audio_clock;
                        }
                        else
                        {
                            ///没有音频的情况下，直接同步到外部时钟
                            audio_pts = (av_gettime() - mVideoStartTime) / 1000000.0;
                            audio_clock = audio_pts;
                        }

            //OUTPUT("%s %f %f \n", __FUNCTION__, video_pts, audio_pts);
                        //主要是 跳转的时候 我们把video_clock设置成0了
                        //因此这里需要更新video_pts
                        //否则当从后面跳转到前面的时候 会卡在这里
                        video_pts = video_clock;

                        if (video_pts <= audio_pts){
                            break;
                        }

                        int delayTime = (video_pts - audio_pts) * 1000;

                        delayTime = delayTime > 5 ? 5:delayTime;

                        if (!mIsNeedPause)
                        {
                            mSleep(delayTime);
                        }
                    }

                    if (pCodecCtx->width != videoWidth || pCodecCtx->height != videoHeight)
                    {
                        videoWidth  = pFrame->width;
                        videoHeight = pFrame->height;

                        if (pFrameYUV != nullptr)
                        {
                            av_free(pFrameYUV);
                        }

                        if (yuv420pBuffer != nullptr)
                        {
                            av_free(yuv420pBuffer);
                        }

                        if (imgConvertCtx != nullptr)
                        {
                            sws_freeContext(imgConvertCtx);
                        }

                        pFrameYUV = av_frame_alloc();

                        int yuvSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1);  //按1字节进行内存对齐,得到的内存大小最接近实际大小
                    //    int yuvSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 0);  //按0字节进行内存对齐，得到的内存大小是0
                    //    int yuvSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 4);   //按4字节进行内存对齐，得到的内存大小稍微大一些

                        unsigned int numBytes = static_cast<unsigned int>(yuvSize);
                        yuv420pBuffer = static_cast<uint8_t *>(av_malloc(numBytes * sizeof(uint8_t)));
                        av_image_fill_arrays(pFrameYUV->data, pFrameYUV->linesize, yuv420pBuffer, AV_PIX_FMT_YUV420P,
                                             pCodecCtx->width, pCodecCtx->height, 1);

                        ///由于解码后的数据不一定都是yuv420p，因此需要将解码后的数据统一转换成YUV420P
                        imgConvertCtx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
                                pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height,
                                AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);

                    }

                    sws_scale(imgConvertCtx,
                            (uint8_t const * const *) pFrame->data,
                            pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data,
                            pFrameYUV->linesize);

                    doDisplayVideo(yuv420pBuffer, pCodecCtx->width, pCodecCtx->height);

                    if (mIsNeedPause)
                    {
                        mIsPause = true;
                        mIsNeedPause = false;
                    }

                }
            }
        }
        av_packet_unref(&pkt1);
        mSleep(15);
    }

//    if (fp_v) {
//        fclose(fp_v);
//        fp_v = NULL;
//    }

    parseCB->quit();

    av_free(pFrame);

    if (pFrameYUV != nullptr)
    {
        av_free(pFrameYUV);
    }

    if (yuv420pBuffer != nullptr)
    {
        av_free(yuv420pBuffer);
    }

    if (imgConvertCtx != nullptr)
    {
        sws_freeContext(imgConvertCtx);
    }

    if (!mIsQuit)
    {
        mIsQuit = true;
    }

    mIsVideoThreadFinished = true;

    fprintf(stderr, "%s finished \n", __FUNCTION__);

    return;
}

int VideoPlayerHK::decodeAudioFrame(bool isBlock)
{
    int audioBufferSize = 0;

    while(1)
    {
        if (mIsQuit)
        {
            mIsAudioThreadFinished = true;
            clearAudioQuene(); //清空队列
            break;
        }

        if (mIsPause == true) //判断暂停
        {
            break;
        }

        mConditon_Audio->Lock();

        if (mAudioPacktList.size() <= 0)
        {
            if (isBlock)
            {
                mConditon_Audio->Wait();
            }
            else
            {
                mConditon_Audio->Unlock();
                break;
            }
        }

        AVPacket packet = mAudioPacktList.front();
        mAudioPacktList.pop_front();
//qDebug()<<__FUNCTION__<<mAudioPacktList.size();
        mConditon_Audio->Unlock();

        AVPacket *pkt = &packet;

        /* if update, update the audio clock w/pts */
        if (pkt->pts != AV_NOPTS_VALUE)
        {
            AVRational timebase = {1, 8000};
            audio_clock = av_q2d(timebase) * pkt->pts;
        }

        //收到这个数据 说明刚刚执行过跳转 现在需要把解码器的数据 清除一下
        if(strcmp((char*)pkt->data,FLUSH_DATA) == 0)
        {
            avcodec_flush_buffers(aCodecCtx/*mAudioStream->codec*/);
            av_packet_unref(pkt);
            continue;
        }

        if (seek_flag_audio)
        {
            //发生了跳转 则跳过关键帧到目的时间的这几帧
           if (audio_clock < seek_time)
           {
               continue;
           }
           else
           {
               seek_flag_audio = 0;
           }
        }

        //解码AVPacket->AVFrame
        int got_frame = 0;
        int size = avcodec_decode_audio4(aCodecCtx, aFrame, &got_frame, &packet);

//保存重采样之前的一个声道的数据方法
//size_t unpadded_linesize = aFrame->nb_samples * av_get_bytes_per_sample((AVSampleFormat) aFrame->format);
//static FILE * fp = fopen("out.pcm", "wb");
//fwrite(aFrame->extended_data[0], 1, unpadded_linesize, fp);

        av_packet_unref(&packet);

        if (got_frame)
        {
            /// ffmpeg解码之后得到的音频数据不是SDL想要的，
            /// 因此这里需要重采样成44100 双声道 AV_SAMPLE_FMT_S16
            if (aFrame_ReSample == NULL)
            {
                aFrame_ReSample = av_frame_alloc();
            }

            if (aFrame_ReSample->nb_samples != aFrame->nb_samples)
            {
                aFrame_ReSample->nb_samples = av_rescale_rnd(swr_get_delay(swrCtx, out_sample_rate) + aFrame->nb_samples,
                            out_sample_rate, in_sample_rate, AV_ROUND_UP);

                av_samples_fill_arrays(aFrame_ReSample->data, aFrame_ReSample->linesize, audio_buf, audio_tgt_channels, aFrame_ReSample->nb_samples, out_sample_fmt, 0);

            }

            int len2 = swr_convert(swrCtx, aFrame_ReSample->data, aFrame_ReSample->nb_samples, (const uint8_t**)aFrame->data, aFrame->nb_samples);
            int resampled_data_size = len2 * audio_tgt_channels * av_get_bytes_per_sample(out_sample_fmt);

            audioBufferSize = resampled_data_size;
            break;
        }
    }

    return audioBufferSize;
}