vp10/common/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 VP10_COMMON_BLOCKD_H_
  13 #define VP10_COMMON_BLOCKD_H_
  14
  15 #include "./vpx_config.h"
  16
  17 #include "vpx_dsp/vpx_dsp_common.h"
  18 #include "vpx_ports/mem.h"
  19 #include "vpx_scale/yv12config.h"
  20
  21 #include "vp10/common/common_data.h"
  22 #include "vp10/common/entropy.h"
  23 #include "vp10/common/entropymode.h"
  24 #include "vp10/common/mv.h"
  25 #include "vp10/common/scale.h"
  26 #include "vp10/common/seg_common.h"
  27 #include "vp10/common/tile_common.h"
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 #define MAX_MB_PLANE 3
  34
  35 typedef enum {
  36   KEY_FRAME = 0,
  37   INTER_FRAME = 1,
  38   FRAME_TYPES,
  39 } FRAME_TYPE;
  40
  41 static INLINE int is_inter_mode(PREDICTION_MODE mode) {
  42   return mode >= NEARESTMV && mode <= NEWMV;
  43 }
  44
  45 /* For keyframes, intra block modes are predicted by the (already decoded)
  46    modes for the Y blocks to the left and above us; for interframes, there
  47    is a single probability table. */
  48
  49 typedef struct {
  50   PREDICTION_MODE as_mode;
  51   int_mv as_mv[2];  // first, second inter predictor motion vectors
  52 } b_mode_info;
  53
  54 // Note that the rate-distortion optimization loop, bit-stream writer, and
  55 // decoder implementation modules critically rely on the defined entry values
  56 // specified herein. They should be refactored concurrently.
  57
  58 #define NONE           -1
  59 #define INTRA_FRAME     0
  60 #define LAST_FRAME      1
  61 #define GOLDEN_FRAME    2
  62 #define ALTREF_FRAME    3
  63 #define MAX_REF_FRAMES  4
  64 typedef int8_t MV_REFERENCE_FRAME;
  65
  66 // This structure now relates to 8x8 block regions.
  67 typedef struct {
  68   // Common for both INTER and INTRA blocks
  69   BLOCK_SIZE sb_type;
  70   PREDICTION_MODE mode;
  71   TX_SIZE tx_size;
  72   int8_t skip;
  73 #if CONFIG_MISC_FIXES
  74   int8_t has_no_coeffs;
  75 #endif
  76   int8_t segment_id;
  77   int8_t seg_id_predicted;  // valid only when temporal_update is enabled
  78
  79   // Only for INTRA blocks
  80   PREDICTION_MODE uv_mode;
  81
  82   // Only for INTER blocks
  83   INTERP_FILTER interp_filter;
  84   MV_REFERENCE_FRAME ref_frame[2];
  85
  86   // TODO(slavarnway): Delete and use bmi[3].as_mv[] instead.
  87   int_mv mv[2];
  88 } MB_MODE_INFO;
  89
  90 typedef struct MODE_INFO {
  91   MB_MODE_INFO mbmi;
  92   b_mode_info bmi[4];
  93 } MODE_INFO;
  94
  95 static INLINE PREDICTION_MODE get_y_mode(const MODE_INFO *mi, int block) {
  96   return mi->mbmi.sb_type < BLOCK_8X8 ? mi->bmi[block].as_mode
  97                                       : mi->mbmi.mode;
  98 }
  99
 100 static INLINE int is_inter_block(const MB_MODE_INFO *mbmi) {
 101   return mbmi->ref_frame[0] > INTRA_FRAME;
 102 }
 103
 104 static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
 105   return mbmi->ref_frame[1] > INTRA_FRAME;
 106 }
 107
 108 PREDICTION_MODE vp10_left_block_mode(const MODE_INFO *cur_mi,
 109                                     const MODE_INFO *left_mi, int b);
 110
 111 PREDICTION_MODE vp10_above_block_mode(const MODE_INFO *cur_mi,
 112                                      const MODE_INFO *above_mi, int b);
 113
 114 enum mv_precision {
 115   MV_PRECISION_Q3,
 116   MV_PRECISION_Q4
 117 };
 118
 119 struct buf_2d {
 120   uint8_t *buf;
 121   int stride;
 122 };
 123
 124 struct macroblockd_plane {
 125   tran_low_t *dqcoeff;
 126   PLANE_TYPE plane_type;
 127   int subsampling_x;
 128   int subsampling_y;
 129   struct buf_2d dst;
 130   struct buf_2d pre[2];
 131   ENTROPY_CONTEXT *above_context;
 132   ENTROPY_CONTEXT *left_context;
 133   int16_t seg_dequant[MAX_SEGMENTS][2];
 134
 135   // number of 4x4s in current block
 136   uint16_t n4_w, n4_h;
 137   // log2 of n4_w, n4_h
 138   uint8_t n4_wl, n4_hl;
 139
 140   // encoder
 141   const int16_t *dequant;
 142 };
 143
 144 #define BLOCK_OFFSET(x, i) ((x) + (i) * 16)
 145
 146 typedef struct RefBuffer {
 147   // TODO(dkovalev): idx is not really required and should be removed, now it
 148   // is used in vp10_onyxd_if.c
 149   int idx;
 150   YV12_BUFFER_CONFIG *buf;
 151   struct scale_factors sf;
 152 } RefBuffer;
 153
 154 typedef struct macroblockd {
 155   struct macroblockd_plane plane[MAX_MB_PLANE];
 156   uint8_t bmode_blocks_wl;
 157   uint8_t bmode_blocks_hl;
 158
 159   FRAME_COUNTS *counts;
 160   TileInfo tile;
 161
 162   int mi_stride;
 163
 164   MODE_INFO **mi;
 165   MODE_INFO *left_mi;
 166   MODE_INFO *above_mi;
 167   MB_MODE_INFO *left_mbmi;
 168   MB_MODE_INFO *above_mbmi;
 169
 170   int up_available;
 171   int left_available;
 172
 173   const vpx_prob (*partition_probs)[PARTITION_TYPES - 1];
 174
 175   /* Distance of MB away from frame edges */
 176   int mb_to_left_edge;
 177   int mb_to_right_edge;
 178   int mb_to_top_edge;
 179   int mb_to_bottom_edge;
 180
 181   FRAME_CONTEXT *fc;
 182
 183   /* pointers to reference frames */
 184   RefBuffer *block_refs[2];
 185
 186   /* pointer to current frame */
 187   const YV12_BUFFER_CONFIG *cur_buf;
 188
 189   ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
 190   ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];
 191
 192   PARTITION_CONTEXT *above_seg_context;
 193   PARTITION_CONTEXT left_seg_context[8];
 194
 195 #if CONFIG_VP9_HIGHBITDEPTH
 196   /* Bit depth: 8, 10, 12 */
 197   int bd;
 198 #endif
 199
 200   int lossless;
 201   int corrupted;
 202
 203   struct vpx_internal_error_info *error_info;
 204 } MACROBLOCKD;
 205
 206 static INLINE BLOCK_SIZE get_subsize(BLOCK_SIZE bsize,
 207                                      PARTITION_TYPE partition) {
 208   return subsize_lookup[partition][bsize];
 209 }
 210
 211 static const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES] = {
 212   DCT_DCT,    // DC
 213   ADST_DCT,   // V
 214   DCT_ADST,   // H
 215   DCT_DCT,    // D45
 216   ADST_ADST,  // D135
 217   ADST_DCT,   // D117
 218   DCT_ADST,   // D153
 219   DCT_ADST,   // D207
 220   ADST_DCT,   // D63
 221   ADST_ADST,  // TM
 222 };
 223
 224 static INLINE TX_TYPE get_tx_type(PLANE_TYPE plane_type, const MACROBLOCKD *xd,
 225                                   int block_idx) {
 226   const MODE_INFO *const mi = xd->mi[0];
 227   const MB_MODE_INFO *const mbmi = &mi->mbmi;
 228
 229   if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mbmi) ||
 230       mbmi->tx_size >= TX_32X32)
 231     return DCT_DCT;
 232
 233   return intra_mode_to_tx_type_lookup[get_y_mode(mi, block_idx)];
 234 }
 235
 236 void vp10_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
 237
 238 static INLINE TX_SIZE get_uv_tx_size_impl(TX_SIZE y_tx_size, BLOCK_SIZE bsize,
 239                                           int xss, int yss) {
 240   if (bsize < BLOCK_8X8) {
 241     return TX_4X4;
 242   } else {
 243     const BLOCK_SIZE plane_bsize = ss_size_lookup[bsize][xss][yss];
 244     return VPXMIN(y_tx_size, max_txsize_lookup[plane_bsize]);
 245   }
 246 }
 247
 248 static INLINE TX_SIZE get_uv_tx_size(const MB_MODE_INFO *mbmi,
 249                                      const struct macroblockd_plane *pd) {
 250   return get_uv_tx_size_impl(mbmi->tx_size, mbmi->sb_type, pd->subsampling_x,
 251                              pd->subsampling_y);
 252 }
 253
 254 static INLINE BLOCK_SIZE get_plane_block_size(BLOCK_SIZE bsize,
 255     const struct macroblockd_plane *pd) {
 256   return ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
 257 }
 258
 259 static INLINE void reset_skip_context(MACROBLOCKD *xd, BLOCK_SIZE bsize) {
 260   int i;
 261   for (i = 0; i < MAX_MB_PLANE; i++) {
 262     struct macroblockd_plane *const pd = &xd->plane[i];
 263     const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
 264     memset(pd->above_context, 0,
 265            sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide_lookup[plane_bsize]);
 266     memset(pd->left_context, 0,
 267            sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high_lookup[plane_bsize]);
 268   }
 269 }
 270
 271 static INLINE const vpx_prob *get_y_mode_probs(const MODE_INFO *mi,
 272                                                const MODE_INFO *above_mi,
 273                                                const MODE_INFO *left_mi,
 274                                                int block) {
 275   const PREDICTION_MODE above = vp10_above_block_mode(mi, above_mi, block);
 276   const PREDICTION_MODE left = vp10_left_block_mode(mi, left_mi, block);
 277   return vp10_kf_y_mode_prob[above][left];
 278 }
 279
 280 typedef void (*foreach_transformed_block_visitor)(int plane, int block,
 281                                                   BLOCK_SIZE plane_bsize,
 282                                                   TX_SIZE tx_size,
 283                                                   void *arg);
 284
 285 void vp10_foreach_transformed_block_in_plane(
 286     const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
 287     foreach_transformed_block_visitor visit, void *arg);
 288
 289
 290 void vp10_foreach_transformed_block(
 291     const MACROBLOCKD* const xd, BLOCK_SIZE bsize,
 292     foreach_transformed_block_visitor visit, void *arg);
 293
 294 static INLINE void txfrm_block_to_raster_xy(BLOCK_SIZE plane_bsize,
 295                                             TX_SIZE tx_size, int block,
 296                                             int *x, int *y) {
 297   const int bwl = b_width_log2_lookup[plane_bsize];
 298   const int tx_cols_log2 = bwl - tx_size;
 299   const int tx_cols = 1 << tx_cols_log2;
 300   const int raster_mb = block >> (tx_size << 1);
 301   *x = (raster_mb & (tx_cols - 1)) << tx_size;
 302   *y = (raster_mb >> tx_cols_log2) << tx_size;
 303 }
 304
 305 void vp10_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
 306                       BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int has_eob,
 307                       int aoff, int loff);
 308
 309 #ifdef __cplusplus
 310 }  // extern "C"
 311 #endif
 312
 313 #endif  // VP10_COMMON_BLOCKD_H_