src/third_party/libvpx/source/libvpx/vp9/common/vp9_blockd.h

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11
  12 #ifndef VP9_COMMON_VP9_BLOCKD_H_
  13 #define VP9_COMMON_VP9_BLOCKD_H_
  14
  15 #include "./vpx_config.h"
  16
  17 #include "vpx_ports/mem.h"
  18 #include "vpx_scale/yv12config.h"
  19
  20 #include "vp9/common/vp9_common.h"
  21 #include "vp9/common/vp9_common_data.h"
  22 #include "vp9/common/vp9_enums.h"
  23 #include "vp9/common/vp9_filter.h"
  24 #include "vp9/common/vp9_mv.h"
  25 #include "vp9/common/vp9_scale.h"
  26 #include "vp9/common/vp9_seg_common.h"
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 #define BLOCK_SIZE_GROUPS 4
  33 #define SKIP_CONTEXTS 3
  34 #define INTER_MODE_CONTEXTS 7
  35
  36 /* Segment Feature Masks */
  37 #define MAX_MV_REF_CANDIDATES 2
  38
  39 #define INTRA_INTER_CONTEXTS 4
  40 #define COMP_INTER_CONTEXTS 5
  41 #define REF_CONTEXTS 5
  42
  43 typedef enum {
  44   PLANE_TYPE_Y  = 0,
  45   PLANE_TYPE_UV = 1,
  46   PLANE_TYPES
  47 } PLANE_TYPE;
  48
  49 typedef char ENTROPY_CONTEXT;
  50
  51 typedef char PARTITION_CONTEXT;
  52
  53 static INLINE int combine_entropy_contexts(ENTROPY_CONTEXT a,
  54                                            ENTROPY_CONTEXT b) {
  55   return (a != 0) + (b != 0);
  56 }
  57
  58 typedef enum {
  59   KEY_FRAME = 0,
  60   INTER_FRAME = 1,
  61   FRAME_TYPES,
  62 } FRAME_TYPE;
  63
  64 typedef enum {
  65   DC_PRED,         // Average of above and left pixels
  66   V_PRED,          // Vertical
  67   H_PRED,          // Horizontal
  68   D45_PRED,        // Directional 45  deg = round(arctan(1/1) * 180/pi)
  69   D135_PRED,       // Directional 135 deg = 180 - 45
  70   D117_PRED,       // Directional 117 deg = 180 - 63
  71   D153_PRED,       // Directional 153 deg = 180 - 27
  72   D207_PRED,       // Directional 207 deg = 180 + 27
  73   D63_PRED,        // Directional 63  deg = round(arctan(2/1) * 180/pi)
  74   TM_PRED,         // True-motion
  75   NEARESTMV,
  76   NEARMV,
  77   ZEROMV,
  78   NEWMV,
  79   MB_MODE_COUNT
  80 } MB_PREDICTION_MODE;
  81
  82 static INLINE int is_inter_mode(MB_PREDICTION_MODE mode) {
  83   return mode >= NEARESTMV && mode <= NEWMV;
  84 }
  85
  86 #define INTRA_MODES (TM_PRED + 1)
  87
  88 #define INTER_MODES (1 + NEWMV - NEARESTMV)
  89
  90 #define INTER_OFFSET(mode) ((mode) - NEARESTMV)
  91
  92 /* For keyframes, intra block modes are predicted by the (already decoded)
  93    modes for the Y blocks to the left and above us; for interframes, there
  94    is a single probability table. */
  95
  96 typedef struct {
  97   MB_PREDICTION_MODE as_mode;
  98   int_mv as_mv[2];  // first, second inter predictor motion vectors
  99 } b_mode_info;
 100
 101 typedef enum {
 102   NONE = -1,
 103   INTRA_FRAME = 0,
 104   LAST_FRAME = 1,
 105   GOLDEN_FRAME = 2,
 106   ALTREF_FRAME = 3,
 107   MAX_REF_FRAMES = 4
 108 } MV_REFERENCE_FRAME;
 109
 110 static INLINE int b_width_log2(BLOCK_SIZE sb_type) {
 111   return b_width_log2_lookup[sb_type];
 112 }
 113 static INLINE int b_height_log2(BLOCK_SIZE sb_type) {
 114   return b_height_log2_lookup[sb_type];
 115 }
 116
 117 static INLINE int mi_width_log2(BLOCK_SIZE sb_type) {
 118   return mi_width_log2_lookup[sb_type];
 119 }
 120
 121 // This structure now relates to 8x8 block regions.
 122 typedef struct {
 123   MB_PREDICTION_MODE mode, uv_mode;
 124   MV_REFERENCE_FRAME ref_frame[2];
 125   TX_SIZE tx_size;
 126   int_mv mv[2];                // for each reference frame used
 127   int_mv ref_mvs[MAX_REF_FRAMES][MAX_MV_REF_CANDIDATES];
 128
 129   uint8_t mode_context[MAX_REF_FRAMES];
 130
 131   unsigned char skip;    // 0=need to decode coeffs, 1=no coefficients
 132   unsigned char segment_id;    // Segment id for this block.
 133
 134   // Flags used for prediction status of various bit-stream signals
 135   unsigned char seg_id_predicted;
 136
 137   INTERP_FILTER interp_filter;
 138
 139   BLOCK_SIZE sb_type;
 140 } MB_MODE_INFO;
 141
 142 typedef struct {
 143   MB_MODE_INFO mbmi;
 144   b_mode_info bmi[4];
 145 } MODE_INFO;
 146
 147 static INLINE int is_inter_block(const MB_MODE_INFO *mbmi) {
 148   return mbmi->ref_frame[0] > INTRA_FRAME;
 149 }
 150
 151 static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
 152   return mbmi->ref_frame[1] > INTRA_FRAME;
 153 }
 154
 155 MB_PREDICTION_MODE vp9_left_block_mode(const MODE_INFO *cur_mi,
 156                                        const MODE_INFO *left_mi, int b);
 157
 158 MB_PREDICTION_MODE vp9_above_block_mode(const MODE_INFO *cur_mi,
 159                                         const MODE_INFO *above_mi, int b);
 160
 161 enum mv_precision {
 162   MV_PRECISION_Q3,
 163   MV_PRECISION_Q4
 164 };
 165
 166 #if CONFIG_ALPHA
 167 enum { MAX_MB_PLANE = 4 };
 168 #else
 169 enum { MAX_MB_PLANE = 3 };
 170 #endif
 171
 172 struct buf_2d {
 173   uint8_t *buf;
 174   int stride;
 175 };
 176
 177 struct macroblockd_plane {
 178   int16_t *dqcoeff;
 179   PLANE_TYPE plane_type;
 180   int subsampling_x;
 181   int subsampling_y;
 182   struct buf_2d dst;
 183   struct buf_2d pre[2];
 184   const int16_t *dequant;
 185   ENTROPY_CONTEXT *above_context;
 186   ENTROPY_CONTEXT *left_context;
 187 };
 188
 189 #define BLOCK_OFFSET(x, i) ((x) + (i) * 16)
 190
 191 typedef struct RefBuffer {
 192   // TODO(dkovalev): idx is not really required and should be removed, now it
 193   // is used in vp9_onyxd_if.c
 194   int idx;
 195   YV12_BUFFER_CONFIG *buf;
 196   struct scale_factors sf;
 197 } RefBuffer;
 198
 199 typedef struct macroblockd {
 200   struct macroblockd_plane plane[MAX_MB_PLANE];
 201
 202   MODE_INFO *last_mi;
 203   int mode_info_stride;
 204
 205   // A NULL indicates that the 8x8 is not part of the image
 206   MODE_INFO **mi_8x8;
 207   MODE_INFO **prev_mi_8x8;
 208   MODE_INFO *mi_stream;
 209
 210   int up_available;
 211   int left_available;
 212
 213   /* Distance of MB away from frame edges */
 214   int mb_to_left_edge;
 215   int mb_to_right_edge;
 216   int mb_to_top_edge;
 217   int mb_to_bottom_edge;
 218
 219   /* pointers to reference frames */
 220   RefBuffer *block_refs[2];
 221
 222   /* pointer to current frame */
 223   const YV12_BUFFER_CONFIG *cur_buf;
 224
 225   /* mc buffer */
 226   DECLARE_ALIGNED(16, uint8_t, mc_buf[80 * 2 * 80 * 2]);
 227
 228   int lossless;
 229   /* Inverse transform function pointers. */
 230   void (*itxm_add)(const int16_t *input, uint8_t *dest, int stride, int eob);
 231
 232   const InterpKernel *interp_kernel;
 233
 234   int corrupted;
 235
 236   /* Y,U,V,(A) */
 237   ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
 238   ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];
 239
 240   PARTITION_CONTEXT *above_seg_context;
 241   PARTITION_CONTEXT left_seg_context[8];
 242 } MACROBLOCKD;
 243
 244
 245
 246 static INLINE BLOCK_SIZE get_subsize(BLOCK_SIZE bsize,
 247                                      PARTITION_TYPE partition) {
 248   const BLOCK_SIZE subsize = subsize_lookup[partition][bsize];
 249   assert(subsize < BLOCK_SIZES);
 250   return subsize;
 251 }
 252
 253 extern const TX_TYPE mode2txfm_map[MB_MODE_COUNT];
 254
 255 static INLINE TX_TYPE get_tx_type_4x4(PLANE_TYPE plane_type,
 256                                       const MACROBLOCKD *xd, int ib) {
 257   const MODE_INFO *const mi = xd->mi_8x8[0];
 258   const MB_MODE_INFO *const mbmi = &mi->mbmi;
 259
 260   if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mbmi))
 261     return DCT_DCT;
 262
 263   return mode2txfm_map[mbmi->sb_type < BLOCK_8X8 ? mi->bmi[ib].as_mode
 264                                                  : mbmi->mode];
 265 }
 266
 267 static INLINE TX_TYPE get_tx_type_8x8(PLANE_TYPE plane_type,
 268                                       const MACROBLOCKD *xd) {
 269   return plane_type == PLANE_TYPE_Y ? mode2txfm_map[xd->mi_8x8[0]->mbmi.mode]
 270                                     : DCT_DCT;
 271 }
 272
 273 static INLINE TX_TYPE get_tx_type_16x16(PLANE_TYPE plane_type,
 274                                         const MACROBLOCKD *xd) {
 275   return plane_type == PLANE_TYPE_Y ? mode2txfm_map[xd->mi_8x8[0]->mbmi.mode]
 276                                     : DCT_DCT;
 277 }
 278
 279 void vp9_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
 280
 281 static INLINE TX_SIZE get_uv_tx_size_impl(TX_SIZE y_tx_size, BLOCK_SIZE bsize) {
 282   if (bsize < BLOCK_8X8) {
 283     return TX_4X4;
 284   } else {
 285     // TODO(dkovalev): Assuming YUV420 (ss_x == 1, ss_y == 1)
 286     const BLOCK_SIZE plane_bsize = ss_size_lookup[bsize][1][1];
 287     return MIN(y_tx_size, max_txsize_lookup[plane_bsize]);
 288   }
 289 }
 290
 291 static INLINE TX_SIZE get_uv_tx_size(const MB_MODE_INFO *mbmi) {
 292   return get_uv_tx_size_impl(mbmi->tx_size, mbmi->sb_type);
 293 }
 294
 295 static INLINE BLOCK_SIZE get_plane_block_size(BLOCK_SIZE bsize,
 296     const struct macroblockd_plane *pd) {
 297   BLOCK_SIZE bs = ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
 298   assert(bs < BLOCK_SIZES);
 299   return bs;
 300 }
 301
 302 typedef void (*foreach_transformed_block_visitor)(int plane, int block,
 303                                                   BLOCK_SIZE plane_bsize,
 304                                                   TX_SIZE tx_size,
 305                                                   void *arg);
 306
 307 void vp9_foreach_transformed_block_in_plane(
 308     const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
 309     foreach_transformed_block_visitor visit, void *arg);
 310
 311
 312 void vp9_foreach_transformed_block(
 313     const MACROBLOCKD* const xd, BLOCK_SIZE bsize,
 314     foreach_transformed_block_visitor visit, void *arg);
 315
 316 static INLINE void txfrm_block_to_raster_xy(BLOCK_SIZE plane_bsize,
 317                                             TX_SIZE tx_size, int block,
 318                                             int *x, int *y) {
 319   const int bwl = b_width_log2(plane_bsize);
 320   const int tx_cols_log2 = bwl - tx_size;
 321   const int tx_cols = 1 << tx_cols_log2;
 322   const int raster_mb = block >> (tx_size << 1);
 323   *x = (raster_mb & (tx_cols - 1)) << tx_size;
 324   *y = (raster_mb >> tx_cols_log2) << tx_size;
 325 }
 326
 327 void vp9_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
 328                       BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int has_eob,
 329                       int aoff, int loff);
 330
 331
 332 static INLINE int get_tx_eob(const struct segmentation *seg, int segment_id,
 333                              TX_SIZE tx_size) {
 334   const int eob_max = 16 << (tx_size << 1);
 335   return vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP) ? 0 : eob_max;
 336 }
 337
 338 #ifdef __cplusplus
 339 }  // extern "C"
 340 #endif
 341
 342 #endif  // VP9_COMMON_VP9_BLOCKD_H_