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


#include "JZsdkLib.h"
#include "./RTK_mmp_dec.h"

#if RTK_MPP_STATUS == VERSION_SWITCH_ON
    #include "rockchip/mpp_common.h"  //这个.h能在mpp的源码中找到
    #include "rockchip/mpp_packet.h"
    #include "rockchip/rk_mpi.h"
    #include "./RTK_mmp_dec.h"

typedef struct {
    //编码器编号，用于选择编码器
    int index;

    // 基础流上下文
    MppCtx ctx;
    MppApi *mpi;

    // 输入/输出
    MppPacket   packet; //用于存放h264，h265数据
    MppFrame    frame;  //用于存放yuv rgb数据

    // 资源分配参数
    unsigned int width;
    unsigned int height;
	unsigned int hor_stride;
    unsigned int ver_stride;
    MppCodingType type;

    // 运行时配置
    unsigned int need_split;  //输入分割设置，整帧输入，这里为0

    MppBufferGroup  frm_grp;
    MppBufferGroup  pkt_grp;
	MppBuffer      frmBuf;
	MppBuffer      pktBuf;
    unsigned char *dataBuf;
    unsigned int  packet_size; //写入的包大小

} MPP_DEC_CONFIG ;

void dump_frame(MppFrame frame, FILE *out_fp)
{
    printf("dump_frame_to_file\n");

    RK_U32 width    = 0;
    RK_U32 height   = 0;
    RK_U32 h_stride = 0;
    RK_U32 v_stride = 0;
    MppFrameFormat fmt  = MPP_FMT_YUV420SP;
    MppBuffer buffer    = NULL;
    RK_U8 *base = NULL;

    width    = mpp_frame_get_width(frame);
    height   = mpp_frame_get_height(frame);
    h_stride = mpp_frame_get_hor_stride(frame);
    v_stride = mpp_frame_get_ver_stride(frame);
    fmt      = mpp_frame_get_fmt(frame);
    buffer   = mpp_frame_get_buffer(frame);

    RK_U32 buf_size = mpp_frame_get_buf_size(frame);
    printf("w x h: %dx%d hor_stride:%d ver_stride:%d buf_size:%d\n",
           width, height, h_stride, v_stride, buf_size);
           
    if (NULL == buffer) {
        printf("buffer is null\n");
        return ;
    }

    base = (RK_U8 *)mpp_buffer_get_ptr(buffer);

    // MPP_FMT_YUV420SP
    if (fmt != MPP_FMT_YUV420SP) {
        printf("fmt %d not supported\n", fmt);
        return;
    }

    RK_U32 i;
    RK_U8 *base_y = base;
    RK_U8 *base_c = base + h_stride * v_stride;

    for (i = 0; i < height; i++, base_y += h_stride) {
        fwrite(base_y, 1, width, out_fp);
    }
    for (i = 0; i < height / 2; i++, base_c += h_stride) {
        fwrite(base_c, 1, width, out_fp);
    }

}

void dump_frame_to_file(MppCtx ctx, MppApi *mpi, MppFrame frame, FILE *out_fp)
{
    printf("decode_and_dump_to_file\n");

    MPP_RET ret;

    if (mpp_frame_get_info_change(frame)) {
        printf("mpp_frame_get_info_change\n");
        /**
         * 第一次解码会到这个分支，需要为解码器设置缓冲区.
         * 解码器缓冲区支持3种模式。参考【图像内存分配以及交互模式】Rockchip_Developer_Guide_MPP_CN.pdf
         * 这里使用纯内部模式。
         */
        ret = mpi->control(ctx, MPP_DEC_SET_INFO_CHANGE_READY, NULL);
        if (ret) {
            printf("mpp_frame_get_info_change mpi->control error"
                    "MPP_DEC_SET_INFO_CHANGE_READY %d\n", ret);
        }
        return;
    }

    RK_U32 err_info = mpp_frame_get_errinfo(frame);
    RK_U32 discard = mpp_frame_get_discard(frame);    
    printf("err_info: %u discard: %u\n", err_info, discard);

    if (err_info) {
        return;
    }
        
    // save
    dump_frame(frame, out_fp);
    return;
}


