granicus.if.org Git - libvpx/blob - 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 typedef struct {
  67   // Number of base colors for Y (0) and UV (1)
  68   uint8_t palette_size[2];
  69   // Value of base colors for Y, U, and V
  70 #if CONFIG_VP9_HIGHBITDEPTH
  71   uint16_t palette_colors[3 * PALETTE_MAX_SIZE];
  72 #else
  73   uint8_t palette_colors[3 * PALETTE_MAX_SIZE];
  74 #endif  // CONFIG_VP9_HIGHBITDEPTH
  75   // Only used by encoder to store the color index of the top left pixel.
  76   // TODO(huisu): move this to encoder
  77   uint8_t palette_first_color_idx[2];
  78 } PALETTE_MODE_INFO;
  79
  80 // This structure now relates to 8x8 block regions.
  81 typedef struct {
  82   // Common for both INTER and INTRA blocks
  83   BLOCK_SIZE sb_type;
  84   PREDICTION_MODE mode;
  85   TX_SIZE tx_size;
  86   int8_t skip;
  87 #if CONFIG_MISC_FIXES
  88   int8_t has_no_coeffs;
  89 #endif
  90   int8_t segment_id;
  91   int8_t seg_id_predicted;  // valid only when temporal_update is enabled
  92
  93   // Only for INTRA blocks
  94   PREDICTION_MODE uv_mode;
  95   PALETTE_MODE_INFO palette_mode_info;
  96
  97   // Only for INTER blocks
  98   INTERP_FILTER interp_filter;
  99   MV_REFERENCE_FRAME ref_frame[2];
 100
 101   // TODO(slavarnway): Delete and use bmi[3].as_mv[] instead.
 102   int_mv mv[2];
 103 } MB_MODE_INFO;
 104
 105 typedef struct MODE_INFO {
 106   MB_MODE_INFO mbmi;
 107   b_mode_info bmi[4];
 108 } MODE_INFO;
 109
 110 static INLINE PREDICTION_MODE get_y_mode(const MODE_INFO *mi, int block) {
 111   return mi->mbmi.sb_type < BLOCK_8X8 ? mi->bmi[block].as_mode
 112                                       : mi->mbmi.mode;
 113 }
 114
 115 static INLINE int is_inter_block(const MB_MODE_INFO *mbmi) {
 116   return mbmi->ref_frame[0] > INTRA_FRAME;
 117 }
 118
 119 static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
 120   return mbmi->ref_frame[1] > INTRA_FRAME;
 121 }
 122
 123 PREDICTION_MODE vp10_left_block_mode(const MODE_INFO *cur_mi,
 124                                     const MODE_INFO *left_mi, int b);
 125
 126 PREDICTION_MODE vp10_above_block_mode(const MODE_INFO *cur_mi,
 127                                      const MODE_INFO *above_mi, int b);
 128
 129 enum mv_precision {
 130   MV_PRECISION_Q3,
 131   MV_PRECISION_Q4
 132 };
 133
 134 struct buf_2d {
 135   uint8_t *buf;
 136   int stride;
 137 };
 138
 139 struct macroblockd_plane {
 140   tran_low_t *dqcoeff;
 141   PLANE_TYPE plane_type;
 142   int subsampling_x;
 143   int subsampling_y;
 144   struct buf_2d dst;
 145   struct buf_2d pre[2];
 146   ENTROPY_CONTEXT *above_context;
 147   ENTROPY_CONTEXT *left_context;
 148   int16_t seg_dequant[MAX_SEGMENTS][2];
 149   uint8_t *color_index_map;
 150
 151   // number of 4x4s in current block
 152   uint16_t n4_w, n4_h;
 153   // log2 of n4_w, n4_h
 154   uint8_t n4_wl, n4_hl;
 155
 156   // encoder
 157   const int16_t *dequant;
 158 };
 159
 160 #define BLOCK_OFFSET(x, i) ((x) + (i) * 16)
 161
 162 typedef struct RefBuffer {
 163   // TODO(dkovalev): idx is not really required and should be removed, now it
 164   // is used in vp10_onyxd_if.c
 165   int idx;
 166   YV12_BUFFER_CONFIG *buf;
 167   struct scale_factors sf;
 168 } RefBuffer;
 169
 170 typedef struct macroblockd {
 171   struct macroblockd_plane plane[MAX_MB_PLANE];
 172   uint8_t bmode_blocks_wl;
 173   uint8_t bmode_blocks_hl;
 174
 175   FRAME_COUNTS *counts;
 176   TileInfo tile;
 177
 178   int mi_stride;
 179
 180   MODE_INFO **mi;
 181   MODE_INFO *left_mi;
 182   MODE_INFO *above_mi;
 183   MB_MODE_INFO *left_mbmi;
 184   MB_MODE_INFO *above_mbmi;
 185
 186   int up_available;
 187   int left_available;
 188
 189   const vpx_prob (*partition_probs)[PARTITION_TYPES - 1];
 190
 191   /* Distance of MB away from frame edges */
 192   int mb_to_left_edge;
 193   int mb_to_right_edge;
 194   int mb_to_top_edge;
 195   int mb_to_bottom_edge;
 196
 197   FRAME_CONTEXT *fc;
 198
 199   /* pointers to reference frames */
 200   RefBuffer *block_refs[2];
 201
 202   /* pointer to current frame */
 203   const YV12_BUFFER_CONFIG *cur_buf;
 204
 205   ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
 206   ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];
 207
 208   PARTITION_CONTEXT *above_seg_context;
 209   PARTITION_CONTEXT left_seg_context[8];
 210
 211 #if CONFIG_VP9_HIGHBITDEPTH
 212   /* Bit depth: 8, 10, 12 */
 213   int bd;
 214 #endif
 215
 216   int lossless;
 217   int corrupted;
 218
 219   struct vpx_internal_error_info *error_info;
 220 } MACROBLOCKD;
 221
 222 static INLINE BLOCK_SIZE get_subsize(BLOCK_SIZE bsize,
 223                                      PARTITION_TYPE partition) {
 224   return subsize_lookup[partition][bsize];
 225 }
 226
 227 static const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES] = {
 228   DCT_DCT,    // DC
 229   ADST_DCT,   // V
 230   DCT_ADST,   // H
 231   DCT_DCT,    // D45
 232   ADST_ADST,  // D135
 233   ADST_DCT,   // D117
 234   DCT_ADST,   // D153
 235   DCT_ADST,   // D207
 236   ADST_DCT,   // D63
 237   ADST_ADST,  // TM
 238 };
 239
 240 static INLINE TX_TYPE get_tx_type(PLANE_TYPE plane_type, const MACROBLOCKD *xd,
 241                                   int block_idx) {
 242   const MODE_INFO *const mi = xd->mi[0];
 243   const MB_MODE_INFO *const mbmi = &mi->mbmi;
 244
 245   if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mbmi) ||
 246       mbmi->tx_size >= TX_32X32)
 247     return DCT_DCT;
 248
 249   return intra_mode_to_tx_type_lookup[get_y_mode(mi, block_idx)];
 250 }
 251
 252 void vp10_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
 253
 254 static INLINE TX_SIZE get_uv_tx_size_impl(TX_SIZE y_tx_size, BLOCK_SIZE bsize,
 255                                           int xss, int yss) {
 256   if (bsize < BLOCK_8X8) {
 257     return TX_4X4;
 258   } else {
 259     const BLOCK_SIZE plane_bsize = ss_size_lookup[bsize][xss][yss];
 260     return VPXMIN(y_tx_size, max_txsize_lookup[plane_bsize]);
 261   }
 262 }
 263
 264 static INLINE TX_SIZE get_uv_tx_size(const MB_MODE_INFO *mbmi,
 265                                      const struct macroblockd_plane *pd) {
 266   return get_uv_tx_size_impl(mbmi->tx_size, mbmi->sb_type, pd->subsampling_x,
 267                              pd->subsampling_y);
 268 }
 269
 270 static INLINE BLOCK_SIZE get_plane_block_size(BLOCK_SIZE bsize,
 271     const struct macroblockd_plane *pd) {
 272   return ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
 273 }
 274
 275 static INLINE void reset_skip_context(MACROBLOCKD *xd, BLOCK_SIZE bsize) {
 276   int i;
 277   for (i = 0; i < MAX_MB_PLANE; i++) {
 278     struct macroblockd_plane *const pd = &xd->plane[i];
 279     const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
 280     memset(pd->above_context, 0,
 281            sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide_lookup[plane_bsize]);
 282     memset(pd->left_context, 0,
 283            sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high_lookup[plane_bsize]);
 284   }
 285 }
 286
 287 static INLINE const vpx_prob *get_y_mode_probs(const MODE_INFO *mi,
 288                                                const MODE_INFO *above_mi,
 289                                                const MODE_INFO *left_mi,
 290                                                int block) {
 291   const PREDICTION_MODE above = vp10_above_block_mode(mi, above_mi, block);
 292   const PREDICTION_MODE left = vp10_left_block_mode(mi, left_mi, block);
 293   return vp10_kf_y_mode_prob[above][left];
 294 }
 295
 296 typedef void (*foreach_transformed_block_visitor)(int plane, int block,
 297                                                   BLOCK_SIZE plane_bsize,
 298                                                   TX_SIZE tx_size,
 299                                                   void *arg);
 300
 301 void vp10_foreach_transformed_block_in_plane(
 302     const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
 303     foreach_transformed_block_visitor visit, void *arg);
 304
 305
 306 void vp10_foreach_transformed_block(
 307     const MACROBLOCKD* const xd, BLOCK_SIZE bsize,
 308     foreach_transformed_block_visitor visit, void *arg);
 309
 310 static INLINE void txfrm_block_to_raster_xy(BLOCK_SIZE plane_bsize,
 311                                             TX_SIZE tx_size, int block,
 312                                             int *x, int *y) {
 313   const int bwl = b_width_log2_lookup[plane_bsize];
 314   const int tx_cols_log2 = bwl - tx_size;
 315   const int tx_cols = 1 << tx_cols_log2;
 316   const int raster_mb = block >> (tx_size << 1);
 317   *x = (raster_mb & (tx_cols - 1)) << tx_size;
 318   *y = (raster_mb >> tx_cols_log2) << tx_size;
 319 }
 320
 321 void vp10_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
 322                       BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int has_eob,
 323                       int aoff, int loff);
 324
 325 #ifdef __cplusplus
 326 }  // extern "C"
 327 #endif
 328
 329 #endif  // VP10_COMMON_BLOCKD_H_