/src/libavc/encoder/svc/isvce_encode_header.c

Source (jump to first uncovered line)
/******************************************************************************
 *
 * 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_encode_header.c
*
* @brief
*  This file contains function definitions related to header encoding.
*
* @author
*  ittiam
*
* @par List of Functions:
*  - isvce_generate_sps()
*  - isvce_generate_pps()
*  - isvce_generate_slice_header()
*  - isvce_populate_sps()
*  - isvce_populate_pps()
*  - isvce_populate_slice_header()
*
*******************************************************************************
*/

#include "ih264_typedefs.h"
#include "ih264_debug.h"

/* Dependencies of ih264e_bitstream.h */
#include "ih264e_error.h"

#include "ih264e_bitstream.h"

#include "isvce_encode_header.h"
#include "isvce_utils.h"

static FORCEINLINE IH264E_ERROR_T isvce_generate_nal_unit_header(bitstrm_t *ps_bitstrm,
                                                                 WORD32 nal_unit_type,
                                                                 WORD32 nal_ref_idc)
{
    WORD32 return_status = IH264E_SUCCESS;

    if(!((nal_unit_type > 0) && (nal_unit_type < 32)))
    {
        return IH264E_FAIL;
    }

    /* forbidden_zero_bit + nal_ref_idc + nal_unit_type */
    PUT_BITS(ps_bitstrm, ((nal_ref_idc << 5) + nal_unit_type),
             (1 + 2 + 5), /*1 forbidden zero bit + 2 nal_ref_idc + 5 nal_unit_type */
             return_status, "nal_unit_header");

    return return_status;
}

/**
******************************************************************************
*
* @brief Generates SPS (Sequence Parameter Set)
*
* @par   Description
*  This function generates Sequence Parameter Set header as per the spec
*
* @param[in]   ps_bitstrm
*  pointer to bitstream context (handle)
*
* @param[in]   ps_sps
*  pointer to structure containing SPS data
*
* @param[in]   ps_vui
*  pointer to structure containing VUI data
*
* @return      success or failure error code
*
******************************************************************************
*/
WORD32 isvce_generate_sps(bitstrm_t *ps_bitstrm, sps_t *ps_sps, NAL_UNIT_TYPE_T nal_type)
{
    WORD32 return_status = IH264E_SUCCESS;
    WORD32 i;
    WORD8 i1_nal_ref_idc = 3;
    vui_t *ps_vui = &ps_sps->s_vui_parameters;

    /* Insert Start Code */
    return_status = ih264e_put_nal_start_code_prefix(ps_bitstrm, 1);
    if(return_status != IH264E_SUCCESS)
    {
        return return_status;
    }
    /* Insert Nal Unit Header */
    return_status = isvce_generate_nal_unit_header(ps_bitstrm, nal_type, i1_nal_ref_idc);
    if(return_status != IH264E_SUCCESS)
    {
        return return_status;
    }

    /* profile_idc */
    PUT_BITS(ps_bitstrm, ps_sps->u1_profile_idc, 8, return_status, "profile_idc");

    /* constrained_set_flags */
    PUT_BITS(ps_bitstrm, ps_sps->u1_constraint_set0_flag, 1, return_status,
             "constrained_set0_flag");
    PUT_BITS(ps_bitstrm, ps_sps->u1_constraint_set1_flag, 1, return_status,
             "constrained_set1_flag");
    PUT_BITS(ps_bitstrm, ps_sps->u1_constraint_set2_flag, 1, return_status,
             "constrained_set2_flag");
    PUT_BITS(ps_bitstrm, ps_sps->u1_constraint_set3_flag, 1, return_status,
             "constrained_set3_flag");

    /* reserved_zero_four_bits */
    PUT_BITS(ps_bitstrm, 0, 4, return_status, "reserved_zero_four_bits");

    /* level_idc */
    PUT_BITS(ps_bitstrm, ps_sps->u1_level_idc, 8, return_status, "level_idc");

    /* seq_parameter_set_id */
    PUT_BITS_UEV(ps_bitstrm, ps_sps->u1_sps_id, return_status, "seq_parameter_set_id");

    if((ps_sps->u1_profile_idc == IH264_SCALABLE_BASELINE) ||
       (ps_sps->u1_profile_idc >= IH264_PROFILE_HIGH))
    {
        /* chroma_format_idc */
        PUT_BITS_UEV(ps_bitstrm, ps_sps->u1_chroma_format_idc, return_status, "chroma_format_idc");

        if(ps_sps->u1_chroma_format_idc == CHROMA_FMT_IDC_YUV444)
        {
            /* i1_residual_colour_transform_flag */
            PUT_BITS(ps_bitstrm, ps_sps->i1_residual_colour_transform_flag, 1, return_status,
                     "i1_residual_colour_transform_flag");
        }

        /* bit_depth_luma_minus8 */
        PUT_BITS_UEV(ps_bitstrm, (ps_sps->i1_bit_depth_luma - 8), return_status,
                     "bit_depth_luma_minus8");

        /* bit_depth_chroma_minus8 */
        PUT_BITS_UEV(ps_bitstrm, (ps_sps->i1_bit_depth_chroma - 8), return_status,
                     "bit_depth_chroma_minus8");

        /* qpprime_y_zero_transform_bypass_flag */
        PUT_BITS(ps_bitstrm, ps_sps->i1_qpprime_y_zero_transform_bypass_flag, 1, return_status,
                 "qpprime_y_zero_transform_bypass_flag");

        /* seq_scaling_matrix_present_flag */
        PUT_BITS(ps_bitstrm, ps_sps->i1_seq_scaling_matrix_present_flag, 1, return_status,
                 "seq_scaling_matrix_present_flag");

        /* seq_scaling_list */
        if(ps_sps->i1_seq_scaling_matrix_present_flag)
        {
            /* TODO_LATER: Will be enabled once scaling list support is added */
        }
    }

    /* log2_max_frame_num_minus4 */
    PUT_BITS_UEV(ps_bitstrm, (ps_sps->i1_log2_max_frame_num - 4), return_status,
                 "log2_max_frame_num_minus4");

    /* pic_order_cnt_type */
    PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_pic_order_cnt_type, return_status, "pic_order_cnt_type");

    if(ps_sps->i1_pic_order_cnt_type == 0)
    {
        /* log2_max_pic_order_cnt_lsb_minus4 */
        PUT_BITS_UEV(ps_bitstrm, (ps_sps->i1_log2_max_pic_order_cnt_lsb - 4), return_status,
                     "log2_max_pic_order_cnt_lsb_minus4");
    }
    else if(ps_sps->i1_pic_order_cnt_type == 1)
    {
        /* delta_pic_order_always_zero_flag */
        PUT_BITS(ps_bitstrm, ps_sps->i1_delta_pic_order_always_zero_flag, 1, return_status,
                 "delta_pic_order_always_zero_flag");

        /* offset_for_non_ref_pic */
        PUT_BITS_SEV(ps_bitstrm, ps_sps->i4_offset_for_non_ref_pic, return_status,
                     "offset_for_non_ref_pic");

        /* offset_for_top_to_bottom_field */
        PUT_BITS_SEV(ps_bitstrm, ps_sps->i4_offset_for_top_to_bottom_field, return_status,
                     "offset_for_top_to_bottom_field");

        /* num_ref_frames_in_pic_order_cnt_cycle */
        PUT_BITS_UEV(ps_bitstrm, ps_sps->u1_num_ref_frames_in_pic_order_cnt_cycle, return_status,
                     "num_ref_frames_in_pic_order_cnt_cycle");

        /* Offset for ref frame */
        for(i = 0; i < ps_sps->u1_num_ref_frames_in_pic_order_cnt_cycle; i++)
        {
            /* offset_for_ref_frame */
            PUT_BITS_SEV(ps_bitstrm, ps_sps->ai4_offset_for_ref_frame[i], return_status,
                         "offset_for_ref_frame");
        }
    }

    /* num_ref_frames */
    PUT_BITS_UEV(ps_bitstrm, ps_sps->u1_max_num_ref_frames, return_status, "num_ref_frames");

    /* gaps_in_frame_num_value_allowed_flag */
    PUT_BITS(ps_bitstrm, ps_sps->i1_gaps_in_frame_num_value_allowed_flag, 1, return_status,
             "gaps_in_frame_num_value_allowed_flag");

    /* pic_width_in_mbs_minus1 */
    PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_width_in_mbs_minus1, return_status,
                 "pic_width_in_mbs_minus1");

    /* pic_height_in_map_units_minus1 */
    PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_height_in_map_units_minus1, return_status,
                 "pic_height_in_map_units_minus1");

    /* frame_mbs_only_flag */
    PUT_BITS(ps_bitstrm, ps_sps->i1_frame_mbs_only_flag, 1, return_status, "frame_mbs_only_flag");

    if(!ps_sps->i1_frame_mbs_only_flag)
    {
        /* mb_adaptive_frame_field_flag */
        PUT_BITS(ps_bitstrm, ps_sps->i1_mb_adaptive_frame_field_flag, 1, return_status,
                 "mb_adaptive_frame_field_flag");
    }

    /* direct_8x8_inference_flag */
    PUT_BITS(ps_bitstrm, ps_sps->i1_direct_8x8_inference_flag, 1, return_status,
             "direct_8x8_inference_flag");

    /* frame_cropping_flag */
    PUT_BITS(ps_bitstrm, ps_sps->i1_frame_cropping_flag, 1, return_status, "frame_cropping_flag");

    if(ps_sps->i1_frame_cropping_flag)
    {
        /* frame_crop_left_offset */
        PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_frame_crop_left_offset, return_status,
                     "frame_crop_left_offset");

        /* frame_crop_right_offset */
        PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_frame_crop_right_offset, return_status,
                     "frame_crop_right_offset");

        /* frame_crop_top_offset */
        PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_frame_crop_top_offset, return_status,
                     "frame_crop_top_offset");

        /* frame_crop_bottom_offset */
        PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_frame_crop_bottom_offset, return_status,
                     "frame_crop_bottom_offset");
    }

    /* vui_parameters_present_flag */
    PUT_BITS(ps_bitstrm, ps_sps->i1_vui_parameters_present_flag, 1, return_status,
             "vui_parameters_present_flag");

    if(ps_sps->i1_vui_parameters_present_flag)
    {
        /* Add vui parameters to the bitstream */;
        return_status = ih264e_generate_vui(ps_bitstrm, ps_vui);
        if(return_status != IH264E_SUCCESS)
        {
            return return_status;
        }
    }

    if(nal_type != NAL_SUBSET_SPS)
    {
        /* rbsp trailing bits */
        return_status = ih264e_put_rbsp_trailing_bits(ps_bitstrm);
    }

    return return_status;
}

