/*
*
* 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.
*/

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

#include "h264d_scalist.h"



static RK_U8 ZZ_SCAN[16] =
{ 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15 };

static RK_U8 ZZ_SCAN8[64] = {
    0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
    12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
    35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
    58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
};

static RK_S32 Default4x4Intra[H264ScalingList4x4Length] =
{ 6, 13, 20, 28, 13, 20, 28, 32, 20, 28, 32, 37, 28, 32, 37, 42 };

static RK_S32 Default4x4Inter[H264ScalingList4x4Length] =
{ 10, 14, 20, 24, 14, 20, 24, 27, 20, 24, 27, 30, 24, 27, 30, 34 };

static RK_S32 Default8x8Intra[H264ScalingList8x8Length] = {
    6, 10, 13, 16, 18, 23, 25, 27, 10, 11, 16, 18, 23, 25, 27, 29,
    13, 16, 18, 23, 25, 27, 29, 31, 16, 18, 23, 25, 27, 29, 31, 33,
    18, 23, 25, 27, 29, 31, 33, 36, 23, 25, 27, 29, 31, 33, 36, 38,
    25, 27, 29, 31, 33, 36, 38, 40, 27, 29, 31, 33, 36, 38, 40, 42
};

static RK_S32 Default8x8Inter[H264ScalingList8x8Length] = {
    9, 13, 15, 17, 19, 21, 22, 24, 13, 13, 17, 19, 21, 22, 24, 25,
    15, 17, 19, 21, 22, 24, 25, 27, 17, 19, 21, 22, 24, 25, 27, 28,
    19, 21, 22, 24, 25, 27, 28, 30, 21, 22, 24, 25, 27, 28, 30, 32,
    22, 24, 25, 27, 28, 30, 32, 33, 24, 25, 27, 28, 30, 32, 33, 35
};

static RK_S32 Default4x4[16] =
{ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 };

static RK_S32 Default8x8[64] = {
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16
};


static void set_sps_scanlist_matrix(H264_SPS_t *sps, H264dVideoCtx_t *p_Vid)
{
    RK_S32 i = 0;

    for (i = 0; i < 6; ++i) {
        if (!sps->seq_scaling_list_present_flag[i]) { // fall-back rule A
            if (i == 0) {
                p_Vid->qmatrix[i] = Default4x4Intra;
            } else if (i == 3) {
                p_Vid->qmatrix[i] = Default4x4Inter;
            } else {
                p_Vid->qmatrix[i] = p_Vid->qmatrix[i - 1];
            }
        } else {
            if (sps->UseDefaultScalingMatrix4x4Flag[i]) {

                p_Vid->qmatrix[i] = (i < 3) ? Default4x4Intra : Default4x4Inter;
            } else {
                p_Vid->qmatrix[i] = sps->ScalingList4x4[i];
            }
        }
    }

    for (i = 6; i < ((sps->chroma_format_idc != H264_CHROMA_444) ? 8 : 12); ++i) {
        if (!sps->seq_scaling_list_present_flag[i]) { // fall-back rule A
            if (i == 6) {
                p_Vid->qmatrix[i] = Default8x8Intra;
            } else if (i == 7) {
                p_Vid->qmatrix[i] = Default8x8Inter;
            } else {
                p_Vid->qmatrix[i] = p_Vid->qmatrix[i - 2];
            }
        } else {
            if (sps->UseDefaultScalingMatrix8x8Flag[i - 6]) {

                p_Vid->qmatrix[i] = (i == 6 || i == 8 || i == 10) ? Default8x8Intra : Default8x8Inter;
            } else {
                p_Vid->qmatrix[i] = sps->ScalingList8x8[i - 6];
            }
        }
    }
}

