/******************************************************************************

*

* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore

*

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

*

******************************************************************************/

/**

 *******************************************************************************

 * @file

 *  ihevcd_parse_slice.c

 *

 * @brief

 *  Contains functions for parsing slice data

 *

 * @author

 *  Harish

 *

 * @par List of Functions:

 *

 * @remarks

 *  None

 *

 *******************************************************************************

 */

/*****************************************************************************/

/* File Includes                                                             */

/*****************************************************************************/

#include <stdio.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include "ihevc_typedefs.h"

#include "iv.h"

#include "ivd.h"

#include "ihevcd_cxa.h"

#include "ithread.h"

#include "ihevc_defs.h"

#include "ihevc_debug.h"

#include "ihevc_structs.h"

#include "ihevc_macros.h"

#include "ihevc_mem_fns.h"

#include "ihevc_platform_macros.h"

#include "ihevc_common_tables.h"

#include "ihevc_error.h"

#include "ihevc_cabac_tables.h"

#include "ihevcd_trace.h"

#include "ihevcd_defs.h"

#include "ihevcd_function_selector.h"

#include "ihevcd_structs.h"

#include "ihevcd_error.h"

#include "ihevcd_nal.h"

#include "ihevcd_bitstream.h"

#include "ihevcd_utils.h"

#include "ihevcd_parse_slice.h"

#include "ihevcd_parse_residual.h"

#include "ihevcd_cabac.h"

#include "ihevcd_job_queue.h"

#include "ihevcd_intra_pred_mode_prediction.h"

#include "ihevcd_common_tables.h"

#include "ihevcd_process_slice.h"

#include "ihevcd_debug.h"

#include "ihevcd_get_mv.h"

#include "ihevcd_boundary_strength.h"

#include "ihevcd_ilf_padding.h"

#include "ihevcd_statistics.h"

/* Bit stream offset threshold */

#define BITSTRM_OFF_THRS 8

#define MIN_CU_QP_DELTA_ABS(x) (-26 + ((x) * 6) / 2)

#define MAX_CU_QP_DELTA_ABS(x) (25 + ((x) * 6) / 2)

/**

 * Table used to decode part_mode if AMP is enabled and current CU is not min CU

 */

const UWORD8 gau1_part_mode_amp[] = { PART_nLx2N, PART_nRx2N, PART_Nx2N, 0xFF, PART_2NxnU, PART_2NxnD, PART_2NxN, 0xFF };

const UWORD32 gau4_ct_depth_mask[] = { 0x0, 0x55555555, 0xAAAAAAAA, 0xFFFFFFFF };

/**

 *******************************************************************************

 *

 * @brief

 *  Parses Transform tree syntax

 *

 * @par Description:

 *  Parses Transform tree syntax as per Section:7.3.9.8

 *

 * @param[in] ps_codec

 *  Pointer to codec context

 *

 * @returns  Status

 *

 * @remarks

 *

 *

 *******************************************************************************

 */

WORD32 ihevcd_parse_transform_tree(codec_t *ps_codec,

                                   WORD32 x0, WORD32 y0,

                                   WORD32 cu_x_base, WORD32 cu_y_base,

                                   WORD32 log2_trafo_size,

                                   WORD32 trafo_depth,

                                   WORD32 blk_idx,

                                   WORD32 intra_pred_mode,

                                   WORD32 chroma_intra_pred_mode_idx)

