| /****************************************************************************** |
| * |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ***************************************************************************** |
| * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore |
| */ |
| |
| /** |
| ******************************************************************************* |
| * @file |
| * ih264e_mc.c |
| * |
| * @brief |
| * Contains definition of functions for motion compensation |
| * |
| * @author |
| * ittiam |
| * |
| * @par List of Functions: |
| * - ih264e_motion_comp_luma() |
| * - ih264e_motion_comp_chroma() |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| /*****************************************************************************/ |
| /* File Includes */ |
| /*****************************************************************************/ |
| |
| /* System include files */ |
| #include <stdio.h> |
| |
| /* User include files */ |
| #include "ih264_typedefs.h" |
| #include "ih264_defs.h" |
| #include "iv2.h" |
| #include "ive2.h" |
| #include "ime_distortion_metrics.h" |
| #include "ime_defs.h" |
| #include "ime_structs.h" |
| #include "ih264_structs.h" |
| #include "ih264_inter_pred_filters.h" |
| #include "ih264_mem_fns.h" |
| #include "ih264_padding.h" |
| #include "ih264_intra_pred_filters.h" |
| #include "ih264_deblk_edge_filters.h" |
| #include "ih264_trans_quant_itrans_iquant.h" |
| #include "ih264_cabac_tables.h" |
| #include "ih264e_defs.h" |
| #include "ih264e_error.h" |
| #include "ih264e_bitstream.h" |
| #include "irc_cntrl_param.h" |
| #include "irc_frame_info_collector.h" |
| #include "ih264e_rate_control.h" |
| #include "ih264e_cabac_structs.h" |
| #include "ih264e_structs.h" |
| #include "ih264e_mc.h" |
| #include "ih264e_half_pel.h" |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief |
| * performs motion compensation for a luma mb for the given mv. |
| * |
| * @par Description |
| * This routine performs motion compensation of an inter mb. When the inter |
| * mb mode is P16x16, there is no need to copy 16x16 unit from reference buffer |
| * to pred buffer. In this case the function returns pointer and stride of the |
| * ref. buffer and this info is used in place of pred buffer else where. |
| * In other cases, the pred buffer is populated via copy / filtering + copy |
| * (q pel cases) and returned. |
| * |
| * @param[in] ps_proc |
| * pointer to current proc ctxt |
| * |
| * @param[out] pu1_pseudo_pred |
| * pseudo prediction buffer |
| * |
| * @param[out] u4_pseudo_pred_strd |
| * pseudo pred buffer stride |
| * |
| * @return none |
| * |
| * @remarks Assumes half pel buffers for the entire frame are populated. |
| * |
| ****************************************************************************** |
| */ |
| void ih264e_motion_comp_luma(process_ctxt_t *ps_proc, UWORD8 **pu1_pseudo_pred, |
| WORD32 *pi4_pseudo_pred_strd) |
| { |
| /* codec context */ |
| codec_t *ps_codec = ps_proc->ps_codec; |
| |
| /* me ctxt */ |
| me_ctxt_t *ps_me_ctxt = &ps_proc->s_me_ctxt; |
| |
| /* Pointer to the structure having motion vectors, size and position of curr partitions */ |
| enc_pu_t *ps_curr_pu; |
| |
| /* pointers to full pel, half pel x, half pel y, half pel xy reference buffer */ |
| UWORD8 *pu1_ref[4]; |
| |
| /* pred buffer ptr */ |
| UWORD8 *pu1_pred; |
| |
| /* strides of full pel, half pel x, half pel y, half pel xy reference buffer */ |
| WORD32 i4_ref_strd[4]; |
| |
| /* pred buffer stride */ |
| WORD32 i4_pred_strd = ps_proc->i4_pred_strd; |
| |
| /* full pel motion vectors */ |
| WORD32 u4_mv_x_full, u4_mv_y_full; |
| |
| /* half pel motion vectors */ |
| WORD32 u4_mv_x_hpel, u4_mv_y_hpel; |
| |
| /* quarter pel motion vectors */ |
| WORD32 u4_mv_x_qpel, u4_mv_y_qpel; |
| |
| /* width & height of the partition */ |
| UWORD32 wd, ht; |
| |
| /* partition idx */ |
| UWORD32 u4_num_prtn; |
| |
| /* half / qpel coefficient */ |
| UWORD32 u4_subpel_factor; |
| |
| /* BIPRED Flag */ |
| WORD32 i4_bipred_flag; |
| |
| /* temp var */ |
| UWORD32 u4_lkup_idx1; |
| |
| /* Init */ |
| i4_ref_strd[0] = ps_proc->i4_rec_strd; |
| |
| i4_ref_strd[1] = i4_ref_strd[2] = i4_ref_strd[3] = |
| ps_me_ctxt->u4_subpel_buf_strd; |
| |
| for (u4_num_prtn = 0; u4_num_prtn < ps_proc->u4_num_sub_partitions; |
| u4_num_prtn++) |
| { |
| mv_t *ps_curr_mv; |
| |
| /* update ptr to curr partition */ |
| ps_curr_pu = ps_proc->ps_pu + u4_num_prtn; |
| |
| /* Set no no bipred */ |
| i4_bipred_flag = 0; |
| |
| switch (ps_curr_pu->b2_pred_mode) |
| { |
| case PRED_L0: |
| ps_curr_mv = &ps_curr_pu->s_me_info[0].s_mv; |
| pu1_ref[0] = ps_proc->apu1_ref_buf_luma[0]; |
| break; |
| |
| case PRED_L1: |
| ps_curr_mv = &ps_curr_pu->s_me_info[1].s_mv; |
| pu1_ref[0] = ps_proc->apu1_ref_buf_luma[1]; |
| break; |
| |
| case PRED_BI: |
| /* |
| * In case of PRED_BI, we only need to ensure that |
| * the reference buffer that gets selected is |
| * ps_proc->pu1_best_subpel_buf |
| */ |
| |
| /* Dummy */ |
| ps_curr_mv = &ps_curr_pu->s_me_info[0].s_mv; |
| pu1_ref[0] = ps_proc->apu1_ref_buf_luma[0]; |
| |
| i4_bipred_flag = 1; |
| break; |
| |
| default: |
| ps_curr_mv = &ps_curr_pu->s_me_info[0].s_mv; |
| pu1_ref[0] = ps_proc->apu1_ref_buf_luma[0]; |
| break; |
| |
| } |
| |
| /* get full pel mv's (full pel units) */ |
| u4_mv_x_full = ps_curr_mv->i2_mvx >> 2; |
| u4_mv_y_full = ps_curr_mv->i2_mvy >> 2; |
| |
| /* get half pel mv's */ |
| u4_mv_x_hpel = (ps_curr_mv->i2_mvx & 0x2) >> 1; |
| u4_mv_y_hpel = (ps_curr_mv->i2_mvy & 0x2) >> 1; |
| |
| /* get quarter pel mv's */ |
| u4_mv_x_qpel = (ps_curr_mv->i2_mvx & 0x1); |
| u4_mv_y_qpel = (ps_curr_mv->i2_mvy & 0x1); |
| |
| /* width and height of partition */ |
| wd = (ps_curr_pu->b4_wd + 1) << 2; |
| ht = (ps_curr_pu->b4_ht + 1) << 2; |
| |
| /* decision ? qpel/hpel, fpel */ |
| u4_subpel_factor = (u4_mv_y_hpel << 3) + (u4_mv_x_hpel << 2) |
| + (u4_mv_y_qpel << 1) + (u4_mv_x_qpel); |
| |
| /* Move ref to position given by MV */ |
| pu1_ref[0] += ((u4_mv_y_full * i4_ref_strd[0]) + u4_mv_x_full); |
| |
| /* Sub pel ptrs/ Biperd pointers init */ |
| pu1_ref[1] = ps_proc->pu1_best_subpel_buf; |
| i4_ref_strd[1] = ps_proc->u4_bst_spel_buf_strd; |
| |
| /* update pred buff ptr */ |
| pu1_pred = ps_proc->pu1_pred_mb |
| + 4 * ps_curr_pu->b4_pos_y * i4_pred_strd |
| + 4 * ps_curr_pu->b4_pos_x; |
| |
| /* u4_lkup_idx1 will be non zero for half pel and bipred */ |
| u4_lkup_idx1 = ((u4_subpel_factor >> 2) != 0) || i4_bipred_flag; |
| |
| { |
| /********************************************************************/ |
| /* if the block is P16x16 MB and mv are not quarter pel motion */ |
| /* vectors, there is no need to copy 16x16 unit from reference frame*/ |
| /* to pred buffer. We might as well send the reference frame buffer */ |
| /* pointer as pred buffer (ofc with updated stride) to fwd transform*/ |
| /* and inverse transform unit. */ |
| /********************************************************************/ |
| if (ps_proc->u4_num_sub_partitions == 1) |
| { |
| *pu1_pseudo_pred = pu1_ref[u4_lkup_idx1]; |
| *pi4_pseudo_pred_strd = i4_ref_strd[u4_lkup_idx1]; |
| |
| } |
| /* |
| * Copying half pel or full pel to prediction buffer |
| * Currently ps_proc->u4_num_sub_partitions will always be 1 as we only support 16x16 in P mbs |
| */ |
| else |
| { |
| ps_codec->pf_inter_pred_luma_copy(pu1_ref[u4_lkup_idx1], |
| pu1_pred, |
| i4_ref_strd[u4_lkup_idx1], |
| i4_pred_strd, ht, wd, NULL, |
| 0); |
| } |
| |
| } |
| } |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief |
| * performs motion compensation for chroma mb |
| * |
| * @par Description |
| * Copies a MB of data from the reference buffer (Full pel, half pel or q pel) |
| * according to the motion vectors given |
| * |
| * @param[in] ps_proc |
| * pointer to current proc ctxt |
| * |
| * @return none |
| * |
| * @remarks Assumes half pel and quarter pel buffers for the entire frame are |
| * populated. |
| ****************************************************************************** |
| */ |
| void ih264e_motion_comp_chroma(process_ctxt_t *ps_proc) |
| { |
| /* codec context */ |
| codec_t *ps_codec = ps_proc->ps_codec; |
| |
| /* Pointer to the structure having motion vectors, size and position of curr partitions */ |
| enc_pu_t *ps_curr_pu; |
| |
| /* pointers to full pel, half pel x, half pel y, half pel xy reference buffer */ |
| UWORD8 *pu1_ref; |
| |
| /* pred buffer ptr */ |
| UWORD8 *pu1_pred; |
| |
| /* strides of full pel reference buffer */ |
| WORD32 i4_ref_strd = ps_proc->i4_rec_strd; |
| |
| /* pred buffer stride */ |
| WORD32 i4_pred_strd = ps_proc->i4_pred_strd; |
| |
| /* full pel motion vectors */ |
| WORD32 u4_mv_x_full, u4_mv_y_full; |
| |
| /* half pel motion vectors */ |
| WORD32 u4_mv_x_hpel, u4_mv_y_hpel; |
| |
| /* quarter pel motion vectors */ |
| WORD32 u4_mv_x_qpel, u4_mv_y_qpel; |
| |
| /* width & height of the partition */ |
| UWORD32 wd, ht; |
| |
| /* partition idx */ |
| UWORD32 u4_num_prtn; |
| |
| WORD32 u4_mv_x; |
| WORD32 u4_mv_y; |
| UWORD8 u1_dx, u1_dy; |
| |
| for (u4_num_prtn = 0; u4_num_prtn < ps_proc->u4_num_sub_partitions; |
| u4_num_prtn++) |
| { |
| mv_t *ps_curr_mv; |
| |
| ps_curr_pu = ps_proc->ps_pu + u4_num_prtn; |
| |
| if (ps_curr_pu->b2_pred_mode != PRED_BI) |
| { |
| ps_curr_mv = &ps_curr_pu->s_me_info[ps_curr_pu->b2_pred_mode].s_mv; |
| pu1_ref = ps_proc->apu1_ref_buf_chroma[ps_curr_pu->b2_pred_mode]; |
| |
| u4_mv_x = ps_curr_mv->i2_mvx >> 3; |
| u4_mv_y = ps_curr_mv->i2_mvy >> 3; |
| |
| /* corresponds to full pel motion vector in luma, but in chroma corresponds to pel formed wiith dx, dy =4 */ |
| u4_mv_x_full = (ps_curr_mv->i2_mvx & 0x4) >> 2; |
| u4_mv_y_full = (ps_curr_mv->i2_mvy & 0x4) >> 2; |
| |
| /* get half pel mv's */ |
| u4_mv_x_hpel = (ps_curr_mv->i2_mvx & 0x2) >> 1; |
| u4_mv_y_hpel = (ps_curr_mv->i2_mvy & 0x2) >> 1; |
| |
| /* get quarter pel mv's */ |
| u4_mv_x_qpel = (ps_curr_mv->i2_mvx & 0x1); |
| u4_mv_y_qpel = (ps_curr_mv->i2_mvy & 0x1); |
| |
| /* width and height of sub macro block */ |
| wd = (ps_curr_pu->b4_wd + 1) << 1; |
| ht = (ps_curr_pu->b4_ht + 1) << 1; |
| |
| /* move the pointers so that they point to the motion compensated locations */ |
| pu1_ref += ((u4_mv_y * i4_ref_strd) + (u4_mv_x << 1)); |
| |
| pu1_pred = ps_proc->pu1_pred_mb |
| + 4 * ps_curr_pu->b4_pos_y * i4_pred_strd |
| + 2 * ps_curr_pu->b4_pos_x; |
| |
| u1_dx = (u4_mv_x_full << 2) + (u4_mv_x_hpel << 1) + (u4_mv_x_qpel); |
| u1_dy = (u4_mv_y_full << 2) + (u4_mv_y_hpel << 1) + (u4_mv_y_qpel); |
| |
| /* cases where u1_dx = 0 or u1_dy = 0 are dealt separately in neon with |
| * separate functions for better performance |
| * |
| * ih264_inter_pred_chroma_dx_zero_a9q |
| * and |
| * ih264_inter_pred_chroma_dy_zero_a9q |
| */ |
| |
| ps_codec->pf_inter_pred_chroma(pu1_ref, pu1_pred, i4_ref_strd, |
| i4_pred_strd, u1_dx, u1_dy, ht, wd); |
| } |
| else /* If the pred mode is PRED_BI */ |
| { |
| /* |
| * We need to interpolate the L0 and L1 ref pics with the chorma MV |
| * then use them to average for bilinrar interpred |
| */ |
| WORD32 i4_predmode; |
| UWORD8 *pu1_ref_buf[2]; |
| |
| /* Temporary buffers to store the interpolated value from L0 and L1 */ |
| pu1_ref_buf[PRED_L0] = ps_proc->apu1_subpel_buffs[0]; |
| pu1_ref_buf[PRED_L1] = ps_proc->apu1_subpel_buffs[1]; |
| |
| |
| for (i4_predmode = 0; i4_predmode < PRED_BI; i4_predmode++) |
| { |
| ps_curr_mv = &ps_curr_pu->s_me_info[i4_predmode].s_mv; |
| pu1_ref = ps_proc->apu1_ref_buf_chroma[i4_predmode]; |
| |
| u4_mv_x = ps_curr_mv->i2_mvx >> 3; |
| u4_mv_y = ps_curr_mv->i2_mvy >> 3; |
| |
| /* |
| * corresponds to full pel motion vector in luma, but in chroma |
| * corresponds to pel formed wiith dx, dy =4 |
| */ |
| u4_mv_x_full = (ps_curr_mv->i2_mvx & 0x4) >> 2; |
| u4_mv_y_full = (ps_curr_mv->i2_mvy & 0x4) >> 2; |
| |
| /* get half pel mv's */ |
| u4_mv_x_hpel = (ps_curr_mv->i2_mvx & 0x2) >> 1; |
| u4_mv_y_hpel = (ps_curr_mv->i2_mvy & 0x2) >> 1; |
| |
| /* get quarter pel mv's */ |
| u4_mv_x_qpel = (ps_curr_mv->i2_mvx & 0x1); |
| u4_mv_y_qpel = (ps_curr_mv->i2_mvy & 0x1); |
| |
| /* width and height of sub macro block */ |
| wd = (ps_curr_pu->b4_wd + 1) << 1; |
| ht = (ps_curr_pu->b4_ht + 1) << 1; |
| |
| /* move the pointers so that they point to the motion compensated locations */ |
| pu1_ref += ((u4_mv_y * i4_ref_strd) + (u4_mv_x << 1)); |
| |
| pu1_pred = ps_proc->pu1_pred_mb |
| + 4 * ps_curr_pu->b4_pos_y * i4_pred_strd |
| + 2 * ps_curr_pu->b4_pos_x; |
| |
| u1_dx = (u4_mv_x_full << 2) + (u4_mv_x_hpel << 1) |
| + (u4_mv_x_qpel); |
| u1_dy = (u4_mv_y_full << 2) + (u4_mv_y_hpel << 1) |
| + (u4_mv_y_qpel); |
| |
| ps_codec->pf_inter_pred_chroma(pu1_ref, |
| pu1_ref_buf[i4_predmode], |
| i4_ref_strd, MB_SIZE, u1_dx, |
| u1_dy, ht, wd); |
| } |
| |
| ps_codec->pf_inter_pred_luma_bilinear(pu1_ref_buf[PRED_L0], |
| pu1_ref_buf[PRED_L1], pu1_pred, |
| MB_SIZE, MB_SIZE, |
| i4_pred_strd, MB_SIZE >> 1, |
| MB_SIZE); |
| } |
| } |
| } |
