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

 *

 * Copyright (C) 2018 The Android Open Source Project

 *

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

 *

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

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

*/

/**

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

* @file ihevce_cabac_rdo.c

*

* @brief

*  This file contains function definitions for rdopt cabac entropy modules

*

* @author

*  ittiam

*

* @List of Functions

*  ihevce_entropy_rdo_frame_init()

*  ihevce_entropy_rdo_ctb_init()

*  ihevce_entropy_rdo_encode_cu()

*  ihevce_cabac_rdo_encode_sao()

*  ihevce_update_best_sao_cabac_state()

*  ihevce_entropy_update_best_cu_states()

*  ihevce_entropy_rdo_encode_tu()

*  ihevce_entropy_rdo_encode_tu_rdoq()

*  ihevce_entropy_rdo_copy_states()

*

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

/* User include files */

#include "ihevc_typedefs.h"

#include "itt_video_api.h"

#include "ihevce_api.h"

#include "rc_cntrl_param.h"

#include "rc_frame_info_collector.h"

#include "rc_look_ahead_params.h"

#include "ihevc_defs.h"

#include "ihevc_structs.h"

#include "ihevc_platform_macros.h"

#include "ihevc_deblk.h"

#include "ihevc_itrans_recon.h"

#include "ihevc_chroma_itrans_recon.h"

#include "ihevc_chroma_intra_pred.h"

#include "ihevc_intra_pred.h"

#include "ihevc_inter_pred.h"

#include "ihevc_mem_fns.h"

#include "ihevc_padding.h"

#include "ihevc_weighted_pred.h"

#include "ihevc_sao.h"

#include "ihevc_resi_trans.h"

#include "ihevc_quant_iquant_ssd.h"

#include "ihevc_cabac_tables.h"

#include "ihevce_defs.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_me_common_defs.h"

#include "ihevce_had_satd.h"

#include "ihevce_error_codes.h"

#include "ihevce_bitstream.h"

#include "ihevce_cabac.h"

#include "ihevce_rdoq_macros.h"

#include "ihevce_function_selector.h"

#include "ihevce_enc_structs.h"

#include "ihevce_entropy_structs.h"

#include "ihevce_cmn_utils_instr_set_router.h"

#include "ihevce_enc_loop_structs.h"

#include "ihevce_cabac_rdo.h"

#include "ihevce_trace.h"

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

/* Function Definitions                                                      */

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

/**

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

*

*  @brief Cabac rdopt frame level initialization.

*

*  @par   Description

*  Registers the sps,vps,pps,slice header pointers in rdopt enntropy contexts

*  and intializes cabac engine (init states) for each init cu and scratch cu

*  contexts

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*  pointer to rdopt entropy context (handle)

*

*  @param[in]   ps_slice_hdr

*  pointer to  current slice header

*

*  @param[in]   ps_sps

*  pointer to active SPS params

*

*  @param[in]   ps_pps

*  pointer to active PPS params

*

*  @param[in]   ps_vps

*  pointer to active VPS params

*

*  @param[in]   pu1_cu_skip_top_row

*  pointer to top row cu skip flags (registered at frame level)

*

*  @return      none

*

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

*/

void ihevce_entropy_rdo_frame_init(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt,

    slice_header_t *ps_slice_hdr,

    pps_t *ps_pps,

    sps_t *ps_sps,

    vps_t *ps_vps,

    UWORD8 *pu1_cu_skip_top_row,

    rc_quant_t *ps_rc_quant_ctxt)