/**
******************************************************************************
*
* @brief Generates PPS (Picture Parameter Set)
*
* @par   Description
*  Generate Picture Parameter Set as per Section 7.3.2.2
*
* @param[in]   ps_bitstrm
*  pointer to bitstream context (handle)
*
* @param[in]   ps_pps
*  pointer to structure containing PPS data
*
* @return      success or failure error code
*
******************************************************************************
*/
WORD32 isvce_generate_pps(bitstrm_t *ps_bitstrm, pps_t *ps_pps, sps_t *ps_sps)
{
    WORD32 return_status = IH264E_SUCCESS;

    /* Insert the NAL start code */
    return_status = ih264e_put_nal_start_code_prefix(ps_bitstrm, 1);
    if(return_status != IH264E_SUCCESS)
    {
        return return_status;
    }

    /* Insert Nal Unit Header */
    PUT_BITS(ps_bitstrm, NAL_PPS_FIRST_BYTE, 8, return_status, "pps_header");

    /* pic_parameter_set_id */
    PUT_BITS_UEV(ps_bitstrm, ps_pps->u1_pps_id, return_status, "pic_parameter_set_id");

    /* seq_parameter_set_id */
    PUT_BITS_UEV(ps_bitstrm, ps_pps->u1_sps_id, return_status, "seq_parameter_set_id");

    /* Entropy coding : 0-VLC; 1 - CABAC */
    PUT_BITS(ps_bitstrm, ps_pps->u1_entropy_coding_mode_flag, 1, return_status,
             "Entropy coding : 0-VLC; 1 - CABAC");

    /* Pic order present flag */
    PUT_BITS(ps_bitstrm, ps_pps->u1_pic_order_present_flag, 1, return_status,
             "Pic order present flag");

    /* Number of slice groups */
    PUT_BITS_UEV(ps_bitstrm, ps_pps->u1_num_slice_groups - 1, return_status,
                 "Number of slice groups");

    if(ps_pps->u1_num_slice_groups > 1)
    {
        /* TODO_LATER: Currently the number of slice groups minus 1 is 0.
         * If this is not the case, we have to add Slice group map type to the bit
         * stream*/
    }

    /* num_ref_idx_l0_default_active_minus1 */
    PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_ref_idx_l0_default_active - 1, return_status,
                 "num_ref_idx_l0_default_active_minus1");

    /* num_ref_idx_l1_default_active_minus1 */
    PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_ref_idx_l1_default_active - 1, return_status,
                 "num_ref_idx_l1_default_active_minus1");

    /* weighted_pred_flag */
    PUT_BITS(ps_bitstrm, ps_pps->i1_weighted_pred_flag, 1, return_status, "weighted_pred_flag");

    /* weighted_bipred_flag */
    PUT_BITS(ps_bitstrm, ps_pps->i1_weighted_bipred_idc, 2, return_status, "weighted_bipred_idc");

    /* pic_init_qp_minus26 */
    PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_pic_init_qp - 26, return_status, "pic_init_qp_minus26");

    /* pic_init_qs_minus26 */
    PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_pic_init_qs - 26, return_status, "pic_init_qs_minus26");

    /* chroma_qp_index_offset */
    PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_chroma_qp_index_offset, return_status,
                 "chroma_qp_index_offset");

    /* deblocking_filter_control_present_flag */
    PUT_BITS(ps_bitstrm, ps_pps->i1_deblocking_filter_control_present_flag, 1, return_status,
             "deblocking_filter_control_present_flag");

    /* constrained_intra_pred_flag */
    PUT_BITS(ps_bitstrm, ps_pps->i1_constrained_intra_pred_flag, 1, return_status,
             "constrained_intra_pred_flag");

    /*redundant_pic_cnt_present_flag */
    PUT_BITS(ps_bitstrm, ps_pps->i1_redundant_pic_cnt_present_flag, 1, return_status,
             "redundant_pic_cnt_present_flag");

    if(ps_sps->u1_profile_idc >= IH264_PROFILE_HIGH)
    {
        /* transform_8x8_mode_flag */
        PUT_BITS(ps_bitstrm, ps_pps->i1_transform_8x8_mode_flag, 1, return_status,
                 "transform_8x8_mode_flag");

        /* pic_scaling_matrix_present_flag */
        PUT_BITS(ps_bitstrm, ps_pps->i1_pic_scaling_matrix_present_flag, 1, return_status,
                 "pic_scaling_matrix_present_flag");

        if(ps_pps->i1_pic_scaling_matrix_present_flag)
        {
            /* TODO_LATER: Will be enabled once scaling list support is added */
        }

        /* Second chroma QP offset */
        PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_second_chroma_qp_index_offset, return_status,
                     "Second chroma QP offset");
    }

    return_status = ih264e_put_rbsp_trailing_bits(ps_bitstrm);

    return return_status;
}

