| /****************************************************************************** |
| * |
| * 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 |
| * ih264_luma_intra_pred_filters.c |
| * |
| * @brief |
| * Contains function definitions for intra prediction filters |
| * |
| * @author |
| * Ittiam |
| * |
| * @par List of Functions: |
| * - ih264_intra_pred_luma_4x4_mode_vert |
| * - ih264_intra_pred_luma_4x4_mode_horz |
| * - ih264_intra_pred_luma_4x4_mode_dc |
| * - ih264_intra_pred_luma_4x4_mode_diag_dl |
| * - ih264_intra_pred_luma_4x4_mode_diag_dr |
| * - ih264_intra_pred_luma_4x4_mode_vert_r |
| * - ih264_intra_pred_luma_4x4_mode_horz_d |
| * - ih264_intra_pred_luma_4x4_mode_vert_l |
| * - ih264_intra_pred_luma_4x4_mode_horz_u |
| * - ih264_intra_pred_luma_8x8_mode_ref_filtering |
| * - ih264_intra_pred_luma_8x8_mode_vert |
| * - ih264_intra_pred_luma_8x8_mode_horz |
| * - ih264_intra_pred_luma_8x8_mode_dc |
| * - ih264_intra_pred_luma_8x8_mode_diag_dl |
| * - ih264_intra_pred_luma_8x8_mode_diag_dr |
| * - ih264_intra_pred_luma_8x8_mode_vert_r |
| * - ih264_intra_pred_luma_8x8_mode_horz_d |
| * - ih264_intra_pred_luma_8x8_mode_vert_l |
| * - ih264_intra_pred_luma_8x8_mode_horz_u |
| * - ih264_intra_pred_luma_16x16_mode_vert |
| * - ih264_intra_pred_luma_16x16_mode_horz |
| * - ih264_intra_pred_luma_16x16_mode_dc |
| * - ih264_intra_pred_luma_16x16_mode_plane |
| * |
| * |
| * @remarks |
| * None |
| * |
| ****************************************************************************** |
| */ |
| |
| /*****************************************************************************/ |
| /* File Includes */ |
| /*****************************************************************************/ |
| /* System include files */ |
| #include <stdio.h> |
| #include <stddef.h> |
| #include <string.h> |
| |
| /* User include files */ |
| #include "ih264_defs.h" |
| #include "ih264_typedefs.h" |
| #include "ih264_macros.h" |
| #include "ih264_platform_macros.h" |
| #include "ih264_intra_pred_filters.h" |
| |
| /* Global variables used only in assembly files*/ |
| const WORD8 ih264_gai1_intrapred_luma_plane_coeffs[] = |
| { 0x01, 0x02, 0x03, 0x04, |
| 0x05, 0x06, 0x07, 0x08, |
| 0x09, 0x0A, 0x0B, 0x0C, |
| 0x0D, 0x0E, 0x0F, 0x10, }; |
| |
| const WORD8 ih264_gai1_intrapred_luma_8x8_horz_u[] = |
| { 0x06,0x15,0x05,0x14, |
| 0x04,0x13,0x03,0x12, |
| 0x02,0x11,0x01,0x10, |
| 0x00,0x1F,0x0F,0x0F |
| }; |
| |
| /******************* LUMA INTRAPREDICTION *******************/ |
| |
| /******************* 4x4 Modes *******************/ |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_vert |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:vertical |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:vertical ,described in sec 8.3.1.2.1 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| void ih264_intra_pred_luma_4x4_mode_vert(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK_SIZE + 1; |
| |
| memcpy(pu1_dst, pu1_top, 4); |
| memcpy(pu1_dst + dst_strd, pu1_top, 4); |
| memcpy(pu1_dst + 2 * dst_strd, pu1_top, 4); |
| memcpy(pu1_dst + 3 * dst_strd, pu1_top, 4); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_horz |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:horizontal |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:horizontal ,described in sec 8.3.1.2.2 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| void ih264_intra_pred_luma_4x4_mode_horz(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_left = pu1_src + BLK_SIZE - 1; |
| |
| memset(pu1_dst, *pu1_left, 4); |
| memset(pu1_dst + dst_strd, *(pu1_left - 1), 4); |
| memset(pu1_dst + 2 * dst_strd, *(pu1_left - 2), 4); |
| memset(pu1_dst + 3 * dst_strd, *(pu1_left - 3), 4); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_dc |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:DC |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:DC ,described in sec 8.3.1.2.3 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_4x4_mode_dc(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 u1_useleft; /* availability of left predictors (only for DC) */ |
| UWORD8 u1_usetop; /* availability of top predictors (only for DC) */ |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| WORD32 val = 0; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK); |
| u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK); |
| pu1_top = pu1_src + BLK_SIZE + 1; |
| pu1_left = pu1_src + BLK_SIZE - 1; |
| |
| if(u1_useleft) |
| { |
| val += *pu1_left--; |
| val += *pu1_left--; |
| val += *pu1_left--; |
| val += *pu1_left + 2; |
| } |
| if(u1_usetop) |
| { |
| val += *pu1_top + *(pu1_top + 1) + *(pu1_top + 2) + *(pu1_top + 3) |
| + 2; |
| } |
| /* Since 2 is added if either left/top pred is there, |
| val still being zero implies both preds are not there */ |
| val = (val) ? (val >> (1 + u1_useleft + u1_usetop)) : 128; |
| |
| /* 4 bytes are copied from src to dst */ |
| memset(pu1_dst, val, 4); |
| memset(pu1_dst + dst_strd, val, 4); |
| memset(pu1_dst + 2 * dst_strd, val, 4); |
| memset(pu1_dst + 3 * dst_strd, val, 4); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_diag_dl |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Left |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Left ,described in sec 8.3.1.2.4 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_4x4_mode_diag_dl(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h; |
| UWORD8 predicted_pixels[7]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src +BLK_SIZE + 1; |
| |
| ui4_a = *pu1_top++; |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_d = *pu1_top++; |
| ui4_e = *pu1_top++; |
| ui4_f = *pu1_top++; |
| ui4_g = *pu1_top++; |
| ui4_h = *pu1_top; |
| |
| predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d); |
| predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e); |
| predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f); |
| predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g); |
| predicted_pixels[5] = FILT121(ui4_f, ui4_g, ui4_h); |
| predicted_pixels[6] = FILT121(ui4_g, ui4_h, ui4_h); |
| |
| memcpy(pu1_dst, predicted_pixels, 4); |
| memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 4); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 4); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 3, 4); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_diag_dr |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Right |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Right ,described in sec 8.3.1.2.5 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_4x4_mode_diag_dr(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */ |
| UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_i, ui4_j, ui4_k, ui4_l, ui4_m; |
| UWORD8 predicted_pixels[7]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK_SIZE + 1; |
| pu1_left = pu1_src + BLK_SIZE - 1; |
| pu1_topleft = pu1_src +BLK_SIZE; |
| |
| ui4_a = *pu1_top++; |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_d = *pu1_top++; |
| ui4_i = *pu1_left--; |
| ui4_j = *pu1_left--; |
| ui4_k = *pu1_left--; |
| ui4_l = *pu1_left; |
| ui4_m = *pu1_topleft; |
| |
| predicted_pixels[2] = FILT121(ui4_j, ui4_i, ui4_m); |
| predicted_pixels[1] = FILT121(ui4_k, ui4_j, ui4_i); |
| predicted_pixels[0] = FILT121(ui4_l, ui4_k, ui4_j); |
| predicted_pixels[3] = FILT121(ui4_i, ui4_m, ui4_a); |
| predicted_pixels[4] = FILT121(ui4_m, ui4_a, ui4_b); |
| predicted_pixels[5] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[6] = FILT121(ui4_b, ui4_c, ui4_d); |
| |
| memcpy(pu1_dst, predicted_pixels + 3, 4); |
| memcpy(pu1_dst + dst_strd, predicted_pixels + 2, 4); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 1, 4); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_vert_r |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:Vertical_Right |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:Vertical_Right ,described in sec 8.3.1.2.6 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_4x4_mode_vert_r(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| |
| UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_i, ui4_j, ui4_k, ui4_m; |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */ |
| UWORD8 predicted_pixels[10]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src +BLK_SIZE + 1; |
| pu1_left = pu1_src + BLK_SIZE - 1; |
| pu1_topleft = pu1_src + BLK_SIZE; |
| |
| ui4_a = *pu1_top++; |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_d = *pu1_top++; |
| ui4_i = *pu1_left--; |
| ui4_j = *pu1_left--; |
| ui4_k = *pu1_left; |
| ui4_m = *pu1_topleft; |
| |
| predicted_pixels[6] = FILT11(ui4_m, ui4_a); |
| predicted_pixels[7] = FILT11(ui4_a, ui4_b); |
| predicted_pixels[8] = FILT11(ui4_b, ui4_c); |
| predicted_pixels[9] = FILT11(ui4_c, ui4_d); |
| predicted_pixels[1] = FILT121(ui4_i, ui4_m, ui4_a); |
| predicted_pixels[2] = FILT121(ui4_m, ui4_a, ui4_b); |
| predicted_pixels[3] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[4] = FILT121(ui4_b, ui4_c, ui4_d); |
| predicted_pixels[5] = FILT121(ui4_j, ui4_i, ui4_m); |
| predicted_pixels[0] = FILT121(ui4_k, ui4_j, ui4_i); |
| |
| memcpy(pu1_dst, predicted_pixels + 6, 4); |
| memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 4); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 5, 4); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4); |
| } |
| |
| /* |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_horz_d |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:Horizontal_Down |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:Horizontal_Down ,described in sec 8.3.1.2.7 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_4x4_mode_horz_d(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */ |
| UWORD32 ui4_a, ui4_b, ui4_c, ui4_i, ui4_j, ui4_k, ui4_l, ui4_m; |
| UWORD8 predicted_pixels[10]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK_SIZE + 1; |
| pu1_left = pu1_src + BLK_SIZE - 1; |
| pu1_topleft = pu1_src + BLK_SIZE; |
| |
| ui4_a = *pu1_top++; |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_i = *pu1_left--; |
| ui4_j = *pu1_left--; |
| ui4_k = *pu1_left--; |
| ui4_l = *pu1_left--; |
| ui4_m = *pu1_topleft; |
| |
| predicted_pixels[6] = FILT11(ui4_i, ui4_m); |
| predicted_pixels[7] = FILT121(ui4_i, ui4_m, ui4_a); |
| predicted_pixels[8] = FILT121(ui4_m, ui4_a, ui4_b); |
| predicted_pixels[9] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[1] = FILT121(ui4_l, ui4_k, ui4_j); |
| predicted_pixels[2] = FILT11(ui4_k, ui4_j); |
| predicted_pixels[3] = FILT121(ui4_k, ui4_j, ui4_i); |
| predicted_pixels[4] = FILT11(ui4_j, ui4_i); |
| predicted_pixels[5] = FILT121(ui4_j, ui4_i, ui4_m); |
| predicted_pixels[0] = FILT11(ui4_l, ui4_k); |
| |
| memcpy(pu1_dst, predicted_pixels + 6, 4); |
| memcpy(pu1_dst + dst_strd, predicted_pixels + 4, 4); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 4); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_vert_l |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:Vertical_Left |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:Vertical_Left ,described in sec 8.3.1.2.8 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_4x4_mode_vert_l(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g; |
| UWORD8 predicted_pixels[10]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK_SIZE + 1; |
| |
| ui4_a = *pu1_top++; |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_d = *pu1_top++; |
| ui4_e = *pu1_top++; |
| ui4_f = *pu1_top++; |
| ui4_g = *pu1_top; |
| |
| predicted_pixels[5] = FILT11(ui4_a, ui4_b); |
| predicted_pixels[6] = FILT11(ui4_b, ui4_c); |
| predicted_pixels[7] = FILT11(ui4_c, ui4_d); |
| predicted_pixels[8] = FILT11(ui4_d, ui4_e); |
| predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d); |
| predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e); |
| predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f); |
| predicted_pixels[9] = FILT11(ui4_e, ui4_f); |
| predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g); |
| |
| memcpy(pu1_dst, predicted_pixels + 5, 4); |
| memcpy(pu1_dst + dst_strd, predicted_pixels, 4); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 6, 4); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 1, 4); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_4x4_mode_horz_u |
| * |
| * @brief |
| * Perform Intra prediction for luma_4x4 mode:Horizontal_Up |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_4x4 mode:Horizontal_Up ,described in sec 8.3.1.2.9 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_4x4_mode_horz_u(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD32 ui4_i, ui4_j, ui4_k, ui4_l; |
| UWORD8 predicted_pixels[10]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_left = pu1_src + BLK_SIZE - 1; |
| |
| ui4_i = *pu1_left--; |
| ui4_j = *pu1_left--; |
| ui4_k = *pu1_left--; |
| ui4_l = *pu1_left--; |
| |
| predicted_pixels[0] = FILT11(ui4_j, ui4_i); |
| predicted_pixels[1] = FILT121(ui4_k, ui4_j, ui4_i); |
| predicted_pixels[2] = FILT11(ui4_k, ui4_j); |
| predicted_pixels[3] = FILT121(ui4_l, ui4_k, ui4_j); |
| predicted_pixels[4] = FILT11(ui4_l, ui4_k); |
| predicted_pixels[5] = FILT121(ui4_l, ui4_l, ui4_k); |
| predicted_pixels[6] = ui4_l; |
| predicted_pixels[7] = ui4_l; |
| predicted_pixels[8] = ui4_l; |
| predicted_pixels[9] = ui4_l; |
| |
| memcpy(pu1_dst, predicted_pixels, 4); |
| memcpy(pu1_dst + dst_strd, predicted_pixels + 2, 4); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 4, 4); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 6, 4); |
| } |
| |
| /******************* 8x8 Modes *******************/ |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_ref_filtering |
| * |
| * @brief |
| * Reference sample filtering process for Intra_8x8 sample prediction |
| * |
| * @par Description: |
| * Perform Reference sample filtering process for Intra_8x8 sample prediction ,described in sec 8.3.2.2.1 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride[Not Used] |
| * |
| * @param[in] dst_strd |
| * integer destination stride[Not Used] |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_8x8_mode_ref_filtering(UWORD8 *pu1_left, |
| UWORD8 *pu1_topleft, |
| UWORD8 *pu1_top, |
| UWORD8 *pu1_dst, |
| WORD32 left_strd, |
| WORD32 ngbr_avail) |
| { |
| WORD32 top_avail, left_avail, top_left_avail, top_right_avail; |
| |
| left_avail = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK); |
| top_avail = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK); |
| top_left_avail = BOOLEAN(ngbr_avail & TOP_LEFT_MB_AVAILABLE_MASK); |
| top_right_avail = BOOLEAN(ngbr_avail & TOP_RIGHT_MB_AVAILABLE_MASK); |
| |
| if(top_avail) |
| { |
| WORD32 i; |
| UWORD32 u4_xm1; |
| |
| if(!top_right_avail) |
| { |
| memset(pu1_dst + 8 + 1 + 8, pu1_top[7], 8); |
| top_right_avail = 1; |
| } |
| else |
| { |
| memcpy(pu1_dst + 8 + 1 + 8, pu1_top + 8, 8); |
| } |
| |
| if(top_left_avail) |
| { |
| pu1_dst[8 + 1 + 0] = FILT121((*pu1_topleft), pu1_top[0], |
| pu1_top[1]); |
| |
| } |
| else |
| { |
| pu1_dst[8 + 1] = ((3 * pu1_top[0]) + pu1_top[1] + 2) >> 2; |
| } |
| |
| for(i = 1; i <= 6; i++) |
| { |
| pu1_dst[8 + 1 + i] = FILT121(pu1_top[i - 1], pu1_top[i], |
| pu1_top[i + 1]); |
| |
| } |
| /* First byte of Top Right input is in pu1_dst[8 + 1 + 8]*/ |
| pu1_dst[8 + 1 + 7] = FILT121(pu1_top[6], pu1_top[7], |
| pu1_dst[8 + 1 + 8]); |
| |
| /* filtered output and source in same buf, to prevent output(x - 1) |
| being over written in process */ |
| u4_xm1 = pu1_top[7]; |
| |
| for(i = 8; i <= 14; i++) |
| { |
| UWORD32 u4_x; |
| u4_x = (u4_xm1 + (pu1_dst[8 + 1 + i] << 1) + pu1_dst[8 + 1 + i + 1] |
| + 2) >> 2; |
| /* assigning u4_xm1 from the un-filtered values for the next iteration */ |
| u4_xm1 = pu1_dst[8 + 1 + i]; |
| pu1_dst[8 + 1 + i] = u4_x; |
| } |
| |
| pu1_dst[8 + 1 + 15] = (u4_xm1 + (3 * pu1_dst[8 + 1 + 15]) + 2) >> 2; |
| |
| } |
| |
| /* pu1_topleft is overloaded. It is both: */ |
| /* a. A pointer for the top left pixel */ |
| /* b. An indicator of availability of top left. */ |
| /* If it is null then top left not available */ |
| if(top_left_avail) |
| { |
| if((!top_avail) || (!left_avail)) |
| { |
| if(top_avail) |
| pu1_dst[8] = (3 * pu1_topleft[0] + pu1_top[0] + 2) >> 2; |
| else if(left_avail) |
| pu1_dst[8] = (3 * pu1_topleft[0] + pu1_left[0] + 2) >> 2; |
| } |
| else |
| { |
| pu1_dst[8] = FILT121(pu1_top[0], (*pu1_topleft), pu1_left[0]); |
| } |
| } |
| |
| if(left_avail) |
| { |
| UWORD32 idx; |
| if(0 != pu1_topleft) |
| { |
| pu1_dst[7] = FILT121((*pu1_topleft), pu1_left[0], |
| pu1_left[left_strd]); |
| } |
| else |
| { |
| pu1_dst[7] = ((3 * pu1_left[0]) + pu1_left[left_strd] + 2) >> 2; |
| } |
| |
| for(idx = 1; idx <= 6; idx++) |
| { |
| pu1_dst[7 - idx] = FILT121(pu1_left[(idx - 1) * left_strd], |
| pu1_left[idx * left_strd], |
| pu1_left[(idx + 1) * left_strd]); |
| |
| } |
| pu1_dst[0] = (pu1_left[6 * left_strd] + 3 * pu1_left[7 * left_strd] + 2) |
| >> 2; |
| |
| } |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_vert |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:vertical |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:vertical ,described in sec 8.3.2.2.2 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| void ih264_intra_pred_luma_8x8_mode_vert(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK8x8SIZE + 1; |
| |
| memcpy(pu1_dst, pu1_top, 8); |
| memcpy(pu1_dst + dst_strd, pu1_top, 8); |
| memcpy(pu1_dst + 2 * dst_strd, pu1_top, 8); |
| memcpy(pu1_dst + 3 * dst_strd, pu1_top, 8); |
| memcpy(pu1_dst + 4 * dst_strd, pu1_top, 8); |
| memcpy(pu1_dst + 5 * dst_strd, pu1_top, 8); |
| memcpy(pu1_dst + 6 * dst_strd, pu1_top, 8); |
| memcpy(pu1_dst + 7 * dst_strd, pu1_top, 8); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_horz |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:horizontal |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:horizontal ,described in sec 8.3.2.2.2 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| void ih264_intra_pred_luma_8x8_mode_horz(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_left = pu1_src + BLK8x8SIZE - 1; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| memset(pu1_dst, *pu1_left, 8); |
| memset(pu1_dst + dst_strd, *(pu1_left - 1), 8); |
| memset(pu1_dst + 2 * dst_strd, *(pu1_left - 2), 8); |
| memset(pu1_dst + 3 * dst_strd, *(pu1_left - 3), 8); |
| memset(pu1_dst + 4 * dst_strd, *(pu1_left - 4), 8); |
| memset(pu1_dst + 5 * dst_strd, *(pu1_left - 5), 8); |
| memset(pu1_dst + 6 * dst_strd, *(pu1_left - 6), 8); |
| memset(pu1_dst + 7 * dst_strd, *(pu1_left - 7), 8); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_dc |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:DC |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:DC ,described in sec 8.3.2.2.4 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_8x8_mode_dc(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 u1_useleft; /* availability of left predictors (only for DC) */ |
| UWORD8 u1_usetop; /* availability of top predictors (only for DC) */ |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| WORD32 row; |
| WORD32 val = 0; |
| UNUSED(src_strd); |
| |
| u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK); |
| u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK); |
| pu1_top = pu1_src + BLK8x8SIZE + 1; |
| pu1_left = pu1_src + BLK8x8SIZE - 1; |
| |
| if(u1_useleft) |
| { |
| for(row = 0; row < BLK8x8SIZE; row++) |
| val += *(pu1_left - row); |
| val += 4; |
| } |
| if(u1_usetop) |
| { |
| for(row = 0; row < BLK8x8SIZE; row++) |
| val += *(pu1_top + row); |
| val += 4; |
| } |
| |
| /* Since 4 is added if either left/top pred is there, |
| val still being zero implies both preds are not there */ |
| val = (val) ? (val >> (2 + u1_useleft + u1_usetop)) : 128; |
| |
| memset(pu1_dst, val, 8); |
| memset(pu1_dst + dst_strd, val, 8); |
| memset(pu1_dst + 2 * dst_strd, val, 8); |
| memset(pu1_dst + 3 * dst_strd, val, 8); |
| memset(pu1_dst + 4 * dst_strd, val, 8); |
| memset(pu1_dst + 5 * dst_strd, val, 8); |
| memset(pu1_dst + 6 * dst_strd, val, 8); |
| memset(pu1_dst + 7 * dst_strd, val, 8); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_diag_dl |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Left |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Left ,described in sec 8.3.2.2.5 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_8x8_mode_diag_dl(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h; |
| UWORD32 ui4_i, ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p; |
| UWORD8 predicted_pixels[15]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK8x8SIZE + 1; |
| |
| ui4_a = *pu1_top++; |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_d = *pu1_top++; |
| ui4_e = *pu1_top++; |
| ui4_f = *pu1_top++; |
| ui4_g = *pu1_top++; |
| ui4_h = *pu1_top++; |
| ui4_i = *pu1_top++; |
| ui4_j = *pu1_top++; |
| ui4_k = *pu1_top++; |
| ui4_l = *pu1_top++; |
| ui4_m = *pu1_top++; |
| ui4_n = *pu1_top++; |
| ui4_o = *pu1_top++; |
| ui4_p = *pu1_top; |
| |
| predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d); |
| predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e); |
| predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f); |
| predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g); |
| predicted_pixels[5] = FILT121(ui4_f, ui4_g, ui4_h); |
| predicted_pixels[6] = FILT121(ui4_g, ui4_h, ui4_i); |
| predicted_pixels[7] = FILT121(ui4_h, ui4_i, ui4_j); |
| predicted_pixels[8] = FILT121(ui4_i, ui4_j, ui4_k); |
| predicted_pixels[9] = FILT121(ui4_j, ui4_k, ui4_l); |
| predicted_pixels[10] = FILT121(ui4_k, ui4_l, ui4_m); |
| predicted_pixels[11] = FILT121(ui4_l, ui4_m, ui4_n); |
| predicted_pixels[12] = FILT121(ui4_m, ui4_n, ui4_o); |
| predicted_pixels[13] = FILT121(ui4_n, ui4_o, ui4_p); |
| predicted_pixels[14] = FILT121(ui4_o, ui4_p, ui4_p); |
| |
| memcpy(pu1_dst, predicted_pixels, 8); |
| memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 8); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 8); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 3, 8); |
| memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 4, 8); |
| memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 5, 8); |
| memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 6, 8); |
| memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 7, 8); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_diag_dr |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Right |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Right ,described in sec 8.3.2.2.6 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_8x8_mode_diag_dr(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */ |
| UWORD32 ui4_a; |
| UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i; |
| UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p, ui4_q; |
| UWORD8 predicted_pixels[15]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK8x8SIZE + 1; |
| pu1_left = pu1_src + BLK8x8SIZE - 1; |
| pu1_topleft = pu1_src + BLK8x8SIZE; |
| |
| ui4_a = *pu1_topleft; |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_d = *pu1_top++; |
| ui4_e = *pu1_top++; |
| ui4_f = *pu1_top++; |
| ui4_g = *pu1_top++; |
| ui4_h = *pu1_top++; |
| ui4_i = *pu1_top; |
| ui4_j = *pu1_left--; |
| ui4_k = *pu1_left--; |
| ui4_l = *pu1_left--; |
| ui4_m = *pu1_left--; |
| ui4_n = *pu1_left--; |
| ui4_o = *pu1_left--; |
| ui4_p = *pu1_left--; |
| ui4_q = *pu1_left; |
| |
| predicted_pixels[6] = FILT121(ui4_a, ui4_j, ui4_k); |
| predicted_pixels[5] = FILT121(ui4_j, ui4_k, ui4_l); |
| predicted_pixels[4] = FILT121(ui4_k, ui4_l, ui4_m); |
| predicted_pixels[3] = FILT121(ui4_l, ui4_m, ui4_n); |
| predicted_pixels[2] = FILT121(ui4_m, ui4_n, ui4_o); |
| predicted_pixels[1] = FILT121(ui4_n, ui4_o, ui4_p); |
| predicted_pixels[0] = FILT121(ui4_o, ui4_p, ui4_q); |
| predicted_pixels[7] = FILT121(ui4_b, ui4_a, ui4_j); |
| predicted_pixels[8] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[9] = FILT121(ui4_b, ui4_c, ui4_d); |
| predicted_pixels[10] = FILT121(ui4_c, ui4_d, ui4_e); |
| predicted_pixels[11] = FILT121(ui4_d, ui4_e, ui4_f); |
| predicted_pixels[12] = FILT121(ui4_e, ui4_f, ui4_g); |
| predicted_pixels[13] = FILT121(ui4_f, ui4_g, ui4_h); |
| predicted_pixels[14] = FILT121(ui4_g, ui4_h, ui4_i); |
| |
| memcpy(pu1_dst, predicted_pixels + 7, 8); |
| memcpy(pu1_dst + dst_strd, predicted_pixels + 6, 8); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 5, 8); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 4, 8); |
| memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 3, 8); |
| memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 2, 8); |
| memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 1, 8); |
| memcpy(pu1_dst + 7 * dst_strd, predicted_pixels, 8); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_vert_r |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:Vertical_Right |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:Vertical_Right ,described in sec 8.3.2.2.7 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ih264_intra_pred_luma_8x8_mode_vert_r(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */ |
| UWORD32 ui4_a; |
| UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i; |
| UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p; |
| UWORD8 predicted_pixels[22]; |
| |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK8x8SIZE + 1; |
| pu1_left = pu1_src + BLK8x8SIZE - 1; |
| pu1_topleft = pu1_src + BLK8x8SIZE; |
| |
| ui4_a = *pu1_topleft; |
| |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_d = *pu1_top++; |
| ui4_e = *pu1_top++; |
| ui4_f = *pu1_top++; |
| ui4_g = *pu1_top++; |
| ui4_h = *pu1_top++; |
| ui4_i = *pu1_top; |
| ui4_j = *pu1_left--; |
| ui4_k = *pu1_left--; |
| ui4_l = *pu1_left--; |
| ui4_m = *pu1_left--; |
| ui4_n = *pu1_left--; |
| ui4_o = *pu1_left--; |
| ui4_p = *pu1_left--; |
| |
| predicted_pixels[0] = FILT121(ui4_o, ui4_n, ui4_m); |
| predicted_pixels[1] = FILT121(ui4_m, ui4_l, ui4_k); |
| predicted_pixels[2] = FILT121(ui4_k, ui4_j, ui4_a); |
| predicted_pixels[3] = FILT11(ui4_a, ui4_b); |
| predicted_pixels[4] = FILT11(ui4_b, ui4_c); |
| predicted_pixels[5] = FILT11(ui4_c, ui4_d); |
| predicted_pixels[6] = FILT11(ui4_d, ui4_e); |
| predicted_pixels[7] = FILT11(ui4_e, ui4_f); |
| predicted_pixels[8] = FILT11(ui4_f, ui4_g); |
| predicted_pixels[9] = FILT11(ui4_g, ui4_h); |
| predicted_pixels[10] = FILT11(ui4_h, ui4_i); |
| predicted_pixels[11] = FILT121(ui4_p, ui4_o, ui4_n); |
| predicted_pixels[12] = FILT121(ui4_n, ui4_m, ui4_l); |
| predicted_pixels[13] = FILT121(ui4_l, ui4_k, ui4_j); |
| predicted_pixels[14] = FILT121(ui4_b, ui4_a, ui4_j); |
| predicted_pixels[15] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[16] = FILT121(ui4_b, ui4_c, ui4_d); |
| predicted_pixels[17] = FILT121(ui4_c, ui4_d, ui4_e); |
| predicted_pixels[18] = FILT121(ui4_d, ui4_e, ui4_f); |
| predicted_pixels[19] = FILT121(ui4_e, ui4_f, ui4_g); |
| predicted_pixels[20] = FILT121(ui4_f, ui4_g, ui4_h); |
| predicted_pixels[21] = FILT121(ui4_g, ui4_h, ui4_i); |
| |
| memcpy(pu1_dst, predicted_pixels + 3, 8); |
| memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 14, 8); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 8); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 13, 8); |
| memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 1, 8); |
| memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 12, 8); |
| memcpy(pu1_dst + 6 * dst_strd, predicted_pixels, 8); |
| memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 11, 8); |
| |
| } |
| |
| /* |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_horz_d |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:Horizontal_Down |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:Horizontal_Down ,described in sec 8.3.2.2.8 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| |
| void ih264_intra_pred_luma_8x8_mode_horz_d(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */ |
| UWORD32 ui4_a; |
| UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i; |
| UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p; |
| UWORD8 predicted_pixels[22]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK8x8SIZE + 1; |
| pu1_left = pu1_src + BLK8x8SIZE - 1; |
| pu1_topleft = pu1_src + BLK8x8SIZE; |
| |
| ui4_a = *pu1_topleft; |
| ui4_j = *pu1_top++; |
| ui4_k = *pu1_top++; |
| ui4_l = *pu1_top++; |
| ui4_m = *pu1_top++; |
| ui4_n = *pu1_top++; |
| ui4_o = *pu1_top++; |
| ui4_p = *pu1_top++; |
| ui4_b = *pu1_left--; |
| ui4_c = *pu1_left--; |
| ui4_d = *pu1_left--; |
| ui4_e = *pu1_left--; |
| ui4_f = *pu1_left--; |
| ui4_g = *pu1_left--; |
| ui4_h = *pu1_left--; |
| ui4_i = *pu1_left; |
| |
| predicted_pixels[0] = FILT11(ui4_h, ui4_i); |
| predicted_pixels[1] = FILT121(ui4_g, ui4_h, ui4_i); |
| predicted_pixels[2] = FILT11(ui4_g, ui4_h); |
| predicted_pixels[3] = FILT121(ui4_f, ui4_g, ui4_h); |
| predicted_pixels[4] = FILT11(ui4_f, ui4_g); |
| predicted_pixels[5] = FILT121(ui4_e, ui4_f, ui4_g); |
| predicted_pixels[6] = FILT11(ui4_e, ui4_f); |
| predicted_pixels[7] = FILT121(ui4_d, ui4_e, ui4_f); |
| predicted_pixels[8] = FILT11(ui4_d, ui4_e); |
| predicted_pixels[9] = FILT121(ui4_c, ui4_d, ui4_e); |
| predicted_pixels[10] = FILT11(ui4_c, ui4_d); |
| predicted_pixels[11] = FILT121(ui4_b, ui4_c, ui4_d); |
| predicted_pixels[12] = FILT11(ui4_b, ui4_c); |
| predicted_pixels[13] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[14] = FILT11(ui4_a, ui4_b); |
| predicted_pixels[15] = FILT121(ui4_j, ui4_a, ui4_b); |
| predicted_pixels[16] = FILT121(ui4_k, ui4_j, ui4_a); |
| predicted_pixels[17] = FILT121(ui4_l, ui4_k, ui4_j); |
| predicted_pixels[18] = FILT121(ui4_m, ui4_l, ui4_k); |
| predicted_pixels[19] = FILT121(ui4_n, ui4_m, ui4_l); |
| predicted_pixels[20] = FILT121(ui4_o, ui4_n, ui4_m); |
| predicted_pixels[21] = FILT121(ui4_p, ui4_o, ui4_n); |
| |
| memcpy(pu1_dst, predicted_pixels + 14, 8); |
| memcpy(pu1_dst + dst_strd, predicted_pixels + 12, 8); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 10, 8); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 8, 8); |
| memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 6, 8); |
| memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 4, 8); |
| memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 2, 8); |
| memcpy(pu1_dst + 7 * dst_strd, predicted_pixels, 8); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_vert_l |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:Vertical_Left |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:Vertical_Left ,described in sec 8.3.2.2.9 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| |
| void ih264_intra_pred_luma_8x8_mode_vert_l(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h; |
| UWORD32 ui4_i, ui4_j, ui4_k, ui4_l, ui4_m; |
| UWORD8 predicted_pixels[22]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + BLK8x8SIZE + 1; |
| |
| ui4_a = *pu1_top++; |
| ui4_b = *pu1_top++; |
| ui4_c = *pu1_top++; |
| ui4_d = *pu1_top++; |
| ui4_e = *pu1_top++; |
| ui4_f = *pu1_top++; |
| ui4_g = *pu1_top++; |
| ui4_h = *pu1_top++; |
| ui4_i = *pu1_top++; |
| ui4_j = *pu1_top++; |
| ui4_k = *pu1_top++; |
| ui4_l = *pu1_top++; |
| ui4_m = *pu1_top++; |
| |
| predicted_pixels[0] = FILT11(ui4_a, ui4_b); |
| predicted_pixels[1] = FILT11(ui4_b, ui4_c); |
| predicted_pixels[2] = FILT11(ui4_c, ui4_d); |
| predicted_pixels[3] = FILT11(ui4_d, ui4_e); |
| predicted_pixels[4] = FILT11(ui4_e, ui4_f); |
| predicted_pixels[5] = FILT11(ui4_f, ui4_g); |
| predicted_pixels[6] = FILT11(ui4_g, ui4_h); |
| predicted_pixels[7] = FILT11(ui4_h, ui4_i); |
| predicted_pixels[8] = FILT11(ui4_i, ui4_j); |
| predicted_pixels[9] = FILT11(ui4_j, ui4_k); |
| predicted_pixels[10] = FILT11(ui4_k, ui4_l); |
| predicted_pixels[11] = FILT121(ui4_a, ui4_b, ui4_c); |
| predicted_pixels[12] = FILT121(ui4_b, ui4_c, ui4_d); |
| predicted_pixels[13] = FILT121(ui4_c, ui4_d, ui4_e); |
| predicted_pixels[14] = FILT121(ui4_d, ui4_e, ui4_f); |
| predicted_pixels[15] = FILT121(ui4_e, ui4_f, ui4_g); |
| predicted_pixels[16] = FILT121(ui4_f, ui4_g, ui4_h); |
| predicted_pixels[17] = FILT121(ui4_g, ui4_h, ui4_i); |
| predicted_pixels[18] = FILT121(ui4_h, ui4_i, ui4_j); |
| predicted_pixels[19] = FILT121(ui4_i, ui4_j, ui4_k); |
| predicted_pixels[20] = FILT121(ui4_j, ui4_k, ui4_l); |
| predicted_pixels[21] = FILT121(ui4_k, ui4_l, ui4_m); |
| |
| memcpy(pu1_dst, predicted_pixels, 8); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 1, 8); |
| memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 2, 8); |
| memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 3, 8); |
| memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 11, 8); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 12, 8); |
| memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 13, 8); |
| memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 14, 8); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_8x8_mode_horz_u |
| * |
| * @brief |
| * Perform Intra prediction for luma_8x8 mode:Horizontal_Up |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_8x8 mode:Horizontal_Up ,described in sec 8.3.2.2.10 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| |
| void ih264_intra_pred_luma_8x8_mode_horz_u(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| |
| { |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p, ui4_q; |
| UWORD8 predicted_pixels[22]; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_left = pu1_src + BLK8x8SIZE - 1; |
| |
| ui4_j = *pu1_left--; |
| ui4_k = *pu1_left--; |
| ui4_l = *pu1_left--; |
| ui4_m = *pu1_left--; |
| ui4_n = *pu1_left--; |
| ui4_o = *pu1_left--; |
| ui4_p = *pu1_left--; |
| ui4_q = *pu1_left; |
| |
| pu1_left = pu1_src + BLK8x8SIZE - 1; |
| |
| predicted_pixels[0] = FILT11(ui4_j, ui4_k); |
| predicted_pixels[1] = FILT121(ui4_j, ui4_k, ui4_l); |
| predicted_pixels[2] = FILT11(ui4_k, ui4_l); |
| predicted_pixels[3] = FILT121(ui4_k, ui4_l, ui4_m); |
| predicted_pixels[4] = FILT11(ui4_l, ui4_m); |
| predicted_pixels[5] = FILT121(ui4_l, ui4_m, ui4_n); |
| predicted_pixels[6] = FILT11(ui4_m, ui4_n); |
| predicted_pixels[7] = FILT121(ui4_m, ui4_n, ui4_o); |
| predicted_pixels[8] = FILT11(ui4_n, ui4_o); |
| predicted_pixels[9] = FILT121(ui4_n, ui4_o, ui4_p); |
| predicted_pixels[10] = FILT11(ui4_o, ui4_p); |
| predicted_pixels[11] = FILT121(ui4_o, ui4_p, ui4_q); |
| predicted_pixels[12] = FILT11(ui4_p, ui4_q); |
| predicted_pixels[13] = FILT121(ui4_p, ui4_q, ui4_q); |
| memset(predicted_pixels+14,ui4_q,8); |
| |
| memcpy(pu1_dst, predicted_pixels, 8); |
| memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 2, 8); |
| memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 4, 8); |
| memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 6, 8); |
| memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 8, 8); |
| memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 10, 8); |
| memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 12, 8); |
| memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 14, 8); |
| } |
| |
| |
| /******************* 16x16 Modes *******************/ |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_16x16_mode_vert |
| * |
| * @brief |
| * Perform Intra prediction for luma_16x16 mode:Vertical |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_16x16 mode:Vertical, described in sec 8.3.3.1 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels (Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| |
| void ih264_intra_pred_luma_16x16_mode_vert(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| WORD32 rows; /* loop variables*/ |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + MB_SIZE + 1; |
| |
| for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd) |
| { |
| memcpy(pu1_dst, pu1_top, 16); |
| pu1_dst += dst_strd; |
| memcpy(pu1_dst, pu1_top, 16); |
| pu1_dst += dst_strd; |
| memcpy(pu1_dst, pu1_top, 16); |
| pu1_dst += dst_strd; |
| memcpy(pu1_dst, pu1_top, 16); |
| } |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_16x16_mode_horz |
| * |
| * @brief |
| * Perform Intra prediction for luma_16x16 mode:Horizontal |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_16x16 mode:Horizontal, described in sec 8.3.3.2 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| |
| void ih264_intra_pred_luma_16x16_mode_horz(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| UWORD8 *pu1_left = NULL; /* Pointer to start of top predictors */ |
| WORD32 rows; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_left = pu1_src + MB_SIZE - 1; |
| |
| for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd, pu1_left --) |
| { |
| memset(pu1_dst, *pu1_left, 16); /* copy the left value to the entire row*/ |
| pu1_left --; |
| pu1_dst += dst_strd; |
| memset(pu1_dst, *pu1_left, 16); |
| pu1_left --; |
| pu1_dst += dst_strd; |
| memset(pu1_dst, *pu1_left, 16); |
| pu1_left --; |
| pu1_dst += dst_strd; |
| memset(pu1_dst, *pu1_left, 16); |
| } |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_16x16_mode_dc |
| * |
| * @brief |
| * Perform Intra prediction for luma_16x16 mode:DC |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_16x16 mode:DC, described in sec 8.3.3.3 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| ** @param[in] ngbr_avail |
| * availability of neighbouring pixels |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| |
| void ih264_intra_pred_luma_16x16_mode_dc(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| WORD8 u1_useleft; /* availability of left predictors (only for DC) */ |
| UWORD8 u1_usetop; /* availability of top predictors (only for DC) */ |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| WORD32 rows; /* loop variables*/ |
| WORD32 val = 0; |
| UNUSED(src_strd); |
| |
| u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK); |
| u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK); |
| pu1_top = pu1_src + MB_SIZE + 1; |
| pu1_left = pu1_src + MB_SIZE - 1; |
| if(u1_useleft) |
| { |
| for(rows = 0; rows < 16; rows++) |
| val += *(pu1_left - rows); |
| val += 8; |
| } |
| if(u1_usetop) |
| { |
| for(rows = 0; rows < 16; rows++) |
| val += *(pu1_top + rows); |
| val += 8; |
| } |
| /* Since 8 is added if either left/top pred is there, |
| val still being zero implies both preds are not there */ |
| val = (val) ? (val >> (3 + u1_useleft + u1_usetop)) : 128; |
| |
| for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd) |
| { |
| memset(pu1_dst, val, 16); |
| pu1_dst += dst_strd; |
| memset(pu1_dst, val, 16); |
| pu1_dst += dst_strd; |
| memset(pu1_dst, val, 16); |
| pu1_dst += dst_strd; |
| memset(pu1_dst, val, 16); |
| } |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| *ih264_intra_pred_luma_16x16_mode_plane |
| * |
| * @brief |
| * Perform Intra prediction for luma_16x16 mode:PLANE |
| * |
| * @par Description: |
| * Perform Intra prediction for luma_16x16 mode:PLANE, described in sec 8.3.3.4 |
| * |
| * @param[in] pu1_src |
| * UWORD8 pointer to the source |
| * |
| * @param[out] pu1_dst |
| * UWORD8 pointer to the destination |
| * |
| * @param[in] src_strd |
| * integer source stride |
| * |
| * @param[in] dst_strd |
| * integer destination stride |
| * |
| * @param[in] ngbr_avail |
| * availability of neighbouring pixels(Not used in this function) |
| * |
| * @returns |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| |
| void ih264_intra_pred_luma_16x16_mode_plane(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 src_strd, |
| WORD32 dst_strd, |
| WORD32 ngbr_avail) |
| { |
| /*! Written with no multiplications */ |
| UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ |
| UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ |
| UWORD8 *pu1_topleft = NULL; |
| WORD32 a, b, c, tmp; |
| UWORD8 *pu1_tmp1, *pu1_tmp2; |
| WORD32 shift; |
| UNUSED(src_strd); |
| UNUSED(ngbr_avail); |
| pu1_top = pu1_src + MB_SIZE + 1; |
| pu1_left = pu1_src + MB_SIZE - 1; |
| pu1_topleft = pu1_src + MB_SIZE; |
| |
| { |
| a = (*(pu1_top + 15) + *(pu1_left - 15)) << 4; |
| |
| /*! Implement Sum(x*(P((x+7),-1) - P((x-7),-1))) x=1...8 */ |
| pu1_tmp1 = pu1_top + 8; |
| pu1_tmp2 = pu1_tmp1 - 2; |
| |
| /* Pixel diffs are only 9 bits; |
| so sign extension allows shifts to be used even for signed */ |
| b = ((*pu1_tmp1++) - (*pu1_tmp2--)); /* x=1 */ |
| b += ((*pu1_tmp1++) - (*pu1_tmp2--)) << 1; /* x=2 */ |
| tmp = ((*pu1_tmp1++) - (*pu1_tmp2--)); |
| b += (tmp << 1) + tmp; /* x=3 */ |
| b += ((*pu1_tmp1++) - (*pu1_tmp2--)) << 2; /* x=4 */ |
| |
| tmp = ((*pu1_tmp1++) - (*pu1_tmp2--)); |
| b += (tmp << 2) + tmp; /* x=5 */ |
| tmp = ((*pu1_tmp1++) - (*pu1_tmp2--)); |
| b += (tmp << 2) + (tmp << 1); /* x=6 */ |
| tmp = ((*pu1_tmp1++) - (*pu1_tmp2--)); |
| b += (tmp << 3) - tmp; /* x=7 */ |
| b += ((*pu1_tmp1) - (*pu1_topleft)) << 3; /* x=8 */ |
| |
| b = ((b << 2) + b + 32) >> 6; /*! (5*H + 32)>>6 */ |
| |
| /*! Implement Sum(y*(P(-1,(y+7)) - P(-1,(y-7)))) y=1...8 */ |
| pu1_tmp1 = pu1_left - 8; |
| pu1_tmp2 = pu1_tmp1 + 2; |
| |
| c = ((*pu1_tmp1) - (*pu1_tmp2)); /* y=1 */ |
| pu1_tmp1--; |
| pu1_tmp2++; |
| c += ((*pu1_tmp1) - (*pu1_tmp2)) << 1; /* y=2 */ |
| pu1_tmp1--; |
| pu1_tmp2++; |
| tmp = ((*pu1_tmp1) - (*pu1_tmp2)); |
| c += (tmp << 1) + tmp; /* y=3 */ |
| pu1_tmp1--; |
| pu1_tmp2++; |
| c += ((*pu1_tmp1) - (*pu1_tmp2)) << 2; /* y=4 */ |
| pu1_tmp1--; |
| pu1_tmp2++; |
| |
| tmp = ((*pu1_tmp1) - (*pu1_tmp2)); |
| c += (tmp << 2) + tmp; /* y=5 */ |
| pu1_tmp1--; |
| pu1_tmp2++; |
| tmp = ((*pu1_tmp1) - (*pu1_tmp2)); |
| c += (tmp << 2) + (tmp << 1); /* y=6 */ |
| pu1_tmp1--; |
| pu1_tmp2++; |
| tmp = ((*pu1_tmp1) - (*pu1_tmp2)); |
| c += (tmp << 3) - tmp; /* y=7 */ |
| pu1_tmp1--; //pu1_tmp2 ++; |
| /* Modified to get (-1,-1) location as *(pu1_top - 1) instead of (pu1_left - ui4_stride) */ |
| //c += ((*pu1_tmp1) - (*(pu1_top - 1)))<<3; /* y=8 */ |
| c += ((*pu1_tmp1) - (*pu1_topleft)) << 3; /* y=8 */ |
| |
| c = ((c << 2) + c + 32) >> 6; /*! (5*V + 32)>>32 */ |
| shift = 3; |
| } |
| |
| /*! Now from the plane parameters a, b, and c, |
| compute the fitted plane values over the block */ |
| { |
| WORD32 tmp1, tmpx, tmpx_init, j, i; |
| |
| tmpx_init = -(b << shift); /* -8b */ |
| tmp = a - (c << shift) + 16; /* a-((4or8)*c)+16 */ |
| for(i = 0; i < 16; i++) |
| { |
| tmp += c; /*increment every time by c to get c*(y-7or3)*/ |
| tmpx = tmpx_init; /* Init to -8b */ |
| for(j = 0; j < 16; j++) |
| { |
| tmpx += b; /* increment every time by b to get b*(x-7or3) */ |
| tmp1 = (tmp + tmpx) >> 5; |
| *pu1_dst++ = CLIP_U8(tmp1); |
| } |
| pu1_dst += (dst_strd - 16); |
| } |
| } |
| } |