{

    WORD32 slice_qp = ps_slice_hdr->i1_slice_qp_delta + ps_pps->i1_pic_init_qp;

    /* Initialize the CTB size from sps parameters */

    WORD32 log2_ctb_size =

        ps_sps->i1_log2_min_coding_block_size + ps_sps->i1_log2_diff_max_min_coding_block_size;

    WORD32 cabac_init_idc;

    (void)ps_rc_quant_ctxt;

    /* sanity checks */

    ASSERT((log2_ctb_size >= 3) && (log2_ctb_size <= 6));

    ASSERT((slice_qp >= ps_rc_quant_ctxt->i2_min_qp) && (slice_qp <= ps_rc_quant_ctxt->i2_max_qp));

    /* register the sps,vps,pps, slice header pts in all cu entropy ctxts   */

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].ps_vps = ps_vps;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].ps_sps = ps_sps;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].ps_pps = ps_pps;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].ps_slice_hdr = ps_slice_hdr;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].ps_vps = ps_vps;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].ps_sps = ps_sps;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].ps_pps = ps_pps;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].ps_slice_hdr = ps_slice_hdr;

    /* initialze the skip cu top row ptrs for all rdo entropy contexts      */

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].pu1_skip_cu_top = pu1_cu_skip_top_row;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].pu1_skip_cu_top = pu1_cu_skip_top_row;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i1_log2_ctb_size = log2_ctb_size;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i1_log2_ctb_size = log2_ctb_size;

    /* initialze the skip cu left flagd for all rdo entropy contexts       */

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].u4_skip_cu_left = 0;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].u4_skip_cu_left = 0;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i1_ctb_num_pcm_blks = 0;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i1_ctb_num_pcm_blks = 0;

    /* residue encoding should be enaled if ZERO_CBF eval is disabled */

#if((!RDOPT_ZERO_CBF_ENABLE) && (RDOPT_ENABLE))

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i4_enable_res_encode = 1;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i4_enable_res_encode = 1;

#else

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i4_enable_res_encode = 0;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i4_enable_res_encode = 0;

#endif

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

    /* Note pu1_cbf_cb, pu1_cbf_cr initialization are done with array idx 1  */

    /* This is because these flags are accessed as pu1_cbf_cb[tfr_depth - 1] */

    /* without cheking for tfr_depth= 0                                      */

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

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].apu1_cbf_cb[0] =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cb[0][1];

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].apu1_cbf_cb[0] =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cb[0][1];

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].apu1_cbf_cr[0] =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cr[0][1];

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].apu1_cbf_cr[0] =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cr[0][1];

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].apu1_cbf_cb[1] =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cb[1][1];

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].apu1_cbf_cb[1] =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cb[1][1];

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].apu1_cbf_cr[1] =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cr[1][1];

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].apu1_cbf_cr[1] =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cr[1][1];

    memset(

        ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cb,

        0,

        (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8));

    memset(

        ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cb,

        0,

        (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8));

    memset(

        ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cr,

        0,

        (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8));

    memset(

        ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cr,

        0,

        (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8));

    /* initialize the cabac init idc based on slice type */

    if(ps_slice_hdr->i1_slice_type == ISLICE)

    {

        cabac_init_idc = 0;

    }

    else if(ps_slice_hdr->i1_slice_type == PSLICE)

    {

        cabac_init_idc = ps_slice_hdr->i1_cabac_init_flag ? 2 : 1;

    }

    else

    {

        cabac_init_idc = ps_slice_hdr->i1_cabac_init_flag ? 1 : 2;

    }

    /* all the entropy contexts in rdo initialized in bit compute mode      */

    ihevce_cabac_init(

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].s_cabac_ctxt,

        NULL, /* bitstream buffer not required in bits compute mode */

        CLIP3(slice_qp, 0, IHEVC_MAX_QP),

        cabac_init_idc,

        CABAC_MODE_COMPUTE_BITS);

    ihevce_cabac_init(

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].s_cabac_ctxt,

        NULL, /* bitstream buffer not required in bits compute mode */

        CLIP3(slice_qp, 0, IHEVC_MAX_QP),

        cabac_init_idc,

        CABAC_MODE_COMPUTE_BITS);

    /* initialize the entropy states in rdopt struct  */

    COPY_CABAC_STATES(

        &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0],

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].s_cabac_ctxt.au1_ctxt_models[0],

        sizeof(ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states));

}

/**

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

*

*  @brief Cabac rdopt ctb level initialization.

*

*  @par   Description

*  initialzes the ctb x and y co-ordinates for all the rdopt entropy contexts

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*  pointer to rdopt entropy context (handle)

*

*  @param[in]   ctb_x

*  current ctb x offset w.r.t frame start (ctb units)

*

*  @param[in]   ctb_y

*  current ctb y offset w.r.t frame start (ctb units)

*

*  @return      none

*

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

*/

void ihevce_entropy_rdo_ctb_init(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, WORD32 ctb_x, WORD32 ctb_y)

