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 #ifndef VP9_COMMON_VP9_BLOCKD_H_
12 #define VP9_COMMON_VP9_BLOCKD_H_
13
14 #include "./vpx_config.h"
15
16 #include "vpx_dsp/vpx_dsp_common.h"
17 #include "vpx_ports/mem.h"
18 #include "vpx_scale/yv12config.h"
19
20 #include "vp9/common/vp9_common_data.h"
21 #include "vp9/common/vp9_entropy.h"
22 #include "vp9/common/vp9_entropymode.h"
23 #include "vp9/common/vp9_mv.h"
24 #include "vp9/common/vp9_scale.h"
25 #include "vp9/common/vp9_seg_common.h"
26 #include "vp9/common/vp9_tile_common.h"
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 #define MAX_MB_PLANE 3
33
34 typedef enum {
35 KEY_FRAME = 0,
36 INTER_FRAME = 1,
37 FRAME_TYPES,
38 } FRAME_TYPE;
39
is_inter_mode(PREDICTION_MODE mode)40 static INLINE int is_inter_mode(PREDICTION_MODE mode) {
41 return mode >= NEARESTMV && mode <= NEWMV;
42 }
43
44 /* For keyframes, intra block modes are predicted by the (already decoded)
45 modes for the Y blocks to the left and above us; for interframes, there
46 is a single probability table. */
47
48 typedef struct {
49 PREDICTION_MODE as_mode;
50 int_mv as_mv[2]; // first, second inter predictor motion vectors
51 } b_mode_info;
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 #define NONE -1
58 #define INTRA_FRAME 0
59 #define LAST_FRAME 1
60 #define GOLDEN_FRAME 2
61 #define ALTREF_FRAME 3
62 #define MAX_REF_FRAMES 4
63 typedef int8_t MV_REFERENCE_FRAME;
64
65 // This structure now relates to 8x8 block regions.
66 typedef struct MODE_INFO {
67 // Common for both INTER and INTRA blocks
68 BLOCK_SIZE sb_type;
69 PREDICTION_MODE mode;
70 TX_SIZE tx_size;
71 int8_t skip;
72 int8_t segment_id;
73 int8_t seg_id_predicted; // valid only when temporal_update is enabled
74
75 // Only for INTRA blocks
76 PREDICTION_MODE uv_mode;
77
78 // Only for INTER blocks
79 INTERP_FILTER interp_filter;
80
81 // if ref_frame[idx] is equal to ALTREF_FRAME then
82 // MACROBLOCKD::block_ref[idx] is an altref
83 MV_REFERENCE_FRAME ref_frame[2];
84
85 // TODO(slavarnway): Delete and use bmi[3].as_mv[] instead.
86 int_mv mv[2];
87
88 b_mode_info bmi[4];
89 } MODE_INFO;
90
get_y_mode(const MODE_INFO * mi,int block)91 static INLINE PREDICTION_MODE get_y_mode(const MODE_INFO *mi, int block) {
92 return mi->sb_type < BLOCK_8X8 ? mi->bmi[block].as_mode : mi->mode;
93 }
94
is_inter_block(const MODE_INFO * mi)95 static INLINE int is_inter_block(const MODE_INFO *mi) {
96 return mi->ref_frame[0] > INTRA_FRAME;
97 }
98
has_second_ref(const MODE_INFO * mi)99 static INLINE int has_second_ref(const MODE_INFO *mi) {
100 return mi->ref_frame[1] > INTRA_FRAME;
101 }
102
103 PREDICTION_MODE vp9_left_block_mode(const MODE_INFO *cur_mi,
104 const MODE_INFO *left_mi, int b);
105
106 PREDICTION_MODE vp9_above_block_mode(const MODE_INFO *cur_mi,
107 const MODE_INFO *above_mi, int b);
108
109 enum mv_precision { MV_PRECISION_Q3, MV_PRECISION_Q4 };
110
111 struct buf_2d {
112 uint8_t *buf;
113 int stride;
114 };
115
116 struct macroblockd_plane {
117 tran_low_t *dqcoeff;
118 int subsampling_x;
119 int subsampling_y;
120 struct buf_2d dst;
121 struct buf_2d pre[2];
122 ENTROPY_CONTEXT *above_context;
123 ENTROPY_CONTEXT *left_context;
124 int16_t seg_dequant[MAX_SEGMENTS][2];
125
126 // number of 4x4s in current block
127 uint16_t n4_w, n4_h;
128 // log2 of n4_w, n4_h
129 uint8_t n4_wl, n4_hl;
130
131 // encoder
132 const int16_t *dequant;
133 };
134
135 #define BLOCK_OFFSET(x, i) ((x) + (i)*16)
136
137 typedef struct RefBuffer {
138 // TODO(dkovalev): idx is not really required and should be removed, now it
139 // is used in vp9_onyxd_if.c
140 int idx;
141 YV12_BUFFER_CONFIG *buf;
142 struct scale_factors sf;
143 } RefBuffer;
144
145 typedef struct macroblockd {
146 struct macroblockd_plane plane[MAX_MB_PLANE];
147 uint8_t bmode_blocks_wl;
148 uint8_t bmode_blocks_hl;
149
150 FRAME_COUNTS *counts;
151 TileInfo tile;
152
153 int mi_stride;
154
155 // Grid of 8x8 cells is placed over the block.
156 // If some of them belong to the same mbtree-block
157 // they will just have same mi[i][j] value
158 MODE_INFO **mi;
159 MODE_INFO *left_mi;
160 MODE_INFO *above_mi;
161
162 unsigned int max_blocks_wide;
163 unsigned int max_blocks_high;
164
165 const vpx_prob (*partition_probs)[PARTITION_TYPES - 1];
166
167 /* Distance of MB away from frame edges */
168 int mb_to_left_edge;
169 int mb_to_right_edge;
170 int mb_to_top_edge;
171 int mb_to_bottom_edge;
172
173 FRAME_CONTEXT *fc;
174
175 /* pointers to reference frames */
176 RefBuffer *block_refs[2];
177
178 /* pointer to current frame */
179 const YV12_BUFFER_CONFIG *cur_buf;
180
181 ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
182 ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];
183
184 PARTITION_CONTEXT *above_seg_context;
185 PARTITION_CONTEXT left_seg_context[8];
186
187 #if CONFIG_VP9_HIGHBITDEPTH
188 /* Bit depth: 8, 10, 12 */
189 int bd;
190 #endif
191
192 int lossless;
193 int corrupted;
194
195 struct vpx_internal_error_info *error_info;
196 } MACROBLOCKD;
197
get_plane_type(int plane)198 static INLINE PLANE_TYPE get_plane_type(int plane) {
199 return (PLANE_TYPE)(plane > 0);
200 }
201
get_subsize(BLOCK_SIZE bsize,PARTITION_TYPE partition)202 static INLINE BLOCK_SIZE get_subsize(BLOCK_SIZE bsize,
203 PARTITION_TYPE partition) {
204 return subsize_lookup[partition][bsize];
205 }
206
207 extern const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES];
208
get_tx_type(PLANE_TYPE plane_type,const MACROBLOCKD * xd)209 static INLINE TX_TYPE get_tx_type(PLANE_TYPE plane_type,
210 const MACROBLOCKD *xd) {
211 const MODE_INFO *const mi = xd->mi[0];
212
213 if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mi))
214 return DCT_DCT;
215
216 return intra_mode_to_tx_type_lookup[mi->mode];
217 }
218
get_tx_type_4x4(PLANE_TYPE plane_type,const MACROBLOCKD * xd,int ib)219 static INLINE TX_TYPE get_tx_type_4x4(PLANE_TYPE plane_type,
220 const MACROBLOCKD *xd, int ib) {
221 const MODE_INFO *const mi = xd->mi[0];
222
223 if (plane_type != PLANE_TYPE_Y || xd->lossless || is_inter_block(mi))
224 return DCT_DCT;
225
226 return intra_mode_to_tx_type_lookup[get_y_mode(mi, ib)];
227 }
228
229 void vp9_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
230
get_uv_tx_size(const MODE_INFO * mi,const struct macroblockd_plane * pd)231 static INLINE TX_SIZE get_uv_tx_size(const MODE_INFO *mi,
232 const struct macroblockd_plane *pd) {
233 assert(mi->sb_type < BLOCK_8X8 ||
234 ss_size_lookup[mi->sb_type][pd->subsampling_x][pd->subsampling_y] !=
235 BLOCK_INVALID);
236 return uv_txsize_lookup[mi->sb_type][mi->tx_size][pd->subsampling_x]
237 [pd->subsampling_y];
238 }
239
240 static INLINE BLOCK_SIZE
get_plane_block_size(BLOCK_SIZE bsize,const struct macroblockd_plane * pd)241 get_plane_block_size(BLOCK_SIZE bsize, const struct macroblockd_plane *pd) {
242 return ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
243 }
244
reset_skip_context(MACROBLOCKD * xd,BLOCK_SIZE bsize)245 static INLINE void reset_skip_context(MACROBLOCKD *xd, BLOCK_SIZE bsize) {
246 int i;
247 for (i = 0; i < MAX_MB_PLANE; i++) {
248 struct macroblockd_plane *const pd = &xd->plane[i];
249 const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
250 memset(pd->above_context, 0,
251 sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide_lookup[plane_bsize]);
252 memset(pd->left_context, 0,
253 sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high_lookup[plane_bsize]);
254 }
255 }
256
get_y_mode_probs(const MODE_INFO * mi,const MODE_INFO * above_mi,const MODE_INFO * left_mi,int block)257 static INLINE const vpx_prob *get_y_mode_probs(const MODE_INFO *mi,
258 const MODE_INFO *above_mi,
259 const MODE_INFO *left_mi,
260 int block) {
261 const PREDICTION_MODE above = vp9_above_block_mode(mi, above_mi, block);
262 const PREDICTION_MODE left = vp9_left_block_mode(mi, left_mi, block);
263 return vp9_kf_y_mode_prob[above][left];
264 }
265
266 typedef void (*foreach_transformed_block_visitor)(int plane, int block, int row,
267 int col,
268 BLOCK_SIZE plane_bsize,
269 TX_SIZE tx_size, void *arg);
270
271 void vp9_foreach_transformed_block_in_plane(
272 const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
273 foreach_transformed_block_visitor visit, void *arg);
274
275 void vp9_foreach_transformed_block(const MACROBLOCKD *const xd,
276 BLOCK_SIZE bsize,
277 foreach_transformed_block_visitor visit,
278 void *arg);
279
280 void vp9_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd,
281 BLOCK_SIZE plane_bsize, TX_SIZE tx_size, int has_eob,
282 int aoff, int loff);
283
284 #ifdef __cplusplus
285 } // extern "C"
286 #endif
287
288 #endif // VP9_COMMON_VP9_BLOCKD_H_
289