/**
******************************************************************************
*
* @brief Generates Slice Header
*
* @par   Description
*  Generate Slice Header as per Section 7.3.5.1
*
* @param[inout]   ps_bitstrm
*  pointer to bitstream context for generating slice header
*
* @param[in]   ps_slice_hdr
*  pointer to slice header params
*
* @param[in]   ps_pps
*  pointer to pps params referred by slice
*
* @param[in]   ps_sps
*  pointer to sps params referred by slice
*
* @param[out]   ps_dup_bit_strm_ent_offset
*  Bitstream struct to store bitstream state
*
* @param[out]   pu4_first_slice_start_offset
*  first slice offset is returned
*
* @return      success or failure error code
*
******************************************************************************
*/
WORD32 isvce_generate_slice_header(bitstrm_t *ps_bitstrm, slice_header_t *ps_slice_hdr,
                                   pps_t *ps_pps, sps_t *ps_sps, UWORD8 u1_idr_flag)
{
    WORD32 return_status = IH264E_SUCCESS;
    UWORD8 u1_slice_type;

    /* Insert start code */
    return_status = ih264e_put_nal_start_code_prefix(ps_bitstrm, 1);
    if(return_status != IH264E_SUCCESS)
    {
        return return_status;
    }
    /* Insert Nal Unit Header */
    return_status = isvce_generate_nal_unit_header(ps_bitstrm, ps_slice_hdr->i1_nal_unit_type,
                                                   ps_slice_hdr->i1_nal_unit_idc);
    if(return_status != IH264E_SUCCESS)
    {
        return return_status;
    }
    /* first_mb_in_slice */
    PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u2_first_mb_in_slice, return_status,
                 "first_mb_in_slice");

    /* slice_type */
    PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u1_slice_type, return_status, "slice_type");

    /* pic_parameter_set_id */
    PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u1_pps_id, return_status, "pic_parameter_set_id");

    /* frame_num */
    PUT_BITS(ps_bitstrm, ps_slice_hdr->i4_frame_num, ps_sps->i1_log2_max_frame_num, return_status,
             "frame_num");

    if(!ps_sps->i1_frame_mbs_only_flag)
    {
        /* field_pic_flag */
        PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_field_pic_flag, 1, return_status, "field_pic_flag");

        if(ps_slice_hdr->i1_field_pic_flag)
        {
            /* bottom_field_flag */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_bottom_field_flag, 1, return_status,
                     "bottom_field_flag");
        }
    }

    if(u1_idr_flag == 1)
    {
        /* u2_idr_pic_id */
        PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u2_idr_pic_id, return_status, "idr_pic_id");
    }

    if(ps_sps->i1_pic_order_cnt_type == 0)
    {
        /* pic_order_cnt_lsb */
        PUT_BITS(ps_bitstrm, ps_slice_hdr->i4_pic_order_cnt_lsb,
                 ps_sps->i1_log2_max_pic_order_cnt_lsb, return_status, "pic_order_cnt_lsb");

        if(ps_pps->u1_pic_order_present_flag && !ps_slice_hdr->i1_field_pic_flag)
        {
            /* delta_pic_order_cnt_bottom */
            PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i4_delta_pic_order_cnt_bottom, return_status,
                         "delta_pic_order_cnt_bottom");
        }
    }

    if(ps_sps->i1_pic_order_cnt_type == 1 && !ps_sps->i1_delta_pic_order_always_zero_flag)
    {
        /* delta_pic_order_cnt[0] */
        PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->ai4_delta_pic_order_cnt[0], return_status,
                     "delta_pic_order_cnt[0]");

        if(ps_pps->u1_pic_order_present_flag && !ps_slice_hdr->i1_field_pic_flag)
        {
            /* delta_pic_order_cnt[1] */
            PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->ai4_delta_pic_order_cnt[1], return_status,
                         "delta_pic_order_cnt[1]");
        }
    }

    if(ps_pps->i1_redundant_pic_cnt_present_flag)
    {
        /* redundant_pic_cnt */
        PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u1_redundant_pic_cnt, return_status,
                     "redundant_pic_cnt");
    }

    u1_slice_type = ps_slice_hdr->u1_slice_type % EPSLICE;

    if(u1_slice_type == BSLICE)
    {
        /* direct_spatial_mv_pred_flag */
        PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_direct_spatial_mv_pred_flag, 1, return_status,
                 "direct_spatial_mv_pred_flag");
    }

    if(u1_slice_type == PSLICE || u1_slice_type == SPSLICE || u1_slice_type == BSLICE)
    {
        /* num_ref_idx_active_override_flag */
        PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_num_ref_idx_active_override_flag, 1, return_status,
                 "num_ref_idx_active_override_flag");

        if(ps_slice_hdr->u1_num_ref_idx_active_override_flag)
        {
            /* num_ref_idx_l0_active_minus1 */
            PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_l0_active - 1, return_status,
                         "num_ref_idx_l0_active_minus1");

            if(u1_slice_type == BSLICE)
            {
                /* num_ref_idx_l1_active_minus1 */
                PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_l1_active - 1, return_status,
                             "num_ref_idx_l1_active_minus1");
            }
        }
    }

    /* ref_pic_list_modification */
    if((u1_slice_type != ISLICE) && (u1_slice_type != SISLICE))
    {
        /* ref_pic_list_modification_flag_l0 */
        PUT_BITS(ps_bitstrm, ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0, 1,
                 return_status, "ref_pic_list_modification_flag_l0");

        if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0)
        {
            UWORD8 i = 0;

            WORD8 *pi1_modification_of_pic_nums_idc_l0 =
                ps_slice_hdr->s_rplm.i1_modification_of_pic_nums_idc_l0;
            UWORD32 *pu4_abs_diff_pic_num_minus1_l0 =
                ps_slice_hdr->s_rplm.u4_abs_diff_pic_num_minus1_l0;
            UWORD8 *pu1_long_term_pic_num_l0 = ps_slice_hdr->s_rplm.u1_long_term_pic_num_l0;

            do
            {
                /* modification_of_pic_nums_idc */
                PUT_BITS_UEV(ps_bitstrm, pi1_modification_of_pic_nums_idc_l0[i], return_status,
                             "modification_of_pic_nums_idc");

                if((0 == pi1_modification_of_pic_nums_idc_l0[i]) ||
                   (1 == pi1_modification_of_pic_nums_idc_l0[i]))
                {
                    /* abs_diff_pic_num_minus1 */
                    PUT_BITS_UEV(ps_bitstrm, pu4_abs_diff_pic_num_minus1_l0[0], return_status,
                                 "abs_diff_pic_num_minus1");

                    pu4_abs_diff_pic_num_minus1_l0++;
                }
                else if(2 == pi1_modification_of_pic_nums_idc_l0[i])
                {
                    /* long_term_pic_num */
                    PUT_BITS_UEV(ps_bitstrm, pu1_long_term_pic_num_l0[0], return_status,
                                 "abs_diff_pic_num_minus1");

                    pu1_long_term_pic_num_l0++;
                }
            } while(pi1_modification_of_pic_nums_idc_l0[i++] != 3);
        }
    }

    if(u1_slice_type == BSLICE)
    {
        /* ref_pic_list_modification_flag_l1 */
        PUT_BITS(ps_bitstrm, ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1, 1,
                 return_status, "ref_pic_list_modification_flag_l1");

        if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1)
        {
            UWORD8 i = 0;

            WORD8 *pi1_modification_of_pic_nums_idc_l1 =
                ps_slice_hdr->s_rplm.i1_modification_of_pic_nums_idc_l1;
            UWORD32 *pu4_abs_diff_pic_num_minus1_l1 =
                ps_slice_hdr->s_rplm.u4_abs_diff_pic_num_minus1_l1;
            UWORD8 *pu1_long_term_pic_num_l1 = ps_slice_hdr->s_rplm.u1_long_term_pic_num_l1;

            do
            {
                /* modification_of_pic_nums_idc */
                PUT_BITS_UEV(ps_bitstrm, pi1_modification_of_pic_nums_idc_l1[i], return_status,
                             "modification_of_pic_nums_idc");

                if((0 == pi1_modification_of_pic_nums_idc_l1[i]) ||
                   (1 == pi1_modification_of_pic_nums_idc_l1[i]))
                {
                    /* abs_diff_pic_num_minus1 */
                    PUT_BITS_UEV(ps_bitstrm, pu4_abs_diff_pic_num_minus1_l1[0], return_status,
                                 "abs_diff_pic_num_minus1");

                    pu4_abs_diff_pic_num_minus1_l1++;
                }
                else if(2 == pi1_modification_of_pic_nums_idc_l1[i])
                {
                    /* long_term_pic_num */
                    PUT_BITS_UEV(ps_bitstrm, pu1_long_term_pic_num_l1[0], return_status,
                                 "abs_diff_pic_num_minus1");

                    pu1_long_term_pic_num_l1++;
                }
            } while(pi1_modification_of_pic_nums_idc_l1[i++] != 3);
        }
    }

    if((ps_pps->i1_weighted_pred_flag && u1_slice_type == PSLICE) ||
       (u1_slice_type == BSLICE && ps_pps->i1_weighted_bipred_idc == 1))
    {
        /* TODO_LATER: Currently there is no support for weighted prediction.
         This needs to be updated when the support is added */
    }

    if(ps_slice_hdr->i1_nal_unit_idc != 0)
    {
        if(u1_idr_flag == 1)
        {
            /* no_output_of_prior_pics_flag  */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_no_output_of_prior_pics_flag, 1, return_status,
                     "no_output_of_prior_pics_flag ");

            /* long_term_reference_flag  */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_long_term_reference_flag, 1, return_status,
                     "long_term_reference_flag ");
        }
        else
        {
            /* adaptive_ref_pic_marking_mode_flag  */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_adaptive_ref_pic_marking_mode_flag, 1,
                     return_status, "adaptive_ref_pic_marking_mode_flag ");

            if(ps_slice_hdr->u1_adaptive_ref_pic_marking_mode_flag)
            {
                /* TODO: if the reference picture marking mode is adaptive
                 add these fields in the bit-stream */
            }
        }
    }

    if(ps_slice_hdr->u1_entropy_coding_mode_flag && u1_slice_type != ISLICE &&
       u1_slice_type != SISLICE)
    {
        /* cabac_init_idc */
        PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_cabac_init_idc, return_status, "cabac_init_idc");
    }

    /* slice_qp_delta */
    PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_qp - ps_pps->i1_pic_init_qp, return_status,
                 "slice_qp_delta");

    if(ps_slice_hdr->u1_slice_type == SPSLICE || ps_slice_hdr->u1_slice_type == SISLICE)
    {
        if(ps_slice_hdr->u1_slice_type == SPSLICE)
        {
            /* sp_for_switch_flag */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_sp_for_switch_flag, 1, return_status,
                     "sp_for_switch_flag");
        }
        /* slice_qs_delta */
        PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->u1_slice_qs - ps_pps->i1_pic_init_qs, return_status,
                     "slice_qs_delta");
    }

    if(ps_pps->i1_deblocking_filter_control_present_flag)
    {
        /* disable_deblocking_filter_idc */
        PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u1_disable_deblocking_filter_idc, return_status,
                     "disable_deblocking_filter_idc");

        if(ps_slice_hdr->u1_disable_deblocking_filter_idc != 1)
        {
            /* slice_alpha_c0_offset_div2 */
            PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_alpha_c0_offset_div2, return_status,
                         "slice_alpha_c0_offset_div2");

            /* slice_beta_offset_div2 */
            PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_beta_offset_div2, return_status,
                         "slice_beta_offset_div2");
        }
    }

    if(ps_slice_hdr->u1_num_slice_groups_minus1 > 0 && ps_pps->u1_slice_group_map_type >= 3 &&
       ps_pps->u1_slice_group_map_type <= 5)
    {
        /* slice_group_change_cycle */
        /* TODO_LATER: Currently the number of slice groups minus 1 is 0.
         * If this is not the case, we have to add Slice group map type to the bit
         * stream */
    }

    return return_status;
}

/**
******************************************************************************
*
* @brief Populates VUI structure
*
* @par   Description
*  Populates VUI structure for its use in header generation
*
* @param[in]   ps_codec
*  pointer to encoder context
*
* @return      success or failure error code
*
******************************************************************************
*/
static IH264E_ERROR_T isvce_populate_vui(isvce_codec_t *ps_codec, sps_t *ps_sps)
{
    vui_t *ps_vui = &ps_sps->s_vui_parameters;

    ps_vui->u1_nal_hrd_parameters_present_flag = 0;
    ps_vui->u1_vcl_hrd_parameters_present_flag = 0;

    ps_vui->u1_bitstream_restriction_flag = 1;
    ps_vui->u1_motion_vectors_over_pic_boundaries_flag = 1;
    ps_vui->u1_max_bytes_per_pic_denom = 0;
    ps_vui->u1_max_bits_per_mb_denom = 0;
    ps_vui->u1_log2_max_mv_length_horizontal = 16;
    ps_vui->u1_log2_max_mv_length_vertical = 16;

    if(ps_codec->s_cfg.u4_num_bframes == 0)
    {
        ps_vui->u1_num_reorder_frames = 0;
    }
    else
    {
        ps_vui->u1_num_reorder_frames = 1;
    }

    ps_vui->u1_max_dec_frame_buffering = ps_sps->u1_max_num_ref_frames;

    return 0;
}