{

    /* initialze the ctb x and y co-ordinates for all the rdopt entropy contexts */

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i4_ctb_x = ctb_x;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i4_ctb_x = ctb_x;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i4_ctb_y = ctb_y;

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i4_ctb_y = ctb_y;

}

/**

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

*

*  @brief Cabac rdopt cu encode function to compute luma bits for a given cu

*         only luma bits are used for rd optimization currently

*

*  @par   Description

*  use a scratch CU entropy context (indicated by rdopt_buf_idx) whose cabac

*  states are reset (to CU init state) and calls the cabac entropy coding

*  unit function to compute the total bits for current CU

*

*  A local CU structutre is prepared (in stack) as the structures that entropy

*  encode expects and the rdopt gets are different

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*   pointer to rdopt entropy context (handle)

*

*  @param[in]   ps_cu_prms

*   pointer to current CU params whose bits are computed

*

*  @param[in]   cu_pos_x

*   current CU x position w.r.t ctb (in 8x8 units)

*

*  @param[in]   cu_pos_y

*   current CU y position w.r.t ctb (in 8x8 units)

*

*  @param[in]   cu_size

*   current cu size (in pel units)

*

*  @param[in]   top_avail

*   top avaialability flag for current CU (required for encoding skip flag)

*

*  @param[in]   left_avail

*   left avaialability flag for current CU (required for encoding skip flag)

*

*  @param[in]   pv_ecd_coeff

*   Compressed coeff residue buffer (for luma)

*

*  @param[in]   rdopt_buf_idx

*   corresponds to the id of the scratch CU entropy context that needs to be

*   used for bit estimation

*

*  @param[out]   pi4_cu_rdopt_tex_bits

*   returns cbf bits if zer0 cbf eval flag is enabled otherwiese returns total

*   tex(including cbf bits)

*

*  @return      total bits required to encode the current CU

*

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

*/

WORD32 ihevce_entropy_rdo_encode_cu(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt,

    enc_loop_cu_final_prms_t *ps_cu_prms,

    WORD32 cu_pos_x,

    WORD32 cu_pos_y,

    WORD32 cu_size,

    WORD32 top_avail,

    WORD32 left_avail,

    void *pv_ecd_coeff,

    WORD32 *pi4_cu_rdopt_tex_bits)

