vp9_onyxc_int.h 11.3 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
#ifndef VP9_COMMON_VP9_ONYXC_INT_H_
#define VP9_COMMON_VP9_ONYXC_INT_H_
John Koleszar's avatar
John Koleszar committed
13

Jim Bankoski's avatar
Jim Bankoski committed
14
#include "./vpx_config.h"
15
#include "vpx/internal/vpx_codec_internal.h"
Jim Bankoski's avatar
Jim Bankoski committed
16
#include "./vp9_rtcd.h"
17 18 19 20
#include "vp9/common/vp9_loopfilter.h"
#include "vp9/common/vp9_entropymv.h"
#include "vp9/common/vp9_entropy.h"
#include "vp9/common/vp9_entropymode.h"
21
#include "vp9/common/vp9_quant_common.h"
22

23
#if CONFIG_VP9_POSTPROC
24
#include "vp9/common/vp9_postproc.h"
25
#endif
John Koleszar's avatar
John Koleszar committed
26

27
#define ALLOWED_REFS_PER_FRAME 3
John Koleszar's avatar
John Koleszar committed
28

29
#define NUM_REF_FRAMES_LOG2 3
30
#define NUM_REF_FRAMES (1 << NUM_REF_FRAMES_LOG2)
31

32 33 34 35
// 1 scratch frame for the new frame, 3 for scaled references on the encoder
// TODO(jkoleszar): These 3 extra references could probably come from the
// normal reference pool.
#define NUM_YV12_BUFFERS (NUM_REF_FRAMES + 4)
John Koleszar's avatar
John Koleszar committed
36

37 38
#define NUM_FRAME_CONTEXTS_LOG2 2
#define NUM_FRAME_CONTEXTS (1 << NUM_FRAME_CONTEXTS_LOG2)
39

