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

 *

 * Copyright (C) 2022 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

*  isvce_cavlc.c

*

* @brief

*  Contains all the routines to code syntax elements and residuals when entropy

*  coding chosen is CAVLC

*

* @author

*  ittiam

*

* @par List of Functions:

*  - isvce_compute_zeroruns_and_trailingones()

*  - isvce_write_coeff4x4_cavlc()

*  - isvce_write_coeff8x8_cavlc()

*  - isvce_encode_residue()

*  - isvce_write_islice_mb_cavlc()

*  - isvce_write_pslice_mb_cavlc()

*

* @remarks

*  None

*

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <assert.h>

#include <limits.h>

/* User include files */

#include "ih264e_config.h"

#include "ih264_typedefs.h"

#include "iv2.h"

#include "ive2.h"

#include "ih264_debug.h"

#include "isvc_macros.h"

#include "isvc_defs.h"

#include "isvce_defs.h"

#include "ih264e_error.h"

#include "ih264e_bitstream.h"

#include "ime_distortion_metrics.h"

#include "ime_defs.h"

#include "ime_structs.h"

#include "ih264_error.h"

#include "isvc_structs.h"

#include "isvc_trans_quant_itrans_iquant.h"

#include "isvc_inter_pred_filters.h"

#include "isvc_mem_fns.h"

#include "ih264_padding.h"

#include "ih264_intra_pred_filters.h"

#include "ih264_deblk_edge_filters.h"

#include "isvc_cabac_tables.h"

#include "irc_cntrl_param.h"

#include "irc_frame_info_collector.h"

#include "isvce_rate_control.h"

#include "isvce_cabac_structs.h"

#include "isvce_structs.h"

#include "isvce_encode_header.h"

#include "ih264_cavlc_tables.h"

#include "isvce_cavlc.h"

#include "ih264e_statistics.h"

#include "ih264e_trace.h"

#include "isvce_encode_header.h"

#include "isvce_utils.h"

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

/* Function Definitions                                                      */

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

/**

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

*

* @brief

*  This function computes run of zero, number of trailing ones and sign of

*  trailing ones basing on the significant coeff map, residual block and

*  total nnz.

*

* @param[in] pi2_res_block

*  Pointer to residual block containing levels in scan order

*

* @param[in] u4_total_coeff

*  Total non-zero coefficients in that sub block

*

* @param[in] pu1_zero_run

*  Pointer to array to store run of zeros

*

* @param[in] u4_sig_coeff_map

*  significant coefficient map

*

* @returns u4_totzero_sign_trailone

*  Bits 0-8 contains number of trailing ones.

*  Bits 8-16 contains bitwise sign information of trailing one

*  Bits 16-24 contains total number of zeros.

*

* @remarks

*  None

*

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

*/

static UWORD32 isvce_compute_zeroruns_and_trailingones(WORD16 *pi2_res_block,

                                                       UWORD32 u4_total_coeff, UWORD8 *pu1_zero_run,

                                                       UWORD32 u4_sig_coeff_map)

{

    UWORD32 i = 0;

    UWORD32 u4_nnz_coeff = 0;

    WORD32 i4_run = -1;

    UWORD32 u4_sign = 0;

    UWORD32 u4_tot_zero = 0;

    UWORD32 u4_trailing1 = 0;

    WORD32 i4_val;

    UWORD32 u4_totzero_sign_trailone;

    UWORD32 *pu4_zero_run;

    pu4_zero_run = (void *) pu1_zero_run;

    pu4_zero_run[0] = 0;

    pu4_zero_run[1] = 0;

    pu4_zero_run[2] = 0;

    pu4_zero_run[3] = 0;

    /* Compute Runs of zeros for all nnz coefficients except the last 3 */

    if(u4_total_coeff > 3)

    {

        for(i = 0; u4_nnz_coeff < (u4_total_coeff - 3); i++)

        {

            i4_run++;

            i4_val = (u4_sig_coeff_map & 0x1);

            u4_sig_coeff_map >>= 1;

            if(i4_val != 0)

            {

                pu1_zero_run[u4_nnz_coeff++] = i4_run;

                i4_run = -1;

            }

        }

    }

    /* Compute T1's, Signof(T1's) and Runs of zeros for the last 3 */

    while(u4_nnz_coeff != u4_total_coeff)

    {

        i4_run++;

        i4_val = (u4_sig_coeff_map & 0x1);

        u4_sig_coeff_map >>= 1;

        if(i4_val != 0)

        {

            if(pi2_res_block[u4_nnz_coeff] == 1)

            {

                pu1_zero_run[u4_nnz_coeff] = i4_run;

                u4_trailing1++;

            }

            else

            {

                if(pi2_res_block[u4_nnz_coeff] == -1)

                {

                    pu1_zero_run[u4_nnz_coeff] = i4_run;

                    u4_sign |= 1 << u4_trailing1;

                    u4_trailing1++;

                }

                else

                {

                    pu1_zero_run[u4_nnz_coeff] = i4_run;

                    u4_trailing1 = 0;

                    u4_sign = 0;

                }

            }

            i4_run = -1;

            u4_nnz_coeff++;

        }

        i++;

    }

    u4_tot_zero = i - u4_total_coeff;

    u4_totzero_sign_trailone = (u4_tot_zero << 16) | (u4_sign << 8) | u4_trailing1;

    return (u4_totzero_sign_trailone);

}

