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