/**
******************************************************************************
*
* @brief Populates sps structure
*
* @par   Description
*  Populates sps structure for its use in header generation
*
* @param[in]   ps_codec
*  pointer to encoder context
*
* @param[out]  ps_sps
*  pointer to sps params that needs to be populated
*
* @return      success or failure error code
*
******************************************************************************
*/
IH264E_ERROR_T isvce_populate_sps(isvce_codec_t *ps_codec, sps_t *ps_sps, UWORD8 u1_sps_id,
                                  UWORD8 u1_profile_idc, isvce_inp_buf_t *ps_inp_buf,
                                  UWORD8 u1_spatial_layer_id)
{
    /* active config parameters */
    isvce_cfg_params_t *ps_cfg = &(ps_codec->s_cfg);

    //    /* level */
    //    IH264_LEVEL_T   level_idc;

    /* error_status */
    IH264E_ERROR_T i4_err_code = IH264E_FAIL;

    /* profile */
    /*
     * Baseline profile supports, 8 bits per sample, 4:2:0 format, CAVLC.
     * B frames are not allowed. Further, Flexible mb ordering, Redundant slices,
     * Arbitrary slice ordering are supported. The constrained baseline profile is
     * baseline profile minus ASO, FMO and redundant slices. To the constrained
     * baseline profile if we add support for B slices, support for encoding
     * interlaced frames, support for weighted prediction and introduce CABAC
     * entropy coding then we have Main Profile.
     */
    ps_sps->u1_profile_idc = u1_profile_idc;

    /* level */
    ps_sps->u1_level_idc = MAX(
        ps_cfg->u4_max_level, (UWORD32) ih264e_get_min_level(ps_cfg->u4_max_wd, ps_cfg->u4_max_ht));

    /* constrained flags */
    /*
     * baseline profile automatically implies set 0 flag
     */
    ps_sps->u1_constraint_set0_flag = (ps_sps->u1_profile_idc == IH264_PROFILE_BASELINE);
    /*
     * main profile automatically implies set 1 flag
     * Although the encoder says it supports Baseline profile it actually supports
     * constrained baseline profile as ASO, FMO and redundant slices are not
     * supported
     */
    ps_sps->u1_constraint_set1_flag = (ps_sps->u1_profile_idc <= IH264_PROFILE_MAIN);
    /*
     * extended profile is not supported
     */
    ps_sps->u1_constraint_set2_flag = 0x00;
    /*
     * level 1b or level 11
     */
    if(ps_sps->u1_level_idc == IH264_LEVEL_1B)
    {
        ps_sps->u1_constraint_set3_flag = 0;
        ps_sps->u1_level_idc = IH264_LEVEL_11;
    }
    else
    {
        ps_sps->u1_constraint_set3_flag = 0;
    }

    /* active sps id */
    ps_sps->u1_sps_id = u1_sps_id;

    if((ps_sps->u1_profile_idc == IH264_SCALABLE_BASELINE) ||
       (ps_sps->u1_profile_idc >= IH264_PROFILE_HIGH))
    {
        /* chroma format idc */
        ps_sps->u1_chroma_format_idc = CHROMA_FMT_IDC_YUV420;

        /* residual_colour_transform_flag */
        ps_sps->i1_residual_colour_transform_flag = 0;

        /* luma bit depth 8 */
        ps_sps->i1_bit_depth_luma = 8;

        /* chroma bit depth 8 */
        ps_sps->i1_bit_depth_chroma = 8;

        /* qpprime_y_zero_transform_bypass_flag */
        ps_sps->i1_qpprime_y_zero_transform_bypass_flag = 0;

        /* seq_scaling_matrix_present_flag */
        ps_sps->i1_seq_scaling_matrix_present_flag = 0;

        if(ps_sps->i1_seq_scaling_matrix_present_flag)
        {
            /* TODO_LATER: Will be enabled once scaling list support is added */
        }
    }

    /* log2_max_frame_num_minus4 */
    ps_sps->i1_log2_max_frame_num = LOG2_MAX_FRAME_NUM_MINUS4 + 4;

    /* pic_order_cnt_type */
    ps_sps->i1_pic_order_cnt_type = 2;

    if(ps_codec->i4_non_ref_frames_in_stream)
    {
        ps_sps->i1_pic_order_cnt_type = 0;
    }

    /* log2_max_pic_order_cnt_lsb_minus4 */
    ps_sps->i1_log2_max_pic_order_cnt_lsb = 8;

    /* TODO : add support for other poc types */
    if(ps_sps->i1_pic_order_cnt_type == 0)
    {
    }
    else if(ps_sps->i1_pic_order_cnt_type == 1)
    {
    }

    ps_sps->u1_max_num_ref_frames = ps_codec->i4_max_num_reference_frames;

    /* gaps_in_frame_num_value_allowed_flag */
    ps_sps->i1_gaps_in_frame_num_value_allowed_flag = 0;

    /* pic width in mb - 1 */
    ps_sps->i2_pic_width_in_mbs_minus1 =
        (ps_inp_buf->as_layer_yuv_buf_props[u1_spatial_layer_id].u4_width >> 4) - 1;

    /* pic height in mb - 1 */
    ps_sps->i2_pic_height_in_map_units_minus1 =
        (ps_inp_buf->as_layer_yuv_buf_props[u1_spatial_layer_id].u4_height >> 4) - 1;

    /* frame_mbs_only_flag, no support for interlace encoding */
    ps_sps->i1_frame_mbs_only_flag = 1;

    /* mb_adaptive_frame_field_flag */
    if(ps_sps->i1_frame_mbs_only_flag == 0)
    {
        ps_sps->i1_mb_adaptive_frame_field_flag = 0;
    }

    /* direct_8x8_inference_flag */
    if(ps_sps->u1_level_idc < IH264_LEVEL_30)
    {
        ps_sps->i1_direct_8x8_inference_flag = 0;
    }
    else
    {
        ps_sps->i1_direct_8x8_inference_flag = 1;
    }

    /* cropping params */
    /*NOTE : Cropping values depend on the chroma format
     * For our case ,decoder interprets the cropping values as 2*num pixels
     * Hence the difference in the disp width and width must be halved before
     * sending to get the expected results
     */
    ps_sps->i1_frame_cropping_flag = 0;
    ps_sps->i2_frame_crop_left_offset = 0;
    ps_sps->i2_frame_crop_right_offset = (ps_codec->s_cfg.u4_wd - ps_codec->s_cfg.u4_disp_wd) >> 1;
    ps_sps->i2_frame_crop_top_offset = 0;
    ps_sps->i2_frame_crop_bottom_offset = (ps_codec->s_cfg.u4_ht - ps_codec->s_cfg.u4_disp_ht) >> 1;

    if(ps_sps->i2_frame_crop_left_offset || ps_sps->i2_frame_crop_right_offset ||
       ps_sps->i2_frame_crop_top_offset || ps_sps->i2_frame_crop_bottom_offset)
    {
        ps_sps->i1_frame_cropping_flag = 1;
    }

    /* vui params */
    ps_sps->i1_vui_parameters_present_flag = !(ps_cfg->u4_disable_vui);

    if(!ps_sps->i1_vui_parameters_present_flag)
    {
        /* populate vui params */
        isvce_populate_vui(ps_codec, ps_sps);
    }
    else
    {
        ps_sps->s_vui_parameters = ps_cfg->s_vui;
    }

    return i4_err_code;
}

/**
******************************************************************************
*
* @brief Populates pps structure
*
* @par   Description
*  Populates pps structure for its use in header generation
*
* @param[in]   ps_codec
*  pointer to encoder context
*
* @param[out]  ps_pps
*  pointer to pps params that needs to be populated
*
* @return      success or failure error code
*
******************************************************************************
*/
IH264E_ERROR_T isvce_populate_pps(isvce_codec_t *ps_codec, pps_t *ps_pps, UWORD8 u1_sps_id,
                                  UWORD8 u1_pps_id, UWORD8 u1_spatial_layer_id)
{
    /* seq_parameter_set_id */
    ps_pps->u1_sps_id = u1_sps_id;

    /* pic_parameter_set_id */
    ps_pps->u1_pps_id = u1_pps_id;

    /* entropy_coding_mode */
    ps_pps->u1_entropy_coding_mode_flag =
        ((ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers > 1) && (0 == u1_spatial_layer_id))
            ? CAVLC
            : ps_codec->s_cfg.u4_entropy_coding_mode;

    /* pic_order_present_flag is unset if we don't have feilds */
    ps_pps->u1_pic_order_present_flag = 0;

    /* Currently number of slice groups supported are 1 */
    ps_pps->u1_num_slice_groups = 1;

    if(ps_pps->u1_num_slice_groups - 1)
    {
        /* TODO_LATER: Currently the number of slice groups minus 1 is 0.
         * If this is not the case, we have to add Slice group map type to the bit
         * stream*/
    }

    /* number of reference frames for list 0 */
    /* FIXME : fix this hard coded value */
    ps_pps->i1_num_ref_idx_l0_default_active = 1;

    /* number of reference frames for list 1 */
    ps_pps->i1_num_ref_idx_l1_default_active = 1;

    /* weighted prediction for now is disabled */
    ps_pps->i1_weighted_pred_flag = 0;
    ps_pps->i1_weighted_bipred_idc = 0;

    /* The intent is to not signal qp from pps. Rather send the same in slice
     * headers */
    ps_pps->i1_pic_init_qp = 0;

    /* The intent is to not signal qp from pps. Rather send the same in slice
     * headers */
    ps_pps->i1_pic_init_qs = 0;

    /* The intent is to not signal qp from pps. Rather send the same in slice
     * headers */
    ps_pps->i1_chroma_qp_index_offset = 0;

    /* deblocking filter flags present in slice header */
    ps_pps->i1_deblocking_filter_control_present_flag = 1;

    /* constrained intra prediction */
    ps_pps->i1_constrained_intra_pred_flag =
        ps_codec->au4_constrained_intra_pred[u1_spatial_layer_id];

    /* sending redundant slices is not supported for now */
    ps_pps->i1_redundant_pic_cnt_present_flag = 0;

    ps_pps->u1_slice_group_map_type = 0;

    return IH264E_SUCCESS;
}