{

    IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;

    sps_t *ps_sps;

    pps_t *ps_pps;

    WORD32 value;

    WORD32 x1, y1;

    WORD32 max_trafo_depth;

    bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;

    WORD32 intra_split_flag;

    WORD32 split_transform_flag;

    WORD32 ctxt_idx;

    cab_ctxt_t *ps_cabac = &ps_codec->s_parse.s_cabac;

    max_trafo_depth = ps_codec->s_parse.s_cu.i4_max_trafo_depth;

    ps_sps = ps_codec->s_parse.ps_sps;

    ps_pps = ps_codec->s_parse.ps_pps;

    intra_split_flag = ps_codec->s_parse.s_cu.i4_intra_split_flag;

    {

        split_transform_flag = 0;

        if((log2_trafo_size <= ps_sps->i1_log2_max_transform_block_size) &&

                        (log2_trafo_size > ps_sps->i1_log2_min_transform_block_size) &&

                        (trafo_depth < max_trafo_depth) &&

                        !(intra_split_flag && (trafo_depth == 0)))

        {

            /* encode the split transform flag, context derived as per Table9-37 */

            ctxt_idx = IHEVC_CAB_SPLIT_TFM + (5 - log2_trafo_size);

            TRACE_CABAC_CTXT("split_transform_flag", ps_cabac->u4_range, ctxt_idx);

            split_transform_flag = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

            AEV_TRACE("split_transform_flag", split_transform_flag,

                      ps_cabac->u4_range);

        }

        else

        {

            WORD32 inter_split_flag = 0;

            if((0 == ps_sps->i1_max_transform_hierarchy_depth_inter) &&

                            (PRED_MODE_INTER == ps_codec->s_parse.s_cu.i4_pred_mode) &&

                            (PART_2Nx2N != ps_codec->s_parse.s_cu.i4_part_mode) &&

                            (0 == trafo_depth))

            {

                inter_split_flag = 1;

            }

            if((log2_trafo_size > ps_sps->i1_log2_max_transform_block_size) ||

                            ((1 == intra_split_flag) && (0 == trafo_depth)) ||

                            (1 == inter_split_flag))

            {

                split_transform_flag = 1;

            }

        }

        if(0 == trafo_depth)

        {

            ps_codec->s_parse.s_cu.ai1_cbf_cr[trafo_depth] = 0;

            ps_codec->s_parse.s_cu.ai1_cbf_cb[trafo_depth] = 0;

#ifdef ENABLE_MAIN_REXT_PROFILE

            if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422)

            {

                ps_codec->s_parse.s_cu.ai1_cbf_cr_subtu[trafo_depth] = 0;

                ps_codec->s_parse.s_cu.ai1_cbf_cb_subtu[trafo_depth] = 0;

            }

#endif

        }

        else

        {

            ps_codec->s_parse.s_cu.ai1_cbf_cb[trafo_depth] = ps_codec->s_parse.s_cu.ai1_cbf_cb[trafo_depth - 1];

            ps_codec->s_parse.s_cu.ai1_cbf_cr[trafo_depth] = ps_codec->s_parse.s_cu.ai1_cbf_cr[trafo_depth - 1];

#ifdef ENABLE_MAIN_REXT_PROFILE

            if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422)

            {

                ps_codec->s_parse.s_cu.ai1_cbf_cb_subtu[trafo_depth] =

                                ps_codec->s_parse.s_cu.ai1_cbf_cb_subtu[trafo_depth - 1];

                ps_codec->s_parse.s_cu.ai1_cbf_cr_subtu[trafo_depth] =

                                ps_codec->s_parse.s_cu.ai1_cbf_cr_subtu[trafo_depth - 1];

            }

#endif

        }

        if ((CHROMA_FMT_IDC_MONOCHROME != ps_sps->i1_chroma_format_idc && log2_trafo_size > 2) ||

            ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444)

        {

            ctxt_idx = IHEVC_CAB_CBCR_IDX + trafo_depth;

            /* CBF for Cb/Cr is sent only if the parent CBF for Cb/Cr is non-zero */

            if((trafo_depth == 0) || ps_codec->s_parse.s_cu.ai1_cbf_cb[trafo_depth - 1])

            {

                TRACE_CABAC_CTXT("cbf_cb", ps_cabac->u4_range, ctxt_idx);

                value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                AEV_TRACE("cbf_cb", value, ps_cabac->u4_range);

                ps_codec->s_parse.s_cu.ai1_cbf_cb[trafo_depth] = value;

#ifdef ENABLE_MAIN_REXT_PROFILE

                if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422

                                && (!split_transform_flag || log2_trafo_size == 3))

                {

                    TRACE_CABAC_CTXT("cbf_cb", ps_cabac->u4_range, ctxt_idx);

                    value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                    AEV_TRACE("cbf_cb", value, ps_cabac->u4_range);

                    ps_codec->s_parse.s_cu.ai1_cbf_cb_subtu[trafo_depth] = value;

                }

#endif

            }

            if((trafo_depth == 0) || ps_codec->s_parse.s_cu.ai1_cbf_cr[trafo_depth - 1])

            {

                TRACE_CABAC_CTXT("cbf_cr", ps_cabac->u4_range, ctxt_idx);

                value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                AEV_TRACE("cbf_cr", value, ps_cabac->u4_range);

                ps_codec->s_parse.s_cu.ai1_cbf_cr[trafo_depth] = value;

#ifdef ENABLE_MAIN_REXT_PROFILE

                if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422

                                && (!split_transform_flag || log2_trafo_size == 3))

                {

                    TRACE_CABAC_CTXT("cbf_cr", ps_cabac->u4_range, ctxt_idx);

                    value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                    AEV_TRACE("cbf_cr", value, ps_cabac->u4_range);

                    ps_codec->s_parse.s_cu.ai1_cbf_cr_subtu[trafo_depth] = value;

                }

