vp9_blockd.h 8.64 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9 10 11
 */


12 13
#ifndef VP9_COMMON_VP9_BLOCKD_H_
#define VP9_COMMON_VP9_BLOCKD_H_
John Koleszar's avatar
John Koleszar committed
14

15
#include "./vpx_config.h"
16 17

#include "vpx_ports/mem.h"
John Koleszar's avatar
John Koleszar committed
18
#include "vpx_scale/yv12config.h"
19 20

#include "vp9/common/vp9_common_data.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
21 22
#include "vp9/common/vp9_entropy.h"
#include "vp9/common/vp9_entropymode.h"
23
#include "vp9/common/vp9_mv.h"
24
#include "vp9/common/vp9_scale.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
25
#include "vp9/common/vp9_seg_common.h"
John Koleszar's avatar
John Koleszar committed
26

27 28 29 30
#ifdef __cplusplus
extern "C" {
#endif

31 32
#define MAX_MB_PLANE 3

John Koleszar's avatar
John Koleszar committed
33 34
typedef enum {
  KEY_FRAME = 0,
35
  INTER_FRAME = 1,
36
  FRAME_TYPES,
John Koleszar's avatar
John Koleszar committed
37 38
} FRAME_TYPE;

39
static INLINE int is_inter_mode(PREDICTION_MODE mode) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
40
  return mode >= NEARESTMV && mode <= NEWMV;
41 42
}

John Koleszar's avatar
John Koleszar committed
43 44 45 46
/* For keyframes, intra block modes are predicted by the (already decoded)
   modes for the Y blocks to the left and above us; for interframes, there
   is a single probability table. */

47
typedef struct {
48
  PREDICTION_MODE as_mode;
49
  int_mv as_mv[2];  // first, second inter predictor motion vectors
50
} b_mode_info;
John Koleszar's avatar
John Koleszar committed
51

52 53 54
// Note that the rate-distortion optimization loop, bit-stream writer, and
// decoder implementation modules critically rely on the enum entry values
// specified herein. They should be refactored concurrently.
John Koleszar's avatar
John Koleszar committed
55
typedef enum {
56
  NONE = -1,
John Koleszar's avatar
John Koleszar committed
57 58 59 60 61
  INTRA_FRAME = 0,
  LAST_FRAME = 1,
  GOLDEN_FRAME = 2,
  ALTREF_FRAME = 3,
  MAX_REF_FRAMES = 4
John Koleszar's avatar
John Koleszar committed
62 63
} MV_REFERENCE_FRAME;

Paul Wilkins's avatar
Paul Wilkins committed
64
// This structure now relates to 8x8 block regions.
John Koleszar's avatar
John Koleszar committed
65
typedef struct {
66 67
  // Common for both INTER and INTRA blocks
  BLOCK_SIZE sb_type;
68
  PREDICTION_MODE mode;
69
  TX_SIZE tx_size;
70 71 72
  int8_t skip;
  int8_t segment_id;
  int8_t seg_id_predicted;  // valid only when temporal_update is enabled
John Koleszar's avatar
John Koleszar committed
73

74
  // Only for INTRA blocks
75
  PREDICTION_MODE uv_mode;
John Koleszar's avatar
John Koleszar committed
76

77 78 79 80 81
  // Only for INTER blocks
  MV_REFERENCE_FRAME ref_frame[2];
  int_mv mv[2];
  int_mv ref_mvs[MAX_REF_FRAMES][MAX_MV_REF_CANDIDATES];
  uint8_t mode_context[MAX_REF_FRAMES];
82
  INTERP_FILTER interp_filter;
83

John Koleszar's avatar
John Koleszar committed
84 85
} MB_MODE_INFO;

hkuang's avatar
hkuang committed
86
typedef struct MODE_INFO {
John Koleszar's avatar
John Koleszar committed
87
  MB_MODE_INFO mbmi;
88
  b_mode_info bmi[4];
John Koleszar's avatar
John Koleszar committed
89 90
} MODE_INFO;

91
static INLINE PREDICTION_MODE get_y_mode(const MODE_INFO *mi, int block) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
92 93 94 95
  return mi->mbmi.sb_type < BLOCK_8X8 ? mi->bmi[block].as_mode
                                      : mi->mbmi.mode;
}

96
static INLINE int is_inter_block(const MB_MODE_INFO *mbmi) {
97 98 99
  return mbmi->ref_frame[0] > INTRA_FRAME;
}

