Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
       3             :  *
       4             :  * This source code is subject to the terms of the BSD 2 Clause License and
       5             :  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
       6             :  * was not distributed with this source code in the LICENSE file, you can
       7             :  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
       8             :  * Media Patent License 1.0 was not distributed with this source code in the
       9             :  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
      10             :  */
      11             : 
      12             : #ifndef AV1_COMMON_RECONINTRA_H_
      13             : #define AV1_COMMON_RECONINTRA_H_
      14             : 
      15             : #include "aom/aom_integer.h"
      16             : #include "av1/common/blockd.h"
      17             : 
      18             : #ifdef __cplusplus
      19             : extern "C" {
      20             : #endif
      21             : 
      22             : #if CONFIG_DPCM_INTRA
      23             : static INLINE int av1_use_dpcm_intra(int plane, PREDICTION_MODE mode,
      24             :                                      TX_TYPE tx_type,
      25             :                                      const MB_MODE_INFO *const mbmi) {
      26             :   (void)mbmi;
      27             :   (void)plane;
      28             : #if CONFIG_EXT_INTRA
      29             :   if (mbmi->sb_type >= BLOCK_8X8 && mbmi->angle_delta[plane != 0]) return 0;
      30             : #endif  // CONFIG_EXT_INTRA
      31             :   return (mode == V_PRED && (tx_type == IDTX || tx_type == H_DCT)) ||
      32             :          (mode == H_PRED && (tx_type == IDTX || tx_type == V_DCT));
      33             : }
      34             : #endif  // CONFIG_DPCM_INTRA
      35             : 
      36             : void av1_init_intra_predictors(void);
      37             : void av1_predict_intra_block_facade(MACROBLOCKD *xd, int plane, int block_idx,
      38             :                                     int blk_col, int blk_row, TX_SIZE tx_size);
      39             : void av1_predict_intra_block(const MACROBLOCKD *xd, int bw, int bh,
      40             :                              BLOCK_SIZE bsize, PREDICTION_MODE mode,
      41             :                              const uint8_t *ref, int ref_stride, uint8_t *dst,
      42             :                              int dst_stride, int aoff, int loff, int plane);
      43             : 
      44             : #if CONFIG_EXT_INTER && CONFIG_INTERINTRA
      45             : // Mapping of interintra to intra mode for use in the intra component
      46             : static const PREDICTION_MODE interintra_to_intra_mode[INTERINTRA_MODES] = {
      47             :   DC_PRED, V_PRED, H_PRED,
      48             : #if CONFIG_ALT_INTRA
      49             :   SMOOTH_PRED
      50             : #else
      51             :   TM_PRED
      52             : #endif
      53             : };
      54             : 
      55             : // Mapping of intra mode to the interintra mode
      56             : static const INTERINTRA_MODE intra_to_interintra_mode[INTRA_MODES] = {
      57             :   II_DC_PRED,     II_V_PRED,     II_H_PRED, II_V_PRED,
      58             : #if CONFIG_ALT_INTRA
      59             :   II_SMOOTH_PRED,
      60             : #else
      61             :   II_TM_PRED,
      62             : #endif
      63             :   II_V_PRED,      II_H_PRED,     II_H_PRED, II_V_PRED,
      64             : #if CONFIG_ALT_INTRA
      65             :   II_SMOOTH_PRED, II_SMOOTH_PRED
      66             : #else
      67             :   II_TM_PRED
      68             : #endif
      69             : };
      70             : #endif  // CONFIG_EXT_INTER && CONFIG_INTERINTRA
      71             : 
      72             : #if CONFIG_FILTER_INTRA
      73             : #define FILTER_INTRA_PREC_BITS 10
      74             : #endif  // CONFIG_FILTER_INTRA
      75             : 
      76             : #if CONFIG_EXT_INTRA
      77           0 : static INLINE int av1_is_directional_mode(PREDICTION_MODE mode,
      78             :                                           BLOCK_SIZE bsize) {
      79           0 :   return mode != DC_PRED && mode != TM_PRED &&
      80             : #if CONFIG_ALT_INTRA
      81           0 :          mode != SMOOTH_PRED &&
      82             : #if CONFIG_SMOOTH_HV
      83             :          mode != SMOOTH_V_PRED && mode != SMOOTH_H_PRED &&
      84             : #endif  // CONFIG_SMOOTH_HV
      85             : #endif  // CONFIG_ALT_INTRA
      86             :          bsize >= BLOCK_8X8;
      87             : }
      88             : #endif  // CONFIG_EXT_INTRA
      89             : 
      90             : #ifdef __cplusplus
      91             : }  // extern "C"
      92             : #endif
      93             : #endif  // AV1_COMMON_RECONINTRA_H_