#endif

            }

        }

        if(split_transform_flag)

        {

            WORD32 intra_pred_mode_tmp;

            WORD32 chroma_intra_pred_mode_tmp_idx = ps_codec->s_parse.s_cu.ai4_intra_chroma_pred_mode_idx[0];

            x1 = x0 + ((1 << log2_trafo_size) >> 1);

            y1 = y0 + ((1 << log2_trafo_size) >> 1);

            /* For transform depth of zero, intra pred mode as decoded at CU */

            /* level is sent to the transform tree nodes */

            /* When depth is non-zero intra pred mode of parent node is sent */

            /* This takes care of passing correct mode to all the child nodes */

            intra_pred_mode_tmp = trafo_depth ? intra_pred_mode : ps_codec->s_parse.s_cu.ai4_intra_luma_pred_mode[0];

            if (ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444)

                chroma_intra_pred_mode_tmp_idx = trafo_depth ? chroma_intra_pred_mode_idx : ps_codec->s_parse.s_cu.ai4_intra_chroma_pred_mode_idx[0];

            ret = ihevcd_parse_transform_tree(ps_codec, x0, y0, x0, y0, log2_trafo_size - 1, trafo_depth + 1, 0, intra_pred_mode_tmp, chroma_intra_pred_mode_tmp_idx);

            RETURN_IF((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret, ret);

            intra_pred_mode_tmp = trafo_depth ? intra_pred_mode : ps_codec->s_parse.s_cu.ai4_intra_luma_pred_mode[1];

            if (ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444)

                chroma_intra_pred_mode_tmp_idx = trafo_depth ? chroma_intra_pred_mode_idx : ps_codec->s_parse.s_cu.ai4_intra_chroma_pred_mode_idx[1];

            ret = ihevcd_parse_transform_tree(ps_codec, x1, y0, x0, y0, log2_trafo_size - 1, trafo_depth + 1, 1, intra_pred_mode_tmp, chroma_intra_pred_mode_tmp_idx);

            RETURN_IF((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret, ret);

            intra_pred_mode_tmp = trafo_depth ? intra_pred_mode : ps_codec->s_parse.s_cu.ai4_intra_luma_pred_mode[2];

            if (ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444)

                chroma_intra_pred_mode_tmp_idx = trafo_depth ? chroma_intra_pred_mode_idx : ps_codec->s_parse.s_cu.ai4_intra_chroma_pred_mode_idx[2];

            ret = ihevcd_parse_transform_tree(ps_codec, x0, y1, x0, y0, log2_trafo_size - 1, trafo_depth + 1, 2, intra_pred_mode_tmp, chroma_intra_pred_mode_tmp_idx);

            RETURN_IF((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret, ret);

            intra_pred_mode_tmp = trafo_depth ? intra_pred_mode : ps_codec->s_parse.s_cu.ai4_intra_luma_pred_mode[3];

            if (ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444)

                chroma_intra_pred_mode_tmp_idx = trafo_depth ? chroma_intra_pred_mode_idx : ps_codec->s_parse.s_cu.ai4_intra_chroma_pred_mode_idx[3];

            ret = ihevcd_parse_transform_tree(ps_codec, x1, y1, x0, y0, log2_trafo_size - 1, trafo_depth + 1, 3, intra_pred_mode_tmp, chroma_intra_pred_mode_tmp_idx);

            RETURN_IF((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret, ret);

        }

        else

        {

            WORD32 ctb_x_base;

            WORD32 ctb_y_base;

            WORD32 cu_qp_delta_abs;

            WORD32 cbf_chroma;

            tu_t *ps_tu = ps_codec->s_parse.ps_tu;

            cu_qp_delta_abs = 0;

            ctb_x_base = ps_codec->s_parse.i4_ctb_x << ps_sps->i1_log2_ctb_size;

            ctb_y_base = ps_codec->s_parse.i4_ctb_y << ps_sps->i1_log2_ctb_size;

            cbf_chroma = ps_codec->s_parse.s_cu.ai1_cbf_cb[trafo_depth]

                            || ps_codec->s_parse.s_cu.ai1_cbf_cr[trafo_depth];

#ifdef ENABLE_MAIN_REXT_PROFILE

            if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422)

            {

                cbf_chroma |= ps_codec->s_parse.s_cu.ai1_cbf_cb_subtu[trafo_depth]

                                || ps_codec->s_parse.s_cu.ai1_cbf_cr_subtu[trafo_depth];

            }

#endif

            if((ps_codec->s_parse.s_cu.i4_pred_mode == PRED_MODE_INTRA) ||

                            (trafo_depth != 0) ||

                            (cbf_chroma))

            {

                ctxt_idx = IHEVC_CAB_CBF_LUMA_IDX;

                ctxt_idx += (trafo_depth == 0) ? 1 : 0;

                TRACE_CABAC_CTXT("cbf_luma", ps_cabac->u4_range, ctxt_idx);

                value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                AEV_TRACE("cbf_luma", value, ps_cabac->u4_range);

                ps_codec->s_parse.s_cu.i1_cbf_luma = value;

            }

            else

            {

                ps_codec->s_parse.s_cu.i1_cbf_luma = 1;

            }

            /* Initialize ps_tu to default values */

            /* If required change this to WORD32 packed write */

            ps_tu->b1_cb_cbf = 0;

#ifdef ENABLE_MAIN_REXT_PROFILE

            ps_tu->b1_cb_cbf_subtu1 = 0;

#endif

            ps_tu->b1_cr_cbf = 0;

#ifdef ENABLE_MAIN_REXT_PROFILE

            ps_tu->b1_cr_cbf_subtu1 = 0;

#endif

            ps_tu->b1_y_cbf = 0;

            ps_tu->b4_pos_x = ((x0 - ctb_x_base) >> 2);

            ps_tu->b4_pos_y = ((y0 - ctb_y_base) >> 2);

            ps_tu->b1_transquant_bypass = ps_codec->s_parse.s_cu.i4_cu_transquant_bypass;

            ps_tu->b3_size = (log2_trafo_size - 2);

            ps_tu->b7_qp = ps_codec->s_parse.u4_qp;

#ifdef ENABLE_MAIN_REXT_PROFILE

            ps_tu->b3_cb_log2_res_scale_abs_plus1 = 0;

            ps_tu->b1_cb_log2_res_sign = 0;

            ps_tu->b3_cr_log2_res_scale_abs_plus1 = 0;

            ps_tu->b1_cr_log2_res_sign = 0;

#endif

            ps_tu->b6_luma_intra_mode = intra_pred_mode;

            ps_tu->b3_chroma_intra_mode_idx = chroma_intra_pred_mode_idx;

            /* Section:7.3.12  Transform unit syntax inlined here */

            if(ps_codec->s_parse.s_cu.i1_cbf_luma || cbf_chroma)

            {

                WORD32 intra_pred_mode_chroma;

                if(ps_pps->i1_cu_qp_delta_enabled_flag && !ps_codec->s_parse.i4_is_cu_qp_delta_coded)

                {

                    WORD32 c_max        = TU_MAX_QP_DELTA_ABS;

                    WORD32 ctxt_inc     = IHEVC_CAB_QP_DELTA_ABS;

                    WORD32 ctxt_inc_max = CTXT_MAX_QP_DELTA_ABS;

                    TRACE_CABAC_CTXT("cu_qp_delta_abs", ps_cabac->u4_range, ctxt_inc);

                    /* qp_delta_abs is coded as combination of tunary and eg0 code  */

                    /* See Table 9-32 and Table 9-37 for details on cu_qp_delta_abs */

                    cu_qp_delta_abs = ihevcd_cabac_decode_bins_tunary(ps_cabac,

                                                                      ps_bitstrm,

                                                                      c_max,

                                                                      ctxt_inc,

                                                                      0,

                                                                      ctxt_inc_max);

                    if(cu_qp_delta_abs >= c_max)

                    {

                        value = ihevcd_cabac_decode_bypass_bins_egk(ps_cabac, ps_bitstrm, 0);

                        cu_qp_delta_abs += value;

                    }

                    AEV_TRACE("cu_qp_delta_abs", cu_qp_delta_abs, ps_cabac->u4_range);

                    ps_codec->s_parse.i4_is_cu_qp_delta_coded = 1;

                    if(cu_qp_delta_abs)

                    {

                        value = ihevcd_cabac_decode_bypass_bin(ps_cabac, ps_bitstrm);

                        AEV_TRACE("cu_qp_delta_sign", value, ps_cabac->u4_range);

                        if(value)

                            cu_qp_delta_abs = -cu_qp_delta_abs;

                    }

                    if (cu_qp_delta_abs < MIN_CU_QP_DELTA_ABS(ps_sps->i1_bit_depth_luma_minus8)

                                    || cu_qp_delta_abs > MAX_CU_QP_DELTA_ABS(ps_sps->i1_bit_depth_luma_minus8))

                    {

                        return IHEVCD_INVALID_PARAMETER;

                    }

                    ps_codec->s_parse.s_cu.i4_cu_qp_delta = cu_qp_delta_abs;

                }

                if(ps_codec->s_parse.s_cu.i1_cbf_luma)

                {

                    ps_tu->b1_y_cbf = 1;

                    ihevcd_parse_residual_coding(ps_codec, x0, y0, log2_trafo_size, 0, intra_pred_mode);

                }

                WORD32 chroma_blk_luma_intra_pred_mode =

                                ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444 ?

                                                intra_pred_mode :

                                                ps_codec->s_parse.s_cu.ai4_intra_luma_pred_mode[0];

                if(4 == chroma_intra_pred_mode_idx)

                    intra_pred_mode_chroma = chroma_blk_luma_intra_pred_mode;

                else

                {

                    intra_pred_mode_chroma = gau1_intra_pred_chroma_modes[chroma_intra_pred_mode_idx];

                    if(intra_pred_mode_chroma == chroma_blk_luma_intra_pred_mode)

                    {

                        intra_pred_mode_chroma = INTRA_ANGULAR(34);

                    }

                }

                if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422)

                {

                    intra_pred_mode_chroma = gau1_intra_pred_chroma_modes_422[intra_pred_mode_chroma];

                }

                if(log2_trafo_size > 2 || ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444)

                {

                    WORD32 trafo_offset = (ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444 ? 0 : 1);

                    WORD32 log2_trafo_size_c = MAX(2, log2_trafo_size - trafo_offset);

#ifdef ENABLE_MAIN_REXT_PROFILE

                    if(ps_pps->i1_cross_component_prediction_enabled_flag

                                    && ps_codec->s_parse.s_cu.i1_cbf_luma

                                    && (ps_codec->s_parse.s_cu.i4_pred_mode == PRED_MODE_INTER

                                                    || chroma_intra_pred_mode_idx == 4))

                    {

                        ctxt_idx = IHEVC_CAB_CCP_LOG2_RES_ABS;

                        TRACE_CABAC_CTXT("log2_res_scale_abs_plus1", ps_cabac->u4_range, ctxt_idx);

                        value = ihevcd_cabac_decode_bins_tunary(ps_cabac, ps_bitstrm, 4, ctxt_idx,

                                                                0, 3);

                        AEV_TRACE("log2_res_scale_abs_plus1", value, ps_cabac->u4_range);

                        if(value != 0)

                        {

                            ctxt_idx = IHEVC_CAB_CCP_RES_SIGN_FLAG;

                            TRACE_CABAC_CTXT("res_scale_sign_flag", ps_cabac->u4_range, ctxt_idx);

                            ps_tu->b1_cb_log2_res_sign = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                            AEV_TRACE("res_scale_sign_flag", value, ps_cabac->u4_range);

                            ps_tu->b3_cb_log2_res_scale_abs_plus1 = value;

                        }

                    }

#endif

                    if(ps_codec->s_parse.s_cu.ai1_cbf_cb[trafo_depth])

                    {

                        ps_tu->b1_cb_cbf = 1;

                        ihevcd_parse_residual_coding(ps_codec, x0, y0, log2_trafo_size_c, 1, intra_pred_mode_chroma);

                    }

#ifdef ENABLE_MAIN_REXT_PROFILE

                    if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422 && ps_codec->s_parse.s_cu.ai1_cbf_cb_subtu[trafo_depth])

                    {

                        ps_tu->b1_cb_cbf_subtu1 = 1;

                        ihevcd_parse_residual_coding(ps_codec, x0, y0 + (1 << log2_trafo_size_c), log2_trafo_size_c, 1, intra_pred_mode_chroma);

                    }

#endif

#ifdef ENABLE_MAIN_REXT_PROFILE

                    if(ps_pps->i1_cross_component_prediction_enabled_flag

                                    && ps_codec->s_parse.s_cu.i1_cbf_luma

                                    && (ps_codec->s_parse.s_cu.i4_pred_mode == PRED_MODE_INTER

                                                    || chroma_intra_pred_mode_idx == 4))

                    {

                        ctxt_idx = IHEVC_CAB_CCP_LOG2_RES_ABS + 4;

                        TRACE_CABAC_CTXT("log2_res_scale_abs_plus1", ps_cabac->u4_range, ctxt_idx);

                        value = ihevcd_cabac_decode_bins_tunary(ps_cabac, ps_bitstrm, 4, ctxt_idx,

                                                                0, 3);

                        AEV_TRACE("log2_res_scale_abs_plus1", value, ps_cabac->u4_range);

                        if(value != 0)

                        {

                            ctxt_idx = IHEVC_CAB_CCP_RES_SIGN_FLAG + 1;

                            TRACE_CABAC_CTXT("res_scale_sign_flag", ps_cabac->u4_range, ctxt_idx);

                            ps_tu->b1_cr_log2_res_sign = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                            AEV_TRACE("res_scale_sign_flag", value, ps_cabac->u4_range);

                            ps_tu->b3_cr_log2_res_scale_abs_plus1 = value;

                        }

                    }

#endif

                    if(ps_codec->s_parse.s_cu.ai1_cbf_cr[trafo_depth])

                    {

                        ps_tu->b1_cr_cbf = 1;

                        ihevcd_parse_residual_coding(ps_codec, x0, y0, log2_trafo_size_c, 2, intra_pred_mode_chroma);

                    }

#ifdef ENABLE_MAIN_REXT_PROFILE

                    if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422 && ps_codec->s_parse.s_cu.ai1_cbf_cr_subtu[trafo_depth])

                    {

                        ps_tu->b1_cr_cbf_subtu1 = 1;

                        ihevcd_parse_residual_coding(ps_codec, x0, y0 + (1 << log2_trafo_size_c), log2_trafo_size_c, 1, intra_pred_mode_chroma);

                    }

#endif

                }

                else if(blk_idx == 3)

                {

                    if(ps_codec->s_parse.s_cu.ai1_cbf_cb[trafo_depth])

                    {

                        ps_tu->b1_cb_cbf = 1;

                        ihevcd_parse_residual_coding(ps_codec, cu_x_base, cu_y_base, log2_trafo_size, 1, intra_pred_mode_chroma);

                    }

#ifdef ENABLE_MAIN_REXT_PROFILE

                    if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422 && ps_codec->s_parse.s_cu.ai1_cbf_cb_subtu[trafo_depth])

                    {

                        ps_tu->b1_cb_cbf_subtu1 = 1;

                        ihevcd_parse_residual_coding(ps_codec, x0, y0, log2_trafo_size, 1, intra_pred_mode_chroma);

                    }

#endif

                    if(ps_codec->s_parse.s_cu.ai1_cbf_cr[trafo_depth])

                    {

                        ps_tu->b1_cr_cbf = 1;

                        ihevcd_parse_residual_coding(ps_codec, cu_x_base, cu_y_base, log2_trafo_size, 2, intra_pred_mode_chroma);

                    }

#ifdef ENABLE_MAIN_REXT_PROFILE

                    if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422 && ps_codec->s_parse.s_cu.ai1_cbf_cr_subtu[trafo_depth])

                    {

                        ps_tu->b1_cr_cbf_subtu1 = 1;

                        ihevcd_parse_residual_coding(ps_codec, x0, y0, log2_trafo_size, 1, intra_pred_mode_chroma);

                    }

#endif

                }

                else

                {

                    //ps_tu->b1_chroma_present = 0;

                    ps_tu->b3_chroma_intra_mode_idx = INTRA_PRED_CHROMA_IDX_NONE;

                }

            }

            else

            {

                if((3 != blk_idx) && (2 == log2_trafo_size && ps_sps->i1_chroma_format_idc != CHROMA_FMT_IDC_YUV444))

                {

                    ps_tu->b3_chroma_intra_mode_idx = INTRA_PRED_CHROMA_IDX_NONE;

                }

            }

            /* Set the first TU in CU flag */

            {

                if((ps_codec->s_parse.s_cu.i4_pos_x << 3) == (ps_tu->b4_pos_x << 2) &&

                                (ps_codec->s_parse.s_cu.i4_pos_y << 3) == (ps_tu->b4_pos_y << 2))

                {

                    ps_tu->b1_first_tu_in_cu = 1;

                }

                else

                {

                    ps_tu->b1_first_tu_in_cu = 0;

                }

            }

            ps_codec->s_parse.ps_tu++;

            ps_codec->s_parse.s_cu.i4_tu_cnt++;

            ps_codec->s_parse.i4_pic_tu_idx++;

        }

    }

    return ret;

}