/**
******************************************************************************
*
* @brief Populates slice header structure
*
* @par   Description
*  Populates slice header structure for its use in header generation
*
* @param[in]  ps_proc
*  pointer to proc context
*
* @param[out]  ps_slice_hdr
*  pointer to slice header structure that needs to be populated
*
* @param[in]  ps_pps
*  pointer to pps params structure referred by the slice
*
* @param[in]   ps_sps
*  pointer to sps params referred by the pps
*
* @return      success or failure error code
*
******************************************************************************
*/
WORD32 isvce_populate_slice_header(isvce_process_ctxt_t *ps_proc, slice_header_t *ps_slice_hdr,
                                   pps_t *ps_pps, sps_t *ps_sps, UWORD8 u1_is_idr)
{
    /* entropy context */
    isvce_entropy_ctxt_t *ps_entropy = &ps_proc->s_entropy;

    isvce_codec_t *ps_codec = ps_proc->ps_codec;

    if(ps_codec->u4_is_curr_frm_ref)
    {
        ps_slice_hdr->i1_nal_unit_idc = 3;
    }
    else
    {
        ps_slice_hdr->i1_nal_unit_idc = 0;
    }

    /* start mb address */
    ps_slice_hdr->u2_first_mb_in_slice = ps_entropy->i4_mb_start_add;

    /* slice type */
    ps_slice_hdr->u1_slice_type = ps_proc->i4_slice_type;

    /* pic_parameter_set_id */
    ps_slice_hdr->u1_pps_id = ps_pps->u1_pps_id;

    /* Separate color plane flag is 0,
     * hence the syntax element color_plane_id not included */

    /* frame num */
    ps_slice_hdr->i4_frame_num = ps_proc->i4_frame_num;

    /* frame_mbs_only_flag, no support for interlace encoding */
    if(!ps_sps->i1_frame_mbs_only_flag)
    {
        ps_slice_hdr->i1_field_pic_flag = 0;

        if(ps_slice_hdr->i1_field_pic_flag)
        {
            ps_slice_hdr->i1_bottom_field_flag = 0;
        }
    }

    /* idr pic id */
    if(u1_is_idr)
    {
        ps_slice_hdr->u2_idr_pic_id = ps_proc->u4_idr_pic_id;
        ps_slice_hdr->i1_nal_unit_type = NAL_SLICE_IDR;
    }
    else
    {
        ps_slice_hdr->i1_nal_unit_type = NAL_SLICE_NON_IDR;
    }

    if(ps_proc->u1_spatial_layer_id > 0)
    {
        ps_slice_hdr->i1_nal_unit_type = NAL_CODED_SLICE_EXTENSION;
    }

    if(ps_sps->i1_pic_order_cnt_type == 0)
    {
        WORD32 i4_poc;
        i4_poc = ps_codec->i4_poc;
        i4_poc %= (1 << ps_sps->i1_log2_max_pic_order_cnt_lsb);
        ps_slice_hdr->i4_pic_order_cnt_lsb = i4_poc;
    }
    /* TODO add support for poc type 1 */
    else if(ps_sps->i1_pic_order_cnt_type == 1)
    {
    }

    /*
     * redundant slices are not currently supported.
     * Hence the syntax element redundant slice cnt is not initialized
     */
    if(ps_pps->i1_redundant_pic_cnt_present_flag)
    {
    }

    /* direct spatial mv pred flag */
    if(ps_proc->i4_slice_type == BSLICE)
    {
        ps_slice_hdr->u1_direct_spatial_mv_pred_flag = 1;
    }

    if(ps_proc->i4_slice_type == PSLICE || ps_proc->i4_slice_type == SPSLICE ||
       ps_proc->i4_slice_type == BSLICE)
    {
        /* num_ref_idx_active_override_flag */
        ps_slice_hdr->u1_num_ref_idx_active_override_flag = 0;

        if(ps_slice_hdr->u1_num_ref_idx_active_override_flag)
        {
            /* num_ref_idx_l0_active_minus1 */

            if(ps_proc->i4_slice_type == BSLICE)
            {
                /* num_ref_idx_l1_active_minus1 */
            }
        }
    }

    /* ref_pic_list_modification */
    if((ps_proc->i4_slice_type != ISLICE) && (ps_proc->i4_slice_type != SISLICE))
    {
        /* ref_pic_list_modification_flag_l0 */
        ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0 = 1;

        if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0)
        {
            ps_slice_hdr->s_rplm.i1_modification_of_pic_nums_idc_l0[0] = 0;
            ps_slice_hdr->s_rplm.i1_modification_of_pic_nums_idc_l0[1] = 3;

            if((ps_codec->i4_frame_num - ps_proc->aps_ref_pic[L0]->i4_frame_num) < 1)
            {
                return IH264E_FAIL;
            }

            ps_slice_hdr->s_rplm.u4_abs_diff_pic_num_minus1_l0[0] =
                ps_codec->i4_frame_num - ps_proc->aps_ref_pic[L0]->i4_frame_num - 1;
        }
    }

    if(ps_proc->i4_slice_type == BSLICE)
    {
        /* ref_pic_list_modification_flag_l1 */
        ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1 = 0;

        if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1)
        {
        }
    }

    /* Currently we do not support weighted pred */
    /* ps_slice_hdr->u1_weighted_bipred_idc = 0; */

    if((ps_pps->i1_weighted_pred_flag &&
        (ps_proc->i4_slice_type == PSLICE || ps_proc->i4_slice_type == SPSLICE)) ||
       (ps_proc->i4_slice_type == BSLICE && ps_pps->i1_weighted_bipred_idc == 1))
    {
        /* TODO_LATER: Currently there is no support for weighted prediction.
             This needs to be updated when the support is added */
    }

    if(ps_slice_hdr->i1_nal_unit_idc != 0)
    {
        if(u1_is_idr)
        {
            /* no_output_of_prior_pics_flag  */
            ps_slice_hdr->u1_no_output_of_prior_pics_flag = 0;

            /* long_term_reference_flag  */
            ps_slice_hdr->u1_long_term_reference_flag = 0;
        }
        else
        {
            /* adaptive_ref_pic_marking_mode_flag  */
            ps_slice_hdr->u1_adaptive_ref_pic_marking_mode_flag = 0;

            if(ps_slice_hdr->u1_adaptive_ref_pic_marking_mode_flag)
            {
                /* TODO: if the reference picture marking mode is adaptive
                     add these fields in the bit-stream */
            }
        }
    }

    /* entropy coding mode flag */
    ps_slice_hdr->u1_entropy_coding_mode_flag = ps_entropy->u1_entropy_coding_mode_flag;

    if(ps_slice_hdr->u1_entropy_coding_mode_flag && ps_proc->i4_slice_type != ISLICE &&
       ps_proc->i4_slice_type != SISLICE)
    {
        /* cabac_init_idc */
        ps_slice_hdr->i1_cabac_init_idc = CABAC_INIT_IDC;
    }

    /* slice qp */
    ps_slice_hdr->i1_slice_qp = ps_proc->u1_frame_qp;

    if(ps_proc->i4_slice_type == SPSLICE || ps_proc->i4_slice_type == SISLICE)
    {
        if(ps_proc->i4_slice_type == SPSLICE)
        {
            /* sp_for_switch_flag */
        }
        /* slice_qs_delta */
    }

    if(ps_pps->i1_deblocking_filter_control_present_flag)
    {
        /* disable_deblocking_filter_idc */
        ps_slice_hdr->u1_disable_deblocking_filter_idc = ps_proc->u4_disable_deblock_level;

        if(ps_slice_hdr->u1_disable_deblocking_filter_idc != 1)
        {
            /* slice_alpha_c0_offset_div2 */
            ps_slice_hdr->i1_slice_alpha_c0_offset_div2 = 0;

            /* slice_beta_offset_div2 */
            ps_slice_hdr->i1_slice_beta_offset_div2 = 0;
        }
    }
    ps_slice_hdr->u1_num_slice_groups_minus1 = 0;
    if(ps_slice_hdr->u1_num_slice_groups_minus1 > 0 && ps_pps->u1_slice_group_map_type >= 3 &&
       ps_pps->u1_slice_group_map_type <= 5)
    {
        /* slice_group_change_cycle */
        /* TODO_LATER: Currently the number of slice groups minus 1 is 0.
         * If this is not the case, we have to add Slice group map type to the bit
         * stream */
    }

    ps_slice_hdr->i1_cabac_init_idc = CABAC_INIT_IDC;

    return IH264E_SUCCESS;
}

/**
******************************************************************************
*
* @brief Populates svc_nalu_ext structure
*
* @par   Description
*  Populates svc_nalu_ext structure for its use in header generation
*
* @param[in]  ps_proc
*  pointer to proc context
*
* @param[out]  ps_slice_hdr
*  pointer to slice header structure that needs to be populated
*
* @param[in]  ps_pps
*  pointer to pps params structure referred by the slice
*
* @param[in]   ps_sps
*  pointer to sps params referred by the pps
*
* @return      success or failure error code
*
******************************************************************************
*/
WORD32 isvce_populate_svc_nalu_extension(isvce_process_ctxt_t *ps_proc,
                                         svc_nalu_ext_t *ps_svc_nalu_ext, NAL_UNIT_TYPE_T nalu_type,
                                         UWORD8 u1_idr_flag)
{
    isvce_codec_t *ps_codec = ps_proc->ps_codec;

    ps_svc_nalu_ext->u1_idr_flag = u1_idr_flag;

    ps_svc_nalu_ext->u1_priority_id = 0;

    ps_svc_nalu_ext->u1_no_inter_layer_pred_flag = ((nalu_type == NAL_PREFIX) ? 1 : 0);

    ps_svc_nalu_ext->u1_dependency_id =
        ((nalu_type == NAL_PREFIX) ? 0 : ps_proc->u1_spatial_layer_id);

    ps_svc_nalu_ext->u1_temporal_id = ps_proc->ps_cur_pic->i1_temporal_id;

    ps_svc_nalu_ext->u1_quality_id = 0;

    ps_svc_nalu_ext->u1_use_ref_base_pic_flag = 0;

    ps_svc_nalu_ext->u1_discardable_flag = 0;

    ps_svc_nalu_ext->u1_output_flag = 1;

    ps_svc_nalu_ext->u1_reserved_three_2bits = 3;

    ps_svc_nalu_ext->s_nalu_header.u1_nal_ref_idc = ps_codec->u4_is_curr_frm_ref ? 3 : 0;

    ps_svc_nalu_ext->s_nalu_header.u1_nal_unit_type = nalu_type;

    return IH264E_SUCCESS;
}

WORD32 isvce_populate_subset_sps(isvce_codec_t *ps_codec, subset_sps_t *ps_subset_sps,
                                 UWORD8 u1_sps_id, isvce_inp_buf_t *ps_inp_buf,
                                 UWORD8 u1_spatial_layer_id)
{
    sps_t *ps_sps = &ps_subset_sps->s_sps;

    isvce_populate_sps(ps_codec, ps_sps, u1_sps_id, IH264_SCALABLE_BASELINE, ps_inp_buf,
                       u1_spatial_layer_id);

    ps_subset_sps->s_sps_svc_ext.u1_inter_layer_deblocking_filter_control_present_flag = 1;

    ps_subset_sps->s_sps_svc_ext.i1_slice_header_restriction_flag = 1;

    ps_subset_sps->s_sps_svc_ext.u1_extended_spatial_scalability_idc = 0;

    ps_subset_sps->s_sps_svc_ext.i1_seq_tcoeff_level_prediction_flag = 0;

    ps_subset_sps->i1_svc_vui_parameters_present_flag = 0;

    ps_subset_sps->i1_additional_extension2_flag = 0;

    ps_subset_sps->s_sps_svc_ext.u1_chroma_phase_x_plus1 = 1;

    ps_subset_sps->s_sps_svc_ext.u1_chroma_phase_y_plus1 = 1;

    ps_subset_sps->s_sps_svc_ext.i1_adaptive_tcoeff_level_prediction_flag = 0;

    return IH264E_SUCCESS;
}