/**

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

*

* @brief

*  This function generates CAVLC coded bit stream for the given residual block

*

* @param[in] pi2_res_block

*  Pointer to residual block containing levels in scan order

*

* @param[in] u4_total_coeff

*  Total non-zero coefficients in the sub block

*

* @param[in] u4_block_type

*  block type

*

* @param[in] pu1_zero_run

*  Pointer to array to store run of zeros

*

* @param[in] u4_nc

*  average of non zero coeff from top and left blocks (when available)

*

* @param[in, out] ps_bit_stream

*  structure pointing to a buffer holding output bit stream

*

* @param[in] u4_sig_coeff_map

*  significant coefficient map of the residual block

*

* @returns

*  error code

*

* @remarks

*  If the block type is CAVLC_CHROMA_4x4_DC, then u4_nc is non-significant

*

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

*/

static IH264E_ERROR_T isvce_write_coeff4x4_cavlc(WORD16 *pi2_res_block, UWORD32 u4_total_coeff,

                                                 ENTROPY_BLK_TYPE u4_block_type,

                                                 UWORD8 *pu1_zero_run, UWORD32 u4_nc,

                                                 bitstrm_t *ps_bit_stream, UWORD32 u4_sig_coeff_map)

{

    IH264E_ERROR_T error_status = IH264E_SUCCESS;

    UWORD32 u4_totzero_sign_trailone = 0;

    UWORD32 u4_trailing_ones = 0;

    UWORD32 u4_tot_zeros = 0;

    UWORD32 u4_remaining_coeff = 0;

    UWORD32 u4_sign1 = 0;

    UWORD32 u4_max_num_coeff = 0;

    const UWORD32 au4_max_num_nnz_coeff[] = {16, 15, 16, 4, 15};

    /* validate inputs */

    ASSERT(u4_block_type <= CAVLC_CHROMA_4x4_AC);

    u4_max_num_coeff = au4_max_num_nnz_coeff[u4_block_type];

    ASSERT(u4_total_coeff <= u4_max_num_coeff);

    if(!u4_total_coeff)

    {

        UWORD32 u4_codeword = 15;

        UWORD32 u4_codesize = 1;

        if(u4_block_type == CAVLC_CHROMA_4x4_DC)

        {

            u4_codeword = 1;

            u4_codesize = 2;

            DEBUG("\n[%d numcoeff, %d numtrailing ones]", u4_total_coeff, 0);

            ENTROPY_TRACE("\tnumber of non zero coeffs ", u4_total_coeff);

            ENTROPY_TRACE("\tnumber of trailing ones ", 0);

        }

        else

        {

            UWORD32 u4_vlcnum = u4_nc >> 1;

            /* write coeff_token */

            if(u4_vlcnum > 3)

            {

                /* Num-FLC */

                u4_codeword = 3;

                u4_codesize = 6;

            }

            else

            {

                /* Num-VLC 0, 1, 2 */

                if(u4_vlcnum > 1)

                {

                    u4_vlcnum = 2;

                }

                u4_codesize <<= u4_vlcnum;

                u4_codeword >>= (4 - u4_codesize);

            }

            DEBUG("\n[%d numcoeff, %d numtrailing ones, %d nnz]", u4_total_coeff, 0, u4_nc);

            ENTROPY_TRACE("\tnumber of non zero coeffs ", u4_total_coeff);

            ENTROPY_TRACE("\tnC ", u4_nc);

        }

        DEBUG("\nCOEFF TOKEN 0: %d u4_codeword, %d u4_codesize", u4_codeword, u4_codesize);

        ENTROPY_TRACE("\tcodeword ", u4_codeword);

        ENTROPY_TRACE("\tcodesize ", u4_codesize);

        error_status = ih264e_put_bits(ps_bit_stream, u4_codeword, u4_codesize);

        return error_status;

    }

    else

    {

        /* Compute zero run, number of trailing ones and their sign. */

        u4_totzero_sign_trailone = isvce_compute_zeroruns_and_trailingones(

            pi2_res_block, u4_total_coeff, pu1_zero_run, u4_sig_coeff_map);

        u4_trailing_ones = u4_totzero_sign_trailone & 0xFF;

        u4_sign1 = (u4_totzero_sign_trailone >> 8) & 0xFF;

        u4_tot_zeros = (u4_totzero_sign_trailone >> 16) & 0xFF;

        u4_remaining_coeff = u4_total_coeff - u4_trailing_ones;

        /* write coeff_token */

        {

            UWORD32 u4_codeword;

            UWORD32 u4_codesize;

            if(u4_block_type == CAVLC_CHROMA_4x4_DC)

            {

                u4_codeword =

                    gu1_code_coeff_token_table_chroma[u4_trailing_ones][u4_total_coeff - 1];

                u4_codesize =

                    gu1_size_coeff_token_table_chroma[u4_trailing_ones][u4_total_coeff - 1];

                DEBUG("\n[%d numcoeff, %d numtrailing ones]", u4_total_coeff, u4_trailing_ones);

                ENTROPY_TRACE("\tnumber of non zero coeffs ", u4_total_coeff);

                ENTROPY_TRACE("\tnumber of trailing ones ", u4_trailing_ones);

            }

            else

            {

                UWORD32 u4_vlcnum = u4_nc >> 1;

                if(u4_vlcnum > 3)

                {

                    /* Num-FLC */

                    u4_codeword = ((u4_total_coeff - 1) << 2) + u4_trailing_ones;

                    u4_codesize = 6;

                }

                else

                {

                    /* Num-VLC 0, 1, 2 */

                    if(u4_vlcnum > 1)

                    {

                        u4_vlcnum = 2;

                    }

                    u4_codeword =

                        gu1_code_coeff_token_table[u4_vlcnum][u4_trailing_ones][u4_total_coeff - 1];

                    u4_codesize =

                        gu1_size_coeff_token_table[u4_vlcnum][u4_trailing_ones][u4_total_coeff - 1];

                }

                DEBUG("\n[%d numcoeff, %d numtrailing ones, %d nnz]", u4_total_coeff,

                      u4_trailing_ones, u4_nc);

                ENTROPY_TRACE("\tnumber of non zero coeffs ", u4_total_coeff);

                ENTROPY_TRACE("\tnumber of trailing ones ", u4_trailing_ones);

                ENTROPY_TRACE("\tnC ", u4_nc);

            }

            DEBUG("\nCOEFF TOKEN 0: %d u4_codeword, %d u4_codesize", u4_codeword, u4_codesize);

            ENTROPY_TRACE("\tcodeword ", u4_codeword);

            ENTROPY_TRACE("\tcodesize ", u4_codesize);

            error_status = ih264e_put_bits(ps_bit_stream, u4_codeword, u4_codesize);

        }

        /* write sign of trailing ones */

        if(u4_trailing_ones)

        {

            DEBUG("\nT1's: %d u4_codeword, %d u4_codesize", u4_sign1, u4_trailing_ones);

            error_status = ih264e_put_bits(ps_bit_stream, u4_sign1, u4_trailing_ones);

            ENTROPY_TRACE("\tnumber of trailing ones ", u4_trailing_ones);

            ENTROPY_TRACE("\tsign of trailing ones ", u4_sign1);

        }

        /* write level codes */

        if(u4_remaining_coeff)

        {

            WORD32 i4_level = pi2_res_block[u4_remaining_coeff - 1];

            UWORD32 u4_escape;

            UWORD32 u4_suffix_length = 0;  // Level-VLC[N]

            UWORD32 u4_abs_level, u4_abs_level_actual = 0;

            WORD32 i4_sign;

            const UWORD32 u4_rndfactor[] = {0, 0, 1, 3, 7, 15, 31};

            DEBUG("\n \t%d coeff,", i4_level);

            ENTROPY_TRACE("\tcoeff ", i4_level);

            if(u4_trailing_ones < 3)

            {

                /* If there are less than 3 T1s, then the first non-T1 level is

                 * incremented if negative (decremented if positive)*/

                if(i4_level < 0)

                {

                    i4_level += 1;

                }

                else

                {

                    i4_level -= 1;

                }

                u4_abs_level_actual = 1;

                /* Initialize VLC table (Suffix Length) to encode the level */

                if(u4_total_coeff > 10)

                {

                    u4_suffix_length = 1;

                }

            }

            i4_sign = (i4_level >> (sizeof(WORD32) * CHAR_BIT - 1));

            u4_abs_level = ((i4_level + i4_sign) ^ i4_sign);

            u4_abs_level_actual += u4_abs_level;

            u4_escape = (u4_abs_level + u4_rndfactor[u4_suffix_length]) >> u4_suffix_length;

            while(1)

            {

                UWORD32 u4_codesize;

                UWORD32 u4_codeword;

                UWORD32 u4_codeval;

                u4_remaining_coeff--;

                GATHER_CAVLC_STATS1();

                {

                    u4_codeval = u4_abs_level << 1;

                    u4_codeval = u4_codeval - 2 - i4_sign;

                    if((!u4_suffix_length) && (u4_escape > 7) && (u4_abs_level < 16))

                    {

                        u4_codeword = (1 << 4) + (u4_codeval - 14);

                        u4_codesize = 19;

                    }

                    else if(u4_escape > 7)

                    {

                        u4_codeword = (1 << 12) + (u4_codeval - (15 << u4_suffix_length));

                        u4_codesize = 28;

                        if(!u4_suffix_length)

                        {

                            u4_codeword -= 15;

                        }

                    }

                    else

                    {

                        u4_codeword =

                            (1 << u4_suffix_length) + (u4_codeval & ((1 << u4_suffix_length) - 1));

                        u4_codesize = (u4_codeval >> u4_suffix_length) + 1 + u4_suffix_length;

                    }

                }

                /*put the level code in bitstream*/

                DEBUG("\nLEVEL: %d u4_codeword, %d u4_codesize", u4_codeword, u4_codesize);

                ENTROPY_TRACE("\tcodeword ", u4_codeword);

                ENTROPY_TRACE("\tcodesize ", u4_codesize);

                error_status = ih264e_put_bits(ps_bit_stream, u4_codeword, u4_codesize);

                if(u4_remaining_coeff == 0) break;

                /*update suffix length for next level*/

                if(u4_suffix_length == 0)

                {

                    u4_suffix_length++;

                }

                if(u4_suffix_length < 6)

                {

                    if(u4_abs_level_actual > gu1_threshold_vlc_level[u4_suffix_length])

                    {

                        u4_suffix_length++;

                    }

                }

                /* next level */

                i4_level = pi2_res_block[u4_remaining_coeff - 1];

                DEBUG("\n \t%d coeff,", i4_level);

                ENTROPY_TRACE("\tcoeff ", i4_level);

                i4_sign = (i4_level >> (sizeof(WORD32) * CHAR_BIT - 1));

                u4_abs_level = ((i4_level + i4_sign) ^ i4_sign);

                u4_abs_level_actual = u4_abs_level;

                u4_escape = (u4_abs_level + u4_rndfactor[u4_suffix_length]) >> u4_suffix_length;

            }

        }

        DEBUG("\n \t %d totalzeros", u4_tot_zeros);

        ENTROPY_TRACE("\ttotal zeros ", u4_tot_zeros);

        /* Write Total Zeros */

        if(u4_total_coeff < u4_max_num_coeff)

        {

            WORD32 index;

            UWORD32 u4_codeword;

            UWORD32 u4_codesize;

            if(u4_block_type == CAVLC_CHROMA_4x4_DC)

            {

                UWORD8 gu1_index_zero_table_chroma[] = {0, 4, 7};

                index = gu1_index_zero_table_chroma[u4_total_coeff - 1] + u4_tot_zeros;

                u4_codesize = gu1_size_zero_table_chroma[index];

                u4_codeword = gu1_code_zero_table_chroma[index];

            }

            else

            {

                index = gu1_index_zero_table[u4_total_coeff - 1] + u4_tot_zeros;

                u4_codesize = gu1_size_zero_table[index];

                u4_codeword = gu1_code_zero_table[index];

            }

            DEBUG("\nTOTAL ZEROS: %d u4_codeword, %d u4_codesize", u4_codeword, u4_codesize);

            ENTROPY_TRACE("\tcodeword ", u4_codeword);

            ENTROPY_TRACE("\tcodesize ", u4_codesize);

            error_status = ih264e_put_bits(ps_bit_stream, u4_codeword, u4_codesize);

        }

        /* Write Run Before */

        if(u4_tot_zeros)

        {

            UWORD32 u4_max_num_coef = u4_total_coeff - 1;

            UWORD32 u4_codeword;

            UWORD32 u4_codesize;

            UWORD32 u4_zeros_left = u4_tot_zeros;

            while(u4_max_num_coef)

            {

                UWORD32 u4_run_before = pu1_zero_run[u4_max_num_coef];

                UWORD32 u4_index;

                if(u4_zeros_left > MAX_ZERO_LEFT)

                {

                    u4_index = gu1_index_run_table[MAX_ZERO_LEFT];

                }

                else

                {

                    u4_index = gu1_index_run_table[u4_zeros_left - 1];

                }

                u4_codesize = gu1_size_run_table[u4_index + u4_run_before];

                u4_codeword = gu1_code_run_table[u4_index + u4_run_before];

                DEBUG("\nRUN BEFORE ZEROS: %d u4_codeword, %d u4_codesize", u4_codeword,

                      u4_codesize);

                ENTROPY_TRACE("\tcodeword ", u4_codeword);

                ENTROPY_TRACE("\tcodesize ", u4_codesize);

                error_status = ih264e_put_bits(ps_bit_stream, u4_codeword, u4_codesize);

                u4_zeros_left -= u4_run_before;

                if(!u4_zeros_left)

                {

                    break;

                }

                u4_max_num_coef--;

            }

        }

    }

    return error_status;

}