{

    /* local cu structure for passing to entrop encode cu module */

    cu_enc_loop_out_t s_enc_cu;

    WORD32 rdopt_buf_idx = ps_rdopt_entropy_ctxt->i4_curr_buf_idx;

    entropy_context_t *ps_cur_cu_entropy =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_buf_idx];

    WORD32 total_bits = 0;

    WORD32 log2_ctb_size = ps_cur_cu_entropy->i1_log2_ctb_size;

    WORD32 log2_cu_size;

    WORD32 cu_depth;

    /* sanity checks */

    ASSERT((rdopt_buf_idx == 0) || (rdopt_buf_idx == 1));

    ASSERT((cu_size >= 8) && (cu_size <= (1 << log2_ctb_size)));

    ASSERT((cu_pos_x >= 0) && (cu_pos_x <= (1 << (log2_ctb_size - 3))));

    ASSERT((cu_pos_y >= 0) && (cu_pos_y <= (1 << (log2_ctb_size - 3))));

    GETRANGE(log2_cu_size, cu_size);

    log2_cu_size -= 1;

    cu_depth = log2_ctb_size - log2_cu_size;

    {

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

        /* prepare local cu structure before calling cabac encode */

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

        /* default be canged to have orred val*/

        s_enc_cu.b1_no_residual_syntax_flag = 0;

        /* initialize cu posx, posy and size */

        s_enc_cu.b3_cu_pos_x = cu_pos_x;

        s_enc_cu.b3_cu_pos_y = cu_pos_y;

        s_enc_cu.b4_cu_size = (cu_size >> 3);

        /* PCM not supported */

        s_enc_cu.b1_pcm_flag = 0;

        s_enc_cu.b1_pred_mode_flag = ps_cu_prms->u1_intra_flag;

        s_enc_cu.b3_part_mode = ps_cu_prms->u1_part_mode;

        s_enc_cu.b1_skip_flag = ps_cu_prms->u1_skip_flag;

        s_enc_cu.b1_tq_bypass_flag = 0;

        s_enc_cu.pv_coeff = pv_ecd_coeff;

        /* store the number of TUs */

        s_enc_cu.u2_num_tus_in_cu = ps_cu_prms->u2_num_tus_in_cu;

        /* ---- intialize the PUs and TUs start ptrs for cur CU ----- */

        s_enc_cu.ps_pu = &ps_cu_prms->as_pu_enc_loop[0];

        s_enc_cu.ps_enc_tu = &ps_cu_prms->as_tu_enc_loop[0];

        /* Corner case : If Part is 2Nx2N and Merge has all TU with zero cbf */

        /* then it has to be coded as skip CU */

        if((SIZE_2Nx2N == ps_cu_prms->u1_part_mode) &&

           /*(1 == ps_cu_prms->u2_num_tus_in_cu) &&*/

           (1 == ps_cu_prms->as_pu_enc_loop[0].b1_merge_flag) && (0 == ps_cu_prms->u1_skip_flag) &&

           (0 == ps_cu_prms->u1_is_cu_coded))

        {

            s_enc_cu.b1_skip_flag = 1;

        }

        if(s_enc_cu.b1_pred_mode_flag == PRED_MODE_INTER)

        {

            s_enc_cu.b1_no_residual_syntax_flag = !ps_cu_prms->u1_is_cu_coded;

        }

        else /* b1_pred_mode_flag == PRED_MODE_INTRA */

        {

            /* copy prev_mode_flag, mpm_idx and rem_intra_pred_mode for each PU */

            memcpy(

                &s_enc_cu.as_prev_rem[0],

                &ps_cu_prms->as_intra_prev_rem[0],

                ps_cu_prms->u2_num_tus_in_cu * sizeof(intra_prev_rem_flags_t));

            s_enc_cu.b3_chroma_intra_pred_mode = ps_cu_prms->u1_chroma_intra_pred_mode;

        }

    }

    /* reset the total bits in cabac engine to zero */

    ps_cur_cu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0;

    ps_cur_cu_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 = 0;

    ps_cur_cu_entropy->s_cabac_ctxt.u4_cbf_bits_q12 = 0;

    ps_cur_cu_entropy->i1_encode_qp_delta = 0;

    /* Call the cabac encode function of current cu to compute bits */

    ihevce_cabac_encode_coding_unit(ps_cur_cu_entropy, &s_enc_cu, cu_depth, top_avail, left_avail);

    /* return total bits after rounding the fractional bits */

    total_bits =

        (ps_cur_cu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >>

        CABAC_FRAC_BITS_Q;

#if RDOPT_ZERO_CBF_ENABLE

    ASSERT(ps_cur_cu_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 == 0);

#endif

    /* return total texture bits rounding the fractional bits */

    *pi4_cu_rdopt_tex_bits =

        (ps_cur_cu_entropy->s_cabac_ctxt.u4_cbf_bits_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >>

        CABAC_FRAC_BITS_Q;

    /*   (   ps_cur_cu_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 +

                (1 << (CABAC_FRAC_BITS_Q - 1))

            ) >>  CABAC_FRAC_BITS_Q;*/

    return (total_bits);

}

/**

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

*

*  @brief Cabac rdo encode sao function to compute bits required for a given

*         ctb to be encoded with any sao type or no SAO.

*

*  @par   Description

*  use a scratch CU entropy context (indicated by rdopt_buf_idx) and init cabac

*  states are reset (to CU init state) and calls the cabac encode sao

*  function to compute the total bits for current CTB

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*   pointer to rdopt entropy context (handle)

*

*  @param[in]   ps_ctb_enc_loop_out

*   pointer to current enc loop CTB output structure

*

*  @return      total bits required to encode the current CTB

*

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

*/

WORD32 ihevce_cabac_rdo_encode_sao(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, ctb_enc_loop_out_t *ps_ctb_enc_loop_out)

{

    /* index to curr buf*/

    WORD32 rdopt_buf_idx = ps_rdopt_entropy_ctxt->i4_curr_buf_idx;

    WORD32 total_bits = 0;

    entropy_context_t *ps_cur_ctb_entropy =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_buf_idx];

    /* copy the intial entropy states from backuped buf to curr buf  */

    memcpy(

        &ps_cur_ctb_entropy->s_cabac_ctxt.au1_ctxt_models[0],

        &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0],

        sizeof(ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states));

    /* reset the total bits in cabac engine to zero */

    ps_cur_ctb_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0;

    ps_cur_ctb_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 = 0;

    ps_cur_ctb_entropy->s_cabac_ctxt.u4_cbf_bits_q12 = 0;

    ps_cur_ctb_entropy->i1_encode_qp_delta = 0;

    //ps_cur_ctb_entropy->s_cabac_ctxt.u4_range = 0;

    ASSERT(ps_cur_ctb_entropy->s_cabac_ctxt.u4_range == 0);

    ihevce_cabac_encode_sao(ps_cur_ctb_entropy, ps_ctb_enc_loop_out);

    /* return total bits after rounding the fractional bits */

    total_bits =

        (ps_cur_ctb_entropy->s_cabac_ctxt.u4_bits_estimated_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >>

        CABAC_FRAC_BITS_Q;

    return (total_bits);

}