/**

 *******************************************************************************

 *

 * @brief

 *  Parses Motion vector difference

 *

 * @par Description:

 *  Parses Motion vector difference as per Section:7.3.9.9

 *

 * @param[in] ps_codec

 *  Pointer to codec context

 *

 * @returns  Error from IHEVCD_ERROR_T

 *

 * @remarks

 *

 *

 *******************************************************************************

 */

IHEVCD_ERROR_T ihevcd_parse_mvd(codec_t *ps_codec, mv_t *ps_mv)

{

    IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;

    WORD32 value;

    WORD32 abs_mvd;

    bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;

    WORD32 abs_mvd_greater0_flag[2];

    WORD32 abs_mvd_greater1_flag[2];

    WORD32 ctxt_idx;

    cab_ctxt_t *ps_cabac = &ps_codec->s_parse.s_cabac;

    ctxt_idx  = IHEVC_CAB_MVD_GRT0;

    /* encode absmvd_x > 0 */

    TRACE_CABAC_CTXT("abs_mvd_greater0_flag[0]", ps_cabac->u4_range, ctxt_idx);

    abs_mvd_greater0_flag[0] = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

    AEV_TRACE("abs_mvd_greater0_flag[0]", abs_mvd_greater0_flag[0], ps_cabac->u4_range);

    /* encode absmvd_y > 0 */

    TRACE_CABAC_CTXT("abs_mvd_greater0_flag[1]", ps_cabac->u4_range, ctxt_idx);

    abs_mvd_greater0_flag[1] = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

    AEV_TRACE("abs_mvd_greater0_flag[1]", abs_mvd_greater0_flag[1], ps_cabac->u4_range);

    ctxt_idx  = IHEVC_CAB_MVD_GRT1;

    abs_mvd_greater1_flag[0] = 0;

    abs_mvd_greater1_flag[1] = 0;

    if(abs_mvd_greater0_flag[0])

    {

        TRACE_CABAC_CTXT("abs_mvd_greater1_flag[0]", ps_cabac->u4_range, ctxt_idx);

        abs_mvd_greater1_flag[0] = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

        AEV_TRACE("abs_mvd_greater1_flag[0]", abs_mvd_greater1_flag[0], ps_cabac->u4_range);

    }

    if(abs_mvd_greater0_flag[1])

    {

        TRACE_CABAC_CTXT("abs_mvd_greater1_flag[1]", ps_cabac->u4_range, ctxt_idx);

        abs_mvd_greater1_flag[1] = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

        AEV_TRACE("abs_mvd_greater1_flag[1]", abs_mvd_greater1_flag[1], ps_cabac->u4_range);

    }

    abs_mvd = 0;

    if(abs_mvd_greater0_flag[0])

    {

        abs_mvd = 1;

        if(abs_mvd_greater1_flag[0])

        {

            value = ihevcd_cabac_decode_bypass_bins_egk(ps_cabac, ps_bitstrm, 1);

            AEV_TRACE("abs_mvd_minus2[0]", value, ps_cabac->u4_range);

            abs_mvd = value + 2;

        }

        value = ihevcd_cabac_decode_bypass_bin(ps_cabac, ps_bitstrm);

        AEV_TRACE("mvd_sign_flag[0]", value, ps_cabac->u4_range);

        if(value)

        {

            abs_mvd = -abs_mvd;

        }

    }

    ps_mv->i2_mvx = abs_mvd;

    abs_mvd = 0;

    if(abs_mvd_greater0_flag[1])

    {

        abs_mvd = 1;

        if(abs_mvd_greater1_flag[1])

        {

            value = ihevcd_cabac_decode_bypass_bins_egk(ps_cabac, ps_bitstrm, 1);

            AEV_TRACE("abs_mvd_minus2[1]", value, ps_cabac->u4_range);

            abs_mvd = value + 2;

        }

        value = ihevcd_cabac_decode_bypass_bin(ps_cabac, ps_bitstrm);

        AEV_TRACE("mvd_sign_flag[1]", value, ps_cabac->u4_range);

        if(value)

        {

            abs_mvd = -abs_mvd;

        }

    }

    ps_mv->i2_mvy = abs_mvd;

    return ret;

}

