vp9_blockd.h 8.86 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"
Scott LaVarnway's avatar
Scott LaVarnway committed
26
#include "vp9/common/vp9_tile_common.h"
John Koleszar's avatar
John Koleszar committed
27

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

32
33
#define MAX_MB_PLANE 3

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

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

John Koleszar's avatar
John Koleszar committed
44
45
46
47
/* 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. */

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

53
// Note that the rate-distortion optimization loop, bit-stream writer, and
54
// decoder implementation modules critically rely on the defined entry values
55
// specified herein. They should be refactored concurrently.
56
57
58
59
60
61
62
63

#define NONE           -1
#define INTRA_FRAME     0
#define LAST_FRAME      1
#define GOLDEN_FRAME    2
#define ALTREF_FRAME    3
#define MAX_REF_FRAMES  4
typedef int8_t MV_REFERENCE_FRAME;
John Koleszar's avatar
John Koleszar committed
64

Paul Wilkins's avatar
Paul Wilkins committed
65
// This structure now relates to 8x8 block regions.
John Koleszar's avatar
John Koleszar committed
66
typedef struct {
67
68
  // Common for both INTER and INTRA blocks
  BLOCK_SIZE sb_type;
69
  PREDICTION_MODE mode;
70
  TX_SIZE tx_size;
71
72
73
  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
74

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

78
  // Only for INTER blocks
79
  INTERP_FILTER interp_filter;
80
  MV_REFERENCE_FRAME ref_frame[2];
81
82

  // TODO(slavarnway): Delete and use bmi[3].as_mv[] instead.
83
  int_mv mv[2];
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

Scott LaVarnway's avatar
Scott LaVarnway committed
148
  FRAME_COUNTS *counts;
Scott LaVarnway's avatar
Scott LaVarnway committed
149
150
  TileInfo tile;

151
  int mi_stride;
John Koleszar's avatar
John Koleszar committed
152

153
  MODE_INFO **mi;
154
155
156
157
  MODE_INFO *left_mi;
  MODE_INFO *above_mi;
  MB_MODE_INFO *left_mbmi;
  MB_MODE_INFO *above_mbmi;
158

John Koleszar's avatar
John Koleszar committed
159
160
  int up_available;
  int left_available;
John Koleszar's avatar
John Koleszar committed
161

162
163
  const vp9_prob (*partition_probs)[PARTITION_TYPES - 1];

John Koleszar's avatar
John Koleszar committed
164
165
166
167
168
169
  /* 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;

170
171
172
  FRAME_CONTEXT *fc;
  int frame_parallel_decoding_mode;

173
  /* pointers to reference frames */
Dmitry Kovalev's avatar
Dmitry Kovalev committed
174
  RefBuffer *block_refs[2];
175

176
177
178
  /* pointer to current frame */
  const YV12_BUFFER_CONFIG *cur_buf;

179
180
181
182
183
184
  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];

185
186
187
188
189
#if CONFIG_VP9_HIGHBITDEPTH
  /* Bit depth: 8, 10, 12 */
  int bd;
#endif

190
  /* dqcoeff are shared by all the planes. So planes must be decoded serially */
191
#if CONFIG_VP9_ENCODER
192
  DECLARE_ALIGNED(16, tran_low_t, dqcoeff[64 * 64]);
193
194
195
#else
  DECLARE_ALIGNED(16, tran_low_t, dqcoeff[32 * 32]);
#endif
196
197
  int lossless;
  int corrupted;
198
199

  struct vpx_internal_error_info *error_info;
John Koleszar's avatar
John Koleszar committed
200
201
} MACROBLOCKD;

202
203
static INLINE BLOCK_SIZE get_subsize(BLOCK_SIZE bsize,
                                     PARTITION_TYPE partition) {
Yunqing Wang's avatar
Yunqing Wang committed
204
  return subsize_lookup[partition][bsize];
205
206
}

207
extern const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES];
208
209
210

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

213
  if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mbmi))
214
    return DCT_DCT;
215

216
  return intra_mode_to_tx_type_lookup[mbmi->mode];
217
}
218

219
220
static INLINE TX_TYPE get_tx_type_4x4(PLANE_TYPE plane_type,
                                      const MACROBLOCKD *xd, int ib) {
221
  const MODE_INFO *const mi = xd->mi[0];
222

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

226
  return intra_mode_to_tx_type_lookup[get_y_mode(mi, ib)];
Deb Mukherjee's avatar
Deb Mukherjee committed
227
228
}

229
void vp9_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
230

231
232
static INLINE TX_SIZE get_uv_tx_size_impl(TX_SIZE y_tx_size, BLOCK_SIZE bsize,
                                          int xss, int yss) {
233
234
235
  if (bsize < BLOCK_8X8) {
    return TX_4X4;
  } else {
236
    const BLOCK_SIZE plane_bsize = ss_size_lookup[bsize][xss][yss];
237
238
239
    return MIN(y_tx_size, max_txsize_lookup[plane_bsize]);
  }
}
John Koleszar's avatar
John Koleszar committed
240

241
242
243
244
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);
245
}
246

247
248
static INLINE BLOCK_SIZE get_plane_block_size(BLOCK_SIZE bsize,
    const struct macroblockd_plane *pd) {
Yunqing Wang's avatar
Yunqing Wang committed
249
  return ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
250
251
}

Scott LaVarnway's avatar
Scott LaVarnway committed
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
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
273
typedef void (*foreach_transformed_block_visitor)(int plane, int block,
274
                                                  BLOCK_SIZE plane_bsize,
275
                                                  TX_SIZE tx_size,
John Koleszar's avatar
John Koleszar committed
276
                                                  void *arg);
Jingning Han's avatar
Jingning Han committed
277

278
void vp9_foreach_transformed_block_in_plane(
279
    const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
280
    foreach_transformed_block_visitor visit, void *arg);
John Koleszar's avatar
John Koleszar committed
281

282
283

void vp9_foreach_transformed_block(
284
    const MACROBLOCKD* const xd, BLOCK_SIZE bsize,
285
    foreach_transformed_block_visitor visit, void *arg);
286

287
288
289
static INLINE void txfrm_block_to_raster_xy(BLOCK_SIZE plane_bsize,
                                            TX_SIZE tx_size, int block,
                                            int *x, int *y) {
290
  const int bwl = b_width_log2_lookup[plane_bsize];
291
  const int tx_cols_log2 = bwl - tx_size;
292
  const int tx_cols = 1 << tx_cols_log2;
293
  const int raster_mb = block >> (tx_size << 1);
294
  *x = (raster_mb & (tx_cols - 1)) << tx_size;
295
  *y = (raster_mb >> tx_cols_log2) << tx_size;
John Koleszar's avatar
John Koleszar committed
296
}
297

298
299
300
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);
301

302
303
304
305
#ifdef __cplusplus
}  // extern "C"
#endif

306
#endif  // VP9_COMMON_VP9_BLOCKD_H_