/**

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

*

*  @brief Updates best sao cabac state.

*

*  @par   Description

*         Copies the cabac states of best cand to init states buf for next ctb.

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*   pointer to rdopt entropy context (handle)

*

*  @param[in]   i4_best_buf_idx

*   Index to the buffer having the cabac states of best candidate

*

*  @return   Success/failure

*

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

*/

WORD32 ihevce_update_best_sao_cabac_state(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, WORD32 i4_best_buf_idx)

{

    /* local cu structure for passing to entrop encode cu module */

    WORD32 rdopt_buf_idx = i4_best_buf_idx;

    entropy_context_t *ps_cur_ctb_entropy =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_buf_idx];

    /* copy the intial entropy states from best buf to intial states buf */

    memcpy(

        &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0],

        &ps_cur_ctb_entropy->s_cabac_ctxt.au1_ctxt_models[0],

        sizeof(ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states));

    /* reset the total bits in cabac engine to zero */

    ps_cur_ctb_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0;

    ps_cur_ctb_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 = 0;

    ps_cur_ctb_entropy->s_cabac_ctxt.u4_cbf_bits_q12 = 0;

    ps_cur_ctb_entropy->i1_encode_qp_delta = 0;

    return (1);

}

/**

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

*

*  @brief Cabac rdopt cu encode function to compute luma bits for a given cu

*         only luma bits are used for rd optimization currently

*

*  @par   Description

*  use a scratch CU entropy context (indicated by rdopt_buf_idx) whose cabac

*  states are reset (to CU init state) and calls the cabac entropy coding

*  unit function to compute the total bits for current CU

*

*  A local CU structutre is prepared (in stack) as the structures that entropy

*  encode expects and the rdopt gets are different

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*   pointer to rdopt entropy context (handle)

*

*  @param[in]   cu_pos_x

*   current CU x position w.r.t ctb (in 8x8 units)

*

*  @param[in]   cu_pos_y

*   current CU y position w.r.t ctb (in 8x8 units)

*

*  @param[in]   cu_size

*   current cu size (in pel units)

*

*  @param[in]   rdopt_best_cu_idx

*   id of the best CU entropy ctxt (rdopt winner candidate)

*

*  @return      total bits required to encode the current CU

*

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

*/

void ihevce_entropy_update_best_cu_states(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt,

    WORD32 cu_pos_x,

    WORD32 cu_pos_y,

    WORD32 cu_size,

    WORD32 cu_skip_flag,

    WORD32 rdopt_best_cu_idx)