/**

 *******************************************************************************

 *

 * @brief

 *  Parses PCM sample

 *

 *

 * @par Description:

 *  Parses PCM sample as per Section:7.3.9.7 Pcm sample syntax

 *

 * @param[in] ps_codec

 *  Pointer to codec context

 *

 * @returns  Error from IHEVCD_ERROR_T

 *

 * @remarks

 *

 *

 *******************************************************************************

 */

IHEVCD_ERROR_T  ihevcd_parse_pcm_sample(codec_t *ps_codec,

                                        WORD32 x0,

                                        WORD32 y0,

                                        WORD32 log2_cb_size)

{

    IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;

    cab_ctxt_t *ps_cabac = &ps_codec->s_parse.s_cabac;

    sps_t *ps_sps;

    WORD32 value;

    WORD32 i;

    WORD32 num_bits;

    UWORD32 u4_sig_coeff_map;

    bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;

    tu_t *ps_tu = ps_codec->s_parse.ps_tu;

    tu_sblk_coeff_data_t *ps_tu_sblk_coeff_data;

    UWORD8 *pu1_coeff_data;

    ps_sps = ps_codec->s_parse.ps_sps;

    UNUSED(value);

    UNUSED(ps_tu);

    UNUSED(ps_cabac);

    UNUSED(x0);

    UNUSED(y0);

    {

        WORD8 *pi1_scan_idx;

        WORD8 *pi1_buf = (WORD8 *)ps_codec->s_parse.pv_tu_coeff_data;

        WORD8 *pi1_num_coded_subblks;

        /* First WORD8 gives number of coded subblocks */

        pi1_num_coded_subblks = pi1_buf++;

        /* Set number of coded subblocks in the current TU to zero */

        /* For PCM there will be only one subblock which is the same size as CU */

        *pi1_num_coded_subblks = 1;

        /* Second WORD8 gives (scan idx << 1) | trans_skip */

        pi1_scan_idx = pi1_buf++;

        *pi1_scan_idx = (0 << 1) | 1;

        /* Store the incremented pointer in pv_tu_coeff_data */

        ps_codec->s_parse.pv_tu_coeff_data = pi1_buf;

    }

    u4_sig_coeff_map = 0xFFFFFFFF;

    ps_tu_sblk_coeff_data = (tu_sblk_coeff_data_t *)ps_codec->s_parse.pv_tu_coeff_data;

    ps_tu_sblk_coeff_data->u2_sig_coeff_map = u4_sig_coeff_map;

    ps_tu_sblk_coeff_data->u2_subblk_pos = 0;

    pu1_coeff_data = (UWORD8 *)&ps_tu_sblk_coeff_data->ai2_level[0];

    num_bits = ps_sps->i1_pcm_sample_bit_depth_luma;

    WORD32 luma_samples = 1 << (log2_cb_size << 1);

    for(i = 0; i < luma_samples; i++)

    {

        TRACE_CABAC_CTXT("pcm_sample_luma", ps_cabac->u4_range, 0);

        BITS_PARSE("pcm_sample_luma", value, ps_bitstrm, num_bits);

        //ps_pcmsample_t->i1_pcm_sample_luma[i] = value;

        *pu1_coeff_data++ = value << (BIT_DEPTH_LUMA - num_bits);

    }

    if(CHROMA_FMT_IDC_MONOCHROME != ps_sps->i1_chroma_format_idc)

    {

        WORD32 chroma_samples = 0;

        if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444)

            chroma_samples = luma_samples << 1;

        else if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV422)

            chroma_samples = luma_samples;

        else if(ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV420)

            chroma_samples = luma_samples >> 1;

        num_bits = ps_sps->i1_pcm_sample_bit_depth_chroma;

        for(i = 0; i < chroma_samples; i++)

        {

            TRACE_CABAC_CTXT("pcm_sample_chroma", ps_cabac->u4_range, 0);

            BITS_PARSE("pcm_sample_chroma", value, ps_bitstrm, num_bits);

            // ps_pcmsample_t->i1_pcm_sample_chroma[i] = value;

            *pu1_coeff_data++ = value << (BIT_DEPTH_CHROMA - num_bits);

        }

    }

    ps_codec->s_parse.pv_tu_coeff_data = pu1_coeff_data;

    return ret;

}