static void set_pps_scanlist_matrix(H264_SPS_t *sps, H264_PPS_t *pps, H264dVideoCtx_t *p_Vid)
{
    RK_S32 i = 0;

    for (i = 0; i < 6; ++i) {
        if (!pps->pic_scaling_list_present_flag[i]) { // fall-back rule B
            if (i == 0) {
                if (!sps->seq_scaling_matrix_present_flag) {
                    p_Vid->qmatrix[i] = Default4x4Intra;
                }
            } else if (i == 3) {
                if (!sps->seq_scaling_matrix_present_flag) {
                    p_Vid->qmatrix[i] = Default4x4Inter;
                }
            } else {
                p_Vid->qmatrix[i] = p_Vid->qmatrix[i - 1];
            }
        } else {
            if (pps->UseDefaultScalingMatrix4x4Flag[i]) {
                p_Vid->qmatrix[i] = (i < 3) ? Default4x4Intra : Default4x4Inter;
            } else {
                p_Vid->qmatrix[i] = pps->ScalingList4x4[i];
            }
        }
    }
    for (i = 6; i < ((sps->chroma_format_idc != H264_CHROMA_444) ? 8 : 12); ++i) {
        if (!pps->pic_scaling_list_present_flag[i]) { // fall-back rule B
            if (i == 6) {
                if (!sps->seq_scaling_matrix_present_flag) {
                    p_Vid->qmatrix[i] = Default8x8Intra;
                }
            } else if (i == 7) {
                if (!sps->seq_scaling_matrix_present_flag)
                    p_Vid->qmatrix[i] = Default8x8Inter;
            } else
                p_Vid->qmatrix[i] = p_Vid->qmatrix[i - 2];
        } else {
            if (pps->UseDefaultScalingMatrix8x8Flag[i - 6]) {
                p_Vid->qmatrix[i] = (i == 6 || i == 8 || i == 10) ? Default8x8Intra : Default8x8Inter;
            } else {
                p_Vid->qmatrix[i] = pps->ScalingList8x8[i - 6];
            }
        }
    }
}

/*!
***********************************************************************
* \brief
*    check profile
***********************************************************************
*/
//extern "C"
RK_U32 is_prext_profile(RK_U32 profile_idc)
{
    return (profile_idc >= H264_PROFILE_HIGH || profile_idc == H264_PROFILE_FREXT_CAVLC444) ? 1 : 0;
}