{

    entropy_context_t *ps_best_cu_entropy =

        &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_best_cu_idx];

    /* CTB x co-ordinate w.r.t frame start           */

    WORD32 ctb_x0_frm = (ps_best_cu_entropy->i4_ctb_x << ps_best_cu_entropy->i1_log2_ctb_size);

    /* CU x co-ordinate w.r.t frame start           */

    WORD32 cu_x0_frm = cu_pos_x + ctb_x0_frm;

    /* bit postion from where top skip flag is extracted; 1bit per 8 pel   */

    WORD32 x_pos = ((cu_x0_frm >> 3) & 0x7);

    /* bit postion from where left skip flag is extracted; 1bit per 8 pel  */

    WORD32 y_pos = ((cu_pos_y >> 3) & 0x7);

    /* top and left skip flags computed based on nbr availability */

    UWORD8 *pu1_top_skip_flags = ps_best_cu_entropy->pu1_skip_cu_top + (cu_x0_frm >> 6);

    UWORD32 u4_skip_left_flags = ps_best_cu_entropy->u4_skip_cu_left;

    ps_best_cu_entropy = &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_best_cu_idx];

    /* copy the entropy states from best rdopt cu states to init states  */

    COPY_CABAC_STATES(

        &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0],

        &ps_best_cu_entropy->s_cabac_ctxt.au1_ctxt_models[0],

        sizeof(ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states));

    /* replicate skip flag in left and top row cu skip flags */

    if(cu_skip_flag)

    {

        SET_BITS(pu1_top_skip_flags[0], x_pos, (cu_size >> 3));

        SET_BITS(u4_skip_left_flags, y_pos, (cu_size >> 3));

    }

    else

    {

        CLEAR_BITS(pu1_top_skip_flags[0], x_pos, (cu_size >> 3));

        CLEAR_BITS(u4_skip_left_flags, y_pos, (cu_size >> 3));

    }

    /* copy the left skip flags in both the rdopt contexts */

    ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].u4_skip_cu_left =

        ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].u4_skip_cu_left = u4_skip_left_flags;

}

/**

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

*

*  @brief Cabac rdopt tu encode function to compute luma bits for a given tu

*         only luma bits are used for rd optimization currently

*

*  @par   Description

*  use a scratch CU entropy context (indicated by rdopt_buf_idx) whose cabac

*  states are reset (to CU init state for first tu) and calls the cabac residue

*  coding function to compute the total bits for current TU

*

*  Note : TU includes only residual coding bits and does not include

*         tu split, cbf and qp delta encoding bits for a TU

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*   pointer to rdopt entropy context (handle)

*

*  @param[in]   pv_ecd_coeff

*   Compressed coeff residue buffer (for luma)

*

*  @param[in]   transform_size

*   current tu size in pel units

*

*  @param[in]   is_luma

*   indicates if it is luma or chrom TU (required for residue encode)

*

*  @return      total bits required to encode the current TU

*

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

*/

WORD32 ihevce_entropy_rdo_encode_tu(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt,

    void *pv_ecd_coeff,

    WORD32 transform_size,

    WORD32 is_luma,

    WORD32 perform_sbh)