100 101 102 103
static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
  return mbmi->ref_frame[1] > INTRA_FRAME;
}

104 105
PREDICTION_MODE vp9_left_block_mode(const MODE_INFO *cur_mi,
                                    const MODE_INFO *left_mi, int b);
106

107 108
PREDICTION_MODE vp9_above_block_mode(const MODE_INFO *cur_mi,
                                     const MODE_INFO *above_mi, int b);
109

110 111 112 113 114
enum mv_precision {
  MV_PRECISION_Q3,
  MV_PRECISION_Q4
};

115 116 117 118 119
struct buf_2d {
  uint8_t *buf;
  int stride;
};

120
struct macroblockd_plane {
121
  tran_low_t *dqcoeff;
122 123 124
  PLANE_TYPE plane_type;
  int subsampling_x;
  int subsampling_y;
125 126
  struct buf_2d dst;
  struct buf_2d pre[2];
127 128
  ENTROPY_CONTEXT *above_context;
  ENTROPY_CONTEXT *left_context;
129 130 131 132
  int16_t seg_dequant[MAX_SEGMENTS][2];

  // encoder
  const int16_t *dequant;
133 134
};

135
#define BLOCK_OFFSET(x, i) ((x) + (i) * 16)
136

Dmitry Kovalev's avatar
Dmitry Kovalev committed
137 138 139 140 141 142 143 144
typedef struct RefBuffer {
  // TODO(dkovalev): idx is not really required and should be removed, now it
  // is used in vp9_onyxd_if.c
  int idx;
  YV12_BUFFER_CONFIG *buf;
  struct scale_factors sf;
} RefBuffer;

Jim Bankoski's avatar
Jim Bankoski committed
145
typedef struct macroblockd {
146
  struct macroblockd_plane plane[MAX_MB_PLANE];
Scott LaVarnway's avatar
Scott LaVarnway committed
147
  FRAME_COUNTS *counts;
148
  int mi_stride;
John Koleszar's avatar
John Koleszar committed
149

150
  MODE_INFO **mi;
151 152 153 154
  MODE_INFO *left_mi;
  MODE_INFO *above_mi;
  MB_MODE_INFO *left_mbmi;
  MB_MODE_INFO *above_mbmi;
155

John Koleszar's avatar
John Koleszar committed
156 157
  int up_available;
  int left_available;
John Koleszar's avatar
John Koleszar committed
158

John Koleszar's avatar
John Koleszar committed
159 160 161 162 163 164
  /* Distance of MB away from frame edges */
  int mb_to_left_edge;
  int mb_to_right_edge;
  int mb_to_top_edge;
  int mb_to_bottom_edge;

165 166 167
  FRAME_CONTEXT *fc;
  int frame_parallel_decoding_mode;

168
  /* pointers to reference frames */
Dmitry Kovalev's avatar
Dmitry Kovalev committed
169
  RefBuffer *block_refs[2];
170

171 172 173
  /* pointer to current frame */
  const YV12_BUFFER_CONFIG *cur_buf;

174 175 176 177 178 179
  ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
  ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];

  PARTITION_CONTEXT *above_seg_context;
  PARTITION_CONTEXT left_seg_context[8];

180 181 182 183 184
#if CONFIG_VP9_HIGHBITDEPTH
  /* Bit depth: 8, 10, 12 */
  int bd;
#endif

185 186
  /* dqcoeff are shared by all the planes. So planes must be decoded serially */
  DECLARE_ALIGNED(16, tran_low_t, dqcoeff[64 * 64]);
187

188 189
  int lossless;
  int corrupted;
190 191

  struct vpx_internal_error_info *error_info;
John Koleszar's avatar
John Koleszar committed
192 193
} MACROBLOCKD;

194 195
static INLINE BLOCK_SIZE get_subsize(BLOCK_SIZE bsize,
                                     PARTITION_TYPE partition) {
Yunqing Wang's avatar
Yunqing Wang committed
196
  return subsize_lookup[partition][bsize];
197 198
}

199
extern const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES];
200 201 202

static INLINE TX_TYPE get_tx_type(PLANE_TYPE plane_type,
                                  const MACROBLOCKD *xd) {
203
  const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
204

205
  if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mbmi))
206
    return DCT_DCT;
207

208
  return intra_mode_to_tx_type_lookup[mbmi->mode];
209
}
210