/**

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

*

* @brief

*  This function generates CAVLC coded bit stream for the given subblock

*

* @param[in] ps_ent_ctxt

*  Pointer to entropy context

*

* @param[in] pi2_res_block

*  Pointers to residual blocks of all the partitions for the current subblk

*  (containing levels in scan order)

*

* @param[in] pu1_nnz

*  Total non-zero coefficients of all the partitions for the current subblk

*

* @param[in] pu2_sig_coeff_map

*  Significant coefficient map of all the partitions for the current subblk

*

* @param[in] u4_block_type

*  entropy coding block type

*

* @param[in] u4_ngbr_avbl

*  top and left availability of all the partitions for the current subblk

*  (packed)

*

* @param[in] pu1_top_nnz

*  pointer to the buffer containing nnz of all the subblks to the top

*

* @param[in] pu1_left_nnz

*  pointer to the buffer containing nnz of all the subblks to the left

*

* @returns error status

*

* @remarks none

*

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

*/

static IH264E_ERROR_T isvce_write_coeff8x8_cavlc(isvce_entropy_ctxt_t *ps_ent_ctxt,

                                                 WORD16 **pi2_res_block, UWORD8 *pu1_nnz,

                                                 UWORD16 *pu2_sig_coeff_map,

                                                 ENTROPY_BLK_TYPE u4_block_type,

                                                 UWORD32 u4_ngbr_avlb, UWORD8 *pu1_top_nnz,

                                                 UWORD8 *pu1_left_nnz)

