vp8/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 __INC_BLOCKD_H
  13 #define __INC_BLOCKD_H
  14
  15 void vpx_log(const char *format, ...);
  16
  17 #include "vpx_config.h"
  18 #include "vpx_scale/yv12config.h"
  19 #include "mv.h"
  20 #include "treecoder.h"
  21 #include "vpx_ports/mem.h"
  22
  23 /*#define DCPRED 1*/
  24 #define DCPREDSIMTHRESH 0
  25 #define DCPREDCNTTHRESH 3
  26
  27 #define MB_FEATURE_TREE_PROBS   3
  28 #define MAX_MB_SEGMENTS         4
  29
  30 #define MAX_REF_LF_DELTAS       4
  31 #define MAX_MODE_LF_DELTAS      4
  32
  33 /* Segment Feature Masks */
  34 #define SEGMENT_DELTADATA   0
  35 #define SEGMENT_ABSDATA     1
  36
  37 typedef struct
  38 {
  39     int r, c;
  40 } POS;
  41
  42 #define PLANE_TYPE_Y_NO_DC    0
  43 #define PLANE_TYPE_Y2         1
  44 #define PLANE_TYPE_UV         2
  45 #define PLANE_TYPE_Y_WITH_DC  3
  46
  47
  48 typedef char ENTROPY_CONTEXT;
  49 typedef struct
  50 {
  51     ENTROPY_CONTEXT y1[4];
  52     ENTROPY_CONTEXT u[2];
  53     ENTROPY_CONTEXT v[2];
  54     ENTROPY_CONTEXT y2;
  55 } ENTROPY_CONTEXT_PLANES;
  56
  57 extern const unsigned char vp8_block2left[25];
  58 extern const unsigned char vp8_block2above[25];
  59
  60 #define VP8_COMBINEENTROPYCONTEXTS( Dest, A, B) \
  61     Dest = (A)+(B);
  62
  63
  64 typedef enum
  65 {
  66     KEY_FRAME = 0,
  67     INTER_FRAME = 1
  68 } FRAME_TYPE;
  69
  70 typedef enum
  71 {
  72     DC_PRED,            /* average of above and left pixels */
  73     V_PRED,             /* vertical prediction */
  74     H_PRED,             /* horizontal prediction */
  75     TM_PRED,            /* Truemotion prediction */
  76     B_PRED,             /* block based prediction, each block has its own prediction mode */
  77
  78     NEARESTMV,
  79     NEARMV,
  80     ZEROMV,
  81     NEWMV,
  82     SPLITMV,
  83
  84     MB_MODE_COUNT
  85 } MB_PREDICTION_MODE;
  86
  87 /* Macroblock level features */
  88 typedef enum
  89 {
  90     MB_LVL_ALT_Q = 0,               /* Use alternate Quantizer .... */
  91     MB_LVL_ALT_LF = 1,              /* Use alternate loop filter value... */
  92     MB_LVL_MAX = 2                  /* Number of MB level features supported */
  93
  94 } MB_LVL_FEATURES;
  95
  96 /* Segment Feature Masks */
  97 #define SEGMENT_ALTQ    0x01
  98 #define SEGMENT_ALT_LF  0x02
  99
 100 #define VP8_YMODES  (B_PRED + 1)
 101 #define VP8_UV_MODES (TM_PRED + 1)
 102
 103 #define VP8_MVREFS (1 + SPLITMV - NEARESTMV)
 104
 105 typedef enum
 106 {
 107     B_DC_PRED,          /* average of above and left pixels */
 108     B_TM_PRED,
 109
 110     B_VE_PRED,           /* vertical prediction */
 111     B_HE_PRED,           /* horizontal prediction */
 112
 113     B_LD_PRED,
 114     B_RD_PRED,
 115
 116     B_VR_PRED,
 117     B_VL_PRED,
 118     B_HD_PRED,
 119     B_HU_PRED,
 120
 121     LEFT4X4,
 122     ABOVE4X4,
 123     ZERO4X4,
 124     NEW4X4,
 125
 126     B_MODE_COUNT
 127 } B_PREDICTION_MODE;
 128
 129 #define VP8_BINTRAMODES (B_HU_PRED + 1)  /* 10 */
 130 #define VP8_SUBMVREFS (1 + NEW4X4 - LEFT4X4)
 131
 132 /* For keyframes, intra block modes are predicted by the (already decoded)
 133    modes for the Y blocks to the left and above us; for interframes, there
 134    is a single probability table. */
 135
 136 union b_mode_info
 137 {
 138     B_PREDICTION_MODE as_mode;
 139     int_mv mv;
 140 };
 141
 142 typedef enum
 143 {
 144     INTRA_FRAME = 0,
 145     LAST_FRAME = 1,
 146     GOLDEN_FRAME = 2,
 147     ALTREF_FRAME = 3,
 148     MAX_REF_FRAMES = 4
 149 } MV_REFERENCE_FRAME;
 150
 151 typedef struct
 152 {
 153     uint8_t mode, uv_mode;
 154     uint8_t ref_frame;
 155     uint8_t is_4x4;
 156     int_mv mv;
 157
 158     uint8_t partitioning;
 159     uint8_t mb_skip_coeff;                                /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */
 160     uint8_t need_to_clamp_mvs;
 161     uint8_t segment_id;                  /* Which set of segmentation parameters should be used for this MB */
 162 } MB_MODE_INFO;
 163
 164 typedef struct
 165 {
 166     MB_MODE_INFO mbmi;
 167     union b_mode_info bmi[16];
 168 } MODE_INFO;
 169
 170 #if CONFIG_MULTI_RES_ENCODING
 171 /* The mb-level information needed to be stored for higher-resolution encoder */
 172 typedef struct
 173 {
 174     MB_PREDICTION_MODE mode;
 175     MV_REFERENCE_FRAME ref_frame;
 176     int_mv mv;
 177     //union b_mode_info bmi[16];
 178     int dissim;    // dissimilarity level of the macroblock
 179 } LOWER_RES_MB_INFO;
 180
 181 /* The frame-level information needed to be stored for higher-resolution
 182  *  encoder */
 183 typedef struct
 184 {
 185     FRAME_TYPE frame_type;
 186     LOWER_RES_MB_INFO *mb_info;
 187 } LOWER_RES_FRAME_INFO;
 188 #endif
 189
 190 typedef struct blockd
 191 {
 192     short *qcoeff;
 193     short *dqcoeff;
 194     unsigned char  *predictor;
 195     short *dequant;
 196
 197     int offset;
 198     char *eob;
 199
 200     union b_mode_info bmi;
 201 } BLOCKD;
 202
 203 typedef void (*vp8_subpix_fn_t)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
 204
 205 typedef struct macroblockd
 206 {
 207     DECLARE_ALIGNED(16, unsigned char,  predictor[384]);
 208     DECLARE_ALIGNED(16, short, qcoeff[400]);
 209     DECLARE_ALIGNED(16, short, dqcoeff[400]);
 210     DECLARE_ALIGNED(16, char,  eobs[25]);
 211
 212     DECLARE_ALIGNED(16, short,  dequant_y1[16]);
 213     DECLARE_ALIGNED(16, short,  dequant_y1_dc[16]);
 214     DECLARE_ALIGNED(16, short,  dequant_y2[16]);
 215     DECLARE_ALIGNED(16, short,  dequant_uv[16]);
 216
 217     /* 16 Y blocks, 4 U, 4 V, 1 DC 2nd order block, each with 16 entries. */
 218     BLOCKD block[25];
 219     int fullpixel_mask;
 220
 221     YV12_BUFFER_CONFIG pre; /* Filtered copy of previous frame reconstruction */
 222     YV12_BUFFER_CONFIG dst;
 223
 224     MODE_INFO *mode_info_context;
 225     int mode_info_stride;
 226
 227 #if CONFIG_TEMPORAL_DENOISING
 228     MB_PREDICTION_MODE best_sse_inter_mode;
 229     int_mv best_sse_mv;
 230     unsigned char need_to_clamp_best_mvs;
 231 #endif
 232
 233     FRAME_TYPE frame_type;
 234
 235     int up_available;
 236     int left_available;
 237
 238     unsigned char *recon_above[3];
 239     unsigned char *recon_left[3];
 240     int recon_left_stride[2];
 241
 242     /* Y,U,V,Y2 */
 243     ENTROPY_CONTEXT_PLANES *above_context;
 244     ENTROPY_CONTEXT_PLANES *left_context;
 245
 246     /* 0 indicates segmentation at MB level is not enabled. Otherwise the individual bits indicate which features are active. */
 247     unsigned char segmentation_enabled;
 248
 249     /* 0 (do not update) 1 (update) the macroblock segmentation map. */
 250     unsigned char update_mb_segmentation_map;
 251
 252     /* 0 (do not update) 1 (update) the macroblock segmentation feature data. */
 253     unsigned char update_mb_segmentation_data;
 254
 255     /* 0 (do not update) 1 (update) the macroblock segmentation feature data. */
 256     unsigned char mb_segement_abs_delta;
 257
 258     /* Per frame flags that define which MB level features (such as quantizer or loop filter level) */
 259     /* are enabled and when enabled the proabilities used to decode the per MB flags in MB_MODE_INFO */
 260     vp8_prob mb_segment_tree_probs[MB_FEATURE_TREE_PROBS];         /* Probability Tree used to code Segment number */
 261
 262     signed char segment_feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];            /* Segment parameters */
 263
 264     /* mode_based Loop filter adjustment */
 265     unsigned char mode_ref_lf_delta_enabled;
 266     unsigned char mode_ref_lf_delta_update;
 267
 268     /* Delta values have the range +/- MAX_LOOP_FILTER */
 269     signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS];                /* 0 = Intra, Last, GF, ARF */
 270     signed char ref_lf_deltas[MAX_REF_LF_DELTAS];                     /* 0 = Intra, Last, GF, ARF */
 271     signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];                      /* 0 = BPRED, ZERO_MV, MV, SPLIT */
 272     signed char mode_lf_deltas[MAX_MODE_LF_DELTAS];                           /* 0 = BPRED, ZERO_MV, MV, SPLIT */
 273
 274     /* Distance of MB away from frame edges */
 275     int mb_to_left_edge;
 276     int mb_to_right_edge;
 277     int mb_to_top_edge;
 278     int mb_to_bottom_edge;
 279
 280
 281
 282     vp8_subpix_fn_t  subpixel_predict;
 283     vp8_subpix_fn_t  subpixel_predict8x4;
 284     vp8_subpix_fn_t  subpixel_predict8x8;
 285     vp8_subpix_fn_t  subpixel_predict16x16;
 286
 287     void *current_bc;
 288
 289     int corrupted;
 290
 291 #if ARCH_X86 || ARCH_X86_64
 292     /* This is an intermediate buffer currently used in sub-pixel motion search
 293      * to keep a copy of the reference area. This buffer can be used for other
 294      * purpose.
 295      */
 296     DECLARE_ALIGNED(32, unsigned char, y_buf[22*32]);
 297 #endif
 298 } MACROBLOCKD;
 299
 300
 301 extern void vp8_build_block_doffsets(MACROBLOCKD *x);
 302 extern void vp8_setup_block_dptrs(MACROBLOCKD *x);
 303
 304 #endif  /* __INC_BLOCKD_H */