/*!
***********************************************************************
* \brief
*    parse sps and process sps
***********************************************************************
*/
//extern "C"
MPP_RET parse_scalingList(BitReadCtx_t *p_bitctx, RK_S32 size, RK_S32 *scaling_list, RK_S32 *use_default)
{
    MPP_RET ret = MPP_ERR_UNKNOW;
    RK_S32 last_scale = 8;
    RK_S32 next_scale = 8;
    RK_S32 delta_scale = 0;
    RK_S32 j = 0, scanj = 0;

    RK_U8  *zz_scan = (size > 16) ? ZZ_SCAN8 : ZZ_SCAN;

    *use_default = 0;
    for (j = 0; j < size; ++j) {
        scanj = zz_scan[j];
        if (next_scale != 0) {
            READ_SE(p_bitctx, &delta_scale);
            next_scale = (last_scale + delta_scale + 256) & 0xff;
            *use_default = (scanj == 0 && next_scale == 0) ? 1 : 0;
        }
        scaling_list[scanj] = (next_scale == 0) ? last_scale : next_scale;
        last_scale = scaling_list[scanj];
    }

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


/*!
***********************************************************************
* \brief
*    parse sps and process sps
***********************************************************************
*/
//extern "C"
MPP_RET get_max_dec_frame_buf_size(H264_SPS_t *sps)
{
    RK_S32 size = 0;
    RK_S32 pic_size = 0;
    MPP_RET ret = MPP_ERR_UNKNOW;


    switch (sps->level_idc) {
    case 9:
        size = 152064;
        break;
    case 10:
        size = 152064;
        break;
    case 11:
        if (sps->constrained_set3_flag && !is_prext_profile(sps->profile_idc)) {
            size = 152064;
        } else {
            size = 345600;
        }
        break;
    case 12:
        size = 912384;
        break;
    case 13:
        size = 912384;
        break;
    case 20:
        size = 912384;
        break;
    case 21:
        size = 1824768;
        break;
    case 22:
        size = 3110400;
        break;
    case 30:
        size = 3110400;
        break;
    case 31:
        size = 6912000;
        break;
    case 32:
        size = 7864320;
        break;
    case 40:
        size = 12582912;
        break;
    case 41:
        size = 12582912;
        break;
    case 42:
        size = 13369344;
        break;
    case 50:
        size = 42393600;
        break;
    case 51:
        size = 70778880;
        break;
    case 52:
        size = 70778880;
        break;
    case 60:
        size = 267386880;
        break;
    case 61:
        size = 267386880;
        break;
    case 62:
        size = 267386880;
        break;
    default:
        ASSERT(0);  // undefined level
        return ret = MPP_NOK;
    }
    pic_size = (sps->pic_width_in_mbs_minus1 + 1)
               * (sps->pic_height_in_map_units_minus1 + 1)
               * (sps->frame_mbs_only_flag ? 1 : 2) * 384;
    size /= pic_size;
    size = MPP_MIN(size, 16);
    sps->max_dec_frame_buffering = size;

    return ret = MPP_OK;
}

/*!
***********************************************************************
* \brief
*    parse sps and process sps
***********************************************************************
*/
//extern "C"
MPP_RET parse_sps_scalinglists(BitReadCtx_t *p_bitctx, H264_SPS_t *sps)
{
    RK_S32 i = 0;
    MPP_RET ret = MPP_ERR_UNKNOW;
    // Parse scaling_list4x4.
    for (i = 0; i < 6; ++i) {
        READ_ONEBIT(p_bitctx, &sps->seq_scaling_list_present_flag[i]);

        if (sps->seq_scaling_list_present_flag[i]) {
            FUN_CHECK(ret = parse_scalingList(p_bitctx, H264ScalingList4x4Length,
                                              sps->ScalingList4x4[i], &sps->UseDefaultScalingMatrix4x4Flag[i]));
        }
    }
    // Parse scaling_list8x8.
    for (i = 0; i < ((sps->chroma_format_idc != H264_CHROMA_444) ? 2 : 6); ++i) {
        READ_ONEBIT(p_bitctx, &sps->seq_scaling_list_present_flag[6 + i]);
        if (sps->seq_scaling_list_present_flag[6 + i]) {
            FUN_CHECK(ret = parse_scalingList(p_bitctx, H264ScalingList8x8Length,
                                              sps->ScalingList8x8[i], &sps->UseDefaultScalingMatrix8x8Flag[i]));
        }
    }

    return ret = MPP_OK;
__BITREAD_ERR:
    ret = p_bitctx->ret;
__FAILED:
    return ret;
}
/*!
***********************************************************************
* \brief
*    prepare scanlist info to register syntax
***********************************************************************
*/
//extern "C"
MPP_RET prepare_init_scanlist(H264_SLICE_t *currSlice)
{
    RK_S32 i = 0;
    H264_SPS_t *sps = currSlice->p_Vid->active_sps;
    H264_PPS_t *pps = currSlice->p_Vid->active_pps;

    if (!pps->pic_scaling_matrix_present_flag && !sps->seq_scaling_matrix_present_flag) {
        for (i = 0; i < 12; i++) {
            currSlice->p_Vid->qmatrix[i] = (i < 6) ? Default4x4 : Default8x8;
        }
    } else {
        if (sps->seq_scaling_matrix_present_flag) { // check sps first
            set_sps_scanlist_matrix(sps, currSlice->p_Vid);
        }
        if (pps->pic_scaling_matrix_present_flag) { // then check pps
            set_pps_scanlist_matrix(sps, pps, currSlice->p_Vid);
        }
    }
    return MPP_OK;
}