{

    IH264E_ERROR_T error_status = IH264E_SUCCESS;

    bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm;

    UWORD8 *pu1_zero_run = ps_ent_ctxt->au1_zero_run, *pu1_ngbr_avbl;

    UWORD32 u4_nC;

    UWORD8 u1_mb_a, u1_mb_b;

    pu1_ngbr_avbl = (void *) (&u4_ngbr_avlb);

    /* encode ac block index 4x4 = 0*/

    u1_mb_a = pu1_ngbr_avbl[0] & 0x0F;

    u1_mb_b = pu1_ngbr_avbl[0] & 0xF0;

    u4_nC = 0;

    if(u1_mb_a) u4_nC += pu1_left_nnz[0];

    if(u1_mb_b) u4_nC += pu1_top_nnz[0];

    if(u1_mb_a && u1_mb_b) u4_nC = (u4_nC + 1) >> 1;

    pu1_left_nnz[0] = pu1_top_nnz[0] = pu1_nnz[0];

    error_status =

        isvce_write_coeff4x4_cavlc(pi2_res_block[0], pu1_nnz[0], u4_block_type, pu1_zero_run, u4_nC,

                                   ps_bitstream, pu2_sig_coeff_map[0]);

    /* encode ac block index 4x4 = 1*/

    u1_mb_a = pu1_ngbr_avbl[1] & 0x0F;

    u1_mb_b = pu1_ngbr_avbl[1] & 0xF0;

    u4_nC = 0;

    if(u1_mb_a) u4_nC += pu1_left_nnz[0];

    if(u1_mb_b) u4_nC += pu1_top_nnz[1];

    if(u1_mb_a && u1_mb_b) u4_nC = (u4_nC + 1) >> 1;

    pu1_left_nnz[0] = pu1_top_nnz[1] = pu1_nnz[1];

    error_status =

        isvce_write_coeff4x4_cavlc(pi2_res_block[1], pu1_nnz[1], u4_block_type, pu1_zero_run, u4_nC,

                                   ps_bitstream, pu2_sig_coeff_map[1]);

    /* encode ac block index 4x4 = 2*/

    u1_mb_a = pu1_ngbr_avbl[2] & 0x0F;

    u1_mb_b = pu1_ngbr_avbl[2] & 0xF0;

    u4_nC = 0;

    if(u1_mb_a) u4_nC += pu1_left_nnz[1];

    if(u1_mb_b) u4_nC += pu1_top_nnz[0];

    if(u1_mb_a && u1_mb_b) u4_nC = (u4_nC + 1) >> 1;

    pu1_left_nnz[1] = pu1_top_nnz[0] = pu1_nnz[2];

    error_status =

        isvce_write_coeff4x4_cavlc(pi2_res_block[2], pu1_nnz[2], u4_block_type, pu1_zero_run, u4_nC,

                                   ps_bitstream, pu2_sig_coeff_map[2]);

    /* encode ac block index 4x4 = 0*/

    u1_mb_a = pu1_ngbr_avbl[3] & 0x0F;

    u1_mb_b = pu1_ngbr_avbl[3] & 0xF0;

    u4_nC = 0;

    if(u1_mb_a) u4_nC += pu1_left_nnz[1];

    if(u1_mb_b) u4_nC += pu1_top_nnz[1];

    if(u1_mb_a && u1_mb_b) u4_nC = (u4_nC + 1) >> 1;

    pu1_left_nnz[1] = pu1_top_nnz[1] = pu1_nnz[3];

    error_status =

        isvce_write_coeff4x4_cavlc(pi2_res_block[3], pu1_nnz[3], u4_block_type, pu1_zero_run, u4_nC,

                                   ps_bitstream, pu2_sig_coeff_map[3]);

    return error_status;

}

