encoder/ih264e_cavlc.c

/******************************************************************************
 *
 * Copyright (C) 2015 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
*  ih264e_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:
*  - ih264e_compute_zeroruns_and_trailingones()
*  - ih264e_write_coeff4x4_cavlc()
*  - ih264e_write_coeff8x8_cavlc()
*  - ih264e_encode_residue()
*  - ih264e_write_islice_mb()
*  - ih264e_write_pslice_mb()
*
* @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 "ih264_defs.h"
#include "ih264e_defs.h"
#include "ih264e_error.h"
#include "ih264e_bitstream.h"
#include "ime_distortion_metrics.h"
#include "ime_structs.h"
#include "ih264_defs.h"
#include "ih264_error.h"
#include "ih264_structs.h"
#include "ih264_trans_quant_itrans_iquant.h"
#include "ih264_inter_pred_filters.h"
#include "ih264_mem_fns.h"
#include "ih264_padding.h"
#include "ih264_intra_pred_filters.h"
#include "ih264_deblk_edge_filters.h"
#include "irc_cntrl_param.h"
#include "irc_frame_info_collector.h"
#include "ih264e_rate_control.h"
#include "ih264e_structs.h"
#include "ih264e_encode_header.h"
#include "ih264_cavlc_tables.h"
#include "ih264e_cavlc.h"
#include "ih264e_statistics.h"
#include "ih264e_trace.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 ih264e_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 ih264e_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 =
                ih264e_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 ih264e_write_coeff8x8_cavlc(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 = ih264e_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 = ih264e_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 = ih264e_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 = ih264e_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 ih264e_encode_residue(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];
    WORD16 *pi2_res_block[4];
    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 = ih264e_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 = ih264e_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 = ih264e_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 = ih264e_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 = ih264e_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 = ih264e_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 = ih264e_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 = ih264e_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 = ih264e_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;
}

#define GET_NUM_BITS(ps_bitstream) ((ps_bitstream->u4_strm_buf_offset << 3) + 32 - ps_bitstream->i4_bits_left_in_cw)

/**
*******************************************************************************
*
* @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 ih264e_write_islice_mb(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;

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

    /* Starting bitstream offset for header in bits */
    bitstream_start_offset = GET_NUM_BITS(ps_bitstream);


    /********************************************************************/
    /*                    BEGIN HEADER GENERATION                       */
    /********************************************************************/

    /* mb header info */
    mb_tpm = *pu1_byte++;
    cbp = *pu1_byte++;
    mb_qp_delta = *pu1_byte++;

    /* mb type */
    mb_type = mb_tpm & 0xF;
    /* is intra ? */
    if (mb_type == I16x16)
    {
        UWORD32 u4_cbp_l, u4_cbp_c;

        u4_cbp_c = (cbp >> 4);
        u4_cbp_l = (cbp & 0xF);
        luma_intra_mode = (mb_tpm >> 4) & 3;
        chroma_intra_mode = (mb_tpm >> 6);

        mb_type_stream =  luma_intra_mode + 1 + (u4_cbp_c << 2) + (u4_cbp_l == 15) * 12;

        /* write mb type */
        PUT_BITS_UEV(ps_bitstream, mb_type_stream, error_status, "mb type");

        /* intra_chroma_pred_mode */
        PUT_BITS_UEV(ps_bitstream, chroma_intra_mode, error_status, "intra_chroma_pred_mode");
    }
    else if (mb_type == I4x4)
    {
        /* mb sub blk modes */
        WORD32 intra_pred_mode_flag, rem_intra_mode;
        WORD32 byte;

        chroma_intra_mode = (mb_tpm >> 6);

        /* write mb type */
        PUT_BITS_UEV(ps_bitstream, 0, error_status, "mb type");

        for (i = 0; i < 16; i += 2)
        {
            /* sub blk idx 1 */
            byte = *pu1_byte++;

            intra_pred_mode_flag = byte & 0x1;

            /* prev_intra4x4_pred_mode_flag */
            PUT_BITS(ps_bitstream, intra_pred_mode_flag, 1, error_status, "prev_intra4x4_pred_mode_flag");

            /* rem_intra4x4_pred_mode */
            if (!intra_pred_mode_flag)
            {
                rem_intra_mode = (byte & 0xF) >> 1;
                PUT_BITS(ps_bitstream, rem_intra_mode, 3, error_status, "rem_intra4x4_pred_mode");
            }

            /* sub blk idx 2 */
            byte >>= 4;

            intra_pred_mode_flag = byte & 0x1;

            /* prev_intra4x4_pred_mode_flag */
            PUT_BITS(ps_bitstream, intra_pred_mode_flag, 1, error_status, "prev_intra4x4_pred_mode_flag");

            /* rem_intra4x4_pred_mode */
            if (!intra_pred_mode_flag)
            {
                rem_intra_mode = (byte & 0xF) >> 1;
                PUT_BITS(ps_bitstream, rem_intra_mode, 3, error_status, "rem_intra4x4_pred_mode");
            }
        }

        /* intra_chroma_pred_mode */
        PUT_BITS_UEV(ps_bitstream, chroma_intra_mode, error_status, "intra_chroma_pred_mode");
    }
    else if (mb_type == I8x8)
    {
        /* transform 8x8 flag */
        UWORD32 u4_transform_size_8x8_flag = ps_ent_ctxt->i1_transform_8x8_mode_flag;

        /* mb sub blk modes */
        WORD32 intra_pred_mode_flag, rem_intra_mode;
        WORD32 byte;

        chroma_intra_mode = (mb_tpm >> 6);

        ASSERT(0);

        /* write mb type */
        PUT_BITS_UEV(ps_bitstream, 0, error_status, "mb type");

        /* u4_transform_size_8x8_flag */
        PUT_BITS(ps_bitstream, u4_transform_size_8x8_flag, 1, error_status, "u4_transform_size_8x8_flag");

        /* write sub block modes */
        for (i = 0; i < 4; i++)
        {
            /* sub blk idx 1 */
            byte = *pu1_byte++;

            intra_pred_mode_flag = byte & 0x1;

            /* prev_intra4x4_pred_mode_flag */
            PUT_BITS(ps_bitstream, intra_pred_mode_flag, 1, error_status, "prev_intra4x4_pred_mode_flag");

            /* rem_intra4x4_pred_mode */
            if (!intra_pred_mode_flag)
            {
                rem_intra_mode = (byte & 0xF) >> 1;
                PUT_BITS(ps_bitstream, rem_intra_mode, 3, error_status, "rem_intra4x4_pred_mode");
            }

            /* sub blk idx 2 */
            byte >>= 4;

            intra_pred_mode_flag = byte & 0x1;

            /* prev_intra4x4_pred_mode_flag */
            PUT_BITS(ps_bitstream, intra_pred_mode_flag, 1, error_status, "prev_intra4x4_pred_mode_flag");

            /* rem_intra4x4_pred_mode */
            if (!intra_pred_mode_flag)
            {
                rem_intra_mode = (byte & 0xF) >> 1;
                PUT_BITS(ps_bitstream, rem_intra_mode, 3, error_status, "rem_intra4x4_pred_mode");
            }
        }

        /* intra_chroma_pred_mode */
        PUT_BITS_UEV(ps_bitstream, chroma_intra_mode, error_status, "intra_chroma_pred_mode");
    }
    else
    {
    }

    /* coded_block_pattern */
    if (mb_type != I16x16)
    {
        PUT_BITS_UEV(ps_bitstream, gu1_cbp_map_tables[cbp][0], error_status, "coded_block_pattern");
    }

    if (cbp || mb_type == I16x16)
    {
        /* mb_qp_delta */
        PUT_BITS_SEV(ps_bitstream, mb_qp_delta, error_status, "mb_qp_delta");
    }

    /* Ending bitstream offset for header in bits */
    bitstream_end_offset = GET_NUM_BITS(ps_bitstream);

    ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset - bitstream_start_offset;

    /* Starting bitstream offset for residue */
    bitstream_start_offset = bitstream_end_offset;

    /* residual */
    error_status = ih264e_encode_residue(ps_ent_ctxt, mb_type, cbp);

    /* Ending bitstream offset for reside in bits */
    bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
    ps_ent_ctxt->u4_residue_bits[0] += bitstream_end_offset - bitstream_start_offset;

    /* store the index of the next mb syntax layer */
    ps_ent_ctxt->pv_mb_header_data = pu1_byte;

    return error_status;
}

