| /****************************************************************************** |
| * |
| * 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 |
| * isvcd_process_bslice.c |
| * |
| * @brief |
| * Contains routines that decode B slice type |
| * |
| * @author |
| * Kishore |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| #include <string.h> |
| #include "ih264_typedefs.h" |
| #include "ih264_macros.h" |
| #include "ih264_platform_macros.h" |
| #include "isvcd_structs.h" |
| #include "ih264d_bitstrm.h" |
| #include "ih264d_parse_cavlc.h" |
| #include "ih264d_mb_utils.h" |
| #include "ih264d_mvpred.h" |
| #include "ih264d_inter_pred.h" |
| #include "ih264d_process_pslice.h" |
| #include "ih264d_error_handler.h" |
| #include "ih264d_tables.h" |
| #include "ih264d_parse_slice.h" |
| #include "ih264d_process_pslice.h" |
| #include "ih264d_process_bslice.h" |
| #include "ih264d_tables.h" |
| #include "ih264d_parse_islice.h" |
| #include "ih264d_mvpred.h" |
| |
| /*! |
| ************************************************************************** |
| * \if Function name : isvcd_one_to_one \endif |
| * |
| * \brief |
| * Initializes forward and backward refernce lists for B slice decoding. |
| * |
| * |
| * \return |
| * 0 on Success and Error code otherwise |
| ************************************************************************** |
| */ |
| void isvcd_one_to_one(svc_dec_lyr_struct_t *ps_svc_lyr_dec, struct pic_buffer_t *ps_col_pic, |
| directmv_t *ps_direct, UWORD8 u1_wd_x, WORD32 u2_sub_mb_ofst, |
| dec_mb_info_t *ps_cur_mb_info) |
| { |
| dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec; |
| UWORD8 *pu1_col_zero_flag_start, u1_col_mb_pred_mode, u1_num_blks, u1_sub_mb_num; |
| UWORD8 u1_init_colzero_flag; |
| UNUSED(ps_cur_mb_info); |
| pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst; |
| u1_col_mb_pred_mode = pu1_col_zero_flag_start[ps_dec->u1_sub_mb_num]; |
| u1_init_colzero_flag = u1_col_mb_pred_mode & 1; |
| u1_col_mb_pred_mode >>= 6; |
| ps_direct->u1_vert_mv_scale = ONE_TO_ONE; |
| ps_direct->u1_col_zeroflag_change = (ps_svc_lyr_dec->u1_base_res_flag) ? 0 : 1; |
| |
| if(u1_wd_x == MB_SIZE) |
| { |
| ps_dec->u1_currB_type = (!!u1_col_mb_pred_mode); |
| if(u1_col_mb_pred_mode == PRED_16x16) |
| { |
| ps_direct->i1_num_partitions = 1; |
| ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst; |
| ps_direct->i1_submb_num[0] = 0; |
| ps_direct->i1_partitionsize[0] = PRED_16x16; |
| |
| return; |
| } |
| else if(u1_col_mb_pred_mode < PRED_8x8) |
| { |
| ps_direct->i1_num_partitions = 2; |
| ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst; |
| ps_direct->i1_submb_num[0] = 0; |
| ps_direct->i1_partitionsize[0] = u1_col_mb_pred_mode; |
| u1_sub_mb_num = (u1_col_mb_pred_mode == PRED_16x8) ? 8 : 2; |
| ps_direct->i1_submb_num[1] = u1_sub_mb_num; |
| ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst + ps_direct->i1_submb_num[1]; |
| ps_direct->i1_partitionsize[1] = u1_col_mb_pred_mode; |
| if((pu1_col_zero_flag_start[u1_sub_mb_num] & 1) != u1_init_colzero_flag) |
| ps_direct->u1_col_zeroflag_change = 1; |
| return; |
| } |
| else |
| { |
| u1_num_blks = 4; |
| } |
| } |
| else |
| { |
| u1_num_blks = 1; |
| } |
| |
| { |
| const UWORD8 *pu1_top_lt_mb_part_idx; |
| UWORD8 u1_col_sub_mb_pred_mode, uc_blk, u1_sub_blk, u1_submb_col = 0; |
| UWORD8 u1_num_sub_blks, uc_direct8x8inf, *pu1_col_zero_flag, u1_sub_mb_num; |
| const UWORD8 *pu1_num_sub_mb_part = (const UWORD8 *) gau1_ih264d_num_submb_part; |
| UWORD8 i1_num_partitions = 0, partition_size; |
| WORD32 mv_index; |
| const UWORD8 *pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct; |
| |
| u1_sub_mb_num = ps_dec->u1_sub_mb_num; |
| uc_direct8x8inf = ps_dec->ps_cur_slice->u1_direct_8x8_inference_flag; |
| pu1_top_lt_mb_part_idx = gau1_ih264d_top_left_mb_part_indx_mod + (PRED_8x8 << 1) + 1; |
| |
| for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++) |
| { |
| partition_size = PRED_8x8; |
| pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct; |
| if(uc_direct8x8inf == 1) |
| { |
| u1_submb_col = u1_sub_mb_num | (u1_sub_mb_num >> 1); |
| mv_index = u2_sub_mb_ofst + u1_submb_col; |
| u1_num_sub_blks = 1; |
| } |
| else |
| { |
| /* colMbPart is either 8x8, 8x4, 4x8, 4x4 */ |
| pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num; |
| u1_col_sub_mb_pred_mode = *pu1_col_zero_flag; |
| u1_col_sub_mb_pred_mode = (u1_col_sub_mb_pred_mode & 0x30) >> 4; |
| partition_size = (UWORD8) ((u1_col_sub_mb_pred_mode) | (PRED_8x8 << 2)); |
| mv_index = u2_sub_mb_ofst + u1_sub_mb_num; |
| pu1_top_lt_sub_mb_idx += (u1_col_sub_mb_pred_mode << 1); |
| u1_num_sub_blks = pu1_num_sub_mb_part[u1_col_sub_mb_pred_mode]; |
| } |
| |
| for(u1_sub_blk = 0; u1_sub_blk < u1_num_sub_blks; u1_sub_blk++, pu1_top_lt_sub_mb_idx++) |
| { |
| u1_sub_mb_num += *pu1_top_lt_sub_mb_idx; |
| mv_index += *pu1_top_lt_sub_mb_idx; |
| ps_direct->i4_mv_indices[i1_num_partitions] = mv_index; |
| ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num; |
| ps_direct->i1_partitionsize[i1_num_partitions] = partition_size; |
| i1_num_partitions++; |
| if(!uc_direct8x8inf) u1_submb_col = u1_sub_mb_num; |
| if((pu1_col_zero_flag_start[u1_submb_col] & 1) != u1_init_colzero_flag) |
| ps_direct->u1_col_zeroflag_change = 1; |
| } |
| u1_sub_mb_num = *pu1_top_lt_mb_part_idx++; |
| } |
| ps_direct->i1_num_partitions = i1_num_partitions; |
| } |
| } |
| |
| /*! |
| ************************************************************************** |
| * \if Function name : isvcd_decode_spatial_direct \endif |
| * |
| * \brief |
| * Decodes spatial direct mode. |
| * |
| * \return |
| * None. |
| * Vijay |
| ************************************************************************** |
| */ |
| WORD32 isvcd_decode_spatial_direct(dec_struct_t *ps_dec, UWORD8 u1_wd_x, |
| dec_mb_info_t *ps_cur_mb_info, UWORD8 u1_mb_num) |
| { |
| svc_dec_lyr_struct_t *ps_svc_lyr_dec = (svc_dec_lyr_struct_t *) ps_dec; |
| mv_pred_t s_mv_pred = {0}; |
| mv_pred_t *ps_mv; |
| UWORD8 u1_col_zero_flag, u1_sub_mb_num, u1_direct_zero_pred_flag = 0; |
| UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; |
| mv_pred_t *ps_mv_ntop_start; |
| mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_mb_num << 4); |
| UWORD8 partition_size, sub_partition, u1_mb_partw, u1_mb_parth; |
| UWORD8 i; |
| WORD8 i1_pred, i1_ref_frame0, i1_ref_frame1; |
| struct pic_buffer_t *ps_ref_frame = NULL, *ps_col_pic, *ps_pic_buff0 = NULL, |
| *ps_pic_buff1 = NULL; |
| |
| UWORD8 u1_zero_pred_cond_f, u1_zero_pred_cond_b; |
| WORD16 i2_spat_pred_mv[4] = {0}; |
| WORD16 *pi2_final_mv0, *pi2_final_mv1; |
| UWORD16 ui2_mask_fwd = 0, ui2_mask_bwd = 0; |
| UWORD32 *pui32_weight_ofsts = NULL; |
| directmv_t s_mvdirect = {0}; |
| UWORD8 u1_colz; |
| UWORD8 u1_final_ref_idx = 0; |
| const UWORD8 *pu1_mb_parth = (const UWORD8 *) gau1_ih264d_mb_parth; |
| const UWORD8 *pu1_mb_partw = (const UWORD8 *) gau1_ih264d_mb_partw; |
| |
| mv_pred_t s_temp_mv_pred = {0}; |
| ps_mv_ntop_start = |
| ps_dec->ps_mv_cur + (u1_mb_num << 4) - (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12; |
| |
| u1_direct_zero_pred_flag = |
| ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, (ps_mv_nmb_start + ps_dec->u1_sub_mb_num), |
| ps_mv_ntop_start + (ps_dec->u1_sub_mb_num & 0x03), &s_mv_pred, |
| ps_dec->u1_sub_mb_num, (u1_wd_x >> 2), 0, 1, B_DIRECT_SPATIAL); |
| |
| i2_spat_pred_mv[0] = s_mv_pred.i2_mv[0]; |
| i2_spat_pred_mv[1] = s_mv_pred.i2_mv[1]; |
| i2_spat_pred_mv[2] = s_mv_pred.i2_mv[2]; |
| i2_spat_pred_mv[3] = s_mv_pred.i2_mv[3]; |
| |
| i1_ref_frame0 = s_mv_pred.i1_ref_frame[0]; |
| i1_ref_frame1 = s_mv_pred.i1_ref_frame[1]; |
| |
| i1_ref_frame0 = (i1_ref_frame0 < 0) ? -1 : i1_ref_frame0; |
| i1_ref_frame1 = (i1_ref_frame1 < 0) ? -1 : i1_ref_frame1; |
| |
| i1_pred = 0; |
| |
| { |
| WORD8 u1_ref_idx, u1_ref_idx1; |
| UWORD32 uc_Idx, uc_Idx1; |
| UWORD8 u1_scale_ref = |
| (ps_dec->ps_cur_slice->u1_mbaff_frame_flag && ps_cur_mb_info->u1_mb_field_decodingflag); |
| u1_final_ref_idx = i1_ref_frame0; |
| if(i1_ref_frame0 >= 0) |
| { |
| /* convert RefIdx if it is MbAff */ |
| u1_ref_idx = i1_ref_frame0; |
| u1_ref_idx1 = i1_ref_frame0; |
| if(u1_scale_ref) |
| { |
| u1_ref_idx1 = u1_ref_idx >> 1; |
| if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb)) |
| u1_ref_idx1 += MAX_REF_BUFS; |
| } |
| /* If i1_ref_frame0 < 0 then refIdxCol is obtained from ps_pic_buff1 */ |
| ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][u1_ref_idx1]; |
| ps_ref_frame = ps_pic_buff0; |
| i1_pred = PRED_L0; |
| } |
| |
| if(i1_ref_frame1 >= 0) |
| { |
| /* convert RefIdx if it is MbAff */ |
| u1_ref_idx = i1_ref_frame1; |
| u1_ref_idx1 = i1_ref_frame1; |
| if(u1_scale_ref) |
| { |
| u1_ref_idx1 = u1_ref_idx >> 1; |
| if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb)) |
| u1_ref_idx1 += MAX_REF_BUFS; |
| } |
| ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][u1_ref_idx1]; |
| i1_pred = i1_pred | PRED_L1; |
| } |
| if(i1_ref_frame0 < 0) |
| { |
| ps_ref_frame = ps_pic_buff1; |
| u1_final_ref_idx = i1_ref_frame1; |
| } |
| |
| u1_zero_pred_cond_f = (u1_direct_zero_pred_flag) || (i1_ref_frame0 < 0); |
| u1_zero_pred_cond_b = (u1_direct_zero_pred_flag) || (i1_ref_frame1 < 0); |
| |
| if(ps_dec->ps_cur_pps->u1_wted_bipred_idc) |
| { |
| uc_Idx = ((i1_ref_frame0 < 1) ? 0 : i1_ref_frame0) * |
| ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]; |
| if(u1_scale_ref) uc_Idx >>= 1; |
| uc_Idx1 = (i1_ref_frame1 < 0) ? 0 : i1_ref_frame1; |
| uc_Idx += (u1_scale_ref) ? (uc_Idx1 >> 1) : uc_Idx1; |
| pui32_weight_ofsts = (UWORD32 *) &ps_dec->pu4_wt_ofsts[2 * X3(uc_Idx)]; |
| |
| if(i1_ref_frame0 < 0) pui32_weight_ofsts += 1; |
| |
| if(u1_scale_ref && (ps_dec->ps_cur_pps->u1_wted_bipred_idc == 2)) |
| { |
| WORD16 i2_ref_idx; |
| i2_ref_idx = MAX(i1_ref_frame0, 0); |
| i2_ref_idx *= (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1] << 1); |
| i2_ref_idx += MAX(i1_ref_frame1, 0); |
| if(!ps_cur_mb_info->u1_topmb) |
| i2_ref_idx += (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0] << 1) * |
| (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1] << 1); |
| pui32_weight_ofsts = (UWORD32 *) &ps_dec->pu4_mbaff_wt_mat[2 * X3(i2_ref_idx)]; |
| } |
| } |
| } |
| |
| s_temp_mv_pred.i1_ref_frame[0] = i1_ref_frame0; |
| s_temp_mv_pred.i1_ref_frame[1] = i1_ref_frame1; |
| s_temp_mv_pred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id; |
| s_temp_mv_pred.u1_pic_type = ps_ref_frame->u1_pic_type; |
| |
| /**********************************************************************/ |
| /* Call the function which gets the number of partitions and */ |
| /* partition info of colocated Mb */ |
| /**********************************************************************/ |
| |
| isvcd_one_to_one(ps_svc_lyr_dec, ps_dec->ps_col_pic, &s_mvdirect, u1_wd_x, |
| ps_dec->i4_submb_ofst, ps_cur_mb_info); |
| |
| ps_col_pic = ps_dec->ps_col_pic; |
| if((s_mvdirect.u1_col_zeroflag_change == 0) || u1_direct_zero_pred_flag) |
| { |
| WORD16 i2_mv_x, i2_mv_y, i2_mvX1, i2_mvY1; |
| /* Most probable case */ |
| u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag + s_mvdirect.i4_mv_indices[0]); |
| u1_col_zero_flag = u1_col_zero_flag & 0x01; |
| |
| if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1))) |
| { |
| i2_mv_x = 0; |
| i2_mv_y = 0; |
| } |
| else |
| { |
| i2_mv_x = i2_spat_pred_mv[0]; |
| i2_mv_y = i2_spat_pred_mv[1]; |
| } |
| |
| if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1))) |
| { |
| i2_mvX1 = 0; |
| i2_mvY1 = 0; |
| } |
| else |
| { |
| i2_mvX1 = i2_spat_pred_mv[2]; |
| i2_mvY1 = i2_spat_pred_mv[3]; |
| } |
| |
| u1_sub_mb_num = ps_dec->u1_sub_mb_num; |
| u1_mb_partw = (u1_wd_x >> 2); |
| |
| if(i1_ref_frame0 >= 0) |
| { |
| { |
| pred_info_pkd_t *ps_pred_pkd; |
| WORD16 i2_mv[2]; |
| WORD8 i1_ref_idx = 0; |
| |
| i2_mv[0] = i2_mv_x; |
| i2_mv[1] = i2_mv_y; |
| |
| ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx; |
| ih264d_fill_pred_info(i2_mv, u1_mb_partw, u1_mb_partw, u1_sub_mb_num, i1_pred, |
| ps_pred_pkd, ps_pic_buff0->u1_pic_buf_id, i1_ref_idx, |
| pui32_weight_ofsts, ps_pic_buff0->u1_pic_type); |
| ps_dec->u4_pred_info_pkd_idx++; |
| ps_cur_mb_info->u1_num_pred_parts++; |
| } |
| } |
| |
| if(i1_ref_frame1 >= 0) |
| { |
| { |
| pred_info_pkd_t *ps_pred_pkd; |
| WORD16 i2_mv[2]; |
| WORD8 i1_ref_idx = 0; |
| |
| i2_mv[0] = i2_mvX1; |
| i2_mv[1] = i2_mvY1; |
| |
| ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx; |
| ih264d_fill_pred_info(i2_mv, u1_mb_partw, u1_mb_partw, u1_sub_mb_num, i1_pred, |
| ps_pred_pkd, ps_pic_buff1->u1_pic_buf_id, i1_ref_idx, |
| pui32_weight_ofsts, ps_pic_buff1->u1_pic_type); |
| ps_dec->u4_pred_info_pkd_idx++; |
| ps_cur_mb_info->u1_num_pred_parts++; |
| } |
| } |
| |
| /* Replication optimisation */ |
| s_temp_mv_pred.i2_mv[0] = i2_mv_x; |
| s_temp_mv_pred.i2_mv[1] = i2_mv_y; |
| s_temp_mv_pred.i2_mv[2] = i2_mvX1; |
| s_temp_mv_pred.i2_mv[3] = i2_mvY1; |
| |
| /* Calculating colocated zero information */ |
| { |
| /*************************************/ |
| /* If(bit2 and bit3 set) */ |
| /* then */ |
| /* (bit0 and bit1) => submmbmode */ |
| /* (bit2 and bit3) => mbmode */ |
| /* else */ |
| /* (bit0 and bit1) => mbmode */ |
| /*************************************/ |
| /*UWORD8 u1_packed_mb_sub_mb_mode = sub_partition ? |
| (s_mvdirect.i1_partitionsize[0]) : ((s_mvdirect.i1_partitionsize[0]) << |
| 2);*/ |
| UWORD8 u1_packed_mb_sub_mb_mode = (u1_mb_partw == 2) ? 0x03 : 0; |
| |
| if(i1_ref_frame0 < 0) |
| { |
| i2_mv_x = i2_mvX1; |
| i2_mv_y = i2_mvY1; |
| } |
| |
| /* Change from left shift 4 to 6 - Varun */ |
| u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1) | |
| ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1) && (ABS(i2_mv_y) <= 1)); |
| u1_colz |= (u1_packed_mb_sub_mb_mode << 6); |
| } |
| ps_mv = ps_mv_nmb_start + u1_sub_mb_num; |
| if(ps_mv) |
| { |
| ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz, u1_mb_partw, |
| u1_mb_partw); |
| } |
| else |
| { |
| return NOT_OK; |
| } |
| |
| if(u1_wd_x == MB_SIZE) ps_dec->u1_currB_type = 0; |
| |
| return OK; |
| } |
| |
| /***************************************************************************/ |
| /* If present MB is 16x16 and the partition of colocated Mb is >= PRED_8x8 */ |
| /* i.e 8x8 or less than 8x8 partitions then set up DMA for (0,0) and */ |
| /* spatially predicted motion vector and do the multiplexing after */ |
| /* motion compensation */ |
| /***************************************************************************/ |
| |
| if((u1_wd_x == MB_SIZE) && (s_mvdirect.i1_num_partitions > 2)) |
| { |
| ps_cur_mb_info->u1_Mux = 1; |
| if(i1_ref_frame0 >= 0) |
| { |
| { |
| pred_info_pkd_t *ps_pred_pkd; |
| WORD8 i1_ref_idx = 0; |
| |
| ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx; |
| ih264d_fill_pred_info(&(i2_spat_pred_mv[0]), 4, 4, 0, i1_pred, ps_pred_pkd, |
| ps_pic_buff0->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts, |
| ps_pic_buff0->u1_pic_type); |
| ps_dec->u4_pred_info_pkd_idx++; |
| ps_cur_mb_info->u1_num_pred_parts++; |
| } |
| |
| /****** (0,0) Motion vectors DMA *****/ |
| { |
| pred_info_pkd_t *ps_pred_pkd; |
| WORD16 i2_mv[2]; |
| WORD8 i1_ref_idx = 0; |
| |
| i2_mv[0] = 0; |
| i2_mv[1] = 0; |
| |
| ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx; |
| ih264d_fill_pred_info(i2_mv, 4, 4, 0, i1_pred, ps_pred_pkd, |
| ps_pic_buff0->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts, |
| ps_pic_buff0->u1_pic_type); |
| ps_dec->u4_pred_info_pkd_idx++; |
| ps_cur_mb_info->u1_num_pred_parts++; |
| } |
| } |
| if(i1_ref_frame1 >= 0) |
| { |
| { |
| pred_info_pkd_t *ps_pred_pkd; |
| WORD8 i1_ref_idx = 0; |
| |
| ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx; |
| ih264d_fill_pred_info(&(i2_spat_pred_mv[2]), 4, 4, 0, i1_pred, ps_pred_pkd, |
| ps_pic_buff1->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts, |
| ps_pic_buff1->u1_pic_type); |
| ps_dec->u4_pred_info_pkd_idx++; |
| ps_cur_mb_info->u1_num_pred_parts++; |
| } |
| |
| /****** (0,0) Motion vectors DMA *****/ |
| { |
| pred_info_pkd_t *ps_pred_pkd; |
| WORD16 i2_mv[2]; |
| WORD8 i1_ref_idx = 0; |
| |
| i2_mv[0] = 0; |
| i2_mv[1] = 0; |
| |
| ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx; |
| ih264d_fill_pred_info(i2_mv, 4, 4, 0, i1_pred, ps_pred_pkd, |
| ps_pic_buff1->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts, |
| ps_pic_buff1->u1_pic_type); |
| ps_dec->u4_pred_info_pkd_idx++; |
| ps_cur_mb_info->u1_num_pred_parts++; |
| } |
| } |
| } |
| |
| for(i = 0; i < s_mvdirect.i1_num_partitions; i++) |
| { |
| partition_size = s_mvdirect.i1_partitionsize[i]; |
| u1_sub_mb_num = s_mvdirect.i1_submb_num[i]; |
| |
| sub_partition = partition_size >> 2; |
| partition_size &= 0x3; |
| u1_mb_partw = pu1_mb_partw[partition_size]; |
| u1_mb_parth = pu1_mb_parth[partition_size]; |
| if(sub_partition != 0) |
| { |
| u1_mb_partw >>= 1; |
| u1_mb_parth >>= 1; |
| } |
| |
| u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag + s_mvdirect.i4_mv_indices[i]); |
| u1_col_zero_flag = u1_col_zero_flag & 0x01; |
| |
| /*if(u1_col != u1_col_zero_flag) |
| u1_init = 1;*/ |
| |
| pi2_final_mv0 = &i2_spat_pred_mv[0]; |
| pi2_final_mv1 = &i2_spat_pred_mv[2]; |
| |
| if(ps_cur_mb_info->u1_Mux != 1) |
| { |
| if(i1_ref_frame0 >= 0) |
| { |
| { |
| pred_info_pkd_t *ps_pred_pkd; |
| WORD8 i1_ref_idx = 0; |
| |
| ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx; |
| ih264d_fill_pred_info(pi2_final_mv0, u1_mb_partw, u1_mb_parth, u1_sub_mb_num, |
| i1_pred, ps_pred_pkd, ps_pic_buff0->u1_pic_buf_id, |
| i1_ref_idx, pui32_weight_ofsts, |
| ps_pic_buff0->u1_pic_type); |
| ps_dec->u4_pred_info_pkd_idx++; |
| ps_cur_mb_info->u1_num_pred_parts++; |
| } |
| } |
| |
| if(i1_ref_frame1 >= 0) |
| { |
| pred_info_pkd_t *ps_pred_pkd; |
| WORD8 i1_ref_idx = 0; |
| |
| ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx; |
| ih264d_fill_pred_info(pi2_final_mv1, u1_mb_partw, u1_mb_parth, u1_sub_mb_num, |
| i1_pred, ps_pred_pkd, ps_pic_buff1->u1_pic_buf_id, i1_ref_idx, |
| pui32_weight_ofsts, ps_pic_buff1->u1_pic_type); |
| ps_dec->u4_pred_info_pkd_idx++; |
| ps_cur_mb_info->u1_num_pred_parts++; |
| } |
| } |
| |
| /* Replication optimisation */ |
| s_temp_mv_pred.i2_mv[0] = pi2_final_mv0[0]; |
| s_temp_mv_pred.i2_mv[1] = pi2_final_mv0[1]; |
| s_temp_mv_pred.i2_mv[2] = pi2_final_mv1[0]; |
| s_temp_mv_pred.i2_mv[3] = pi2_final_mv1[1]; |
| |
| /* Calculating colocated zero information */ |
| { |
| WORD16 i2_mv_x = 0, i2_mv_y = 0; |
| /*************************************/ |
| /* If(bit2 and bit3 set) */ |
| /* then */ |
| /* (bit0 and bit1) => submmbmode */ |
| /* (bit2 and bit3) => mbmode */ |
| /* else */ |
| /* (bit0 and bit1) => mbmode */ |
| /*************************************/ |
| UWORD8 u1_packed_mb_sub_mb_mode = sub_partition |
| ? (s_mvdirect.i1_partitionsize[i]) |
| : ((s_mvdirect.i1_partitionsize[i]) << 2); |
| |
| if(i1_ref_frame0 >= 0) |
| { |
| i2_mv_x = pi2_final_mv0[0]; |
| i2_mv_y = pi2_final_mv0[1]; |
| } |
| else |
| { |
| i2_mv_x = pi2_final_mv1[0]; |
| i2_mv_y = pi2_final_mv1[1]; |
| } |
| |
| u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1) | |
| ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1) && (ABS(i2_mv_y) <= 1)); |
| u1_colz |= (u1_packed_mb_sub_mb_mode << 4); |
| } |
| ps_mv = ps_mv_nmb_start + u1_sub_mb_num; |
| if(ps_mv) |
| { |
| ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz, u1_mb_parth, |
| u1_mb_partw); |
| } |
| else |
| { |
| return NOT_OK; |
| } |
| } |
| i = 0; |
| if(i1_ref_frame0 >= 0) ps_cur_mb_info->u2_mask[i++] = ui2_mask_fwd; |
| if(i1_ref_frame1 >= 0) ps_cur_mb_info->u2_mask[i] = ui2_mask_bwd; |
| |
| return OK; |
| } |