//rtk解码器初始化
//输入内容，编码器参数的地址
T_JZsdkReturnCode RTK_mmp_dec_Init(void **index, MppCodingType int_type, MppFrameFormat out_format, int width, int height)
{
    MppParam param = NULL;

    //创建一解码器参数
    MPP_DEC_CONFIG *DecConfigInput = NULL;
    int ret;//返回值

    //为编码器参数注册内存
    DecConfigInput = (MPP_DEC_CONFIG *)malloc(sizeof(MPP_DEC_CONFIG));  
    if (DecConfigInput == NULL) {  
        JZSDK_LOG_ERROR("mpp编码器参数内存分配失败");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  

    //初始化编码器参数
    // 资源分配参数
    DecConfigInput->height = height;
    DecConfigInput->width = width;

   	DecConfigInput->hor_stride = MPP_ALIGN(width, 16);
    DecConfigInput->ver_stride = MPP_ALIGN(height, 16); 

    DecConfigInput->type = int_type;
    DecConfigInput->packet_size = (3*DecConfigInput->hor_stride*DecConfigInput->ver_stride); //一般这个值够了

    // 运行时配置
    DecConfigInput->need_split = 0;

    //如果是其他类型，dec_tpye为1 mjpeg则为0
    int dec_type =  (DecConfigInput->type != MPP_VIDEO_CodingMJPEG) ? (1) : (0);


    // /*************************************
    // //创建输入输出的数组  
    // ************************************/
    if (dec_type == 1)  //普通的视频类型
    {
        DecConfigInput->dataBuf = (unsigned char*)malloc(DecConfigInput->packet_size);
        if(DecConfigInput->dataBuf == NULL)
        {
            JZSDK_LOG_ERROR("摄像头的视频回复帧内存注册错误");
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }

        ret = mpp_packet_init(&DecConfigInput->packet, DecConfigInput->dataBuf, DecConfigInput->packet_size);
        if (ret) {
            JZSDK_LOG_ERROR("mpp_packet_init failed");
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }
    }
    else //mjpeg下的视频类型
    {
        ret = mpp_buffer_group_get_internal(&DecConfigInput->frm_grp, MPP_BUFFER_TYPE_ION);
        if (ret) {
            JZSDK_LOG_ERROR("failed to get buffer group for input frame ret %d", ret);
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }

        ret = mpp_buffer_group_get_internal(&DecConfigInput->pkt_grp, MPP_BUFFER_TYPE_ION);
        if (ret) {
            JZSDK_LOG_ERROR("failed to get buffer group for output packet ret %d", ret);
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }

        ret = mpp_frame_init(&DecConfigInput->frame); /* output frame */
        if (MPP_OK != ret) 
        {
            JZSDK_LOG_ERROR("mpp_frame_init failed");
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }

        /*
         * NOTE: For jpeg could have YUV420 and YUV422 the buffer should be
         * larger for output. And the buffer dimension should align to 16.
         * YUV420 buffer is 3/2 times of w*h.
         * YUV422 buffer is 2 times of w*h.
         * So create larger buffer with 2 times w*h.
         */
        ret = mpp_buffer_get(DecConfigInput->frm_grp, &DecConfigInput->frmBuf, DecConfigInput->hor_stride * DecConfigInput->ver_stride * 4);
        if (ret) {
            JZSDK_LOG_ERROR("failed to get buffer for input frame ret %d", ret);
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }

        // NOTE: for mjpeg decoding send the whole file

        ret = mpp_buffer_get(DecConfigInput->pkt_grp, &DecConfigInput->pktBuf, DecConfigInput->packet_size);
        if (ret) {
            JZSDK_LOG_ERROR("failed to get buffer for input frame ret %d", ret);
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }

        mpp_packet_init_with_buffer(&DecConfigInput->packet, DecConfigInput->pktBuf);
        DecConfigInput->dataBuf = mpp_buffer_get_ptr(DecConfigInput->pktBuf);

        mpp_frame_set_buffer(DecConfigInput->frame, DecConfigInput->frmBuf);
    }
    
    printf("创建输入输出的数组初始化完毕\n");
    
    // 创建解码器  
    ret = mpp_create(&DecConfigInput->ctx, &DecConfigInput->mpi);  
    if (ret != MPP_OK) 
    {  
        free(DecConfigInput);  
        JZSDK_LOG_ERROR("解码器创建失败");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  
    else
    {
        printf("解码器创建成功\n");
    }

    /**
     *      配置解码器
     *      - 解码文件需要 split 模式
     *      - 设置非阻塞模式，0非阻塞（默认），-1阻塞，+val 超时(ms)
     */
    param = &(DecConfigInput->need_split);
    ret = DecConfigInput->mpi->control(DecConfigInput->ctx, MPP_DEC_SET_PARSER_SPLIT_MODE, param);  
    if (ret != MPP_OK) {  
        mpp_destroy(DecConfigInput->ctx); // 销毁创建的编码器  
        free(DecConfigInput);  
        JZSDK_LOG_ERROR("mpi->control error MPP_DEC_SET_PARSER_SPLIT_MODE");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  
    else
    {
        printf("解码器配置创建成功\n");
    }

    // //设置超时
    // // NOTE: timeout value please refer to MppPollType definition
    // //  0   - non-block call (default)
    // // -1   - block call
    // // +val - timeout value in ms
    // if (timeout) {
    //     param = &timeout;
    //     ret = mpi->control(ctx, MPP_SET_OUTPUT_TIMEOUT, param);
    //     if (MPP_OK != ret) {
    //         mpp_err("Failed to set output timeout %d ret %d\n", timeout, ret);
    //         goto MPP_TEST_OUT;
    //     }
    // }
    
    //初始化mpp编解码器
    //参数1 mmp初始上下文
    //参数2 DEC解码 ENC编码
    //参数3 编解码的格式
        /*MPP_VIDEO_CodingAVC :   H.264
        MPP_VIDEO_CodingHEVC:   H.265
        MPP_VIDEO_CodingVP8 :   VP8
        MPP_VIDEO_CodingVP9 :   VP9
        MPP_VIDEO_CodingMJPEG : MJPEG */
    ret = mpp_init(DecConfigInput->ctx, MPP_CTX_DEC, DecConfigInput->type);  
    if (ret != MPP_OK) {  
        mpp_destroy(DecConfigInput->ctx);  
        free(DecConfigInput);  
        JZSDK_LOG_ERROR("mpp解码初始化失败");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }     
    else
    {
        printf("mpp解码初始化成功\n");
    } 

    //输出的码流格式
	param = &out_format;
    ret = DecConfigInput->mpi->control(DecConfigInput->ctx, MPP_DEC_SET_OUTPUT_FORMAT, param);
    if (ret == MPP_OK)
    {
        printf("输出格式正确\n");
    }
    else
    {
        printf("输出格式错误\n");
    }
    

    //把编码器地址传递回去
    *index = (void *)DecConfigInput;
    printf("mmp解码器初始化完毕\n");

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}



T_JZsdkReturnCode RTK_mmp_dec_input(void **index ,unsigned char *input_data, unsigned int input_data_len, MppFrame *out_put_frame)
{
    int ret; //返回值
    int pktEos = 0;
	MppTask task = NULL;

    //1、获取编码器参数
    MPP_DEC_CONFIG *DecConfigInput = (MPP_DEC_CONFIG *)*index;  

    //2、将解码的数据放入划好的地址
    memset(DecConfigInput->dataBuf,0,DecConfigInput->packet_size);
    memcpy(DecConfigInput->dataBuf , input_data ,input_data_len );
    
	mpp_packet_set_pos(DecConfigInput->packet, DecConfigInput->dataBuf); //设置packet的 有效数据 的开始位置
    mpp_packet_set_length(DecConfigInput->packet, input_data_len);  //设置packet的 有效数据 的长度

	if(pktEos) //结束标志，这边估计是不会用了
	{
		mpp_packet_set_eos(DecConfigInput->packet);
	}

    ret = DecConfigInput->mpi->poll(DecConfigInput->ctx, MPP_PORT_INPUT, MPP_POLL_BLOCK);
    if (ret) 
	{
        JZSDK_LOG_ERROR("mpp input poll failed");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	ret = DecConfigInput->mpi->dequeue(DecConfigInput->ctx, MPP_PORT_INPUT, &task);  /* input queue */
    if (ret) 
	{
        JZSDK_LOG_ERROR("mpp task input dequeue failed");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    //mpp_assert(task);
	mpp_task_meta_set_packet(task, KEY_INPUT_PACKET, DecConfigInput->packet);
    mpp_task_meta_set_frame (task, KEY_OUTPUT_FRAME,  DecConfigInput->frame);

	ret = DecConfigInput->mpi->enqueue(DecConfigInput->ctx, MPP_PORT_INPUT, task);  /* input queue */
    if (ret) 
	{
        JZSDK_LOG_ERROR("mpp task input enqueue failed");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	/* poll and wait here */
    ret = DecConfigInput->mpi->poll(DecConfigInput->ctx, MPP_PORT_OUTPUT, MPP_POLL_BLOCK);
    if (ret) 
	{
        JZSDK_LOG_ERROR("mpp output poll failed");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	ret = DecConfigInput->mpi->dequeue(DecConfigInput->ctx, MPP_PORT_OUTPUT, &task); /* output queue */
    if (ret) 
	{
        JZSDK_LOG_ERROR("mpp task output dequeue failed");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    //mpp_assert(task);

	if (task)
	{
        mpp_task_meta_get_frame(task, KEY_OUTPUT_FRAME, &DecConfigInput->frame);

		if (DecConfigInput->frame) 
		{
            //把解码出来的数据传递回去
            *out_put_frame = DecConfigInput->frame;

            //printf("解码成功\n");

            if (mpp_frame_get_eos(DecConfigInput->frame))
            {
				printf("found eos frame\n");
			}
        }

		ret = DecConfigInput->mpi->enqueue(DecConfigInput->ctx, MPP_PORT_OUTPUT, task);
        if (ret)
        {
			JZSDK_LOG_ERROR("mpp task output enqueue failed\n");
		}
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

#endif