WORD32 isvce_populate_svc_slice(isvce_process_ctxt_t *ps_proc, svc_slice_header_t *ps_svc_slice_hdr,
                                pps_t *ps_pps, subset_sps_t *ps_subset_sps,
                                svc_nalu_ext_t *ps_svc_nalu_ext)
{
    WORD32 i4_return_status;

    i4_return_status =
        isvce_populate_slice_header(ps_proc, &ps_svc_slice_hdr->s_slice_header, ps_pps,
                                    &ps_subset_sps->s_sps, ps_svc_nalu_ext->u1_idr_flag);

    if(IH264E_SUCCESS != i4_return_status)
    {
        return IH264E_FAIL;
    }

    ps_svc_slice_hdr->i1_slice_skip_flag = 0;
    ps_svc_slice_hdr->i1_adaptive_residual_prediction_flag = ENABLE_RESIDUAL_PREDICTION;
    ps_svc_slice_hdr->i1_default_residual_prediction_flag = 0;
    ps_svc_slice_hdr->i1_adaptive_base_mode_flag = ENABLE_ILP_MV || ENABLE_IBL_MODE;
    ps_svc_slice_hdr->i1_default_base_mode_flag = 0;
    ps_svc_slice_hdr->i1_tcoeff_level_prediction_flag = 0;
    ps_svc_slice_hdr->i1_constrained_intra_resampling_flag = 0;
    ps_svc_slice_hdr->i1_adaptive_motion_prediction_flag = USE_ILP_MV_AS_MVP;
    ps_svc_slice_hdr->i1_default_motion_prediction_flag = 0;
    ps_svc_slice_hdr->u4_disable_inter_layer_deblocking_filter_idc =
        !ENABLE_INTRA_BASE_DEBLOCK || ps_proc->u4_disable_deblock_level;

    if(ps_svc_slice_hdr->u4_disable_inter_layer_deblocking_filter_idc != 1)
    {
        /* slice_alpha_c0_offset_div2 */
        ps_svc_slice_hdr->i4_inter_layer_slice_alpha_c0_offset_div2 = 0;

        /* slice_beta_offset_div2 */
        ps_svc_slice_hdr->i4_inter_layer_slice_beta_offset_div2 = 0;
    }

    if((ps_svc_nalu_ext->u1_quality_id == 0) && (ps_svc_nalu_ext->u1_no_inter_layer_pred_flag == 0))
    {
        ps_svc_slice_hdr->u4_ref_layer_dq_id = (ps_proc->u1_spatial_layer_id - 1) << 4;
    }

    return IH264E_SUCCESS;
}

/**
******************************************************************************
*
* @brief Signals prefix_nal_unit_rbsp
*
* @par   Description
*  prefix_nal_unit_rbsp as per Section G.7.3.2.12
*
* @param[inout]   ps_bitstrm
*  pointer to bitstream context for generating slice header
*
* @param[in]    svc_nalu_ext
*  pointer to svc NAL unit structure
*
* @param[in]    ps_slice_header
*  pointer to slice header
*
* @return      success or failure error code
*
******************************************************************************
*/
WORD32 isvce_generate_prefix_nal(bitstrm_t *ps_bitstrm, svc_nalu_ext_t *ps_svc_nalu_ext,
                                 slice_header_t *ps_slice_header, UWORD8 u1_max_num_ref_frames,
                                 UWORD8 u1_num_spatial_layers)
{
    WORD32 return_status = IH264E_SUCCESS;

    WORD32 i4_store_ref_base_pic_flag = 0;
    WORD32 i4_additional_prefix_nal_unit_extension_flag = 0;

    if(ps_svc_nalu_ext->u1_dependency_id == (u1_num_spatial_layers - 1))
    {
        i4_store_ref_base_pic_flag = 1;
        if(u1_max_num_ref_frames < 2)
        {
            i4_store_ref_base_pic_flag = 0;
        }
    }

    /* store_ref_base_pic_flag */
    if(ps_svc_nalu_ext->s_nalu_header.u1_nal_ref_idc != 0)
    {
        PUT_BITS(ps_bitstrm, i4_store_ref_base_pic_flag, 1, return_status,
                 "store_ref_base_pic_flag");

        if((ps_svc_nalu_ext->u1_use_ref_base_pic_flag || i4_store_ref_base_pic_flag) &&
           !ps_svc_nalu_ext->u1_idr_flag)
        {
            PUT_BITS(ps_bitstrm, ps_slice_header->u1_adaptive_ref_pic_marking_mode_flag, 1,
                     return_status, "DPRM: adaptive_ref_base_pic_marking_mode_flag");
        }

        PUT_BITS(ps_bitstrm, i4_additional_prefix_nal_unit_extension_flag, 1, return_status,
                 "additional_prefix_nal_unit_extension_flag");
    }

    /* rbsp trailing bits */
    return_status = ih264e_put_rbsp_trailing_bits(ps_bitstrm);

    return return_status;
}