/**

 *******************************************************************************

 *

 * @brief

 *  Parses Prediction unit

 *

 * @par Description:

 *  Parses Prediction unit as per Section:7.3.9.6

 *

 * @param[in] ps_codec

 *  Pointer to codec context

 *

 * @returns  Error from IHEVCD_ERROR_T

 *

 * @remarks

 *

 *

 *******************************************************************************

 */

IHEVCD_ERROR_T  ihevcd_parse_pu_mvp(codec_t *ps_codec, pu_t *ps_pu)

{

    IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;

    WORD32 value;

    slice_header_t *ps_slice_hdr;

    bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;

    cab_ctxt_t *ps_cabac = &ps_codec->s_parse.s_cabac;

    WORD32 inter_pred_idc;

    ps_slice_hdr = ps_codec->s_parse.ps_slice_hdr;

    if(ps_slice_hdr->i1_slice_type == BSLICE)

    {

        WORD32 pu_w_plus_pu_h;

        WORD32 ctxt_idx;

        /* required to check if w+h==12 case */

        pu_w_plus_pu_h = ((ps_pu->b4_wd + 1) << 2) + ((ps_pu->b4_ht + 1) << 2);

        if(12 == pu_w_plus_pu_h)

        {

            ctxt_idx = IHEVC_CAB_INTER_PRED_IDC + 4;

            TRACE_CABAC_CTXT("inter_pred_idc", ps_cabac->u4_range, ctxt_idx);

            inter_pred_idc = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm,

                                                     ctxt_idx);

        }

        else

        {

            /* larger PUs can be encoded as bi_pred/l0/l1 inter_pred_idc */

            WORD32 is_bipred;

            ctxt_idx = IHEVC_CAB_INTER_PRED_IDC + ps_codec->s_parse.i4_ct_depth;

            TRACE_CABAC_CTXT("inter_pred_idc", ps_cabac->u4_range, ctxt_idx);

            is_bipred = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

            inter_pred_idc = PRED_BI;

            if(!is_bipred)

            {

                ctxt_idx = IHEVC_CAB_INTER_PRED_IDC + 4;

                inter_pred_idc = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm,

                                                         ctxt_idx);

            }

        }

        AEV_TRACE("inter_pred_idc", inter_pred_idc, ps_cabac->u4_range);

    }

    else

        inter_pred_idc = PRED_L0;

    ps_pu->mv.i1_l0_ref_idx = 0;

    ps_pu->mv.i1_l1_ref_idx = 0;

    /* Decode MVD for L0 for PRED_L0 or PRED_BI */

    if(inter_pred_idc != PRED_L1)

    {

        WORD32 active_refs = ps_slice_hdr->i1_num_ref_idx_l0_active;

        WORD32 ref_idx = 0;

        WORD32 ctxt_idx;

        if(active_refs > 1)

        {

            ctxt_idx = IHEVC_CAB_INTER_REF_IDX;

            /* encode the context modelled first bin */

            TRACE_CABAC_CTXT("ref_idx", ps_cabac->u4_range, ctxt_idx);

            ref_idx = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

            if((active_refs > 2) && ref_idx)

            {

                WORD32 value;

                /* encode the context modelled second bin */

                ctxt_idx++;

                value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                ref_idx += value;

                if((active_refs > 3) && value)

                {

                    /* encode remaining bypass bins */

                    ref_idx = ihevcd_cabac_decode_bypass_bins_tunary(ps_cabac,

                                                                     ps_bitstrm,

                                                                     (active_refs - 3)

                    );

                    ref_idx += 2;

                }

            }

            AEV_TRACE("ref_idx", ref_idx, ps_cabac->u4_range);

        }

        ref_idx = CLIP3(ref_idx, 0, MAX_DPB_SIZE - 1);

        ps_pu->mv.i1_l0_ref_idx = ref_idx;

        ihevcd_parse_mvd(ps_codec, &ps_pu->mv.s_l0_mv);

        ctxt_idx = IHEVC_CAB_MVP_L0L1;

        value = ihevcd_cabac_decode_bin(ps_cabac,

                                        ps_bitstrm,

                                        ctxt_idx);

        AEV_TRACE("mvp_l0/l1_flag", value, ps_cabac->u4_range);

        ps_pu->b1_l0_mvp_idx = value;

    }

    /* Decode MVD for L1 for PRED_L1 or PRED_BI */

    if(inter_pred_idc != PRED_L0)

    {

        WORD32 active_refs = ps_slice_hdr->i1_num_ref_idx_l1_active;

        WORD32 ref_idx = 0;

        WORD32 ctxt_idx;

        if(active_refs > 1)

        {

            ctxt_idx = IHEVC_CAB_INTER_REF_IDX;

            TRACE_CABAC_CTXT("ref_idx", ps_cabac->u4_range, ctxt_idx);

            /* encode the context modelled first bin */

            ref_idx = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

            if((active_refs > 2) && ref_idx)

            {

                WORD32 value;

                /* encode the context modelled second bin */

                ctxt_idx++;

                value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

                ref_idx += value;

                if((active_refs > 3) && value)

                {

                    /* encode remaining bypass bins */

                    ref_idx = ihevcd_cabac_decode_bypass_bins_tunary(ps_cabac,

                                                                     ps_bitstrm,

                                                                     (active_refs - 3)

                    );

                    ref_idx += 2;

                }

            }

            AEV_TRACE("ref_idx", ref_idx, ps_cabac->u4_range);

        }

        ref_idx = CLIP3(ref_idx, 0, MAX_DPB_SIZE - 1);

        ps_pu->mv.i1_l1_ref_idx = ref_idx;

        if(ps_slice_hdr->i1_mvd_l1_zero_flag && inter_pred_idc == PRED_BI)

        {

            ps_pu->mv.s_l1_mv.i2_mvx = 0;

            ps_pu->mv.s_l1_mv.i2_mvy = 0;

        }

        else

        {

            ihevcd_parse_mvd(ps_codec, &ps_pu->mv.s_l1_mv);

        }

        ctxt_idx = IHEVC_CAB_MVP_L0L1;

        value = ihevcd_cabac_decode_bin(ps_cabac,

                                        ps_bitstrm,

                                        ctxt_idx);

        AEV_TRACE("mvp_l0/l1_flag", value, ps_cabac->u4_range);

        ps_pu->b1_l1_mvp_idx = value;

    }

    ps_pu->b2_pred_mode = inter_pred_idc;

    return ret;

}