211 212
static INLINE TX_TYPE get_tx_type_4x4(PLANE_TYPE plane_type,
                                      const MACROBLOCKD *xd, int ib) {
213
  const MODE_INFO *const mi = xd->mi[0];
214

Dmitry Kovalev's avatar
Dmitry Kovalev committed
215
  if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(&mi->mbmi))
Yaowu Xu's avatar
Yaowu Xu committed
216
    return DCT_DCT;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
217

218
  return intra_mode_to_tx_type_lookup[get_y_mode(mi, ib)];
Deb Mukherjee's avatar
Deb Mukherjee committed
219 220
}

221
void vp9_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
222

223 224
static INLINE TX_SIZE get_uv_tx_size_impl(TX_SIZE y_tx_size, BLOCK_SIZE bsize,
                                          int xss, int yss) {
225 226 227
  if (bsize < BLOCK_8X8) {
    return TX_4X4;
  } else {
228
    const BLOCK_SIZE plane_bsize = ss_size_lookup[bsize][xss][yss];
229 230 231
    return MIN(y_tx_size, max_txsize_lookup[plane_bsize]);
  }
}
John Koleszar's avatar
John Koleszar committed
232

233 234 235 236
static INLINE TX_SIZE get_uv_tx_size(const MB_MODE_INFO *mbmi,
                                     const struct macroblockd_plane *pd) {
  return get_uv_tx_size_impl(mbmi->tx_size, mbmi->sb_type, pd->subsampling_x,
                             pd->subsampling_y);
237
}
238

239 240
static INLINE BLOCK_SIZE get_plane_block_size(BLOCK_SIZE bsize,
    const struct macroblockd_plane *pd) {
Yunqing Wang's avatar
Yunqing Wang committed
241
  return ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
242 243
}

Scott LaVarnway's avatar
Scott LaVarnway committed
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
static INLINE void reset_skip_context(MACROBLOCKD *xd, BLOCK_SIZE bsize) {
  int i;
  for (i = 0; i < MAX_MB_PLANE; i++) {
    struct macroblockd_plane *const pd = &xd->plane[i];
    const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
    memset(pd->above_context, 0,
           sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide_lookup[plane_bsize]);
    memset(pd->left_context, 0,
           sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high_lookup[plane_bsize]);
  }
}

static INLINE const vp9_prob *get_y_mode_probs(const MODE_INFO *mi,
                                               const MODE_INFO *above_mi,
                                               const MODE_INFO *left_mi,
                                               int block) {
  const PREDICTION_MODE above = vp9_above_block_mode(mi, above_mi, block);
  const PREDICTION_MODE left = vp9_left_block_mode(mi, left_mi, block);
  return vp9_kf_y_mode_prob[above][left];
}

John Koleszar's avatar
John Koleszar committed
265
typedef void (*foreach_transformed_block_visitor)(int plane, int block,
266
                                                  BLOCK_SIZE plane_bsize,
267
                                                  TX_SIZE tx_size,
John Koleszar's avatar
John Koleszar committed
268
                                                  void *arg);
Jingning Han's avatar
Jingning Han committed
269

270
void vp9_foreach_transformed_block_in_plane(
271
    const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
272
    foreach_transformed_block_visitor visit, void *arg);
John Koleszar's avatar
John Koleszar committed
273

274 275

void vp9_foreach_transformed_block(
276
    const MACROBLOCKD* const xd, BLOCK_SIZE bsize,
277
    foreach_transformed_block_visitor visit, void *arg);
278

279 280 281
static INLINE void txfrm_block_to_raster_xy(BLOCK_SIZE plane_bsize,
                                            TX_SIZE tx_size, int block,
                                            int *x, int *y) {
282
  const int bwl = b_width_log2_lookup[plane_bsize];
283
  const int tx_cols_log2 = bwl - tx_size;
284
  const int tx_cols = 1 << tx_cols_log2;
285
  const int raster_mb = block >> (tx_size << 1);
286
  *x = (raster_mb & (tx_cols - 1)) << tx_size;
287
  *y = (raster_mb >> tx_cols_log2) << tx_size;
John Koleszar's avatar
John Koleszar committed
288
}
289

290 291 292
void vp9_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
                      BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int has_eob,
                      int aoff, int loff);
293

294 295 296 297
#ifdef __cplusplus
}  // extern "C"
#endif

298
#endif  // VP9_COMMON_VP9_BLOCKD_H_