/*
*
* Copyright 2015 Rockchip Electronics Co. LTD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#define MODULE_TAG "h264d_pps"

#include <string.h>

#include "mpp_err.h"

#include "h264d_pps.h"
#include "h264d_scalist.h"
#include "h264d_dpb.h"

static void reset_curpps_data(H264_PPS_t *cur_pps)
{
    memset(cur_pps, 0, sizeof(H264_PPS_t));
    cur_pps->seq_parameter_set_id = 0;  // reset
    cur_pps->pic_parameter_set_id = 0;
}

static MPP_RET parse_pps_calingLists(BitReadCtx_t *p_bitctx, H264_SPS_t *sps, H264_PPS_t *pps)
{
    RK_S32 i = 0;
    MPP_RET ret = MPP_ERR_UNKNOW;

    for (i = 0; i < 6; ++i) {
        READ_ONEBIT(p_bitctx, &pps->pic_scaling_list_present_flag[i]);

        if (pps->pic_scaling_list_present_flag[i]) {
            FUN_CHECK (ret = parse_scalingList(p_bitctx, H264ScalingList4x4Length,
                                               pps->ScalingList4x4[i], &pps->UseDefaultScalingMatrix4x4Flag[i]));
        }
    }
    if (pps->transform_8x8_mode_flag) {
        for (i = 0; i < ((sps->chroma_format_idc != 3) ? 2 : 6); ++i) {
            READ_ONEBIT(p_bitctx, &pps->pic_scaling_list_present_flag[i + 6]);
            if (pps->pic_scaling_list_present_flag[i + 6]) {
                FUN_CHECK(ret = parse_scalingList(p_bitctx, H264ScalingList8x8Length,
                                                  pps->ScalingList8x8[i], &pps->UseDefaultScalingMatrix8x8Flag[i]));
            }
        }
    }

    return ret = MPP_OK;
__BITREAD_ERR:
    ret = p_bitctx->ret;
__FAILED:
    return ret;
}

static MPP_RET parser_pps(BitReadCtx_t *p_bitctx, H264_SPS_t *cur_sps, H264_PPS_t *cur_pps)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    READ_UE(p_bitctx, &cur_pps->pic_parameter_set_id);
    READ_UE(p_bitctx, &cur_pps->seq_parameter_set_id);
    //VAL_CHECK(ret, cur_pps->seq_parameter_set_id < 32);
    if (cur_pps->seq_parameter_set_id < 0 || cur_pps->seq_parameter_set_id >= MAXSPS) {
        cur_pps->seq_parameter_set_id = 0;
    }
    if (cur_pps->pic_parameter_set_id < 0 || cur_pps->pic_parameter_set_id >= MAXPPS)    {
        cur_pps->pic_parameter_set_id = 0;
    }
    READ_ONEBIT(p_bitctx, &cur_pps->entropy_coding_mode_flag);
    READ_ONEBIT(p_bitctx, &cur_pps->bottom_field_pic_order_in_frame_present_flag);

    READ_UE(p_bitctx, &cur_pps->num_slice_groups_minus1);
    VAL_CHECK(ret, cur_pps->num_slice_groups_minus1 <= 1);
    READ_UE(p_bitctx, &cur_pps->num_ref_idx_l0_default_active_minus1);
    VAL_CHECK(ret, cur_pps->num_ref_idx_l0_default_active_minus1 < 32);
    READ_UE(p_bitctx, &cur_pps->num_ref_idx_l1_default_active_minus1);
    VAL_CHECK(ret, cur_pps->num_ref_idx_l1_default_active_minus1 < 32);
    READ_ONEBIT(p_bitctx, &cur_pps->weighted_pred_flag);
    READ_BITS(p_bitctx, 2, &cur_pps->weighted_bipred_idc);
    VAL_CHECK(ret, cur_pps->weighted_bipred_idc < 3);
    READ_SE(p_bitctx, &cur_pps->pic_init_qp_minus26);
    READ_SE(p_bitctx, &cur_pps->pic_init_qs_minus26);
    READ_SE(p_bitctx, &cur_pps->chroma_qp_index_offset);
    cur_pps->second_chroma_qp_index_offset = cur_pps->chroma_qp_index_offset;
    READ_ONEBIT(p_bitctx, &cur_pps->deblocking_filter_control_present_flag);
    READ_ONEBIT(p_bitctx, &cur_pps->constrained_intra_pred_flag);
    READ_ONEBIT(p_bitctx, &cur_pps->redundant_pic_cnt_present_flag);
    VAL_CHECK(ret , cur_pps->redundant_pic_cnt_present_flag == 0);

    if (mpp_has_more_rbsp_data(p_bitctx)) {
        READ_ONEBIT(p_bitctx, &cur_pps->transform_8x8_mode_flag);
        READ_ONEBIT(p_bitctx, &cur_pps->pic_scaling_matrix_present_flag);
        if (cur_pps->pic_scaling_matrix_present_flag) {
            H264D_WARNNING("Picture scaling matrix present.");
            FUN_CHECK(ret = parse_pps_calingLists(p_bitctx, cur_sps, cur_pps));
        }
        READ_SE(p_bitctx, &cur_pps->second_chroma_qp_index_offset);
    } else {
        cur_pps->transform_8x8_mode_flag = 0;
        cur_pps->second_chroma_qp_index_offset = cur_pps->chroma_qp_index_offset;
    }
    cur_pps->Valid = 1;

    return ret = MPP_OK;

__BITREAD_ERR:
    ret = p_bitctx->ret;
__FAILED:

    return ret;
}


/*!
***********************************************************************
* \brief
*    parser pps and process pps
***********************************************************************
*/
//extern "C"
MPP_RET process_pps(H264_SLICE_t *currSlice)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    H264dCurCtx_t *p_Cur = currSlice->p_Cur;
    BitReadCtx_t *p_bitctx = &p_Cur->bitctx;
    H264_PPS_t *cur_pps = &p_Cur->pps;

    reset_curpps_data(cur_pps);// reset

    FUN_CHECK(ret = parser_pps(p_bitctx, &p_Cur->sps, cur_pps));
    //!< MakePPSavailable
    ASSERT(cur_pps->Valid == 1);
    if (!currSlice->p_Vid->ppsSet[cur_pps->pic_parameter_set_id]) {
        currSlice->p_Vid->ppsSet[cur_pps->pic_parameter_set_id] = mpp_malloc(H264_PPS_t, 1);
    }

    memcpy(currSlice->p_Vid->ppsSet[cur_pps->pic_parameter_set_id], cur_pps, sizeof(H264_PPS_t));
    p_Cur->p_Vid->spspps_update = 1;

    return ret = MPP_OK;
