2015-08-06 05:00:31 +03:00
|
|
|
/*
|
2016-09-02 22:04:54 +03:00
|
|
|
* Copyright (c) 2016, Alliance for Open Media. All rights reserved
|
2015-08-06 05:00:31 +03:00
|
|
|
*
|
2016-09-02 22:04:54 +03:00
|
|
|
* This source code is subject to the terms of the BSD 2 Clause License and
|
|
|
|
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
|
|
|
|
* was not distributed with this source code in the LICENSE file, you can
|
|
|
|
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
|
|
|
|
* Media Patent License 1.0 was not distributed with this source code in the
|
|
|
|
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
|
2015-08-06 05:00:31 +03:00
|
|
|
*/
|
2016-08-31 00:01:10 +03:00
|
|
|
#ifndef AV1_COMMON_MVREF_COMMON_H_
|
|
|
|
#define AV1_COMMON_MVREF_COMMON_H_
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-23 02:08:15 +03:00
|
|
|
#include "av1/common/onyxc_int.h"
|
|
|
|
#include "av1/common/blockd.h"
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2016-11-21 21:15:30 +03:00
|
|
|
#if CONFIG_REF_MV
|
2016-10-17 09:06:35 +03:00
|
|
|
#define MVREF_NEIGHBOURS 9
|
|
|
|
#else
|
2015-08-06 05:00:31 +03:00
|
|
|
#define MVREF_NEIGHBOURS 8
|
2016-10-17 09:06:35 +03:00
|
|
|
#endif
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
typedef struct position {
|
|
|
|
int row;
|
|
|
|
int col;
|
|
|
|
} POSITION;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
BOTH_ZERO = 0,
|
|
|
|
ZERO_PLUS_PREDICTED = 1,
|
|
|
|
BOTH_PREDICTED = 2,
|
|
|
|
NEW_PLUS_NON_INTRA = 3,
|
|
|
|
BOTH_NEW = 4,
|
|
|
|
INTRA_PLUS_NON_INTRA = 5,
|
|
|
|
BOTH_INTRA = 6,
|
|
|
|
INVALID_CASE = 9
|
|
|
|
} motion_vector_context;
|
|
|
|
|
|
|
|
// This is used to figure out a context for the ref blocks. The code flattens
|
|
|
|
// an array that would have 3 possible counts (0, 1 & 2) for 3 choices by
|
|
|
|
// adding 9 for each intra block, 3 for each zero mv and 1 for each new
|
|
|
|
// motion vector. This single number is then converted into a context
|
|
|
|
// with a single lookup ( counter_to_context ).
|
|
|
|
static const int mode_2_counter[MB_MODE_COUNT] = {
|
|
|
|
9, // DC_PRED
|
|
|
|
9, // V_PRED
|
|
|
|
9, // H_PRED
|
|
|
|
9, // D45_PRED
|
|
|
|
9, // D135_PRED
|
|
|
|
9, // D117_PRED
|
|
|
|
9, // D153_PRED
|
|
|
|
9, // D207_PRED
|
|
|
|
9, // D63_PRED
|
2016-11-29 00:05:36 +03:00
|
|
|
#if CONFIG_ALT_INTRA
|
|
|
|
9, // SMOOTH_PRED
|
|
|
|
#endif // CONFIG_ALT_INTRA
|
|
|
|
9, // TM_PRED
|
|
|
|
0, // NEARESTMV
|
|
|
|
0, // NEARMV
|
|
|
|
3, // ZEROMV
|
|
|
|
1, // NEWMV
|
2016-01-08 02:13:52 +03:00
|
|
|
#if CONFIG_EXT_INTER
|
2016-08-12 04:55:00 +03:00
|
|
|
1, // NEWFROMNEARMV
|
|
|
|
0, // NEAREST_NEARESTMV
|
|
|
|
0, // NEAREST_NEARMV
|
|
|
|
0, // NEAR_NEARESTMV
|
|
|
|
0, // NEAR_NEARMV
|
|
|
|
1, // NEAREST_NEWMV
|
|
|
|
1, // NEW_NEARESTMV
|
|
|
|
1, // NEAR_NEWMV
|
|
|
|
1, // NEW_NEARMV
|
|
|
|
3, // ZERO_ZEROMV
|
|
|
|
1, // NEW_NEWMV
|
2016-01-08 02:13:52 +03:00
|
|
|
#endif // CONFIG_EXT_INTER
|
2015-08-06 05:00:31 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
// There are 3^3 different combinations of 3 counts that can be either 0,1 or
|
|
|
|
// 2. However the actual count can never be greater than 2 so the highest
|
|
|
|
// counter we need is 18. 9 is an invalid counter that's never used.
|
|
|
|
static const int counter_to_context[19] = {
|
2016-08-12 04:55:00 +03:00
|
|
|
BOTH_PREDICTED, // 0
|
|
|
|
NEW_PLUS_NON_INTRA, // 1
|
|
|
|
BOTH_NEW, // 2
|
|
|
|
ZERO_PLUS_PREDICTED, // 3
|
|
|
|
NEW_PLUS_NON_INTRA, // 4
|
|
|
|
INVALID_CASE, // 5
|
|
|
|
BOTH_ZERO, // 6
|
|
|
|
INVALID_CASE, // 7
|
|
|
|
INVALID_CASE, // 8
|
2015-08-06 05:00:31 +03:00
|
|
|
INTRA_PLUS_NON_INTRA, // 9
|
|
|
|
INTRA_PLUS_NON_INTRA, // 10
|
2016-08-12 04:55:00 +03:00
|
|
|
INVALID_CASE, // 11
|
2015-08-06 05:00:31 +03:00
|
|
|
INTRA_PLUS_NON_INTRA, // 12
|
2016-08-12 04:55:00 +03:00
|
|
|
INVALID_CASE, // 13
|
|
|
|
INVALID_CASE, // 14
|
|
|
|
INVALID_CASE, // 15
|
|
|
|
INVALID_CASE, // 16
|
|
|
|
INVALID_CASE, // 17
|
|
|
|
BOTH_INTRA // 18
|
2015-08-06 05:00:31 +03:00
|
|
|
};
|
|
|
|
|
2016-11-21 21:15:30 +03:00
|
|
|
#if !CONFIG_REF_MV
|
2015-08-06 05:00:31 +03:00
|
|
|
static const POSITION mv_ref_blocks[BLOCK_SIZES][MVREF_NEIGHBOURS] = {
|
|
|
|
// 4X4
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -2, 0 },
|
|
|
|
{ 0, -2 },
|
|
|
|
{ -2, -1 },
|
|
|
|
{ -1, -2 },
|
|
|
|
{ -2, -2 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 4X8
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -2, 0 },
|
|
|
|
{ 0, -2 },
|
|
|
|
{ -2, -1 },
|
|
|
|
{ -1, -2 },
|
|
|
|
{ -2, -2 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 8X4
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -2, 0 },
|
|
|
|
{ 0, -2 },
|
|
|
|
{ -2, -1 },
|
|
|
|
{ -1, -2 },
|
|
|
|
{ -2, -2 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 8X8
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -2, 0 },
|
|
|
|
{ 0, -2 },
|
|
|
|
{ -2, -1 },
|
|
|
|
{ -1, -2 },
|
|
|
|
{ -2, -2 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 8X16
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { 0, -1 },
|
|
|
|
{ -1, 0 },
|
|
|
|
{ 1, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ 0, -2 },
|
|
|
|
{ -2, 0 },
|
|
|
|
{ -2, -1 },
|
|
|
|
{ -1, -2 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 16X8
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, 1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -2, 0 },
|
|
|
|
{ 0, -2 },
|
|
|
|
{ -1, -2 },
|
|
|
|
{ -2, -1 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 16X16
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, 1 },
|
|
|
|
{ 1, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -3, 0 },
|
|
|
|
{ 0, -3 },
|
|
|
|
{ -3, -3 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 16X32
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { 0, -1 },
|
|
|
|
{ -1, 0 },
|
|
|
|
{ 2, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -1, 1 },
|
|
|
|
{ 0, -3 },
|
|
|
|
{ -3, 0 },
|
|
|
|
{ -3, -3 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 32X16
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, 2 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ 1, -1 },
|
|
|
|
{ -3, 0 },
|
|
|
|
{ 0, -3 },
|
|
|
|
{ -3, -3 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 32X32
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 1 },
|
|
|
|
{ 1, -1 },
|
|
|
|
{ -1, 2 },
|
|
|
|
{ 2, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -3, 0 },
|
|
|
|
{ 0, -3 },
|
|
|
|
{ -3, -3 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 32X64
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { 0, -1 },
|
|
|
|
{ -1, 0 },
|
|
|
|
{ 4, -1 },
|
|
|
|
{ -1, 2 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ 0, -3 },
|
|
|
|
{ -3, 0 },
|
|
|
|
{ 2, -1 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 64X32
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, 4 },
|
|
|
|
{ 2, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -3, 0 },
|
|
|
|
{ 0, -3 },
|
|
|
|
{ -1, 2 } },
|
2015-08-06 05:00:31 +03:00
|
|
|
// 64X64
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -1, 3 },
|
|
|
|
{ 3, -1 },
|
|
|
|
{ -1, 4 },
|
|
|
|
{ 4, -1 },
|
|
|
|
{ -1, -1 },
|
|
|
|
{ -1, 0 },
|
|
|
|
{ 0, -1 },
|
|
|
|
{ -1, 6 } },
|
2016-03-07 16:46:39 +03:00
|
|
|
#if CONFIG_EXT_PARTITION
|
|
|
|
// TODO(debargha/jingning) Making them twice the 32x64, .. ones above
|
|
|
|
// 64x128
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { 0, -2 },
|
|
|
|
{ -2, 0 },
|
|
|
|
{ 8, -2 },
|
|
|
|
{ -2, 4 },
|
|
|
|
{ -2, -2 },
|
|
|
|
{ 0, -6 },
|
|
|
|
{ -6, 0 },
|
|
|
|
{ 4, -2 } },
|
2016-03-07 16:46:39 +03:00
|
|
|
// 128x64
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -2, 0 },
|
|
|
|
{ 0, -2 },
|
|
|
|
{ -2, 8 },
|
|
|
|
{ 4, -2 },
|
|
|
|
{ -2, -2 },
|
|
|
|
{ -6, 0 },
|
|
|
|
{ 0, -6 },
|
|
|
|
{ -2, 4 } },
|
2016-03-07 16:46:39 +03:00
|
|
|
// 128x128
|
2016-08-12 04:55:00 +03:00
|
|
|
{ { -2, 6 },
|
|
|
|
{ 6, -2 },
|
|
|
|
{ -2, 8 },
|
|
|
|
{ 8, -2 },
|
|
|
|
{ -2, -2 },
|
|
|
|
{ -2, 0 },
|
|
|
|
{ 0, -2 },
|
|
|
|
{ -2, 12 } },
|
2016-03-07 16:46:39 +03:00
|
|
|
#endif // CONFIG_EXT_PARTITION
|
2015-08-06 05:00:31 +03:00
|
|
|
};
|
2016-10-17 09:06:35 +03:00
|
|
|
#endif
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
static const int idx_n_column_to_subblock[4][2] = {
|
2016-08-12 04:55:00 +03:00
|
|
|
{ 1, 2 }, { 1, 3 }, { 3, 2 }, { 3, 3 }
|
2015-08-06 05:00:31 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
// clamp_mv_ref
|
2016-03-07 16:46:39 +03:00
|
|
|
#if CONFIG_EXT_PARTITION
|
2016-08-12 04:55:00 +03:00
|
|
|
#define MV_BORDER (16 << 3) // Allow 16 pels in 1/8th pel units
|
2016-03-07 16:46:39 +03:00
|
|
|
#else
|
2016-08-12 04:55:00 +03:00
|
|
|
#define MV_BORDER (8 << 3) // Allow 8 pels in 1/8th pel units
|
|
|
|
#endif // CONFIG_EXT_PARTITION
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2015-10-02 19:09:24 +03:00
|
|
|
static INLINE void clamp_mv_ref(MV *mv, int bw, int bh, const MACROBLOCKD *xd) {
|
|
|
|
clamp_mv(mv, xd->mb_to_left_edge - bw * 8 - MV_BORDER,
|
2016-08-12 04:55:00 +03:00
|
|
|
xd->mb_to_right_edge + bw * 8 + MV_BORDER,
|
|
|
|
xd->mb_to_top_edge - bh * 8 - MV_BORDER,
|
|
|
|
xd->mb_to_bottom_edge + bh * 8 + MV_BORDER);
|
2015-08-06 05:00:31 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// This function returns either the appropriate sub block or block's mv
|
|
|
|
// on whether the block_size < 8x8 and we have check_sub_blocks set.
|
|
|
|
static INLINE int_mv get_sub_block_mv(const MODE_INFO *candidate, int which_mv,
|
|
|
|
int search_col, int block_idx) {
|
2016-11-21 21:15:30 +03:00
|
|
|
#if CONFIG_REF_MV
|
|
|
|
(void)search_col;
|
2016-11-22 01:20:22 +03:00
|
|
|
(void)block_idx;
|
2016-10-17 09:06:35 +03:00
|
|
|
return candidate->mbmi.mv[which_mv];
|
|
|
|
#else
|
2015-08-06 05:00:31 +03:00
|
|
|
return block_idx >= 0 && candidate->mbmi.sb_type < BLOCK_8X8
|
2016-08-12 04:55:00 +03:00
|
|
|
? candidate
|
|
|
|
->bmi[idx_n_column_to_subblock[block_idx][search_col == 0]]
|
|
|
|
.as_mv[which_mv]
|
|
|
|
: candidate->mbmi.mv[which_mv];
|
2016-10-17 09:06:35 +03:00
|
|
|
#endif
|
2015-08-06 05:00:31 +03:00
|
|
|
}
|
|
|
|
|
2016-02-18 03:10:38 +03:00
|
|
|
#if CONFIG_REF_MV
|
|
|
|
static INLINE int_mv get_sub_block_pred_mv(const MODE_INFO *candidate,
|
2016-08-12 04:55:00 +03:00
|
|
|
int which_mv, int search_col,
|
|
|
|
int block_idx) {
|
2016-11-21 09:34:12 +03:00
|
|
|
(void)search_col;
|
|
|
|
(void)block_idx;
|
2016-10-17 09:06:35 +03:00
|
|
|
return candidate->mbmi.mv[which_mv];
|
2016-02-18 03:10:38 +03:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
// Performs mv sign inversion if indicated by the reference frame combination.
|
|
|
|
static INLINE int_mv scale_mv(const MB_MODE_INFO *mbmi, int ref,
|
|
|
|
const MV_REFERENCE_FRAME this_ref_frame,
|
|
|
|
const int *ref_sign_bias) {
|
|
|
|
int_mv mv = mbmi->mv[ref];
|
|
|
|
if (ref_sign_bias[mbmi->ref_frame[ref]] != ref_sign_bias[this_ref_frame]) {
|
|
|
|
mv.as_mv.row *= -1;
|
|
|
|
mv.as_mv.col *= -1;
|
|
|
|
}
|
|
|
|
return mv;
|
|
|
|
}
|
|
|
|
|
2015-10-20 20:31:40 +03:00
|
|
|
#define CLIP_IN_ADD(mv, bw, bh, xd) clamp_mv_ref(mv, bw, bh, xd)
|
|
|
|
|
2015-08-06 05:00:31 +03:00
|
|
|
// This macro is used to add a motion vector mv_ref list if it isn't
|
|
|
|
// already in the list. If it's the second motion vector it will also
|
|
|
|
// skip all additional processing and jump to done!
|
2016-08-12 04:55:00 +03:00
|
|
|
#define ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done) \
|
|
|
|
do { \
|
|
|
|
(mv_ref_list)[(refmv_count)] = (mv); \
|
|
|
|
CLIP_IN_ADD(&(mv_ref_list)[(refmv_count)].as_mv, (bw), (bh), (xd)); \
|
2015-10-20 20:31:40 +03:00
|
|
|
if (refmv_count && (mv_ref_list)[1].as_int != (mv_ref_list)[0].as_int) { \
|
2016-08-12 04:55:00 +03:00
|
|
|
(refmv_count) = 2; \
|
|
|
|
goto Done; \
|
|
|
|
} \
|
|
|
|
(refmv_count) = 1; \
|
2015-08-06 05:00:31 +03:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
// If either reference frame is different, not INTRA, and they
|
|
|
|
// are different from each other scale and add the mv to our list.
|
|
|
|
#define IF_DIFF_REF_FRAME_ADD_MV(mbmi, ref_frame, ref_sign_bias, refmv_count, \
|
2016-08-12 04:55:00 +03:00
|
|
|
mv_ref_list, bw, bh, xd, Done) \
|
|
|
|
do { \
|
|
|
|
if (is_inter_block(mbmi)) { \
|
|
|
|
if ((mbmi)->ref_frame[0] != ref_frame) \
|
|
|
|
ADD_MV_REF_LIST(scale_mv((mbmi), 0, ref_frame, ref_sign_bias), \
|
|
|
|
refmv_count, mv_ref_list, bw, bh, xd, Done); \
|
|
|
|
if (has_second_ref(mbmi) && (mbmi)->ref_frame[1] != ref_frame) \
|
|
|
|
ADD_MV_REF_LIST(scale_mv((mbmi), 1, ref_frame, ref_sign_bias), \
|
|
|
|
refmv_count, mv_ref_list, bw, bh, xd, Done); \
|
|
|
|
} \
|
2015-08-06 05:00:31 +03:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
// Checks that the given mi_row, mi_col and search point
|
|
|
|
// are inside the borders of the tile.
|
2016-08-12 04:55:00 +03:00
|
|
|
static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row,
|
2015-08-06 05:00:31 +03:00
|
|
|
const POSITION *mi_pos) {
|
2016-03-11 20:42:49 +03:00
|
|
|
return !(mi_row + mi_pos->row < tile->mi_row_start ||
|
|
|
|
mi_col + mi_pos->col < tile->mi_col_start ||
|
|
|
|
mi_row + mi_pos->row >= tile->mi_row_end ||
|
|
|
|
mi_col + mi_pos->col >= tile->mi_col_end);
|
2015-08-06 05:00:31 +03:00
|
|
|
}
|
|
|
|
|
2016-01-13 02:06:59 +03:00
|
|
|
static INLINE void lower_mv_precision(MV *mv, int allow_hp) {
|
2016-09-30 00:21:37 +03:00
|
|
|
if (!allow_hp) {
|
2016-08-12 04:55:00 +03:00
|
|
|
if (mv->row & 1) mv->row += (mv->row > 0 ? -1 : 1);
|
|
|
|
if (mv->col & 1) mv->col += (mv->col > 0 ? -1 : 1);
|
2016-01-13 02:06:59 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-09 20:07:39 +03:00
|
|
|
#if CONFIG_REF_MV
|
2016-11-18 22:01:48 +03:00
|
|
|
static INLINE uint8_t av1_get_pred_diff_ctx(const int_mv pred_mv,
|
|
|
|
const int_mv this_mv) {
|
|
|
|
if (abs(this_mv.as_mv.row - pred_mv.as_mv.row) <= 4 &&
|
|
|
|
abs(this_mv.as_mv.col - pred_mv.as_mv.col) <= 4)
|
|
|
|
return 2;
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
static INLINE int av1_nmv_ctx(const uint8_t ref_mv_count,
|
2016-09-27 22:55:32 +03:00
|
|
|
const CANDIDATE_MV *ref_mv_stack, int ref,
|
|
|
|
int ref_mv_idx) {
|
2016-02-18 22:57:44 +03:00
|
|
|
#if CONFIG_EXT_INTER
|
|
|
|
return 0;
|
|
|
|
#endif
|
2016-09-27 22:55:32 +03:00
|
|
|
|
2016-11-18 22:01:48 +03:00
|
|
|
if (ref_mv_stack[ref_mv_idx].weight >= REF_CAT_LEVEL && ref_mv_count > 0)
|
|
|
|
return ref_mv_stack[ref_mv_idx].pred_diff[ref];
|
2016-09-27 22:55:32 +03:00
|
|
|
|
2016-02-18 22:57:44 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
static INLINE int8_t av1_ref_frame_type(const MV_REFERENCE_FRAME *const rf) {
|
2016-06-22 01:06:40 +03:00
|
|
|
if (rf[1] > INTRA_FRAME) {
|
Code refactoring on Macros related to ref frame numbers
We have renamed following Macros to avoid name confusion:
REFS_PER_FRAME --> INTER_REFS_PER_FRAME
(= ALTREF_FRAME - LAST_FRAME + 1)
MAX_REF_FRAMES --> TOTAL_REFS_PER_FRAME
(= ALTREF_FRAME - INTRA_FRAME + 1)
INTER_REFS_PER_FRAME specifies the maximum number of reference frames
that each Inter frame may use.
TOTAL_REFS_PER_FRAME is equal to INTER_REFS_PER_FRAME + 1, which
counts the INTRA_FRAME.
Further, at the encoder side, since REF_FRAMES specifies the maximum
number of the reference frames that the encoder may store, REF_FRAMES
is usually larger than INTER_REFS_PER_FRAME. For example, in the
ext-refs experiment, REF_FRAMES == 8, which allows the encoder to
store maximum 8 reference frames in the buffer, but
INTER_REFS_PER_FRAME equals to 6, which allows each Inter frame may
use up to 6 frames out of the 8 buffered frames as its references.
Hence, in order to explore the possibility to store more reference
frames in future patches, we modified a couple of array sizes to
accomodate the case that the number of buffered reference frames is
not always equal to the number of the references that are being used
by each Inter frame.
Change-Id: I19e42ef608946cc76ebfd3e965a05f4b9b93a0b3
2016-08-04 00:46:43 +03:00
|
|
|
return TOTAL_REFS_PER_FRAME + FWD_RF_OFFSET(rf[0]) +
|
2016-08-12 04:55:00 +03:00
|
|
|
BWD_RF_OFFSET(rf[1]) * FWD_REFS;
|
2016-06-22 01:06:40 +03:00
|
|
|
}
|
2015-12-12 09:39:40 +03:00
|
|
|
|
|
|
|
return rf[0];
|
|
|
|
}
|
|
|
|
|
2016-06-22 19:36:17 +03:00
|
|
|
static MV_REFERENCE_FRAME ref_frame_map[COMP_REFS][2] = {
|
2016-06-22 01:06:40 +03:00
|
|
|
#if CONFIG_EXT_REFS
|
2016-08-12 04:55:00 +03:00
|
|
|
{ LAST_FRAME, BWDREF_FRAME }, { LAST2_FRAME, BWDREF_FRAME },
|
|
|
|
{ LAST3_FRAME, BWDREF_FRAME }, { GOLDEN_FRAME, BWDREF_FRAME },
|
|
|
|
|
|
|
|
{ LAST_FRAME, ALTREF_FRAME }, { LAST2_FRAME, ALTREF_FRAME },
|
|
|
|
{ LAST3_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }
|
2016-06-22 01:06:40 +03:00
|
|
|
#else
|
2016-08-12 04:55:00 +03:00
|
|
|
{ LAST_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }
|
2016-06-22 01:06:40 +03:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
static INLINE void av1_set_ref_frame(MV_REFERENCE_FRAME *rf,
|
|
|
|
int8_t ref_frame_type) {
|
Code refactoring on Macros related to ref frame numbers
We have renamed following Macros to avoid name confusion:
REFS_PER_FRAME --> INTER_REFS_PER_FRAME
(= ALTREF_FRAME - LAST_FRAME + 1)
MAX_REF_FRAMES --> TOTAL_REFS_PER_FRAME
(= ALTREF_FRAME - INTRA_FRAME + 1)
INTER_REFS_PER_FRAME specifies the maximum number of reference frames
that each Inter frame may use.
TOTAL_REFS_PER_FRAME is equal to INTER_REFS_PER_FRAME + 1, which
counts the INTRA_FRAME.
Further, at the encoder side, since REF_FRAMES specifies the maximum
number of the reference frames that the encoder may store, REF_FRAMES
is usually larger than INTER_REFS_PER_FRAME. For example, in the
ext-refs experiment, REF_FRAMES == 8, which allows the encoder to
store maximum 8 reference frames in the buffer, but
INTER_REFS_PER_FRAME equals to 6, which allows each Inter frame may
use up to 6 frames out of the 8 buffered frames as its references.
Hence, in order to explore the possibility to store more reference
frames in future patches, we modified a couple of array sizes to
accomodate the case that the number of buffered reference frames is
not always equal to the number of the references that are being used
by each Inter frame.
Change-Id: I19e42ef608946cc76ebfd3e965a05f4b9b93a0b3
2016-08-04 00:46:43 +03:00
|
|
|
if (ref_frame_type >= TOTAL_REFS_PER_FRAME) {
|
|
|
|
rf[0] = ref_frame_map[ref_frame_type - TOTAL_REFS_PER_FRAME][0];
|
|
|
|
rf[1] = ref_frame_map[ref_frame_type - TOTAL_REFS_PER_FRAME][1];
|
2015-12-12 09:39:40 +03:00
|
|
|
} else {
|
|
|
|
rf[0] = ref_frame_type;
|
2017-01-21 02:03:11 +03:00
|
|
|
rf[1] = NONE_FRAME;
|
Code refactoring on Macros related to ref frame numbers
We have renamed following Macros to avoid name confusion:
REFS_PER_FRAME --> INTER_REFS_PER_FRAME
(= ALTREF_FRAME - LAST_FRAME + 1)
MAX_REF_FRAMES --> TOTAL_REFS_PER_FRAME
(= ALTREF_FRAME - INTRA_FRAME + 1)
INTER_REFS_PER_FRAME specifies the maximum number of reference frames
that each Inter frame may use.
TOTAL_REFS_PER_FRAME is equal to INTER_REFS_PER_FRAME + 1, which
counts the INTRA_FRAME.
Further, at the encoder side, since REF_FRAMES specifies the maximum
number of the reference frames that the encoder may store, REF_FRAMES
is usually larger than INTER_REFS_PER_FRAME. For example, in the
ext-refs experiment, REF_FRAMES == 8, which allows the encoder to
store maximum 8 reference frames in the buffer, but
INTER_REFS_PER_FRAME equals to 6, which allows each Inter frame may
use up to 6 frames out of the 8 buffered frames as its references.
Hence, in order to explore the possibility to store more reference
frames in future patches, we modified a couple of array sizes to
accomodate the case that the number of buffered reference frames is
not always equal to the number of the references that are being used
by each Inter frame.
Change-Id: I19e42ef608946cc76ebfd3e965a05f4b9b93a0b3
2016-08-04 00:46:43 +03:00
|
|
|
assert(ref_frame_type > INTRA_FRAME &&
|
|
|
|
ref_frame_type < TOTAL_REFS_PER_FRAME);
|
2015-12-12 09:39:40 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
static INLINE int16_t av1_mode_context_analyzer(
|
2016-02-05 20:35:34 +03:00
|
|
|
const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf,
|
|
|
|
BLOCK_SIZE bsize, int block) {
|
2015-12-09 20:07:39 +03:00
|
|
|
int16_t mode_ctx = 0;
|
2016-09-27 22:55:32 +03:00
|
|
|
int8_t ref_frame_type = av1_ref_frame_type(rf);
|
|
|
|
|
2015-12-09 20:07:39 +03:00
|
|
|
if (block >= 0) {
|
|
|
|
mode_ctx = mode_context[rf[0]] & 0x00ff;
|
2016-12-14 22:05:10 +03:00
|
|
|
#if !CONFIG_CB4X4
|
2015-12-09 20:07:39 +03:00
|
|
|
if (block > 0 && bsize < BLOCK_8X8 && bsize > BLOCK_4X4)
|
|
|
|
mode_ctx |= (1 << SKIP_NEARESTMV_SUB8X8_OFFSET);
|
2016-12-14 22:05:10 +03:00
|
|
|
#else
|
|
|
|
(void)block;
|
|
|
|
(void)bsize;
|
|
|
|
#endif
|
2015-12-09 20:07:39 +03:00
|
|
|
|
|
|
|
return mode_ctx;
|
|
|
|
}
|
|
|
|
|
2016-11-17 22:53:23 +03:00
|
|
|
return mode_context[ref_frame_type];
|
2015-12-09 20:07:39 +03:00
|
|
|
}
|
2016-01-22 05:07:31 +03:00
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack,
|
|
|
|
int ref_idx) {
|
2016-03-28 20:26:27 +03:00
|
|
|
if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
|
2016-10-05 19:08:44 +03:00
|
|
|
ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL)
|
|
|
|
return 0;
|
2016-01-22 05:07:31 +03:00
|
|
|
|
2016-03-28 20:26:27 +03:00
|
|
|
if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
|
2016-02-12 03:38:13 +03:00
|
|
|
ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
|
2016-03-17 21:26:52 +03:00
|
|
|
return 2;
|
2016-01-22 05:07:31 +03:00
|
|
|
|
2016-02-12 03:38:13 +03:00
|
|
|
if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL &&
|
2016-10-05 19:08:44 +03:00
|
|
|
ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
|
|
|
|
return 3;
|
2016-01-22 05:07:31 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-12-09 20:07:39 +03:00
|
|
|
#endif
|
|
|
|
|
2015-08-06 05:00:31 +03:00
|
|
|
typedef void (*find_mv_refs_sync)(void *const data, int mi_row);
|
2016-08-31 00:01:10 +03:00
|
|
|
void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
|
|
|
|
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
|
2015-11-24 02:05:18 +03:00
|
|
|
#if CONFIG_REF_MV
|
2016-08-31 00:01:10 +03:00
|
|
|
uint8_t *ref_mv_count, CANDIDATE_MV *ref_mv_stack,
|
2016-01-20 03:45:45 +03:00
|
|
|
#if CONFIG_EXT_INTER
|
2016-08-31 00:01:10 +03:00
|
|
|
int16_t *compound_mode_context,
|
2016-01-20 03:45:45 +03:00
|
|
|
#endif // CONFIG_EXT_INTER
|
2015-11-24 02:05:18 +03:00
|
|
|
#endif
|
2016-08-31 00:01:10 +03:00
|
|
|
int_mv *mv_ref_list, int mi_row, int mi_col,
|
|
|
|
find_mv_refs_sync sync, void *const data,
|
|
|
|
int16_t *mode_context);
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
// check a list of motion vectors by sad score using a number rows of pixels
|
|
|
|
// above and a number cols of pixels in the left to select the one with best
|
|
|
|
// score to use as ref motion vector
|
2016-08-31 00:01:10 +03:00
|
|
|
void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
|
|
|
|
int_mv *near_mv);
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-10-14 03:27:51 +03:00
|
|
|
void av1_append_sub8x8_mvs_for_idx(const AV1_COMMON *cm, MACROBLOCKD *xd,
|
|
|
|
int block, int ref, int mi_row, int mi_col,
|
2016-03-15 01:04:58 +03:00
|
|
|
#if CONFIG_REF_MV
|
2016-08-31 00:01:10 +03:00
|
|
|
CANDIDATE_MV *ref_mv_stack,
|
|
|
|
uint8_t *ref_mv_count,
|
2016-03-15 01:04:58 +03:00
|
|
|
#endif
|
2016-01-08 02:13:52 +03:00
|
|
|
#if CONFIG_EXT_INTER
|
2016-08-31 00:01:10 +03:00
|
|
|
int_mv *mv_list,
|
2016-01-08 02:13:52 +03:00
|
|
|
#endif // CONFIG_EXT_INTER
|
2016-08-31 00:01:10 +03:00
|
|
|
int_mv *nearest_mv, int_mv *near_mv);
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-01-08 02:13:52 +03:00
|
|
|
#if CONFIG_EXT_INTER
|
|
|
|
// This function keeps a mode count for a given MB/SB
|
2016-08-31 00:01:10 +03:00
|
|
|
void av1_update_mv_context(const MACROBLOCKD *xd, MODE_INFO *mi,
|
|
|
|
MV_REFERENCE_FRAME ref_frame, int_mv *mv_ref_list,
|
|
|
|
int block, int mi_row, int mi_col,
|
|
|
|
int16_t *mode_context);
|
2016-01-08 02:13:52 +03:00
|
|
|
#endif // CONFIG_EXT_INTER
|
|
|
|
|
2016-09-09 00:48:15 +03:00
|
|
|
#if CONFIG_WARPED_MOTION
|
|
|
|
int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
|
|
|
|
double *pts, double *pts_inref);
|
|
|
|
#endif // CONFIG_WARPED_MOTION
|
|
|
|
|
2015-08-06 05:00:31 +03:00
|
|
|
#ifdef __cplusplus
|
|
|
|
} // extern "C"
|
|
|
|
#endif
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
#endif // AV1_COMMON_MVREF_COMMON_H_
|