blob: 06efe5f33808ec846fc0fb6848edaaac37f84869 [file] [log] [blame]
#include "viddec_parser_ops.h"
#include "viddec_pm.h"
#include "h264.h"
#include "h264parse.h"
#include "h264parse.h"
#include "h264parse_dpb.h"
#include <vbp_trace.h>
typedef struct _ParsedSliceHeaderH264Secure
{
unsigned int size;
unsigned char nal_ref_idc;
unsigned char nal_unit_type;
unsigned char slice_type;
unsigned char redundant_pic_cnt;
unsigned short first_mb_in_slice;
char slice_qp_delta;
char slice_qs_delta;
unsigned char luma_log2_weight_denom;
unsigned char chroma_log2_weight_denom;
unsigned char cabac_init_idc;
unsigned char pic_order_cnt_lsb;
unsigned char pic_parameter_set_id;
unsigned short idr_pic_id;
unsigned char colour_plane_id;
char slice_alpha_c0_offset_div2;
char slice_beta_offset_div2;
unsigned char slice_group_change_cycle;
unsigned char disable_deblocking_filter_idc;
unsigned int frame_num;
int delta_pic_order_cnt_bottom;
int delta_pic_order_cnt[2];
unsigned char num_reorder_cmds[2];
unsigned char num_ref_active_minus1[2];
unsigned int weights_present[2][2];
unsigned short num_mem_man_ops;
union {
struct {
unsigned field_pic_flag : 1;
unsigned bottom_field_flag : 1;
unsigned num_ref_idx_active_override_flag : 1;
unsigned direct_spatial_mv_pred_flag : 1;
unsigned no_output_of_prior_pics_flag : 1;
unsigned long_term_reference_flag : 1;
unsigned idr_flag : 1;
unsigned anchor_pic_flag : 1;
unsigned inter_view_flag : 1;
} bits;
unsigned short value;
} flags;
unsigned short view_id;
unsigned char priority_id;
unsigned char temporal_id;
} ParsedSliceHeaderH264Secure;
typedef struct _vbp_h264_sliceheader {
uint32_t sliceHeaderKey;
ParsedSliceHeaderH264Secure parsedSliceHeader;
uint32_t *reorder_cmd;
int16_t *weight;
uint32_t *pic_marking;
} vbp_h264_sliceheader;
/* Init function which can be called to intialized local context on open and flush and preserve*/
void viddec_h264secure_init(void *ctxt, uint32_t *persist_mem, uint32_t preserve)
{
struct h264_viddec_parser* parser = ctxt;
h264_Info * pInfo = &(parser->info);
if (!preserve)
{
/* we don't initialize this data if we want to preserve
sequence and gop information */
h264_init_sps_pps(parser,persist_mem);
}
/* picture level info which will always be initialized */
h264_init_Info_under_sps_pps_level(pInfo);
return;
}
/* ------------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------------ */
uint32_t viddec_h264secure_parse(void *parent, void *ctxt)
{
struct h264_viddec_parser* parser = ctxt;
h264_Info * pInfo = &(parser->info);
h264_Status status = H264_STATUS_ERROR;
uint8_t nal_ref_idc = 0;
///// Parse NAL Unit header
pInfo->img.g_new_frame = 0;
pInfo->push_to_cur = 1;
pInfo->is_current_workload_done =0;
pInfo->nal_unit_type = 0;
h264_Parse_NAL_Unit(parent, pInfo, &nal_ref_idc);
///// Check frame bounday for non-vcl elimitter
h264_check_previous_frame_end(pInfo);
pInfo->has_slice = 0;
//////// Parse valid NAL unit
switch ( pInfo->nal_unit_type )
{
case h264_NAL_UNIT_TYPE_IDR:
if (pInfo->got_start) {
pInfo->img.recovery_point_found |= 1;
}
pInfo->sei_rp_received = 0;
case h264_NAL_UNIT_TYPE_SLICE:
{
pInfo->has_slice = 1;
h264_Slice_Header_t next_SliceHeader;
/// Reset next slice header
h264_memset(&next_SliceHeader, 0x0, sizeof(h264_Slice_Header_t));
next_SliceHeader.nal_ref_idc = nal_ref_idc;
if ((1 == pInfo->primary_pic_type_plus_one) && (pInfo->got_start))
{
pInfo->img.recovery_point_found |= 4;
}
pInfo->primary_pic_type_plus_one = 0;
////////////////////////////////////////////////////////////////////////////
// Step 2: Parsing slice header
////////////////////////////////////////////////////////////////////////////
/// PWT
pInfo->h264_pwt_start_byte_offset = 0;
pInfo->h264_pwt_start_bit_offset = 0;
pInfo->h264_pwt_end_byte_offset = 0;
pInfo->h264_pwt_end_bit_offset = 0;
pInfo->h264_pwt_enabled = 0;
/// IDR flag
next_SliceHeader.idr_flag = (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR);
/// Pass slice header
status = h264_Parse_Slice_Layer_Without_Partitioning_RBSP(parent, pInfo, &next_SliceHeader);
pInfo->sei_information.recovery_point = 0;
if (next_SliceHeader.sh_error & 3)
{
ETRACE("Slice Header parsing error.\n");
break;
}
pInfo->img.current_slice_num++;
////////////////////////////////////////////////////////////////////////////
// Step 3: Processing if new picture coming
// 1) if it's the second field
// 2) if it's a new frame
////////////////////////////////////////////////////////////////////////////
//AssignQuantParam(pInfo);
if (h264_is_new_picture_start(pInfo, next_SliceHeader, pInfo->SliceHeader))
{
//
///----------------- New Picture.boundary detected--------------------
//
pInfo->img.g_new_pic++;
//
// Complete previous picture
h264_dpb_store_previous_picture_in_dpb(pInfo, 0, 0); //curr old
//h264_hdr_post_poc(0, 0, use_old);
//
// Update slice structures:
h264_update_old_slice(pInfo, next_SliceHeader); //cur->old; next->cur;
//
// 1) if resolution change: reset dpb
// 2) else: init frame store
h264_update_img_info(pInfo); //img, dpb
//
///----------------- New frame.boundary detected--------------------
//
pInfo->img.second_field = h264_is_second_field(pInfo);
if (pInfo->img.second_field == 0)
{
pInfo->img.g_new_frame = 1;
h264_dpb_update_queue_dangling_field(pInfo);
//
/// DPB management
/// 1) check the gaps
/// 2) assign fs for non-exist frames
/// 3) fill the gaps
/// 4) store frame into DPB if ...
//
//if(pInfo->SliceHeader.redundant_pic_cnt)
{
h264_dpb_gaps_in_frame_num_mem_management(pInfo);
}
}
//
/// Decoding POC
h264_hdr_decoding_poc (pInfo, 0, 0);
//
/// Init Frame Store for next frame
h264_dpb_init_frame_store (pInfo);
pInfo->img.current_slice_num = 1;
if (pInfo->SliceHeader.first_mb_in_slice != 0)
{
////Come here means we have slice lost at the beginning, since no FMO support
pInfo->SliceHeader.sh_error |= (pInfo->SliceHeader.structure << 17);
}
/// Emit out the New Frame
if (pInfo->img.g_new_frame)
{
h264_parse_emit_start_new_frame(parent, pInfo);
}
h264_parse_emit_current_pic(parent, pInfo);
}
else ///////////////////////////////////////////////////// If Not a picture start
{
//
/// Update slice structures: cur->old; next->cur;
h264_update_old_slice(pInfo, next_SliceHeader);
//
/// 1) if resolution change: reset dpb
/// 2) else: update img info
h264_update_img_info(pInfo);
}
//////////////////////////////////////////////////////////////
// Step 4: DPB reference list init and reordering
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////// Update frame Type--- IDR/I/P/B for frame or field
h264_update_frame_type(pInfo);
h264_dpb_update_ref_lists(pInfo);
/// Emit out the current "good" slice
h264_parse_emit_current_slice(parent, pInfo);
}
break;
///// * Main profile doesn't support Data Partition, skipped.... *////
case h264_NAL_UNIT_TYPE_DPA:
case h264_NAL_UNIT_TYPE_DPB:
case h264_NAL_UNIT_TYPE_DPC:
//OS_INFO("***********************DP feature, not supported currently*******************\n");
status = H264_STATUS_NOTSUPPORT;
break;
//// * Parsing SEI info *////
case h264_NAL_UNIT_TYPE_SEI:
status = H264_STATUS_OK;
//OS_INFO("*****************************SEI**************************************\n");
if (pInfo->sps_valid) {
//h264_user_data_t user_data; /// Replace with tmp buffer while porting to FW
pInfo->number_of_first_au_info_nal_before_first_slice++;
/// parsing the SEI info
status = h264_Parse_Supplemental_Enhancement_Information_Message(parent, pInfo);
}
//h264_rbsp_trailing_bits(pInfo);
break;
case h264_NAL_UNIT_TYPE_SPS:
{
//OS_INFO("*****************************SPS**************************************\n");
///
/// Can not define local SPS since the Current local stack size limitation!
/// Could be changed after the limitation gone
///
VTRACE("h264_NAL_UNIT_TYPE_SPS +++");
uint8_t old_sps_id=0;
vui_seq_parameters_t_not_used vui_seq_not_used;
old_sps_id = pInfo->active_SPS.seq_parameter_set_id;
h264_memset(&(pInfo->active_SPS), 0x0, sizeof(seq_param_set_used));
VTRACE("old_sps_id = %d", old_sps_id);
status = h264_Parse_SeqParameterSet(parent, pInfo, &(pInfo->active_SPS), &vui_seq_not_used, (int32_t *)pInfo->TMP_OFFSET_REFFRM_PADDR_GL);
if (status == H264_STATUS_OK) {
VTRACE("pInfo->active_SPS.seq_parameter_set_id = %d", pInfo->active_SPS.seq_parameter_set_id);
h264_Parse_Copy_Sps_To_DDR(pInfo, &(pInfo->active_SPS), pInfo->active_SPS.seq_parameter_set_id);
pInfo->sps_valid = 1;
if (1==pInfo->active_SPS.pic_order_cnt_type) {
h264_Parse_Copy_Offset_Ref_Frames_To_DDR(pInfo,(int32_t *)pInfo->TMP_OFFSET_REFFRM_PADDR_GL,pInfo->active_SPS.seq_parameter_set_id);
}
}
///// Restore the active SPS if new arrival's id changed
if (old_sps_id>=MAX_NUM_SPS) {
h264_memset(&(pInfo->active_SPS), 0x0, sizeof(seq_param_set_used));
pInfo->active_SPS.seq_parameter_set_id = 0xff;
}
else {
if (old_sps_id!=pInfo->active_SPS.seq_parameter_set_id) {
h264_Parse_Copy_Sps_From_DDR(pInfo, &(pInfo->active_SPS), old_sps_id);
}
else {
//h264_memset(&(pInfo->active_SPS), 0x0, sizeof(seq_param_set));
// h264_Parse_Copy_Sps_From_DDR(pInfo, &(pInfo->active_SPS), old_sps_id);
VTRACE("old_sps_id==pInfo->active_SPS.seq_parameter_set_id");
pInfo->active_SPS.seq_parameter_set_id = 0xff;
}
}
pInfo->number_of_first_au_info_nal_before_first_slice++;
VTRACE("h264_NAL_UNIT_TYPE_SPS ---");
}
break;
case h264_NAL_UNIT_TYPE_PPS:
{
//OS_INFO("*****************************PPS**************************************\n");
VTRACE("h264_NAL_UNIT_TYPE_PPS +++");
uint32_t old_sps_id = pInfo->active_SPS.seq_parameter_set_id;
uint32_t old_pps_id = pInfo->active_PPS.pic_parameter_set_id;
VTRACE("old_sps_id = %d, old_pps_id = %d", old_sps_id, old_pps_id);
h264_memset(&pInfo->active_PPS, 0x0, sizeof(pic_param_set));
pInfo->number_of_first_au_info_nal_before_first_slice++;
if (h264_Parse_PicParameterSet(parent, pInfo, &pInfo->active_PPS)== H264_STATUS_OK)
{
h264_Parse_Copy_Sps_From_DDR(pInfo, &(pInfo->active_SPS), pInfo->active_PPS.seq_parameter_set_id);
VTRACE("pInfo->active_PPS.seq_parameter_set_id = %d", pInfo->active_PPS.seq_parameter_set_id);
VTRACE("pInfo->active_SPS.seq_parameter_set_id = %d", pInfo->active_SPS.seq_parameter_set_id);
if (old_sps_id != pInfo->active_SPS.seq_parameter_set_id)
{
pInfo->Is_SPS_updated = 1;
}
if (pInfo->active_SPS.seq_parameter_set_id != 0xff) {
h264_Parse_Copy_Pps_To_DDR(pInfo, &pInfo->active_PPS, pInfo->active_PPS.pic_parameter_set_id);
pInfo->got_start = 1;
if (pInfo->sei_information.recovery_point)
{
pInfo->img.recovery_point_found |= 2;
//// Enable the RP recovery if no IDR ---Cisco
if ((pInfo->img.recovery_point_found & 1)==0)
pInfo->sei_rp_received = 1;
}
}
else
{
h264_Parse_Copy_Sps_From_DDR(pInfo, &(pInfo->active_SPS), old_sps_id);
}
} else {
if (old_sps_id<MAX_NUM_SPS)
h264_Parse_Copy_Sps_From_DDR(pInfo, &(pInfo->active_SPS), old_sps_id);
if (old_pps_id<MAX_NUM_PPS)
h264_Parse_Copy_Pps_From_DDR(pInfo, &(pInfo->active_PPS), old_pps_id);
}
VTRACE("pInfo->active_PPS.seq_parameter_set_id = %d", pInfo->active_PPS.seq_parameter_set_id);
VTRACE("pInfo->active_SPS.seq_parameter_set_id = %d", pInfo->active_SPS.seq_parameter_set_id);
VTRACE("h264_NAL_UNIT_TYPE_PPS ---");
} //// End of PPS parsing
break;
case h264_NAL_UNIT_TYPE_EOSeq:
case h264_NAL_UNIT_TYPE_EOstream:
h264_init_dpb(&(pInfo->dpb));
pInfo->is_current_workload_done=1;
status = H264_STATUS_OK;
pInfo->number_of_first_au_info_nal_before_first_slice++;
break;
case h264_NAL_UNIT_TYPE_Acc_unit_delimiter:
///// primary_pic_type
{
uint32_t code = 0xff;
int32_t ret = 0;
ret = viddec_pm_get_bits(parent, (uint32_t *)&(code), 3);
if (ret != -1) {
//if(pInfo->got_start && (code == 0))
//{
//pInfo->img.recovery_point_found |= 4;
//}
pInfo->primary_pic_type_plus_one = (uint8_t)(code)+1;
status = H264_STATUS_OK;
}
pInfo->number_of_first_au_info_nal_before_first_slice++;
break;
}
case h264_NAL_UNIT_TYPE_Reserved1:
case h264_NAL_UNIT_TYPE_Reserved2:
case h264_NAL_UNIT_TYPE_Reserved3:
case h264_NAL_UNIT_TYPE_Reserved4:
case h264_NAL_UNIT_TYPE_Reserved5:
status = H264_STATUS_OK;
pInfo->number_of_first_au_info_nal_before_first_slice++;
break;
case h264_NAL_UNIT_TYPE_filler_data:
status = H264_STATUS_OK;
break;
case h264_NAL_UNIT_TYPE_ACP:
break;
case h264_NAL_UNIT_TYPE_SPS_extension:
case h264_NAL_UNIT_TYPE_unspecified:
case h264_NAL_UNIT_TYPE_unspecified2:
status = H264_STATUS_OK;
//nothing
break;
default:
status = H264_STATUS_OK;
break;
}
//pInfo->old_nal_unit_type = pInfo->nal_unit_type;
switch ( pInfo->nal_unit_type )
{
case h264_NAL_UNIT_TYPE_IDR:
case h264_NAL_UNIT_TYPE_SLICE:
case h264_NAL_UNIT_TYPE_Acc_unit_delimiter:
case h264_NAL_UNIT_TYPE_SPS:
case h264_NAL_UNIT_TYPE_PPS:
case h264_NAL_UNIT_TYPE_SEI:
case h264_NAL_UNIT_TYPE_EOSeq:
case h264_NAL_UNIT_TYPE_EOstream:
case h264_NAL_UNIT_TYPE_Reserved1:
case h264_NAL_UNIT_TYPE_Reserved2:
case h264_NAL_UNIT_TYPE_Reserved3:
case h264_NAL_UNIT_TYPE_Reserved4:
case h264_NAL_UNIT_TYPE_Reserved5:
{
pInfo->old_nal_unit_type = pInfo->nal_unit_type;
break;
}
default:
break;
}
return status;
}
/* ------------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------------------------ */
void viddec_h264secure_get_context_size(viddec_parser_memory_sizes_t *size)
{
/* Should return size of my structure */
size->context_size = sizeof(struct h264_viddec_parser);
size->persist_size = MAX_NUM_SPS * sizeof(seq_param_set_all)
+ MAX_NUM_PPS * sizeof(pic_param_set)
+ MAX_NUM_SPS * sizeof(int32_t) * MAX_NUM_REF_FRAMES_IN_PIC_ORDER_CNT_CYCLE
+ sizeof(int32_t) * MAX_NUM_REF_FRAMES_IN_PIC_ORDER_CNT_CYCLE;
}
/*--------------------------------------------------------------------------------------------------*/
//
// The syntax elements reordering_of_pic_nums_idc, abs_diff_pic_num_minus1, and long_term_pic_num
// specify the change from the initial reference picture lists to the reference picture lists to be used
// for decoding the slice
// reordering_of_pic_nums_idc:
// 0: abs_diff_pic_num_minus1 is present and corresponds to a difference to subtract from a picture number prediction value
// 1: abs_diff_pic_num_minus1 is present and corresponds to a difference to add to a picture number prediction value
// 2: long_term_pic_num is present and specifies the long-term picture number for a reference picture
// 3: End loop for reordering of the initial reference picture list
//
/*--------------------------------------------------------------------------------------------------*/
h264_Status h264secure_Parse_Ref_Pic_List_Reordering(h264_Info* pInfo, void *newdata, h264_Slice_Header_t *SliceHeader)
{
//h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
int32_t reorder= -1;
uint32_t code;
vbp_h264_sliceheader* sliceheader_p = (vbp_h264_sliceheader*) newdata;
if ((SliceHeader->slice_type != h264_PtypeI) && (SliceHeader->slice_type != h264_PtypeSI))
{
SliceHeader->sh_refpic_l0.ref_pic_list_reordering_flag = (uint8_t)(sliceheader_p->parsedSliceHeader.num_reorder_cmds[0] > 0);
VTRACE("sliceheader_p->parsedSliceHeader.num_reorder_cmds[0] = %d",
sliceheader_p->parsedSliceHeader.num_reorder_cmds[0]);
if (SliceHeader->sh_refpic_l0.ref_pic_list_reordering_flag)
{
if(sliceheader_p->parsedSliceHeader.num_reorder_cmds[0] > MAX_NUM_REF_FRAMES) {
return H264_SliceHeader_ERROR;
}
for (reorder = 0; reorder < sliceheader_p->parsedSliceHeader.num_reorder_cmds[0]; reorder++) {
code = sliceheader_p->reorder_cmd[reorder];
SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] = code >> 24;
VTRACE("SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[%d] = %d",
reorder,
SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder]
);
if ((SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 0) || (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 1))
{
SliceHeader->sh_refpic_l0.list_reordering_num[reorder].abs_diff_pic_num_minus1 = code & 0xFFFFFF;
VTRACE("abs_diff_pic_num_minus1 = %d", SliceHeader->sh_refpic_l0.list_reordering_num[reorder].abs_diff_pic_num_minus1);
}
else if (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 2)
{
SliceHeader->sh_refpic_l0.list_reordering_num[reorder].long_term_pic_num = code & 0xFFFFFF;
VTRACE("long_term_pic_num = %d", SliceHeader->sh_refpic_l0.list_reordering_num[reorder].long_term_pic_num);
}
if (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 3)
{
VTRACE("break here");
break;
}
}
SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] = 3;
}
}
if (SliceHeader->slice_type == h264_PtypeB)
{
SliceHeader->sh_refpic_l1.ref_pic_list_reordering_flag = (uint8_t)(sliceheader_p->parsedSliceHeader.num_reorder_cmds[1] > 0);
VTRACE("sliceheader_p->parsedSliceHeader.num_reorder_cmds[1] = %d",
sliceheader_p->parsedSliceHeader.num_reorder_cmds[1]);
if (SliceHeader->sh_refpic_l1.ref_pic_list_reordering_flag)
{
if (sliceheader_p->parsedSliceHeader.num_reorder_cmds[1] > MAX_NUM_REF_FRAMES) {
return H264_SliceHeader_ERROR;
}
for (reorder = 0; reorder < sliceheader_p->parsedSliceHeader.num_reorder_cmds[1]; reorder++) {
code = *(sliceheader_p->reorder_cmd + sliceheader_p->parsedSliceHeader.num_reorder_cmds[0] + reorder);
SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] = code >> 24;
if ((SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 0) || (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 1))
{
SliceHeader->sh_refpic_l1.list_reordering_num[reorder].abs_diff_pic_num_minus1 = code & 0xFFFFFF;
}
else if (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 2)
{
SliceHeader->sh_refpic_l1.list_reordering_num[reorder].long_term_pic_num = code & 0xFFFFFF;
}
if (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 3)
{
break;
}
}
SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] = 3;
}
}
return H264_STATUS_OK;
}
h264_Status h264secure_Parse_Pred_Weight_Table(h264_Info* pInfo, void *newdata, h264_Slice_Header_t *SliceHeader)
{
uint32_t i =0, j=0;
uint8_t flag;
uint32_t weightidx = 0;
vbp_h264_sliceheader* sliceheader_p = (vbp_h264_sliceheader*) newdata;
SliceHeader->sh_predwttbl.luma_log2_weight_denom = sliceheader_p->parsedSliceHeader.luma_log2_weight_denom;
if (pInfo->active_SPS.sps_disp.chroma_format_idc != 0)
{
SliceHeader->sh_predwttbl.chroma_log2_weight_denom = sliceheader_p->parsedSliceHeader.chroma_log2_weight_denom;
}
for (i=0; i< SliceHeader->num_ref_idx_l0_active; i++)
{
flag = ((sliceheader_p->parsedSliceHeader.weights_present[0][0] >> i) & 0x01);
SliceHeader->sh_predwttbl.luma_weight_l0_flag = flag;
if (SliceHeader->sh_predwttbl.luma_weight_l0_flag)
{
SliceHeader->sh_predwttbl.luma_weight_l0[i] = sliceheader_p->weight[weightidx++];
SliceHeader->sh_predwttbl.luma_offset_l0[i] = sliceheader_p->weight[weightidx++];
}
else
{
SliceHeader->sh_predwttbl.luma_weight_l0[i] = (1 << SliceHeader->sh_predwttbl.luma_log2_weight_denom);
SliceHeader->sh_predwttbl.luma_offset_l0[i] = 0;
}
if (pInfo->active_SPS.sps_disp.chroma_format_idc != 0)
{
flag = ((sliceheader_p->parsedSliceHeader.weights_present[0][1] >> i) & 0x01);
SliceHeader->sh_predwttbl.chroma_weight_l0_flag = flag;
if (SliceHeader->sh_predwttbl.chroma_weight_l0_flag)
{
for (j=0; j <2; j++)
{
SliceHeader->sh_predwttbl.chroma_weight_l0[i][j] = sliceheader_p->weight[weightidx++];
SliceHeader->sh_predwttbl.chroma_offset_l0[i][j] = sliceheader_p->weight[weightidx++];
}
}
else
{
for (j=0; j <2; j++)
{
SliceHeader->sh_predwttbl.chroma_weight_l0[i][j] = (1 << SliceHeader->sh_predwttbl.chroma_log2_weight_denom);
SliceHeader->sh_predwttbl.chroma_offset_l0[i][j] = 0;
}
}
}
}
if (SliceHeader->slice_type == h264_PtypeB)
{
for (i=0; i< SliceHeader->num_ref_idx_l1_active; i++)
{
flag = ((sliceheader_p->parsedSliceHeader.weights_present[1][0] >> i) & 0x01);
SliceHeader->sh_predwttbl.luma_weight_l1_flag = flag;
if (SliceHeader->sh_predwttbl.luma_weight_l1_flag)
{
SliceHeader->sh_predwttbl.luma_weight_l1[i] = sliceheader_p->weight[weightidx++];
SliceHeader->sh_predwttbl.luma_offset_l1[i] = sliceheader_p->weight[weightidx++];
}
else
{
SliceHeader->sh_predwttbl.luma_weight_l1[i] = (1 << SliceHeader->sh_predwttbl.luma_log2_weight_denom);
SliceHeader->sh_predwttbl.luma_offset_l1[i] = 0;
}
if (pInfo->active_SPS.sps_disp.chroma_format_idc != 0)
{
flag = ((sliceheader_p->parsedSliceHeader.weights_present[1][1] >> i) & 0x01);
SliceHeader->sh_predwttbl.chroma_weight_l1_flag = flag;
if (SliceHeader->sh_predwttbl.chroma_weight_l1_flag)
{
for (j=0; j <2; j++)
{
SliceHeader->sh_predwttbl.chroma_weight_l1[i][j] = sliceheader_p->weight[weightidx++];
SliceHeader->sh_predwttbl.chroma_offset_l1[i][j] = sliceheader_p->weight[weightidx++];
}
}
else
{
for (j=0; j <2; j++)
{
SliceHeader->sh_predwttbl.chroma_weight_l1[i][j] = (1 << SliceHeader->sh_predwttbl.chroma_log2_weight_denom);
SliceHeader->sh_predwttbl.chroma_offset_l1[i][j] = 0;
}
}
}
}
}
return H264_STATUS_OK;
} ///// End of h264_Parse_Pred_Weight_Table
h264_Status h264secure_Parse_Dec_Ref_Pic_Marking(h264_Info* pInfo, void *newdata,h264_Slice_Header_t *SliceHeader)
{
vbp_h264_sliceheader* sliceheader_p = (vbp_h264_sliceheader*) newdata;
uint8_t i = 0;
uint32_t idx = 0;
uint32_t code;
if (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
{
SliceHeader->sh_dec_refpic.no_output_of_prior_pics_flag = (uint8_t)sliceheader_p->parsedSliceHeader.flags.bits.no_output_of_prior_pics_flag;
SliceHeader->sh_dec_refpic.long_term_reference_flag = (uint8_t)sliceheader_p->parsedSliceHeader.flags.bits.long_term_reference_flag;
pInfo->img.long_term_reference_flag = SliceHeader->sh_dec_refpic.long_term_reference_flag;
}
else
{
SliceHeader->sh_dec_refpic.adaptive_ref_pic_marking_mode_flag = (uint8_t)(sliceheader_p->parsedSliceHeader.num_mem_man_ops > 0);
VTRACE("SliceHeader->sh_dec_refpic.adaptive_ref_pic_marking_mode_flag = %d", SliceHeader->sh_dec_refpic.adaptive_ref_pic_marking_mode_flag);
///////////////////////////////////////////////////////////////////////////////////////
//adaptive_ref_pic_marking_mode_flag Reference picture marking mode specified
// Sliding window reference picture marking mode: A marking mode
// providing a first-in first-out mechanism for short-term reference pictures.
// Adaptive reference picture marking mode: A reference picture
// marking mode providing syntax elements to specify marking of
// reference pictures as unused for reference?and to assign long-term
// frame indices.
///////////////////////////////////////////////////////////////////////////////////////
if (SliceHeader->sh_dec_refpic.adaptive_ref_pic_marking_mode_flag)
{
do
{
if (i < NUM_MMCO_OPERATIONS)
{
code = sliceheader_p->pic_marking[idx++];
SliceHeader->sh_dec_refpic.memory_management_control_operation[i] = (uint8_t)(code >> 24);
if ((SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 1) || (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 3))
{
SliceHeader->sh_dec_refpic.difference_of_pic_num_minus1[i] = code & 0xFFFFFF;
}
if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 2)
{
SliceHeader->sh_dec_refpic.long_term_pic_num[i] = code & 0xFFFFFF;
}
if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 6)
{
SliceHeader->sh_dec_refpic.long_term_frame_idx[i] = code & 0xFFFFFF;
}
if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 3) {
SliceHeader->sh_dec_refpic.long_term_frame_idx[i] = sliceheader_p->pic_marking[idx++];
}
if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 4)
{
SliceHeader->sh_dec_refpic.max_long_term_frame_idx_plus1[i] = code & 0xFFFFFF;
}
if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 5)
{
pInfo->img.curr_has_mmco_5 = 1;
}
}
if (i >= NUM_MMCO_OPERATIONS) {
return H264_STATUS_ERROR;
}
} while (SliceHeader->sh_dec_refpic.memory_management_control_operation[i++] != 0);
}
}
SliceHeader->sh_dec_refpic.dec_ref_pic_marking_count = i;
return H264_STATUS_OK;
}
uint32_t h264secure_Update_Slice_Header(h264_Info* pInfo, void *newdata, h264_Slice_Header_t *SliceHeader)
{
h264_Status retStatus = H264_STATUS_OK;
uint8_t data;
vbp_h264_sliceheader* sliceheader_p = (vbp_h264_sliceheader*) newdata;
///// first_mb_in_slice
SliceHeader->first_mb_in_slice = sliceheader_p->parsedSliceHeader.first_mb_in_slice;
///// slice_type
data = sliceheader_p->parsedSliceHeader.slice_type;
SliceHeader->slice_type = (data%5);
if (SliceHeader->slice_type > h264_PtypeI) {
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
SliceHeader->pic_parameter_id = (uint8_t)sliceheader_p->parsedSliceHeader.pic_parameter_set_id;
retStatus = h264_active_par_set(pInfo, SliceHeader);
switch (pInfo->active_SPS.profile_idc)
{
case h264_ProfileBaseline:
case h264_ProfileMain:
case h264_ProfileExtended:
pInfo->active_PPS.transform_8x8_mode_flag=0;
pInfo->active_PPS.pic_scaling_matrix_present_flag =0;
pInfo->active_PPS.second_chroma_qp_index_offset = pInfo->active_PPS.chroma_qp_index_offset;
default:
break;
}
uint32_t code;
int32_t max_mb_num=0;
SliceHeader->frame_num = (int32_t)sliceheader_p->parsedSliceHeader.frame_num;
/// Picture structure
SliceHeader->structure = FRAME;
SliceHeader->field_pic_flag = 0;
SliceHeader->bottom_field_flag = 0;
if (!(pInfo->active_SPS.sps_disp.frame_mbs_only_flag))
{
/// field_pic_flag
SliceHeader->field_pic_flag = (uint8_t)sliceheader_p->parsedSliceHeader.flags.bits.field_pic_flag;
if (SliceHeader->field_pic_flag)
{
SliceHeader->bottom_field_flag = (uint8_t)sliceheader_p->parsedSliceHeader.flags.bits.bottom_field_flag;
SliceHeader->structure = SliceHeader->bottom_field_flag? BOTTOM_FIELD: TOP_FIELD;
}
}
////// Check valid or not of first_mb_in_slice
if (SliceHeader->structure == FRAME) {
max_mb_num = pInfo->img.FrameHeightInMbs * pInfo->img.PicWidthInMbs;
} else {
max_mb_num = pInfo->img.FrameHeightInMbs * pInfo->img.PicWidthInMbs/2;
}
if (pInfo->active_SPS.sps_disp.mb_adaptive_frame_field_flag & (!(pInfo->SliceHeader.field_pic_flag))) {
SliceHeader->first_mb_in_slice <<=1;
}
if (SliceHeader->first_mb_in_slice >= max_mb_num) {
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
if (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
{
SliceHeader->idr_pic_id = sliceheader_p->parsedSliceHeader.idr_pic_id;
}
if (pInfo->active_SPS.pic_order_cnt_type == 0)
{
SliceHeader->pic_order_cnt_lsb = (uint32_t)sliceheader_p->parsedSliceHeader.pic_order_cnt_lsb;
if ((pInfo->active_PPS.pic_order_present_flag) && !(SliceHeader->field_pic_flag))
{
SliceHeader->delta_pic_order_cnt_bottom = sliceheader_p->parsedSliceHeader.delta_pic_order_cnt_bottom;
}
else
{
SliceHeader->delta_pic_order_cnt_bottom = 0;
}
}
if ((pInfo->active_SPS.pic_order_cnt_type == 1) && !(pInfo->active_SPS.delta_pic_order_always_zero_flag))
{
SliceHeader->delta_pic_order_cnt[0] = sliceheader_p->parsedSliceHeader.delta_pic_order_cnt[0];
if ((pInfo->active_PPS.pic_order_present_flag) && !(SliceHeader->field_pic_flag))
{
SliceHeader->delta_pic_order_cnt[1] = sliceheader_p->parsedSliceHeader.delta_pic_order_cnt[1];
}
}
if (pInfo->active_PPS.redundant_pic_cnt_present_flag)
{
SliceHeader->redundant_pic_cnt = sliceheader_p->parsedSliceHeader.redundant_pic_cnt;
if (SliceHeader->redundant_pic_cnt > 127) {
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
} else {
SliceHeader->redundant_pic_cnt = 0;
}
int32_t slice_alpha_c0_offset, slice_beta_offset;
uint32_t bits_offset =0, byte_offset =0;
uint8_t is_emul =0;
/// direct_spatial_mv_pred_flag
if (SliceHeader->slice_type == h264_PtypeB)
{
SliceHeader->direct_spatial_mv_pred_flag = (uint8_t)sliceheader_p->parsedSliceHeader.flags.bits.direct_spatial_mv_pred_flag;
}
else
{
SliceHeader->direct_spatial_mv_pred_flag = 0;
}
//
// Reset ref_idx and Overide it if exist
//
SliceHeader->num_ref_idx_l0_active = pInfo->active_PPS.num_ref_idx_l0_active;
SliceHeader->num_ref_idx_l1_active = pInfo->active_PPS.num_ref_idx_l1_active;
if ((SliceHeader->slice_type == h264_PtypeP) || (SliceHeader->slice_type == h264_PtypeSP) || (SliceHeader->slice_type == h264_PtypeB))
{
SliceHeader->num_ref_idx_active_override_flag = (uint8_t)sliceheader_p->parsedSliceHeader.flags.bits.num_ref_idx_active_override_flag;
if (SliceHeader->num_ref_idx_active_override_flag)
{
SliceHeader->num_ref_idx_l0_active = sliceheader_p->parsedSliceHeader.num_ref_active_minus1[0]+ 1;
if (SliceHeader->slice_type == h264_PtypeB)
{
SliceHeader->num_ref_idx_l1_active = sliceheader_p->parsedSliceHeader.num_ref_active_minus1[1]+1;
}
}
}
if (SliceHeader->slice_type != h264_PtypeB) {
SliceHeader->num_ref_idx_l1_active = 0;
}
if ((SliceHeader->num_ref_idx_l0_active > MAX_NUM_REF_FRAMES) || (SliceHeader->num_ref_idx_l1_active > MAX_NUM_REF_FRAMES))
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
if (h264secure_Parse_Ref_Pic_List_Reordering(pInfo,newdata,SliceHeader) != H264_STATUS_OK)
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
////
//// Parse Pred_weight_table but not store it becasue it will be reparsed in HW
////
if (((pInfo->active_PPS.weighted_pred_flag) && ((SliceHeader->slice_type == h264_PtypeP) || (SliceHeader->slice_type == h264_PtypeSP))) || ((pInfo->active_PPS.weighted_bipred_idc == 1) && (SliceHeader->slice_type == h264_PtypeB)))
{
if (h264secure_Parse_Pred_Weight_Table(pInfo,newdata, SliceHeader) != H264_STATUS_OK)
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
}
////
//// Parse Ref_pic marking if there
////
if (SliceHeader->nal_ref_idc != 0)
{
if (h264secure_Parse_Dec_Ref_Pic_Marking(pInfo, newdata, SliceHeader) != H264_STATUS_OK)
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
}
if ((pInfo->active_PPS.entropy_coding_mode_flag) && (SliceHeader->slice_type != h264_PtypeI) && (SliceHeader->slice_type != h264_PtypeSI))
{
SliceHeader->cabac_init_idc = sliceheader_p->parsedSliceHeader.cabac_init_idc;
}
else
{
SliceHeader->cabac_init_idc = 0;
}
if (SliceHeader->cabac_init_idc > 2)
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
SliceHeader->slice_qp_delta = sliceheader_p->parsedSliceHeader.slice_qp_delta;
if ( (SliceHeader->slice_qp_delta > (25-pInfo->active_PPS.pic_init_qp_minus26)) || (SliceHeader->slice_qp_delta < -(26+pInfo->active_PPS.pic_init_qp_minus26)))
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
if ((SliceHeader->slice_type == h264_PtypeSP)|| (SliceHeader->slice_type == h264_PtypeSI) )
{
if (SliceHeader->slice_type == h264_PtypeSP)
{
SliceHeader->sp_for_switch_flag = 0;
}
SliceHeader->slice_qs_delta = sliceheader_p->parsedSliceHeader.slice_qs_delta;
if ( (SliceHeader->slice_qs_delta > (25-pInfo->active_PPS.pic_init_qs_minus26)) || (SliceHeader->slice_qs_delta < -(26+pInfo->active_PPS.pic_init_qs_minus26)) )
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
}
if (pInfo->active_PPS.deblocking_filter_control_present_flag)
{
SliceHeader->disable_deblocking_filter_idc = sliceheader_p->parsedSliceHeader.disable_deblocking_filter_idc;
if (SliceHeader->disable_deblocking_filter_idc != 1)
{
SliceHeader->slice_alpha_c0_offset_div2 = sliceheader_p->parsedSliceHeader.slice_alpha_c0_offset_div2;
slice_alpha_c0_offset = SliceHeader->slice_alpha_c0_offset_div2 << 1;
if (slice_alpha_c0_offset < -12 || slice_alpha_c0_offset > 12)
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
SliceHeader->slice_beta_offset_div2 = sliceheader_p->parsedSliceHeader.slice_beta_offset_div2;
slice_beta_offset = SliceHeader->slice_beta_offset_div2 << 1;
if (slice_beta_offset < -12 || slice_beta_offset > 12)
{
retStatus = H264_STATUS_NOTSUPPORT;
return retStatus;
}
}
else
{
SliceHeader->slice_alpha_c0_offset_div2 = 0;
SliceHeader->slice_beta_offset_div2 = 0;
}
}
retStatus = H264_STATUS_OK;
return retStatus;
}
uint32_t viddec_h264secure_update(void *parent, void *data, uint32_t size)
{
viddec_pm_cxt_t * parser_cxt = (viddec_pm_cxt_t *)parent;
struct h264_viddec_parser* parser = (struct h264_viddec_parser*) &parser_cxt->codec_data[0];
h264_Info * pInfo = &(parser->info);
h264_Status status = H264_STATUS_ERROR;
vbp_h264_sliceheader* sliceheader_p = (vbp_h264_sliceheader*) data;
pInfo->img.g_new_frame = 0;
pInfo->push_to_cur = 1;
pInfo->is_current_workload_done =0;
pInfo->nal_unit_type = 0;
pInfo->nal_unit_type = sliceheader_p->parsedSliceHeader.nal_unit_type;
h264_Slice_Header_t next_SliceHeader;
/// Reset next slice header
h264_memset(&next_SliceHeader, 0x0, sizeof(h264_Slice_Header_t));
next_SliceHeader.nal_ref_idc = sliceheader_p->parsedSliceHeader.nal_ref_idc;
if ( (1==pInfo->primary_pic_type_plus_one)&&(pInfo->got_start))
{
pInfo->img.recovery_point_found |=4;
}
pInfo->primary_pic_type_plus_one = 0;
////////////////////////////////////////////////////////////////////////////
// Step 2: Parsing slice header
////////////////////////////////////////////////////////////////////////////
/// PWT
pInfo->h264_pwt_start_byte_offset=0;
pInfo->h264_pwt_start_bit_offset=0;
pInfo->h264_pwt_end_byte_offset=0;
pInfo->h264_pwt_end_bit_offset=0;
pInfo->h264_pwt_enabled =0;
/// IDR flag
next_SliceHeader.idr_flag = (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR);
/// Pass slice header
status = h264secure_Update_Slice_Header(pInfo, sliceheader_p, &next_SliceHeader);
pInfo->sei_information.recovery_point = 0;
pInfo->img.current_slice_num++;
////////////////////////////////////////////////////////////////////////////
// Step 3: Processing if new picture coming
// 1) if it's the second field
// 2) if it's a new frame
////////////////////////////////////////////////////////////////////////////
//AssignQuantParam(pInfo);
if (h264_is_new_picture_start(pInfo, next_SliceHeader, pInfo->SliceHeader))
{
//
///----------------- New Picture.boundary detected--------------------
//
pInfo->img.g_new_pic++;
//
// Complete previous picture
h264_dpb_store_previous_picture_in_dpb(pInfo, 0, 0); //curr old
//
// Update slice structures:
h264_update_old_slice(pInfo, next_SliceHeader); //cur->old; next->cur;
//
// 1) if resolution change: reset dpb
// 2) else: init frame store
h264_update_img_info(pInfo); //img, dpb
//
///----------------- New frame.boundary detected--------------------
//
pInfo->img.second_field = h264_is_second_field(pInfo);
if (pInfo->img.second_field == 0)
{
pInfo->img.g_new_frame = 1;
h264_dpb_update_queue_dangling_field(pInfo);
h264_dpb_gaps_in_frame_num_mem_management(pInfo);
}
/// Decoding POC
h264_hdr_decoding_poc (pInfo, 0, 0);
//
/// Init Frame Store for next frame
h264_dpb_init_frame_store (pInfo);
pInfo->img.current_slice_num = 1;
if (pInfo->SliceHeader.first_mb_in_slice != 0)
{
////Come here means we have slice lost at the beginning, since no FMO support
pInfo->SliceHeader.sh_error |= (pInfo->SliceHeader.structure << 17);
}
}
else ///////////////////////////////////////////////////// If Not a picture start
{
/// Update slice structures: cur->old; next->cur;
h264_update_old_slice(pInfo, next_SliceHeader);
/// 1) if resolution change: reset dpb
/// 2) else: update img info
h264_update_img_info(pInfo);
}
//////////////////////////////////////////////////////////////
// Step 4: DPB reference list init and reordering
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////// Update frame Type--- IDR/I/P/B for frame or field
h264_update_frame_type(pInfo);
h264_dpb_update_ref_lists( pInfo);
return status;
}