__FAILED:
    return ret;
}

/*!
***********************************************************************
* \brief
*    prase sps and process sps
***********************************************************************
*/
//extern "C"
MPP_RET activate_pps(H264dVideoCtx_t *p_Vid, H264_PPS_t *pps)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    INP_CHECK(ret, !p_Vid && !pps);
    if (p_Vid->active_pps != pps) {
        if (p_Vid->dec_pic) {
            //!< return if the last picture has already been finished
            FUN_CHECK(ret = exit_picture(p_Vid, &p_Vid->dec_pic));
        }
        p_Vid->active_pps = pps;
    }
__RETURN:
    return ret = MPP_OK;
__FAILED:
    return ret;
}

/*!
***********************************************************************
* \brief
*    parser nal prefix
***********************************************************************
*/
//extern "C"
MPP_RET process_prefix(H264_SLICE_t *currSlice)
{
    MPP_RET ret = MPP_ERR_UNKNOW;

    H264dCurCtx_t *p_Cur = currSlice->p_Cur;
    BitReadCtx_t *p_bitctx = &p_Cur->bitctx;
    H264_PREFIX_t *cur_prefix = &p_Cur->prefix;

    if (currSlice->nal_reference_idc) {
        READ_ONEBIT(p_bitctx, &cur_prefix->store_ref_base_pic_flag);

        if ((currSlice->svcExt.use_ref_base_pic_flag ||
             cur_prefix->store_ref_base_pic_flag) &&
            !currSlice->svcExt.idr_flag) {
            H264D_LOG("read dec_ref_base_pic_marking\n");
        }
    }

    return ret = MPP_OK;
__BITREAD_ERR:
    return p_bitctx->ret;
}