John Koleszar's avatar
John Koleszar committed
40
typedef struct frame_contexts {
41 42
  vp9_prob y_mode_prob[BLOCK_SIZE_GROUPS][INTRA_MODES - 1];
  vp9_prob uv_mode_prob[INTRA_MODES][INTRA_MODES - 1];
43
  vp9_prob partition_prob[FRAME_TYPES][PARTITION_CONTEXTS][PARTITION_TYPES - 1];
44
  vp9_coeff_probs_model coef_probs[TX_SIZES][BLOCK_TYPES];
45 46 47
  vp9_prob switchable_interp_prob[SWITCHABLE_FILTERS + 1]
                                 [SWITCHABLE_FILTERS - 1];
  vp9_prob inter_mode_probs[INTER_MODE_CONTEXTS][INTER_MODES - 1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
48 49 50 51
  vp9_prob intra_inter_prob[INTRA_INTER_CONTEXTS];
  vp9_prob comp_inter_prob[COMP_INTER_CONTEXTS];
  vp9_prob single_ref_prob[REF_CONTEXTS][2];
  vp9_prob comp_ref_prob[REF_CONTEXTS];
52
  struct tx_probs tx_probs;
Deb Mukherjee's avatar
Deb Mukherjee committed
53
  vp9_prob mbskip_probs[MBSKIP_CONTEXTS];
54
  nmv_context nmvc;
John Koleszar's avatar
John Koleszar committed
55 56
} FRAME_CONTEXT;

57
typedef struct {
58 59
  unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
  unsigned int uv_mode[INTRA_MODES][INTRA_MODES];
60
  unsigned int partition[PARTITION_CONTEXTS][PARTITION_TYPES];
61 62
  vp9_coeff_count_model coef[TX_SIZES][BLOCK_TYPES];
  unsigned int eob_branch[TX_SIZES][BLOCK_TYPES][REF_TYPES]
63
                         [COEF_BANDS][PREV_COEF_CONTEXTS];
64 65 66
  unsigned int switchable_interp[SWITCHABLE_FILTERS + 1]
                                [SWITCHABLE_FILTERS];
  unsigned int inter_mode[INTER_MODE_CONTEXTS][INTER_MODES];
67 68 69 70 71 72 73 74 75 76
  unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
  unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
  unsigned int single_ref[REF_CONTEXTS][2][2];
  unsigned int comp_ref[REF_CONTEXTS][2];
  struct tx_counts tx;
  unsigned int mbskip[MBSKIP_CONTEXTS][2];
  nmv_context_counts mv;
} FRAME_COUNTS;


John Koleszar's avatar
John Koleszar committed
77 78 79 80 81
typedef enum {
  SINGLE_PREDICTION_ONLY = 0,
  COMP_PREDICTION_ONLY   = 1,
  HYBRID_PREDICTION      = 2,
  NB_PREDICTION_TYPES    = 3,
82
} COMPPREDMODE_TYPE;
83

84
typedef struct VP9Common {
John Koleszar's avatar
John Koleszar committed
85
  struct vpx_internal_error_info  error;
John Koleszar's avatar
John Koleszar committed
86

87 88
  DECLARE_ALIGNED(16, int16_t, y_dequant[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, uv_dequant[QINDEX_RANGE][8]);
89
#if CONFIG_ALPHA
90
  DECLARE_ALIGNED(16, int16_t, a_dequant[QINDEX_RANGE][8]);
91
#endif
John Koleszar's avatar
John Koleszar committed
92

93 94
  int width;
  int height;
95 96
  int display_width;
  int display_height;
97 98
  int last_width;
  int last_height;
John Koleszar's avatar
John Koleszar committed
99

100 101 102 103 104 105
  // TODO(jkoleszar): this implies chroma ss right now, but could vary per
  // plane. Revisit as part of the future change to YV12_BUFFER_CONFIG to
  // support additional planes.
  int subsampling_x;
  int subsampling_y;

John Koleszar's avatar
John Koleszar committed
106
  YV12_BUFFER_CONFIG *frame_to_show;
107

John Koleszar's avatar
John Koleszar committed
108
  YV12_BUFFER_CONFIG yv12_fb[NUM_YV12_BUFFERS];
109
  int fb_idx_ref_cnt[NUM_YV12_BUFFERS]; /* reference counts */
110 111
  int ref_frame_map[NUM_REF_FRAMES]; /* maps fb_idx to reference slot */

112 113 114 115 116 117
  // TODO(jkoleszar): could expand active_ref_idx to 4, with 0 as intra, and
  // roll new_fb_idx into it.

  // Each frame can reference ALLOWED_REFS_PER_FRAME buffers
  int active_ref_idx[ALLOWED_REFS_PER_FRAME];
  struct scale_factors active_ref_scale[ALLOWED_REFS_PER_FRAME];
Yunqing Wang's avatar
Yunqing Wang committed
118
  struct scale_factors_common active_ref_scale_comm[ALLOWED_REFS_PER_FRAME];
119
  int new_fb_idx;
120

John Koleszar's avatar
John Koleszar committed
121
  YV12_BUFFER_CONFIG post_proc_buffer;
Attila Nagy's avatar
Attila Nagy committed
122

Jim Bankoski's avatar
Jim Bankoski committed
123
  FRAME_TYPE last_frame_type;  /* last frame's frame type for motion search.*/
John Koleszar's avatar
John Koleszar committed
124
  FRAME_TYPE frame_type;
John Koleszar's avatar
John Koleszar committed
125

John Koleszar's avatar
John Koleszar committed
126
  int show_frame;
127
  int last_show_frame;
John Koleszar's avatar
John Koleszar committed
128

129 130 131
  // Flag signaling that the frame is encoded using only INTRA modes.
  int intra_only;

132 133
  int allow_high_precision_mv;

134
  // Flag signaling that the frame context should be reset to default values.
135 136
  // 0 or 1 implies don't reset, 2 reset just the context specified in the
  // frame header, 3 reset all contexts.
137 138
  int reset_frame_context;

John Koleszar's avatar
John Koleszar committed
139
  int frame_flags;
140
  // MBs, mb_rows/cols is in 16-pixel units; mi_rows/cols is in
Jingning Han's avatar
Jingning Han committed
141
  // MODE_INFO (8-pixel) units.
John Koleszar's avatar
John Koleszar committed
142
  int MBs;
143 144
  int mb_rows, mi_rows;
  int mb_cols, mi_cols;
John Koleszar's avatar
John Koleszar committed
145
  int mode_info_stride;
John Koleszar's avatar
John Koleszar committed
146

John Koleszar's avatar
John Koleszar committed
147
  /* profile settings */
148
  TX_MODE tx_mode;
John Koleszar's avatar
John Koleszar committed
149

John Koleszar's avatar
John Koleszar committed
150
  int base_qindex;
151 152 153
  int y_dc_delta_q;
  int uv_dc_delta_q;
  int uv_ac_delta_q;
154 155 156 157
#if CONFIG_ALPHA
  int a_dc_delta_q;
  int a_ac_delta_q;
#endif
John Koleszar's avatar
John Koleszar committed
158

John Koleszar's avatar
John Koleszar committed
159 160
  /* We allocate a MODE_INFO struct for each macroblock, together with
     an extra row on top and column on the left to simplify prediction. */
John Koleszar's avatar
John Koleszar committed
161

John Koleszar's avatar
John Koleszar committed
162 163 164 165
  MODE_INFO *mip; /* Base of allocated array */
  MODE_INFO *mi;  /* Corresponds to upper left visible macroblock */
  MODE_INFO *prev_mip; /* MODE_INFO array 'mip' from last decoded frame */
  MODE_INFO *prev_mi;  /* 'mi' from last frame (points into prev_mip) */
John Koleszar's avatar
John Koleszar committed
166

167 168 169 170
  MODE_INFO **mi_grid_base;
  MODE_INFO **mi_grid_visible;
  MODE_INFO **prev_mi_grid_base;
  MODE_INFO **prev_mi_grid_visible;
John Koleszar's avatar
John Koleszar committed
171

John Koleszar's avatar
John Koleszar committed
172 173
  // Persistent mb segment id map used in prediction.
  unsigned char *last_frame_seg_map;
174

175
  INTERPOLATION_TYPE mcomp_filter_type;
Attila Nagy's avatar
Attila Nagy committed
176

John Koleszar's avatar
John Koleszar committed
177
  loop_filter_info_n lf_info;
Attila Nagy's avatar
Attila Nagy committed
178

179
  int refresh_frame_context;    /* Two state 0 = NO, 1 = YES */
John Koleszar's avatar
John Koleszar committed
180

John Koleszar's avatar
John Koleszar committed
181
  int ref_frame_sign_bias[MAX_REF_FRAMES];    /* Two state 0, 1 */
John Koleszar's avatar
John Koleszar committed
182

183
  struct loopfilter lf;
184
  struct segmentation seg;
185

186
  /* Y,U,V */
187 188
  ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
  ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];
John Koleszar's avatar
John Koleszar committed
189

190 191
  // partition contexts
  PARTITION_CONTEXT *above_seg_context;
192
  PARTITION_CONTEXT left_seg_context[8];
193

John Koleszar's avatar
John Koleszar committed
194
  // Context probabilities for reference frame prediction
Ronald S. Bultje's avatar
Ronald S. Bultje committed
195 196 197 198
  int allow_comp_inter_inter;
  MV_REFERENCE_FRAME comp_fixed_ref;
  MV_REFERENCE_FRAME comp_var_ref[2];
  COMPPREDMODE_TYPE comp_pred_mode;
Paul Wilkins's avatar
Paul Wilkins committed
199

John Koleszar's avatar
John Koleszar committed
200
  FRAME_CONTEXT fc;  /* this frame entropy */
201 202
  FRAME_CONTEXT frame_contexts[NUM_FRAME_CONTEXTS];
  unsigned int  frame_context_idx; /* Context to use/update */
203
  FRAME_COUNTS counts;
John Koleszar's avatar
John Koleszar committed
204

John Koleszar's avatar
John Koleszar committed
205 206
  unsigned int current_video_frame;
  int version;
John Koleszar's avatar
John Koleszar committed
207

208
#if CONFIG_VP9_POSTPROC
John Koleszar's avatar
John Koleszar committed
209
  struct postproc_state  postproc_state;
210
#endif
211

212
  int error_resilient_mode;
213
  int frame_parallel_decoding_mode;
214

Dmitry Kovalev's avatar
Dmitry Kovalev committed
215
  int log2_tile_cols, log2_tile_rows;
216 217
  int cur_tile_mi_col_start, cur_tile_mi_col_end;
  int cur_tile_mi_row_start, cur_tile_mi_row_end;
218
} VP9_COMMON;
John Koleszar's avatar
John Koleszar committed
219

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
static int get_free_fb(VP9_COMMON *cm) {
  int i;
  for (i = 0; i < NUM_YV12_BUFFERS; i++)
    if (cm->fb_idx_ref_cnt[i] == 0)
      break;

  assert(i < NUM_YV12_BUFFERS);
  cm->fb_idx_ref_cnt[i] = 1;
  return i;
}

static void ref_cnt_fb(int *buf, int *idx, int new_idx) {
  if (buf[*idx] > 0)
    buf[*idx]--;

  *idx = new_idx;

  buf[new_idx]++;
}

240
static int mi_cols_aligned_to_sb(int n_mis) {
James Zern's avatar
James Zern committed
241
  return ALIGN_POWER_OF_TWO(n_mis, MI_BLOCK_SIZE_LOG2);
242 243
}

244 245 246 247 248 249 250 251 252 253 254 255
static INLINE void set_skip_context(VP9_COMMON *cm, MACROBLOCKD *xd,
                                    int mi_row, int mi_col) {
  const int above_idx = mi_col * 2;
  const int left_idx = (mi_row * 2) & 15;
  int i;
  for (i = 0; i < MAX_MB_PLANE; i++) {
    struct macroblockd_plane *const pd = &xd->plane[i];
    pd->above_context = cm->above_context[i] + (above_idx >> pd->subsampling_x);
    pd->left_context = cm->left_context[i] + (left_idx >> pd->subsampling_y);
  }
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
256 257 258 259 260
// return the node index in the prob tree for binary coding
static int check_bsize_coverage(int bs, int mi_rows, int mi_cols,
                                int mi_row, int mi_col) {
  const int r = (mi_row + bs < mi_rows);
  const int c = (mi_col + bs < mi_cols);
261

Dmitry Kovalev's avatar
Dmitry Kovalev committed
262
  if (r && c)
263 264
    return 0;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
265 266 267 268 269
  if (c && !r)
    return 1;  // only allow horizontal/split partition types

  if (r && !c)
    return 2;  // only allow vertical/split partition types
270 271 272 273

  return -1;
}

274 275 276
static void set_mi_row_col(VP9_COMMON *cm, MACROBLOCKD *xd,
                       int mi_row, int bh,
                       int mi_col, int bw) {
Yaowu Xu's avatar
Yaowu Xu committed
277 278 279 280
  xd->mb_to_top_edge    = -((mi_row * MI_SIZE) * 8);
  xd->mb_to_bottom_edge = ((cm->mi_rows - bh - mi_row) * MI_SIZE) * 8;
  xd->mb_to_left_edge   = -((mi_col * MI_SIZE) * 8);
  xd->mb_to_right_edge  = ((cm->mi_cols - bw - mi_col) * MI_SIZE) * 8;
281 282

  // Are edges available for intra prediction?
283 284
  xd->up_available    = (mi_row != 0);
  xd->left_available  = (mi_col > cm->cur_tile_mi_col_start);
285 286
}

287 288 289 290
static void set_prev_mi(VP9_COMMON *cm) {
  const int use_prev_in_find_mv_refs = cm->width == cm->last_width &&
                                       cm->height == cm->last_height &&
                                       !cm->error_resilient_mode &&
Adrian Grange's avatar
Adrian Grange committed
291
                                       !cm->intra_only &&
292 293 294 295 296 297
                                       cm->last_show_frame;
  // Special case: set prev_mi to NULL when the previous mode info
  // context cannot be used.
  cm->prev_mi = use_prev_in_find_mv_refs ?
                  cm->prev_mip + cm->mode_info_stride + 1 : NULL;
}
298 299 300 301 302

static INLINE int frame_is_intra_only(const VP9_COMMON *const cm) {
  return cm->frame_type == KEY_FRAME || cm->intra_only;
}

303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
static INLINE void update_partition_context(VP9_COMMON *cm,
                                            int mi_row, int mi_col,
                                            BLOCK_SIZE sb_type,
                                            BLOCK_SIZE sb_size) {
  PARTITION_CONTEXT *above_ctx = cm->above_seg_context + mi_col;
  PARTITION_CONTEXT *left_ctx = cm->left_seg_context + (mi_row & MI_MASK);

  const int bsl = b_width_log2(sb_size), bs = (1 << bsl) / 2;
  const int bwl = b_width_log2(sb_type);
  const int bhl = b_height_log2(sb_type);
  const int boffset = b_width_log2(BLOCK_64X64) - bsl;
  const char pcval0 = ~(0xe << boffset);
  const char pcval1 = ~(0xf << boffset);
  const char pcvalue[2] = {pcval0, pcval1};

  assert(MAX(bwl, bhl) <= bsl);

  // update the partition context at the end notes. set partition bits
  // of block sizes larger than the current one to be one, and partition
  // bits of smaller block sizes to be zero.
  vpx_memset(above_ctx, pcvalue[bwl == bsl], bs);
  vpx_memset(left_ctx, pcvalue[bhl == bsl], bs);
}

static INLINE int partition_plane_context(const VP9_COMMON *cm,
                                          int mi_row, int mi_col,
                                          BLOCK_SIZE sb_type) {
  const PARTITION_CONTEXT *above_ctx = cm->above_seg_context + mi_col;
  const PARTITION_CONTEXT *left_ctx = cm->left_seg_context + (mi_row & MI_MASK);

  int bsl = mi_width_log2(sb_type), bs = 1 << bsl;
  int above = 0, left = 0, i;
  int boffset = mi_width_log2(BLOCK_64X64) - bsl;

  assert(mi_width_log2(sb_type) == mi_height_log2(sb_type));
  assert(bsl >= 0);
  assert(boffset >= 0);

  for (i = 0; i < bs; i++)
    above |= (above_ctx[i] & (1 << boffset));
  for (i = 0; i < bs; i++)
    left |= (left_ctx[i] & (1 << boffset));

  above = (above > 0);
  left  = (left > 0);

  return (left * 2 + above) + bsl * PARTITION_PLOFFSET;
}

352
#endif  // VP9_COMMON_VP9_ONYXC_INT_H_