/**

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

*

* @brief

*  This function encodes luma and chroma residues of a macro block when

*  the entropy coding mode chosen is cavlc.

*

* @param[in] ps_ent_ctxt

*  Pointer to entropy context

*

* @param[in] u4_mb_type

*  current mb type

*

* @param[in] u4_cbp

*  coded block pattern for the current mb

*

* @returns error code

*

* @remarks none

*

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

*/

static IH264E_ERROR_T isvce_encode_residue(isvce_entropy_ctxt_t *ps_ent_ctxt, UWORD32 u4_mb_type,

                                           UWORD32 u4_cbp)

{

    /* error status */

    IH264E_ERROR_T error_status = IH264E_SUCCESS;

    /* packed residue */

    void *pv_mb_coeff_data = ps_ent_ctxt->pv_mb_coeff_data;

    /* bit stream buffer */

    bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm;

    /* zero run */

    UWORD8 *pu1_zero_run = ps_ent_ctxt->au1_zero_run;

    /* temp var */

    UWORD32 u4_nC, u4_ngbr_avlb;

    UWORD8 au1_nnz[4], *pu1_ngbr_avlb, *pu1_top_nnz, *pu1_left_nnz;

    UWORD16 au2_sig_coeff_map[4] = {0};

    WORD16 *pi2_res_block[4] = {NULL};

    UWORD8 *pu1_slice_idx = ps_ent_ctxt->pu1_slice_idx;

    tu_sblk_coeff_data_t *ps_mb_coeff_data;

    ENTROPY_BLK_TYPE e_entropy_blk_type = CAVLC_LUMA_4x4;

    /* ngbr availability */

    UWORD8 u1_mb_a, u1_mb_b;

    /* cbp */

    UWORD32 u4_cbp_luma = u4_cbp & 0xF, u4_cbp_chroma = u4_cbp >> 4;

    /* mb indices */

    WORD32 i4_mb_x, i4_mb_y;

    /* derive neighbor availability */

    i4_mb_x = ps_ent_ctxt->i4_mb_x;

    i4_mb_y = ps_ent_ctxt->i4_mb_y;

    pu1_slice_idx += (i4_mb_y * ps_ent_ctxt->i4_wd_mbs);

    /* left macroblock availability */

    u1_mb_a = (i4_mb_x == 0 || (pu1_slice_idx[i4_mb_x - 1] != pu1_slice_idx[i4_mb_x])) ? 0 : 1;

    /* top macroblock availability */

    u1_mb_b = (i4_mb_y == 0 ||

               (pu1_slice_idx[i4_mb_x - ps_ent_ctxt->i4_wd_mbs] != pu1_slice_idx[i4_mb_x]))

                  ? 0

                  : 1;

    pu1_ngbr_avlb = (void *) (&u4_ngbr_avlb);

    pu1_top_nnz = ps_ent_ctxt->pu1_top_nnz_luma[ps_ent_ctxt->i4_mb_x];

    pu1_left_nnz = (UWORD8 *) &ps_ent_ctxt->u4_left_nnz_luma;

    /* encode luma residue */

    /* mb type intra 16x16 */

    if(u4_mb_type == I16x16)

    {

        /* parse packed coeff data structure for residual data */

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[0],

                                   au2_sig_coeff_map[0], pi2_res_block[0]);

        /* estimate nnz for the current mb */

        u4_nC = 0;

        if(u1_mb_a) u4_nC += pu1_left_nnz[0];

        if(u1_mb_b) u4_nC += pu1_top_nnz[0];

        if(u1_mb_a && u1_mb_b) u4_nC = (u4_nC + 1) >> 1;

        /* encode dc block */

        ENTROPY_TRACE("Luma DC blk idx %d", 0);

        error_status =

            isvce_write_coeff4x4_cavlc(pi2_res_block[0], au1_nnz[0], CAVLC_LUMA_4x4_DC,

                                       pu1_zero_run, u4_nC, ps_bitstream, au2_sig_coeff_map[0]);

        e_entropy_blk_type = CAVLC_LUMA_4x4_AC;

    }

    if(u4_cbp_luma & 1)

    {

        /* encode ac block index 8x8 = 0*/

        /* parse packed coeff data structure for residual data */

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[0],

                                   au2_sig_coeff_map[0], pi2_res_block[0]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[1],

                                   au2_sig_coeff_map[1], pi2_res_block[1]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[2],

                                   au2_sig_coeff_map[2], pi2_res_block[2]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[3],

                                   au2_sig_coeff_map[3], pi2_res_block[3]);

        /* derive sub block neighbor availability */

        pu1_ngbr_avlb[0] = (u1_mb_b << 4) | (u1_mb_a);

        pu1_ngbr_avlb[1] = (u1_mb_b << 4) | 1;

        pu1_ngbr_avlb[2] = (1 << 4) | (u1_mb_a);

        pu1_ngbr_avlb[3] = 0x11;

        /* encode sub blk */

        ENTROPY_TRACE("Luma blk idx %d", 0);

        error_status =

            isvce_write_coeff8x8_cavlc(ps_ent_ctxt, pi2_res_block, au1_nnz, au2_sig_coeff_map,

                                       e_entropy_blk_type, u4_ngbr_avlb, pu1_top_nnz, pu1_left_nnz);

    }

    else

    {

        pu1_top_nnz[0] = pu1_top_nnz[1] = 0;

        pu1_left_nnz[0] = pu1_left_nnz[1] = 0;

    }

    if(u4_cbp_luma & 2)

    {

        /* encode ac block index 8x8 = 1*/

        /* parse packed coeff data structure for residual data */

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[0],

                                   au2_sig_coeff_map[0], pi2_res_block[0]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[1],

                                   au2_sig_coeff_map[1], pi2_res_block[1]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[2],

                                   au2_sig_coeff_map[2], pi2_res_block[2]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[3],

                                   au2_sig_coeff_map[3], pi2_res_block[3]);

        /* derive sub block neighbor availability */

        pu1_ngbr_avlb[1] = pu1_ngbr_avlb[0] = (u1_mb_b << 4) | 1;

        pu1_ngbr_avlb[3] = pu1_ngbr_avlb[2] = 0x11;

        /* encode sub blk */

        ENTROPY_TRACE("Luma blk idx %d", 1);

        error_status = isvce_write_coeff8x8_cavlc(ps_ent_ctxt, pi2_res_block, au1_nnz,

                                                  au2_sig_coeff_map, e_entropy_blk_type,

                                                  u4_ngbr_avlb, pu1_top_nnz + 2, pu1_left_nnz);

    }

    else

    {

        (pu1_top_nnz + 2)[0] = (pu1_top_nnz + 2)[1] = 0;

        pu1_left_nnz[0] = pu1_left_nnz[1] = 0;

    }

    if(u4_cbp_luma & 0x4)

    {

        /* encode ac block index 8x8 = 2*/

        /* parse packed coeff data structure for residual data */

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[0],

                                   au2_sig_coeff_map[0], pi2_res_block[0]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[1],

                                   au2_sig_coeff_map[1], pi2_res_block[1]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[2],

                                   au2_sig_coeff_map[2], pi2_res_block[2]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[3],

                                   au2_sig_coeff_map[3], pi2_res_block[3]);

        /* derive sub block neighbor availability */

        pu1_ngbr_avlb[2] = pu1_ngbr_avlb[0] = (1 << 4) | u1_mb_a;

        pu1_ngbr_avlb[1] = pu1_ngbr_avlb[3] = 0x11;

        /* encode sub blk */

        ENTROPY_TRACE("Luma blk idx %d", 2);

        error_status = isvce_write_coeff8x8_cavlc(ps_ent_ctxt, pi2_res_block, au1_nnz,

                                                  au2_sig_coeff_map, e_entropy_blk_type,

                                                  u4_ngbr_avlb, pu1_top_nnz, (pu1_left_nnz + 2));

    }

    else

    {

        pu1_top_nnz[0] = pu1_top_nnz[1] = 0;

        (pu1_left_nnz + 2)[0] = (pu1_left_nnz + 2)[1] = 0;

    }

    if(u4_cbp_luma & 0x8)

    {

        /* encode ac block index 8x8 = 3*/

        /* parse packed coeff data structure for residual data */

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[0],

                                   au2_sig_coeff_map[0], pi2_res_block[0]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[1],

                                   au2_sig_coeff_map[1], pi2_res_block[1]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[2],

                                   au2_sig_coeff_map[2], pi2_res_block[2]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[3],

                                   au2_sig_coeff_map[3], pi2_res_block[3]);

        /* derive sub block neighbor availability */

        u4_ngbr_avlb = 0x11111111;

        /* encode sub blk */

        ENTROPY_TRACE("Luma blk idx %d", 3);

        error_status = isvce_write_coeff8x8_cavlc(ps_ent_ctxt, pi2_res_block, au1_nnz,

                                                  au2_sig_coeff_map, e_entropy_blk_type,

                                                  u4_ngbr_avlb, pu1_top_nnz + 2, pu1_left_nnz + 2);

    }

    else

    {

        (pu1_top_nnz + 2)[0] = (pu1_top_nnz + 2)[1] = 0;

        (pu1_left_nnz + 2)[0] = (pu1_left_nnz + 2)[1] = 0;

    }

    /* encode chroma residue */

    if(u4_cbp_chroma & 3)

    {

        /* parse packed coeff data structure for residual data */

        /* cb, cr */

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[0],

                                   au2_sig_coeff_map[0], pi2_res_block[0]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[1],

                                   au2_sig_coeff_map[1], pi2_res_block[1]);

        /* encode dc block */

        /* cb, cr */

        ENTROPY_TRACE("Chroma DC blk idx %d", 0);

        error_status =

            isvce_write_coeff4x4_cavlc(pi2_res_block[0], au1_nnz[0], CAVLC_CHROMA_4x4_DC,

                                       pu1_zero_run, 0, ps_bitstream, au2_sig_coeff_map[0]);

        ENTROPY_TRACE("Chroma DC blk idx %d", 1);

        error_status =

            isvce_write_coeff4x4_cavlc(pi2_res_block[1], au1_nnz[1], CAVLC_CHROMA_4x4_DC,

                                       pu1_zero_run, 0, ps_bitstream, au2_sig_coeff_map[1]);

    }

    pu1_top_nnz = ps_ent_ctxt->pu1_top_nnz_cbcr[ps_ent_ctxt->i4_mb_x];

    pu1_left_nnz = (UWORD8 *) &ps_ent_ctxt->u4_left_nnz_cbcr;

    /* encode sub blk */

    if(u4_cbp_chroma & 0x2)

    {

        /* encode ac block index 8x8 = 0*/

        /* derive sub block neighbor availability */

        pu1_ngbr_avlb[0] = (u1_mb_b << 4) | (u1_mb_a);

        pu1_ngbr_avlb[1] = (u1_mb_b << 4) | 1;

        pu1_ngbr_avlb[2] = (1 << 4) | (u1_mb_a);

        pu1_ngbr_avlb[3] = 0x11;

        /* parse packed coeff data structure for residual data */

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[0],

                                   au2_sig_coeff_map[0], pi2_res_block[0]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[1],

                                   au2_sig_coeff_map[1], pi2_res_block[1]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[2],

                                   au2_sig_coeff_map[2], pi2_res_block[2]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[3],

                                   au2_sig_coeff_map[3], pi2_res_block[3]);

        ENTROPY_TRACE("Chroma AC blk idx %d", 0);

        error_status = isvce_write_coeff8x8_cavlc(ps_ent_ctxt, pi2_res_block, au1_nnz,

                                                  au2_sig_coeff_map, CAVLC_CHROMA_4x4_AC,

                                                  u4_ngbr_avlb, pu1_top_nnz, pu1_left_nnz);

    }

    else

    {

        pu1_top_nnz[0] = pu1_top_nnz[1] = 0;

        pu1_left_nnz[0] = pu1_left_nnz[1] = 0;

    }

    pu1_top_nnz += 2;

    pu1_left_nnz += 2;

    /* encode sub blk */

    if(u4_cbp_chroma & 0x2)

    {

        /* parse packed coeff data structure for residual data */

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[0],

                                   au2_sig_coeff_map[0], pi2_res_block[0]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[1],

                                   au2_sig_coeff_map[1], pi2_res_block[1]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[2],

                                   au2_sig_coeff_map[2], pi2_res_block[2]);

        PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, au1_nnz[3],

                                   au2_sig_coeff_map[3], pi2_res_block[3]);

        ENTROPY_TRACE("Chroma AC blk idx %d", 1);

        error_status = isvce_write_coeff8x8_cavlc(ps_ent_ctxt, pi2_res_block, au1_nnz,

                                                  au2_sig_coeff_map, CAVLC_CHROMA_4x4_AC,

                                                  u4_ngbr_avlb, pu1_top_nnz, pu1_left_nnz);

    }

    else

    {

        pu1_top_nnz[0] = pu1_top_nnz[1] = 0;

        pu1_left_nnz[0] = pu1_left_nnz[1] = 0;

    }

    /* store the index of the next mb coeff data */

    ps_ent_ctxt->pv_mb_coeff_data = pv_mb_coeff_data;

    return error_status;

}