WORD32 isvce_generate_slice_header_svc(bitstrm_t *ps_bitstrm, pps_t *ps_pps,
                                       svc_nalu_ext_t *ps_svc_nalu_ext,
                                       svc_slice_header_t *ps_svc_slice_hdr,
                                       subset_sps_t *ps_subset_sps)
{
    WORD32 return_status = IH264E_SUCCESS;

    UWORD8 u1_slice_type;
    sps_t *ps_sps = &ps_subset_sps->s_sps;
    slice_header_t *ps_slice_hdr = &ps_svc_slice_hdr->s_slice_header;

    /* first_mb_in_slice */
    PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u2_first_mb_in_slice, return_status,
                 "SH: first_mb_in_slice");

    /* slice_type */
    PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u1_slice_type, return_status, "SH: slice_type");

    /* pic_parameter_set_id */
    PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u1_pps_id, return_status, "SH: pic_parameter_set_id");

    /* frame_num */
    PUT_BITS(ps_bitstrm, ps_slice_hdr->i4_frame_num, ps_sps->i1_log2_max_frame_num, return_status,
             "SH: frame_num");

    if(!ps_sps->i1_frame_mbs_only_flag)
    {
        /* field_pic_flag */
        PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_field_pic_flag, 1, return_status,
                 "SH: field_pic_flag");

        if(ps_slice_hdr->i1_field_pic_flag)
        {
            /* bottom_field_flag */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_bottom_field_flag, 1, return_status,
                     "SH: bottom_field_flag");
        }
    }

    if(ps_svc_nalu_ext->u1_idr_flag == 1)
    {
        /* u2_idr_pic_id */
        PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u2_idr_pic_id, return_status, "SH: idr_pic_id");
    }

    if(ps_sps->i1_pic_order_cnt_type == 0)
    {
        /* pic_order_cnt_lsb */
        PUT_BITS(ps_bitstrm, ps_slice_hdr->i4_pic_order_cnt_lsb,
                 ps_sps->i1_log2_max_pic_order_cnt_lsb, return_status, "SH: pic_order_cnt_lsb");

        if(ps_pps->u1_pic_order_present_flag && !ps_slice_hdr->i1_field_pic_flag)
        {
            /* delta_pic_order_cnt_bottom */
            PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i4_delta_pic_order_cnt_bottom, return_status,
                         "SH: delta_pic_order_cnt_bottom");
        }
    }

    if(ps_sps->i1_pic_order_cnt_type == 1 && !ps_sps->i1_delta_pic_order_always_zero_flag)
    {
        /* delta_pic_order_cnt[0] */
        PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->ai4_delta_pic_order_cnt[0], return_status,
                     "SH: delta_pic_order_cnt[0]");

        if(ps_pps->u1_pic_order_present_flag && !ps_slice_hdr->i1_field_pic_flag)
        {
            /* delta_pic_order_cnt[1] */
            PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->ai4_delta_pic_order_cnt[1], return_status,
                         "SH: delta_pic_order_cnt[1]");
        }
    }

    if(ps_pps->i1_redundant_pic_cnt_present_flag)
    {
        /* redundant_pic_cnt */
        PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u1_redundant_pic_cnt, return_status,
                     "SH: redundant_pic_cnt");
    }

    u1_slice_type = ps_slice_hdr->u1_slice_type % EPSLICE;

    if(ps_svc_nalu_ext->u1_quality_id == 0)
    {
        if(u1_slice_type == BSLICE)
        {
            /* direct_spatial_mv_pred_flag */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_direct_spatial_mv_pred_flag, 1, return_status,
                     "SH: direct_spatial_mv_pred_flag");
        }

        if(u1_slice_type == PSLICE || u1_slice_type == BSLICE)
        {
            /* num_ref_idx_active_override_flag */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_num_ref_idx_active_override_flag, 1,
                     return_status, "SH: num_ref_idx_active_override_flag");

            if(ps_slice_hdr->u1_num_ref_idx_active_override_flag)
            {
                /* num_ref_idx_l0_active_minus1 */
                PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_l0_active - 1, return_status,
                             "SH: num_ref_idx_l0_active_minus1");

                if(u1_slice_type == BSLICE)
                {
                    /* num_ref_idx_l1_active_minus1 */
                    PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_l1_active - 1,
                                 return_status, "SH: num_ref_idx_l1_active_minus1");
                }
            }
        }

        /* ref_pic_list_modification */
        if((u1_slice_type != ISLICE) && (u1_slice_type != SISLICE))
        {
            /* ref_pic_list_modification_flag_l0 */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0, 1,
                     return_status, "RPLR: ref_pic_list_reordering_flag");

            if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0)
            {
                UWORD8 i = 0;

                WORD8 *pi1_modification_of_pic_nums_idc_l0 =
                    ps_slice_hdr->s_rplm.i1_modification_of_pic_nums_idc_l0;
                UWORD32 *pu4_abs_diff_pic_num_minus1_l0 =
                    ps_slice_hdr->s_rplm.u4_abs_diff_pic_num_minus1_l0;
                UWORD8 *pu1_long_term_pic_num_l0 = ps_slice_hdr->s_rplm.u1_long_term_pic_num_l0;

                do
                {
                    /* modification_of_pic_nums_idc */
                    PUT_BITS_UEV(ps_bitstrm, pi1_modification_of_pic_nums_idc_l0[i], return_status,
                                 "RPLR: reordering_of_pic_nums_idc");

                    if((0 == pi1_modification_of_pic_nums_idc_l0[i]) ||
                       (1 == pi1_modification_of_pic_nums_idc_l0[i]))
                    {
                        /* abs_diff_pic_num_minus1 */
                        PUT_BITS_UEV(ps_bitstrm, pu4_abs_diff_pic_num_minus1_l0[0], return_status,
                                     "RPLR: abs_diff_pic_num_minus1");

                        pu4_abs_diff_pic_num_minus1_l0++;
                    }
                    else if(2 == pi1_modification_of_pic_nums_idc_l0[i])
                    {
                        /* long_term_pic_num */
                        PUT_BITS_UEV(ps_bitstrm, pu1_long_term_pic_num_l0[0], return_status,
                                     "RPLR: long_term_pic_num");

                        pu1_long_term_pic_num_l0++;
                    }
                } while(pi1_modification_of_pic_nums_idc_l0[i++] != 3);
            }
        }

        if(u1_slice_type == BSLICE)
        {
            /* ref_pic_list_modification_flag_l1 */
            PUT_BITS(ps_bitstrm, ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1, 1,
                     return_status, "SH: ref_pic_list_modification_flag_l1");

            if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1)
            {
                UWORD8 i = 0;

                WORD8 *pi1_modification_of_pic_nums_idc_l1 =
                    ps_slice_hdr->s_rplm.i1_modification_of_pic_nums_idc_l1;
                UWORD32 *pu4_abs_diff_pic_num_minus1_l1 =
                    ps_slice_hdr->s_rplm.u4_abs_diff_pic_num_minus1_l1;
                UWORD8 *pu1_long_term_pic_num_l1 = ps_slice_hdr->s_rplm.u1_long_term_pic_num_l1;

                do
                {
                    /* modification_of_pic_nums_idc */
                    PUT_BITS_UEV(ps_bitstrm, pi1_modification_of_pic_nums_idc_l1[i], return_status,
                                 "SH: modification_of_pic_nums_idc");

                    if((0 == pi1_modification_of_pic_nums_idc_l1[i]) ||
                       (1 == pi1_modification_of_pic_nums_idc_l1[i]))
                    {
                        /* abs_diff_pic_num_minus1 */
                        PUT_BITS_UEV(ps_bitstrm, pu4_abs_diff_pic_num_minus1_l1[0], return_status,
                                     "SH: abs_diff_pic_num_minus1");

                        pu4_abs_diff_pic_num_minus1_l1++;
                    }
                    else if(2 == pi1_modification_of_pic_nums_idc_l1[i])
                    {
                        /* long_term_pic_num */
                        PUT_BITS_UEV(ps_bitstrm, pu1_long_term_pic_num_l1[0], return_status,
                                     "SH: abs_diff_pic_num_minus1");

                        pu1_long_term_pic_num_l1++;
                    }
                } while(pi1_modification_of_pic_nums_idc_l1[i++] != 3);
            }
        }

        if((ps_pps->i1_weighted_pred_flag && u1_slice_type == PSLICE) ||
           (u1_slice_type == BSLICE && ps_pps->i1_weighted_bipred_idc == 1))
        {
            /* TODO_LATER: Currently there is no support for weighted prediction.
             This needs to be updated when the support is added */
        }

        if(ps_slice_hdr->i1_nal_unit_idc != 0)
        {
            if(ps_svc_nalu_ext->u1_idr_flag)
            {
                /* no_output_of_prior_pics_flag  */
                PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_no_output_of_prior_pics_flag, 1,
                         return_status, "DRPM: no_output_of_prior_pics_flag ");

                /* long_term_reference_flag  */
                PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_long_term_reference_flag, 1, return_status,
                         "DRPM: long_term_reference_flag ");
            }
            else
            {
                /* adaptive_ref_pic_marking_mode_flag  */
                PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_adaptive_ref_pic_marking_mode_flag, 1,
                         return_status, "DPRM: adaptive_ref_pic_marking_mode_flag ");

                if(ps_slice_hdr->u1_adaptive_ref_pic_marking_mode_flag)
                {
                    /* TODO: if the reference picture marking mode is adaptive
                     add these fields in the bit-stream */
                }
            }
            if(ps_subset_sps->s_sps_svc_ext.i1_slice_header_restriction_flag == 0)
            {
                WORD32 i4_store_ref_base_pic_flag = 0;

                if(ps_sps->u1_max_num_ref_frames >= 2)
                {
                    i4_store_ref_base_pic_flag = 1;
                }

                /* store_ref_base_pic_flag */
                PUT_BITS(ps_bitstrm, i4_store_ref_base_pic_flag, 1, return_status,
                         "SH: store_ref_base_pic_flag");

                if((ps_svc_nalu_ext->u1_use_ref_base_pic_flag || i4_store_ref_base_pic_flag) &&
                   (!ps_svc_nalu_ext->u1_idr_flag))
                {
                    PUT_BITS(ps_bitstrm, ps_slice_hdr->u1_adaptive_ref_pic_marking_mode_flag, 1,
                             return_status, "SH: adaptive_ref_base_pic_marking_mode_flag");
                }
            }
        }
    }

    if(ps_slice_hdr->u1_entropy_coding_mode_flag && u1_slice_type != ISLICE)
    {
        /* cabac_init_idc */
        PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_cabac_init_idc, return_status,
                     "SH: cabac_init_idc");
    }

    /* slice_qp_delta */
    PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_qp - ps_pps->i1_pic_init_qp, return_status,
                 "SH: slice_qp_delta");

    if(ps_pps->i1_deblocking_filter_control_present_flag)
    {
        /* disable_deblocking_filter_idc */
        PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->u1_disable_deblocking_filter_idc, return_status,
                     "SH: disable_deblocking_filter_idc");

        if(ps_slice_hdr->u1_disable_deblocking_filter_idc != 1)
        {
            /* slice_alpha_c0_offset_div2 */
            PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_alpha_c0_offset_div2, return_status,
                         "SH: slice_alpha_c0_offset_div2");

            /* slice_beta_offset_div2 */
            PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_beta_offset_div2, return_status,
                         "SH: slice_beta_offset_div2");
        }
    }

    if(ps_slice_hdr->u1_num_slice_groups_minus1 > 0 && ps_pps->u1_slice_group_map_type >= 3 &&
       ps_pps->u1_slice_group_map_type <= 5)
    {
        /* slice_group_change_cycle */
        /* TODO_LATER: Currently the number of slice groups minus 1 is 0.
         * If this is not the case, we have to add Slice group map type to the bit
         * stream */
    }

    if((ps_svc_nalu_ext->u1_no_inter_layer_pred_flag == 0) && (ps_svc_nalu_ext->u1_quality_id == 0))
    {
        PUT_BITS_UEV(ps_bitstrm, ps_svc_slice_hdr->u4_ref_layer_dq_id, return_status,
                     "SH: ref_layer_dq_id");
        if(ps_subset_sps->s_sps_svc_ext.u1_inter_layer_deblocking_filter_control_present_flag)
        {
            PUT_BITS_UEV(ps_bitstrm, ps_svc_slice_hdr->u4_disable_inter_layer_deblocking_filter_idc,
                         return_status, "SH: disable_inter_layer_deblocking_filter_idc");
            if(ps_svc_slice_hdr->u4_disable_inter_layer_deblocking_filter_idc != 1)
            {
                PUT_BITS_SEV(ps_bitstrm,
                             ps_svc_slice_hdr->i4_inter_layer_slice_alpha_c0_offset_div2,
                             return_status, "SH: inter_layer_slice_alpha_c0_offset_div2");
                PUT_BITS_SEV(ps_bitstrm, ps_svc_slice_hdr->i4_inter_layer_slice_beta_offset_div2,
                             return_status, "SH: inter_layer_slice_beta_offset_div2");
            }
        }
        PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_constrained_intra_resampling_flag, 1,
                 return_status, "SH: constrained_intra_resampling_flag");
        if(ps_subset_sps->s_sps_svc_ext.u1_extended_spatial_scalability_idc == 2)
        {
            if(ps_sps->u1_chroma_format_idc > 0)
            {
                PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_ref_layer_chroma_phase_x_plus1_flag, 1,
                         return_status, "SH: ref_layer_chroma_phase_x_plus1_flag");
                PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_ref_layer_chroma_phase_y_plus1, 2,
                         return_status, "SH: ref_layer_chroma_phase_y_plus1");
            }
            PUT_BITS_SEV(ps_bitstrm, ps_svc_slice_hdr->i4_scaled_ref_layer_left, return_status,
                         "SH: scaled_ref_layer_left_offset");
            PUT_BITS_SEV(ps_bitstrm, ps_svc_slice_hdr->i4_scaled_ref_layer_top, return_status,
                         "SH: scaled_ref_layer_top_offset");
            PUT_BITS_SEV(ps_bitstrm, ps_svc_slice_hdr->i4_scaled_ref_layer_right, return_status,
                         "SH: scaled_ref_layer_right_offset");
            PUT_BITS_SEV(ps_bitstrm, ps_svc_slice_hdr->i4_scaled_ref_layer_bottom, return_status,
                         "SH: scaled_ref_layer_bottom_offset");
        }
    }

    if(!ps_svc_nalu_ext->u1_no_inter_layer_pred_flag)
    {
        PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_slice_skip_flag, 1, return_status,
                 "SH: slice_skip_flag");
        if(ps_svc_slice_hdr->i1_slice_skip_flag)
        {
            PUT_BITS_UEV(ps_bitstrm, ps_svc_slice_hdr->u4_num_mbs_in_slice_minus1, return_status,
                         "SH: num_mbs_in_slice_minus1");
        }
        else
        {
            PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_adaptive_base_mode_flag, 1, return_status,
                     "SH: adaptive_base_mode_flag");
            if(!ps_svc_slice_hdr->i1_adaptive_base_mode_flag)
                PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_default_base_mode_flag, 1, return_status,
                         "SH: default_base_mode_flag");

            if(!ps_svc_slice_hdr->i1_default_base_mode_flag)
            {
                PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_adaptive_motion_prediction_flag, 1,
                         return_status, "SH: adaptive_motion_prediction_flag");
                if(!ps_svc_slice_hdr->i1_adaptive_motion_prediction_flag)
                    PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_default_motion_prediction_flag, 1,
                             return_status, "SH: default_motion_prediction_flag");
            }
            PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_adaptive_residual_prediction_flag, 1,
                     return_status, "SH: adaptive_residual_prediction_flag");
            if(!ps_svc_slice_hdr->i1_adaptive_residual_prediction_flag)
                PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_default_residual_prediction_flag, 1,
                         return_status, "SH: default_residual_prediction_flag");
        }

        if(ps_subset_sps->s_sps_svc_ext.i1_adaptive_tcoeff_level_prediction_flag)
        {
            PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->i1_tcoeff_level_prediction_flag, 1,
                     return_status, "SH: tcoeff_level_prediction_flag");
        }
    }

    if(!ps_subset_sps->s_sps_svc_ext.i1_slice_header_restriction_flag &&
       !ps_svc_slice_hdr->i1_slice_skip_flag)
    {
        PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->u4_scan_idx_start, 4, return_status,
                 "SH: scan_idx_start");
        PUT_BITS(ps_bitstrm, ps_svc_slice_hdr->u4_scan_idx_end, 4, return_status,
                 "SH: scan_idx_end");
    }

    return return_status;
}

