2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
2012-11-30 01:36:10 +01:00
|
|
|
#ifndef VP9_COMMON_VP9_ONYXC_INT_H_
|
|
|
|
#define VP9_COMMON_VP9_ONYXC_INT_H_
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2010-05-24 17:39:59 +02:00
|
|
|
#include "vpx_config.h"
|
|
|
|
#include "vpx/internal/vpx_codec_internal.h"
|
2012-11-09 02:09:30 +01:00
|
|
|
#include "vp9_rtcd.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_loopfilter.h"
|
|
|
|
#include "vp9/common/vp9_entropymv.h"
|
|
|
|
#include "vp9/common/vp9_entropy.h"
|
|
|
|
#include "vp9/common/vp9_entropymode.h"
|
2013-04-30 22:39:50 +02:00
|
|
|
#include "vp9/common/vp9_quant_common.h"
|
2013-04-03 00:08:50 +02:00
|
|
|
|
2013-09-04 19:02:08 +02:00
|
|
|
#if CONFIG_VP9_POSTPROC
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_postproc.h"
|
2011-08-01 22:42:14 +02:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-07-15 21:26:58 +02:00
|
|
|
#define ALLOWED_REFS_PER_FRAME 3
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-07-12 20:37:43 +02:00
|
|
|
#define NUM_REF_FRAMES_LOG2 3
|
2013-07-15 21:26:58 +02:00
|
|
|
#define NUM_REF_FRAMES (1 << NUM_REF_FRAMES_LOG2)
|
2013-04-09 19:17:22 +02:00
|
|
|
|
2013-02-20 21:34:31 +01:00
|
|
|
// 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)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-07-12 20:37:43 +02:00
|
|
|
#define NUM_FRAME_CONTEXTS_LOG2 2
|
|
|
|
#define NUM_FRAME_CONTEXTS (1 << NUM_FRAME_CONTEXTS_LOG2)
|
2013-01-16 00:57:11 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct frame_contexts {
|
2013-08-23 03:40:34 +02:00
|
|
|
vp9_prob y_mode_prob[BLOCK_SIZE_GROUPS][INTRA_MODES - 1];
|
|
|
|
vp9_prob uv_mode_prob[INTRA_MODES][INTRA_MODES - 1];
|
2013-06-03 19:39:40 +02:00
|
|
|
vp9_prob partition_prob[NUM_FRAME_TYPES][NUM_PARTITION_CONTEXTS]
|
|
|
|
[PARTITION_TYPES - 1];
|
2013-07-27 02:15:37 +02:00
|
|
|
vp9_coeff_probs_model coef_probs[TX_SIZES][BLOCK_TYPES];
|
2013-08-23 03:40:34 +02:00
|
|
|
vp9_prob switchable_interp_prob[SWITCHABLE_FILTERS + 1]
|
|
|
|
[SWITCHABLE_FILTERS - 1];
|
|
|
|
vp9_prob inter_mode_probs[INTER_MODE_CONTEXTS][INTER_MODES - 1];
|
2013-06-06 22:44:34 +02:00
|
|
|
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];
|
2013-07-11 02:36:06 +02:00
|
|
|
struct tx_probs tx_probs;
|
2013-06-07 22:24:14 +02:00
|
|
|
vp9_prob mbskip_probs[MBSKIP_CONTEXTS];
|
2013-06-29 01:16:03 +02:00
|
|
|
nmv_context nmvc;
|
2010-05-18 17:58:33 +02:00
|
|
|
} FRAME_CONTEXT;
|
|
|
|
|
2013-07-24 02:02:08 +02:00
|
|
|
typedef struct {
|
2013-08-23 03:40:34 +02:00
|
|
|
unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
|
|
|
|
unsigned int uv_mode[INTRA_MODES][INTRA_MODES];
|
2013-07-24 02:02:08 +02:00
|
|
|
unsigned int partition[NUM_PARTITION_CONTEXTS][PARTITION_TYPES];
|
2013-07-27 02:15:37 +02:00
|
|
|
vp9_coeff_count_model coef[TX_SIZES][BLOCK_TYPES];
|
|
|
|
unsigned int eob_branch[TX_SIZES][BLOCK_TYPES][REF_TYPES]
|
2013-07-24 02:02:08 +02:00
|
|
|
[COEF_BANDS][PREV_COEF_CONTEXTS];
|
2013-08-23 03:40:34 +02:00
|
|
|
unsigned int switchable_interp[SWITCHABLE_FILTERS + 1]
|
|
|
|
[SWITCHABLE_FILTERS];
|
|
|
|
unsigned int inter_mode[INTER_MODE_CONTEXTS][INTER_MODES];
|
2013-07-24 02:02:08 +02:00
|
|
|
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;
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef enum {
|
|
|
|
SINGLE_PREDICTION_ONLY = 0,
|
|
|
|
COMP_PREDICTION_ONLY = 1,
|
|
|
|
HYBRID_PREDICTION = 2,
|
|
|
|
NB_PREDICTION_TYPES = 3,
|
2012-02-29 02:25:45 +01:00
|
|
|
} COMPPREDMODE_TYPE;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
typedef struct VP9Common {
|
2012-07-14 00:21:29 +02:00
|
|
|
struct vpx_internal_error_info error;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-07-01 20:36:07 +02:00
|
|
|
DECLARE_ALIGNED(16, int16_t, y_dequant[QINDEX_RANGE][8]);
|
|
|
|
DECLARE_ALIGNED(16, int16_t, uv_dequant[QINDEX_RANGE][8]);
|
2013-05-16 02:55:08 +02:00
|
|
|
#if CONFIG_ALPHA
|
2013-07-01 20:36:07 +02:00
|
|
|
DECLARE_ALIGNED(16, int16_t, a_dequant[QINDEX_RANGE][8]);
|
2013-05-16 02:55:08 +02:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-03-21 00:41:30 +01:00
|
|
|
int width;
|
|
|
|
int height;
|
2013-03-14 22:36:08 +01:00
|
|
|
int display_width;
|
|
|
|
int display_height;
|
2013-02-20 21:34:31 +01:00
|
|
|
int last_width;
|
|
|
|
int last_height;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-07 00:52:06 +02:00
|
|
|
// 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;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG *frame_to_show;
|
2010-07-22 14:07:32 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG yv12_fb[NUM_YV12_BUFFERS];
|
2013-01-15 22:49:44 +01:00
|
|
|
int fb_idx_ref_cnt[NUM_YV12_BUFFERS]; /* reference counts */
|
2013-01-16 21:19:42 +01:00
|
|
|
int ref_frame_map[NUM_REF_FRAMES]; /* maps fb_idx to reference slot */
|
|
|
|
|
2013-04-25 02:20:53 +02:00
|
|
|
// 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];
|
2013-01-15 22:49:44 +01:00
|
|
|
int new_fb_idx;
|
2013-04-25 02:20:53 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG post_proc_buffer;
|
2011-06-10 13:10:21 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
FRAME_TYPE last_frame_type; /* Save last frame's frame type for motion search. */
|
|
|
|
FRAME_TYPE frame_type;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int show_frame;
|
2013-04-19 22:32:15 +02:00
|
|
|
int last_show_frame;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-30 02:16:00 +02:00
|
|
|
// Flag signaling that the frame is encoded using only INTRA modes.
|
|
|
|
int intra_only;
|
|
|
|
|
|
|
|
// Flag signaling that the frame context should be reset to default values.
|
2013-06-08 00:55:15 +02:00
|
|
|
// 0 or 1 implies don't reset, 2 reset just the context specified in the
|
|
|
|
// frame header, 3 reset all contexts.
|
2013-05-30 02:16:00 +02:00
|
|
|
int reset_frame_context;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int frame_flags;
|
2013-04-26 20:57:17 +02:00
|
|
|
// MBs, mb_rows/cols is in 16-pixel units; mi_rows/cols is in
|
2013-05-05 07:09:43 +02:00
|
|
|
// MODE_INFO (8-pixel) units.
|
2012-07-14 00:21:29 +02:00
|
|
|
int MBs;
|
2013-04-26 20:57:17 +02:00
|
|
|
int mb_rows, mi_rows;
|
|
|
|
int mb_cols, mi_cols;
|
2012-07-14 00:21:29 +02:00
|
|
|
int mode_info_stride;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* profile settings */
|
2013-07-19 20:37:13 +02:00
|
|
|
TX_MODE tx_mode;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int base_qindex;
|
|
|
|
int last_kf_gf_q; /* Q used on the last GF or KF */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-17 00:05:52 +02:00
|
|
|
int y_dc_delta_q;
|
|
|
|
int uv_dc_delta_q;
|
|
|
|
int uv_ac_delta_q;
|
2013-05-16 02:55:08 +02:00
|
|
|
#if CONFIG_ALPHA
|
|
|
|
int a_dc_delta_q;
|
|
|
|
int a_ac_delta_q;
|
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* We allocate a MODE_INFO struct for each macroblock, together with
|
|
|
|
an extra row on top and column on the left to simplify prediction. */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
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) */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Persistent mb segment id map used in prediction.
|
|
|
|
unsigned char *last_frame_seg_map;
|
2012-01-27 19:29:07 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
INTERPOLATIONFILTERTYPE mcomp_filter_type;
|
2011-06-10 13:10:21 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
loop_filter_info_n lf_info;
|
2011-06-10 13:10:21 +02:00
|
|
|
|
2013-04-26 23:39:58 +02:00
|
|
|
int refresh_frame_context; /* Two state 0 = NO, 1 = YES */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int ref_frame_sign_bias[MAX_REF_FRAMES]; /* Two state 0, 1 */
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-08-09 23:41:51 +02:00
|
|
|
struct loopfilter lf;
|
2013-08-14 20:20:33 +02:00
|
|
|
struct segmentation seg;
|
2013-08-09 23:41:51 +02:00
|
|
|
|
2013-02-15 19:15:42 +01:00
|
|
|
/* Y,U,V */
|
2013-04-29 19:37:25 +02:00
|
|
|
ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
|
|
|
|
ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-23 19:12:18 +02:00
|
|
|
// partition contexts
|
|
|
|
PARTITION_CONTEXT *above_seg_context;
|
2013-05-08 00:36:30 +02:00
|
|
|
PARTITION_CONTEXT left_seg_context[8];
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Context probabilities for reference frame prediction
|
2013-06-06 22:44:34 +02:00
|
|
|
int allow_comp_inter_inter;
|
|
|
|
MV_REFERENCE_FRAME comp_fixed_ref;
|
|
|
|
MV_REFERENCE_FRAME comp_var_ref[2];
|
|
|
|
COMPPREDMODE_TYPE comp_pred_mode;
|
2012-02-02 15:33:34 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
FRAME_CONTEXT fc; /* this frame entropy */
|
2013-01-16 00:57:11 +01:00
|
|
|
FRAME_CONTEXT frame_contexts[NUM_FRAME_CONTEXTS];
|
|
|
|
unsigned int frame_context_idx; /* Context to use/update */
|
2013-07-24 02:02:08 +02:00
|
|
|
FRAME_COUNTS counts;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int current_video_frame;
|
|
|
|
int version;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-09-04 19:02:08 +02:00
|
|
|
#if CONFIG_VP9_POSTPROC
|
2012-07-14 00:21:29 +02:00
|
|
|
struct postproc_state postproc_state;
|
2011-08-01 22:42:14 +02:00
|
|
|
#endif
|
2012-06-26 01:23:58 +02:00
|
|
|
|
2013-01-15 15:43:35 +01:00
|
|
|
int error_resilient_mode;
|
2013-01-25 20:30:28 +01:00
|
|
|
int frame_parallel_decoding_mode;
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01:00
|
|
|
|
2013-07-16 23:47:15 +02:00
|
|
|
int log2_tile_cols, log2_tile_rows;
|
2013-07-22 22:23:33 +02:00
|
|
|
int cur_tile_mi_col_start, cur_tile_mi_col_end;
|
|
|
|
int cur_tile_mi_row_start, cur_tile_mi_row_end;
|
2012-10-31 01:53:32 +01:00
|
|
|
} VP9_COMMON;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-01-15 00:52:20 +01:00
|
|
|
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]++;
|
|
|
|
}
|
|
|
|
|
2013-07-08 23:54:04 +02:00
|
|
|
static int mi_cols_aligned_to_sb(int n_mis) {
|
2013-08-22 23:45:24 +02:00
|
|
|
return ALIGN_POWER_OF_TWO(n_mis, MI_BLOCK_SIZE_LOG2);
|
2013-04-23 19:12:18 +02:00
|
|
|
}
|
|
|
|
|
2013-08-12 20:24:24 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-03 20:15:58 +02:00
|
|
|
static INLINE void set_partition_seg_context(VP9_COMMON *cm, MACROBLOCKD *xd,
|
2013-05-12 00:19:56 +02:00
|
|
|
int mi_row, int mi_col) {
|
|
|
|
xd->above_seg_context = cm->above_seg_context + mi_col;
|
2013-07-03 20:15:58 +02:00
|
|
|
xd->left_seg_context = cm->left_seg_context + (mi_row & MI_MASK);
|
2013-05-12 00:19:56 +02:00
|
|
|
}
|
|
|
|
|
2013-08-23 00:45:56 +02:00
|
|
|
// 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);
|
2013-06-07 00:33:57 +02:00
|
|
|
|
2013-08-23 00:45:56 +02:00
|
|
|
if (r && c)
|
2013-06-07 00:33:57 +02:00
|
|
|
return 0;
|
|
|
|
|
2013-08-23 00:45:56 +02:00
|
|
|
if (c && !r)
|
|
|
|
return 1; // only allow horizontal/split partition types
|
|
|
|
|
|
|
|
if (r && !c)
|
|
|
|
return 2; // only allow vertical/split partition types
|
2013-06-07 00:33:57 +02:00
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
static void set_mi_row_col(VP9_COMMON *cm, MACROBLOCKD *xd,
|
|
|
|
int mi_row, int bh,
|
|
|
|
int mi_col, int bw) {
|
|
|
|
xd->mb_to_top_edge = -((mi_row * MI_SIZE) << 3);
|
|
|
|
xd->mb_to_bottom_edge = ((cm->mi_rows - bh - mi_row) * MI_SIZE) << 3;
|
|
|
|
xd->mb_to_left_edge = -((mi_col * MI_SIZE) << 3);
|
|
|
|
xd->mb_to_right_edge = ((cm->mi_cols - bw - mi_col) * MI_SIZE) << 3;
|
2013-02-20 19:16:24 +01:00
|
|
|
|
|
|
|
// Are edges available for intra prediction?
|
2013-04-26 20:57:17 +02:00
|
|
|
xd->up_available = (mi_row != 0);
|
|
|
|
xd->left_available = (mi_col > cm->cur_tile_mi_col_start);
|
|
|
|
xd->right_available = (mi_col + bw < cm->cur_tile_mi_col_end);
|
2013-02-20 19:16:24 +01:00
|
|
|
}
|
|
|
|
|
2013-03-28 18:42:23 +01:00
|
|
|
static int get_token_alloc(int mb_rows, int mb_cols) {
|
2013-05-09 01:15:54 +02:00
|
|
|
return mb_rows * mb_cols * (48 * 16 + 4);
|
2013-03-28 18:42:23 +01:00
|
|
|
}
|
2013-05-29 22:42:23 +02:00
|
|
|
|
|
|
|
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 &&
|
2013-06-09 19:10:33 +02:00
|
|
|
!cm->intra_only &&
|
2013-05-29 22:42:23 +02:00
|
|
|
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;
|
|
|
|
}
|
2012-12-19 00:31:19 +01:00
|
|
|
#endif // VP9_COMMON_VP9_ONYXC_INT_H_
|