/**

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

*

* @brief

*  This function generates CAVLC coded bit stream for an Intra Slice.

*

* @description

*  The mb syntax layer for intra slices constitutes luma mb mode, luma sub modes

*  (if present), mb qp delta, coded block pattern, chroma mb mode and

*  luma/chroma residue. These syntax elements are written as directed by table

*  7.3.5 of h264 specification.

*

* @param[in] ps_ent_ctxt

*  pointer to entropy context

*

* @returns error code

*

* @remarks none

*

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

*/

IH264E_ERROR_T isvce_write_islice_mb_cavlc(isvce_entropy_ctxt_t *ps_ent_ctxt)

{

    /* error status */

    IH264E_ERROR_T error_status = IH264E_SUCCESS;

    /* bit stream ptr */

    bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm;

    /* packed header data */

    UWORD8 *pu1_byte = ps_ent_ctxt->pv_mb_header_data;

    isvce_mb_hdr_common_t *ps_mb_hdr = (isvce_mb_hdr_common_t *) ps_ent_ctxt->pv_mb_header_data;

    /* mb header info */

    /*

     * mb_tpm : mb type plus mode

     * mb_type : luma mb type and chroma mb type are packed

     * cbp : coded block pattern

     * mb_qp_delta : mb qp delta

     * chroma_intra_mode : chroma intra mode

     * luma_intra_mode : luma intra mode

     */

    WORD32 mb_tpm, mb_type, cbp, chroma_intra_mode, luma_intra_mode;

    WORD8 mb_qp_delta;

    /* temp var */

    WORD32 i, mb_type_stream;

    WORD32 bitstream_start_offset, bitstream_end_offset;

    svc_slice_header_t *ps_svc_slice_header =

        ps_ent_ctxt->ps_svc_slice_hdr_base +

        (ps_ent_ctxt->i4_cur_slice_idx % SVC_MAX_SLICE_HDR_CNT);

    /* Starting bitstream offset for header in bits */

    bitstream_start_offset = isvce_get_num_bits(ps_bitstream);

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

    /*                    BEGIN HEADER GENERATION                       */

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

    if(ps_ent_ctxt->u1_spatial_layer_id && ps_svc_slice_header->i1_adaptive_base_mode_flag)

    {

        /* write base_mode_flag */

        PUT_BITS(ps_bitstream, ps_mb_hdr->u1_base_mode_flag, 1, error_status, "base_mode_flag");

    }

    else

    {

        ps_mb_hdr->u1_base_mode_flag = 0;

    }

    /* mb header info */

    mb_tpm = ps_mb_hdr->u1_mb_type_mode;

    cbp = ps_mb_hdr->u1_cbp;

    mb_qp_delta =

        ((WORD16) ps_mb_hdr->u1_mb_qp) - ((WORD16) ps_ent_ctxt->ps_mb_qp_ctxt->u1_cur_mb_qp);

    /* mb type */

    mb_type = mb_tpm & 0xF;

    /* is intra ? */

    if(!ps_mb_hdr->u1_base_mode_flag)

    {

        if(mb_type == I16x16)

        {

            UWORD32 u4_cbp_l, u4_cbp_c;

            u4_cbp_c = (cbp >> 4);

            u4_cbp_l = (cbp & 0xF);