2128 lines
76 KiB
C
2128 lines
76 KiB
C
/******************************************************************************
|
|
*
|
|
* 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;
|
|
}
|