{

    WORD32 log2_tfr_size;

    WORD32 total_bits = 0;

    WORD32 curr_buf_idx = ps_rdopt_entropy_ctxt->i4_curr_buf_idx;

    entropy_context_t *ps_cur_tu_entropy;

    ps_cur_tu_entropy = &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[curr_buf_idx];

    ASSERT((transform_size >= 4) && (transform_size <= 32));

    /* transform size to log2transform size */

    GETRANGE(log2_tfr_size, transform_size);

    log2_tfr_size -= 1;

    /* reset the total bits in cabac engine to zero */

    ps_cur_tu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0;

    ps_cur_tu_entropy->i1_encode_qp_delta = 0;

    /* Call the cabac residue encode function to compute TU bits */

    ihevce_cabac_residue_encode_rdopt(

        ps_cur_tu_entropy, pv_ecd_coeff, log2_tfr_size, is_luma, perform_sbh);

    /* return total bits after rounding the fractional bits */

    total_bits =

        (ps_cur_tu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >>

        CABAC_FRAC_BITS_Q;

    return (total_bits);

}

/**

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

*

*  @brief Cabac rdopt tu encode function to compute bits for a given tu. Actual

*  RDOQ algorithm is performed by the ihevce_cabac_residue_encode_rdoq function

*  called by this function.

*

*  @par   Description

*  use a scratch CU entropy context (indicated by rdopt_buf_idx) whose cabac

*  states are reset (to CU init state for first tu) and calls the cabac residue

*  coding function to compute the total bits for current TU

*

*  Note : TU includes only residual coding bits and does not include

*         tu split, cbf and qp delta encoding bits for a TU

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*   pointer to rdopt entropy context (handle)

*

*  @param[in]   pv_ecd_coeff

*   Compressed coeff residue buffer

*

*  @param[in]   transform_size

*   current tu size in pel units

*

*  @param[in]   first_tu_of_cu

*   indicates if the tu is the first unit of cu (required for initializing

*   cabac ctxts)

*

*  @param[in]   rdopt_buf_idx

*   corresponds to the id of the rdopt CU entropy context that needs to be

*   used for bit estimation

*

*  @param[in]   is_luma

*   indicates if it is luma or chrom TU (required for residue encode)

*

*  @param[in]   intra_nxn_mode

*   indicates if it is luma or chrom TU (required for residue encode)

*

*  @param[inout] ps_rdoq_ctxt

*  pointer to rdoq context structure

*

*  @param[inout] pi4_coded_tu_dist

*  Pointer to the variable which will contain the transform domain distortion

*  of the entire TU, when any of the coeffs in the TU are coded

*

*  @param[inout] pi4_not_coded_tu_dist

*  Pointer to the variable which will contain the transform domain distortion

*  of the enture TU, when all the coeffs in the TU are coded

*

*  @return      total bits required to encode the current TU

*

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

*/

WORD32 ihevce_entropy_rdo_encode_tu_rdoq(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt,

    void *pv_ecd_coeff,

    WORD32 transform_size,

    WORD32 is_luma,

    rdoq_sbh_ctxt_t *ps_rdoq_ctxt,

    LWORD64 *pi8_coded_tu_dist,

    LWORD64 *pi8_not_coded_tu_dist,

    WORD32 perform_sbh)

{

    WORD32 log2_tfr_size;

    WORD32 total_bits = 0;

    WORD32 curr_buf_idx = ps_rdopt_entropy_ctxt->i4_curr_buf_idx;

    entropy_context_t *ps_cur_tu_entropy;

    ps_cur_tu_entropy = &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[curr_buf_idx];

    ASSERT((transform_size >= 4) && (transform_size <= 32));

    /* transform size to log2transform size */

    GETRANGE(log2_tfr_size, transform_size);

    log2_tfr_size -= 1;

    /* reset the total bits in cabac engine to zero */

    ps_cur_tu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0;

    ps_cur_tu_entropy->i1_encode_qp_delta = 0;

    /* Call the cabac residue encode function to compute TU bits */

    ihevce_cabac_residue_encode_rdoq(

        ps_cur_tu_entropy,

        pv_ecd_coeff,

        log2_tfr_size,

        is_luma,

        (void *)ps_rdoq_ctxt,

        pi8_coded_tu_dist,

        pi8_not_coded_tu_dist,

        perform_sbh);

    /* return total bits after rounding the fractional bits */

    total_bits =

        (ps_cur_tu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >>

        CABAC_FRAC_BITS_Q;

    return (total_bits);

}

/**

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

*

*  @brief Cabac rdopt copy functions for copying states (which will be used later)

*

*  @par   Description

*  Does the HEVC style of entropy sync by copying the state to/from rdo context

*  from/to row level cabac states at start of row/2nd ctb of row

*

*  Caller needs to make sure UPDATE_ENT_SYNC_RDO_STATE is used for first ctb of

*  every row (leaving first row of slice) and STORE_ENT_SYNC_RDO_STATE is used for

*  storing the cabac states at the end of 2nd ctb of a row.

*

*  @param[inout]   ps_rdopt_entropy_ctxt

*  pointer to rdopt entropy context (handle)

*

*  @param[in]   pu1_entropy_sync_states

*  pointer to entropy sync cabac states

*

*  @param[in]   copy_mode

*  mode of copying cabac states. Shall be either UPDATE_ENT_SYNC_RDO_STATE and

*  STORE_ENT_SYNC_RDO_STATE

*

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

*/

void ihevce_entropy_rdo_copy_states(

    rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, UWORD8 *pu1_entropy_sync_states, WORD32 copy_mode)

{

    /* sanity checks */

    ASSERT((copy_mode == STORE_ENT_SYNC_RDO_STATE) || (copy_mode == UPDATE_ENT_SYNC_RDO_STATE));

    if(STORE_ENT_SYNC_RDO_STATE == copy_mode)

    {

        COPY_CABAC_STATES(

            pu1_entropy_sync_states,

            &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0],

            IHEVC_CAB_CTXT_END);

    }

    else if(UPDATE_ENT_SYNC_RDO_STATE == copy_mode)

    {

        COPY_CABAC_STATES(

            &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0],

            pu1_entropy_sync_states,

            IHEVC_CAB_CTXT_END);

    }

}