WORD32 isvce_seq_parameter_set_svc_extension(bitstrm_t *ps_bitstrm, subset_sps_t *ps_sub_sps,
                                             UWORD8 u1_chroma_format_idc)
{
    WORD32 return_status = IH264E_SUCCESS;

    /* inter_layer_deblocking_filter_control_present_flag */
    PUT_BITS(ps_bitstrm,
             ps_sub_sps->s_sps_svc_ext.u1_inter_layer_deblocking_filter_control_present_flag, 1,
             return_status, "SPS: inter_layer_deblocking_filter_control_present_flag");

    /* extended_spatial_scalability */
    PUT_BITS(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.u1_extended_spatial_scalability_idc, 2,
             return_status, "SPS: extended_spatial_scalability");

    if(u1_chroma_format_idc == 1 || u1_chroma_format_idc == 2)
    {
        /* chroma_phase_x_plus1_flag */
        PUT_BITS(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.u1_chroma_phase_x_plus1, 1, return_status,
                 "SPS: chroma_phase_x_plus1_flag");
    }

    if(u1_chroma_format_idc == 1)
    {
        /* chroma_phase_y_plus1 */
        PUT_BITS(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.u1_chroma_phase_y_plus1, 2, return_status,
                 "SPS: chroma_phase_y_plus1");
    }

    if(ps_sub_sps->s_sps_svc_ext.u1_extended_spatial_scalability_idc == 1)
    {
        if(u1_chroma_format_idc > 0)
        {
            /* seq_ref_layer_chroma_phase_x_plus1_flag */
            PUT_BITS(ps_bitstrm,
                     ps_sub_sps->s_sps_svc_ext.u1_seq_ref_layer_chroma_phase_x_plus1_flag, 1,
                     return_status, "SPS: seq_ref_layer_chroma_phase_x_plus1_flag");

            /* seq_ref_layer_chroma_phase_y_plus1 */
            PUT_BITS(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.u1_seq_ref_layer_chroma_phase_y_plus1, 2,
                     return_status, "SPS: seq_ref_layer_chroma_phase_y_plus1");
        }
        /* seq_scaled_ref_layer_left_offset */
        PUT_BITS_SEV(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.i4_seq_scaled_ref_layer_left_offset,
                     return_status, "SPS: seq_scaled_ref_layer_left_offset");

        /* seq_scaled_ref_layer_top_offset */
        PUT_BITS_SEV(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.i4_seq_scaled_ref_layer_top_offset,
                     return_status, "SPS: seq_scaled_ref_layer_top_offset");

        /* seq_scaled_ref_layer_right_offset */
        PUT_BITS_SEV(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.i4_seq_scaled_ref_layer_right_offset,
                     return_status, "SPS: seq_scaled_ref_layer_right_offset");

        /* seq_scaled_ref_layer_bottom_offset */
        PUT_BITS_SEV(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.i4_seq_scaled_ref_layer_bottom_offset,
                     return_status, "SPS: seq_scaled_ref_layer_bottom_offset");
    }

    /* seq_tcoeff_level_prediction_flag */
    PUT_BITS(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.i1_seq_tcoeff_level_prediction_flag, 1,
             return_status, "SPS: seq_tcoeff_level_prediction_flag");

    if(ps_sub_sps->s_sps_svc_ext.i1_seq_tcoeff_level_prediction_flag)
    {
        /* adaptive_tcoeff_level_prediction_flag */
        PUT_BITS(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.i1_adaptive_tcoeff_level_prediction_flag, 1,
                 return_status, "SPS: adaptive_tcoeff_level_prediction_flag");
    }

    /* slice_header_restriction_flag */
    PUT_BITS(ps_bitstrm, ps_sub_sps->s_sps_svc_ext.i1_slice_header_restriction_flag, 1,
             return_status, "SPS: slice_header_restriction_flag");

    return return_status;
}

WORD32 isvce_svc_vui_parameters_extension(bitstrm_t *ps_bitstrm, svc_vui_ext_t *ps_svc_vui)
{
    WORD32 return_status = IH264E_SUCCESS;
    UWORD32 i;

    PUT_BITS_UEV(ps_bitstrm, ps_svc_vui->u4_vui_ext_num_entries_minus1, return_status,
                 "num_layers_minus1");

    for(i = 0; i < ps_svc_vui->u4_vui_ext_num_entries_minus1; i++)
    {
        /* dependency_id */
        PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_dependency_id[i], 3, return_status,
                 "dependency_id");

        /* quality_id */
        PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_quality_id[i], 4, return_status, "quality_id");

        /* temporal_id */
        PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_temporal_id[i], 3, return_status,
                 "temporal_id");

        /* timing_info_present_flag */
        PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_timing_info_present_flag[i], 1, return_status,
                 "timing_info_present_flag");

        if(ps_svc_vui->u1_vui_ext_timing_info_present_flag[i])
        {
            /* num_units_in_tick */
            PUT_BITS(ps_bitstrm, ps_svc_vui->u4_vui_ext_num_units_in_tick[i], 32, return_status,
                     "num_units_in_tick");

            /* time_scale */
            PUT_BITS(ps_bitstrm, ps_svc_vui->u4_vui_ext_time_scale[i], 32, return_status,
                     "time_scale");

            /* fixed_frame_rate_flag */
            PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_fixed_frame_rate_flag[i], 1, return_status,
                     "fixed_frame_rate_flag");
        }

        /* nal_hrd_parameters_present_flag */
        PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_nal_hrd_params_present_flag[i], 1,
                 return_status, "nal_hrd_parameters_present_flag");

        if(ps_svc_vui->u1_vui_ext_nal_hrd_params_present_flag[i])
        {
        }

        /* nal_hrd_parameters_present_flag */
        PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_vcl_hrd_params_present_flag[i], 1,
                 return_status, "vcl_hrd_parameters_present_flag");

        if(ps_svc_vui->u1_vui_ext_vcl_hrd_params_present_flag[i])
        {
        }

        if(ps_svc_vui->u1_vui_ext_nal_hrd_params_present_flag[i] ||
           ps_svc_vui->u1_vui_ext_vcl_hrd_params_present_flag[i])
        {
            /* low_delay_hrd_flag */
            PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_low_delay_hrd_flag[i], 1, return_status,
                     "low_delay_hrd_flag");
        }

        /* pic_struct_present_flag */
        PUT_BITS(ps_bitstrm, ps_svc_vui->u1_vui_ext_pic_struct_present_flag[i], 1, return_status,
                 "pic_struct_present_flag");
    }

    return return_status;
}

WORD32 isvce_generate_subset_sps(bitstrm_t *ps_bitstrm, subset_sps_t *ps_subset_sps)
{
    WORD32 return_status = IH264E_SUCCESS;
    sps_t *ps_sps = &ps_subset_sps->s_sps;
    return_status = isvce_generate_sps(ps_bitstrm, &ps_subset_sps->s_sps, NAL_SUBSET_SPS);

    /* generate subset sps */
    if(ps_sps->u1_profile_idc == IH264_SCALABLE_BASELINE ||
       ps_sps->u1_profile_idc == IH264_SCALABLE_HIGH_PROFILE)
    {
        isvce_seq_parameter_set_svc_extension(ps_bitstrm, ps_subset_sps,
                                              ps_sps->u1_chroma_format_idc);

        /* svc_vui_parameters_present_flag */
        PUT_BITS(ps_bitstrm, ps_subset_sps->i1_svc_vui_parameters_present_flag, 1, return_status,
                 "SPS: svc_vui_parameters_present_flag");

        if(ps_subset_sps->i1_svc_vui_parameters_present_flag == 1)
        {
            svc_vui_ext_t *ps_svc_vui = NULL;
            isvce_svc_vui_parameters_extension(ps_bitstrm, ps_svc_vui);
        }

        /* additional_extension2_flag */
        PUT_BITS(ps_bitstrm, ps_subset_sps->i1_additional_extension2_flag, 1, return_status,
                 "SPS: additional_extension2_flag");
    }

    /* rbsp trailing bits */
    return_status = ih264e_put_rbsp_trailing_bits(ps_bitstrm);

    return return_status;
}
/**
******************************************************************************
*
* @brief Generates svc_nalu_ext
*
* @par   Description
*  Generate svc_nalu_ext as per Section G.7.3.1.1
*
* @param[inout]   ps_bitstrm
*  pointer to bitstream context for generating slice header
*
* @param[in]   ps_svc_nalu_ext
*  pointer to svc_nalu_ext struct
*
* @return    success or failure error code
*
******************************************************************************
*/
WORD32 isvce_generate_svc_nalu_extension(bitstrm_t *ps_bitstrm, svc_nalu_ext_t *ps_svc_nalu_ext,
                                         UWORD8 u1_nalu_id)
{
    WORD32 return_status = IH264E_SUCCESS;

    /* Insert start code */
    return_status = ih264e_put_nal_start_code_prefix(ps_bitstrm, 1);

    if(return_status != IH264E_SUCCESS)
    {
        return return_status;
    }

    /* Insert Nal Unit Header */
    return_status = isvce_generate_nal_unit_header(ps_bitstrm, u1_nalu_id, 3);

    if(return_status != IH264E_SUCCESS)
    {
        return return_status;
    }

    /* reserved_one_bit */
    PUT_BITS(ps_bitstrm, 1, 1, return_status, "NAL unit header: reserved_one_bit");

    /* idr_flag */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_idr_flag, 1, return_status,
             "NAL unit header: idr_flag");

    /* priority_id */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_priority_id, 6, return_status,
             "NAL unit header: priority_id");

    /* no_inter_layer_pred_flag */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_no_inter_layer_pred_flag, 1, return_status,
             "NAL unit header: no_inter_layer_pred_flag");

    /* dependency_id */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_dependency_id, 3, return_status,
             "NAL unit header: dependency_id");

    /* quality_id */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_quality_id, 4, return_status,
             "NAL unit header: quality_id");

    /* temporal_id */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_temporal_id, 3, return_status,
             "NAL unit header: temporal_id");

    /* use_ref_base_pic_flag */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_use_ref_base_pic_flag, 1, return_status,
             "NAL unit header: use_ref_base_pic_flag");

    /* discardable_flag */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_discardable_flag, 1, return_status,
             "NAL unit header: discardable_flag");

    /* output_flag */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_output_flag, 1, return_status,
             "NAL unit header: output_flag");

    /* reserved_three_2bits */
    PUT_BITS(ps_bitstrm, ps_svc_nalu_ext->u1_reserved_three_2bits, 2, return_status,
             "NAL unit header: reserved_three_2bits");

    return return_status;
}

Coverage Report

Created: 2025-07-11 06:39