/**

 *******************************************************************************

 *

 * @brief

 *  Parses Prediction unit

 *

 * @par Description:

 *  Parses Prediction unit as per Section:7.3.9.6

 *

 * @param[in] ps_codec

 *  Pointer to codec context

 *

 * @returns  Error from IHEVCD_ERROR_T

 *

 * @remarks

 *

 *

 *******************************************************************************

 */

IHEVCD_ERROR_T  ihevcd_parse_prediction_unit(codec_t *ps_codec,

                                             WORD32 x0,

                                             WORD32 y0,

                                             WORD32 wd,

                                             WORD32 ht)

{

    IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;

    slice_header_t *ps_slice_hdr;

    sps_t *ps_sps;

    bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;

    WORD32 ctb_x_base;

    WORD32 ctb_y_base;

    pu_t *ps_pu = ps_codec->s_parse.ps_pu;

    cab_ctxt_t *ps_cabac = &ps_codec->s_parse.s_cabac;

    ps_slice_hdr = ps_codec->s_parse.ps_slice_hdr;

    /* Set PU structure to default values */

    memset(ps_pu, 0, sizeof(pu_t));

    ps_sps = ps_codec->s_parse.ps_sps;

    ctb_x_base = ps_codec->s_parse.i4_ctb_x << ps_sps->i1_log2_ctb_size;

    ctb_y_base = ps_codec->s_parse.i4_ctb_y << ps_sps->i1_log2_ctb_size;

    ps_pu->b4_pos_x = (x0 - ctb_x_base) >> 2;

    ps_pu->b4_pos_y = (y0 - ctb_y_base) >> 2;

    ps_pu->b4_wd = (wd >> 2) - 1;

    ps_pu->b4_ht = (ht >> 2) - 1;

    ps_pu->b1_intra_flag = 0;

    ps_pu->b3_part_mode = ps_codec->s_parse.s_cu.i4_part_mode;

    if(PRED_MODE_SKIP == ps_codec->s_parse.s_cu.i4_pred_mode)

    {

        WORD32 merge_idx = 0;

        if(ps_slice_hdr->i1_max_num_merge_cand > 1)

        {

            WORD32 ctxt_idx = IHEVC_CAB_MERGE_IDX_EXT;

            WORD32 bin;

            TRACE_CABAC_CTXT("merge_idx", ps_cabac->u4_range, ctxt_idx);

            bin = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

            if(bin)

            {

                if(ps_slice_hdr->i1_max_num_merge_cand > 2)

                {

                    merge_idx = ihevcd_cabac_decode_bypass_bins_tunary(

                                    ps_cabac, ps_bitstrm,

                                    (ps_slice_hdr->i1_max_num_merge_cand - 2));

                }