/**
*******************************************************************************
*
* @brief
*  This function generates CAVLC coded bit stream for Inter slices
*
* @description
*  The mb syntax layer for inter 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 ih264e_write_pslice_mb(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;

    /* 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
     * ps_pu :  Pointer to the array of structures having motion vectors, size
     * and position of sub partitions
     */
    WORD32 mb_tpm, mb_type, cbp, chroma_intra_mode, luma_intra_mode;
    WORD8 mb_qp_delta;

    /* temp var */
    WORD32 i, mb_type_stream, cbptable = 1;

    WORD32 is_inter = 0;

    WORD32 bitstream_start_offset, bitstream_end_offset;

    /* Starting bitstream offset for header in bits */
    bitstream_start_offset = GET_NUM_BITS(ps_bitstream);

    /********************************************************************/
    /*                    BEGIN HEADER GENERATION                       */
    /********************************************************************/

    /* mb header info */
    mb_tpm = *pu1_byte++;

    /* mb type */
    mb_type = mb_tpm & 0xF;

    /* check for skip */
    if (mb_type == PSKIP)
    {
        UWORD32 *nnz;

        is_inter = 1;

        /* increment skip counter */
        (*ps_ent_ctxt->pi4_mb_skip_run)++;

        /* store the index of the next mb syntax layer */
        ps_ent_ctxt->pv_mb_header_data = pu1_byte;

        /* set nnz to zero */
        ps_ent_ctxt->u4_left_nnz_luma = 0;
        nnz = (UWORD32 *)ps_ent_ctxt->pu1_top_nnz_luma[ps_ent_ctxt->i4_mb_x];
        *nnz = 0;
        ps_ent_ctxt->u4_left_nnz_cbcr = 0;
        nnz = (UWORD32 *)ps_ent_ctxt->pu1_top_nnz_cbcr[ps_ent_ctxt->i4_mb_x];
        *nnz = 0;

        /* residual */
        error_status = ih264e_encode_residue(ps_ent_ctxt, P16x16, 0);

        bitstream_end_offset = GET_NUM_BITS(ps_bitstream);

        ps_ent_ctxt->u4_header_bits[is_inter] += bitstream_end_offset - bitstream_start_offset;

        return error_status;
    }

    /* remaining mb header info */
    cbp = *pu1_byte++;
    mb_qp_delta = *pu1_byte++;

    /* mb skip run */
    PUT_BITS_UEV(ps_bitstream, *ps_ent_ctxt->pi4_mb_skip_run, error_status, "mb skip run");

    /* reset skip counter */
    *ps_ent_ctxt->pi4_mb_skip_run = 0;

    /* is intra ? */
    if (mb_type == I16x16)
    {
        UWORD32 u4_cbp_l, u4_cbp_c;

        is_inter = 0;

        u4_cbp_c = (cbp >> 4);
        u4_cbp_l = (cbp & 0xF);
        luma_intra_mode = (mb_tpm >> 4) & 3;
        chroma_intra_mode = (mb_tpm >> 6);

        mb_type_stream =  luma_intra_mode + 1 + (u4_cbp_c << 2) + (u4_cbp_l == 15) * 12;

        mb_type_stream += 5;

        /* write mb type */
        PUT_BITS_UEV(ps_bitstream, mb_type_stream, error_status, "mb type");

        /* intra_chroma_pred_mode */
        PUT_BITS_UEV(ps_bitstream, chroma_intra_mode, error_status, "intra_chroma_pred_mode");
    }
    else if (mb_type == I4x4)
    {
        /* mb sub blk modes */
        WORD32 intra_pred_mode_flag, rem_intra_mode;
        WORD32 byte;

        is_inter = 0;

        chroma_intra_mode = (mb_tpm >> 6);
        cbptable = 0;

        /* write mb type */
        PUT_BITS_UEV(ps_bitstream, 5, error_status, "mb type");

        for (i = 0; i < 16; i += 2)
        {
            /* sub blk idx 1 */
            byte = *pu1_byte++;

            intra_pred_mode_flag = byte & 0x1;

            /* prev_intra4x4_pred_mode_flag */
            PUT_BITS(ps_bitstream, intra_pred_mode_flag, 1, error_status, "prev_intra4x4_pred_mode_flag");

            /* rem_intra4x4_pred_mode */
            if (!intra_pred_mode_flag)
            {
                rem_intra_mode = (byte & 0xF) >> 1;
                PUT_BITS(ps_bitstream, rem_intra_mode, 3, error_status, "rem_intra4x4_pred_mode");
            }

            /* sub blk idx 2 */
            byte >>= 4;

            intra_pred_mode_flag = byte & 0x1;

            /* prev_intra4x4_pred_mode_flag */
            PUT_BITS(ps_bitstream, intra_pred_mode_flag, 1, error_status, "prev_intra4x4_pred_mode_flag");

            /* rem_intra4x4_pred_mode */
            if (!intra_pred_mode_flag)
            {
                rem_intra_mode = (byte & 0xF) >> 1;
                PUT_BITS(ps_bitstream, rem_intra_mode, 3, error_status, "rem_intra4x4_pred_mode");
            }
        }

        /* intra_chroma_pred_mode */
        PUT_BITS_UEV(ps_bitstream, chroma_intra_mode, error_status, "intra_chroma_pred_mode");
    }
    else if (mb_type == I8x8)
    {
        /* transform 8x8 flag */
        UWORD32 u4_transform_size_8x8_flag = ps_ent_ctxt->i1_transform_8x8_mode_flag;

        /* mb sub blk modes */
        WORD32 intra_pred_mode_flag, rem_intra_mode;
        WORD32 byte;

        is_inter = 0;

        chroma_intra_mode = (mb_tpm >> 6);
        cbptable = 0;

        ASSERT(0);

        /* write mb type */
        PUT_BITS_UEV(ps_bitstream, 5, error_status, "mb type");

        /* u4_transform_size_8x8_flag */
        PUT_BITS(ps_bitstream, u4_transform_size_8x8_flag, 1, error_status, "u4_transform_size_8x8_flag");

        /* write sub block modes */
        for (i = 0; i < 4; i++)
        {
            /* sub blk idx 1 */
            byte = *pu1_byte++;

            intra_pred_mode_flag = byte & 0x1;

            /* prev_intra4x4_pred_mode_flag */
            PUT_BITS(ps_bitstream, intra_pred_mode_flag, 1, error_status, "prev_intra4x4_pred_mode_flag");

            /* rem_intra4x4_pred_mode */
            if (!intra_pred_mode_flag)
            {
                rem_intra_mode = (byte & 0xF) >> 1;
                PUT_BITS(ps_bitstream, rem_intra_mode, 3, error_status, "rem_intra4x4_pred_mode");
            }

            /* sub blk idx 2 */
            byte >>= 4;

            intra_pred_mode_flag = byte & 0x1;

            /* prev_intra4x4_pred_mode_flag */
            PUT_BITS(ps_bitstream, intra_pred_mode_flag, 1, error_status, "prev_intra4x4_pred_mode_flag");

            /* rem_intra4x4_pred_mode */
            if (!intra_pred_mode_flag)
            {
                rem_intra_mode = (byte & 0xF) >> 1;
                PUT_BITS(ps_bitstream, rem_intra_mode, 3, error_status, "rem_intra4x4_pred_mode");
            }
        }

        /* intra_chroma_pred_mode */
        PUT_BITS_UEV(ps_bitstream, chroma_intra_mode, error_status, "intra_chroma_pred_mode");
    }
    else
    {
        /* inter macro block partition cnt */
        const UWORD8 au1_part_cnt[] = { 1, 2, 2, 4 };

        /* mv ptr */
        WORD16 *pi2_mv_ptr = (WORD16 *)pu1_byte;

        /* number of partitions for the current mb */
        UWORD32 u4_part_cnt = au1_part_cnt[mb_type - 3];

        is_inter = 1;

        /* write mb type */
        PUT_BITS_UEV(ps_bitstream, mb_type - 3, error_status, "mb type");

        for (i = 0; i < (WORD32)u4_part_cnt; i++)
        {
            PUT_BITS_SEV(ps_bitstream, *pi2_mv_ptr++, error_status, "mv x");

            PUT_BITS_SEV(ps_bitstream, *pi2_mv_ptr++, error_status, "mv y");
        }

        pu1_byte = (UWORD8 *)pi2_mv_ptr;
    }

    /* coded_block_pattern */
    if (mb_type != I16x16)
    {
        PUT_BITS_UEV(ps_bitstream, gu1_cbp_map_tables[cbp][cbptable], error_status, "coded_block_pattern");
    }

    if (cbp || mb_type == I16x16)
    {
        /* mb_qp_delta */
        PUT_BITS_SEV(ps_bitstream, mb_qp_delta, error_status, "mb_qp_delta");
    }


    /* Ending bitstream offset for header in bits */
    bitstream_end_offset = GET_NUM_BITS(ps_bitstream);

    ps_ent_ctxt->u4_header_bits[is_inter] += bitstream_end_offset - bitstream_start_offset;

    /* start bitstream offset for residue in bits */
    bitstream_start_offset = bitstream_end_offset;

    /* residual */
    error_status = ih264e_encode_residue(ps_ent_ctxt, mb_type, cbp);

    /* Ending bitstream offset for residue in bits */
    bitstream_end_offset = GET_NUM_BITS(ps_bitstream);

    ps_ent_ctxt->u4_residue_bits[is_inter] += bitstream_end_offset - bitstream_start_offset;

    /* store the index of the next mb syntax layer */
    ps_ent_ctxt->pv_mb_header_data = pu1_byte;

    return error_status;
}