#define VP9_FRAME_MARKER 0x2
+static INLINE int get_unsigned_bits_gen(unsigned int num_values) {
+ int cat = 0;
+ if (num_values <= 1)
+ return 0;
+ num_values--;
+ while (num_values > 0) {
+ cat++;
+ num_values >>= 1;
+ }
+ return cat;
+}
#ifdef __cplusplus
} // extern "C"
#if CONFIG_WEDGE_PARTITION
vp9_prob wedge_interinter_prob[BLOCK_SIZES];
#endif // CONFIG_WEDGE_PARTITION
+#if CONFIG_GLOBAL_MOTION
+ vp9_prob global_motion_types_prob[GLOBAL_MOTION_TYPES - 1];
+#endif // CONFIG_GLOBAL_MOTION
} FRAME_CONTEXT;
typedef struct {
unsigned int y_palette_size[10][PALETTE_SIZES];
unsigned int uv_palette_size[10][PALETTE_SIZES];
#endif // CONFIG_PALETTE
+#if CONFIG_GLOBAL_MOTION
+ unsigned int global_motion_types[GLOBAL_MOTION_TYPES];
+#endif // CONFIG_GLOBAL_MOTION
} FRAME_COUNTS;
extern const vp9_prob vp9_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1];
* be found in the AUTHORS file in the root of the source tree.
*/
+#include <math.h>
+
#include "vp9/common/vp9_onyxc_int.h"
#include "vp9/common/vp9_entropymv.h"
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10
};
+#if CONFIG_GLOBAL_MOTION
+const vp9_tree_index vp9_global_motion_types_tree
+ [TREE_SIZE(GLOBAL_MOTION_TYPES)] = {
+ -GLOBAL_ZERO, 2,
+ -GLOBAL_TRANSLATION, -GLOBAL_ROTZOOM
+};
+
+static const vp9_prob default_global_motion_types_prob
+ [GLOBAL_MOTION_TYPES - 1] = {
+ // Currently only translation is used, so make the second prob very high.
+ 240, 255
+};
+
+static void convert_params_to_rotzoom(double *H, Global_Motion_Params *model) {
+ double z = 1.0 + (double) model->zoom / (1 << ZOOM_PRECISION_BITS);
+ double r = (double) model->rotation / (1 << ROTATION_PRECISION_BITS);
+ H[0] = (1 + z) * cos(r * M_PI / 180.0);
+ H[1] = -(1 + z) * sin(r * M_PI / 180.0);
+ H[2] = (double) model->mv.as_mv.col / 8.0;
+ H[3] = (double) model->mv.as_mv.row / 8.0;
+}
+
+static int_mv get_global_mv(int col, int row, Global_Motion_Params *model) {
+ int_mv mv;
+ double H[4];
+ double x, y;
+ convert_params_to_rotzoom(H, model);
+ x = H[0] * col + H[1] * row + H[2];
+ y = -H[1] * col + H[0] * row + H[3];
+ mv.as_mv.col = (int)floor(x * 8 + 0.5) - col;
+ mv.as_mv.row = (int)floor(y * 8 + 0.5) - row;
+ return mv;
+}
+
+int_mv vp9_get_global_sb_center_mv(int col, int row, BLOCK_SIZE bsize,
+ Global_Motion_Params *model) {
+ col += num_4x4_blocks_wide_lookup[bsize] * 2;
+ row += num_4x4_blocks_high_lookup[bsize] * 2;
+ return get_global_mv(col, row, model);
+}
+
+int_mv vp9_get_global_sub8x8_center_mv(int col, int row, int block,
+ Global_Motion_Params *model) {
+ if (block == 0 || block == 2)
+ col += 2;
+ else
+ col += 6;
+ if (block == 0 || block == 1)
+ row += 2;
+ else
+ row += 6;
+ return get_global_mv(col, row, model);
+}
+#endif // CONFIG_GLOBAL_MOTION
+
static INLINE int mv_class_base(MV_CLASS_TYPE c) {
return c ? CLASS0_SIZE << (c + 2) : 0;
}
static void inc_mv_component(int v, nmv_component_counts *comp_counts,
int incr, int usehp) {
int s, z, c, o, d, e, f;
- assert(v != 0); /* should not be zero */
+ assert(v != 0); /* should not be zero */
s = v < 0;
comp_counts->sign[s] += incr;
z = (s ? -v : v) - 1; /* magnitude - 1 */
#if CONFIG_INTRABC
cm->fc.ndvc = default_nmv_context;
#endif // CONFIG_INTRABC
+#if CONFIG_GLOBAL_MOTION
+ vp9_copy(cm->fc.global_motion_types_prob, default_global_motion_types_prob);
+#endif // CONFIG_GLOBAL_MOTION
}
#include "./vpx_config.h"
+#include "vp9/common/vp9_enums.h"
#include "vp9/common/vp9_mv.h"
#include "vp9/common/vp9_prob.h"
void vp9_inc_mv(const MV *mv, nmv_context_counts *mvctx);
+#if CONFIG_GLOBAL_MOTION
+#define MAX_GLOBAL_MOTION_MODELS 1
+
+#define ZOOM_PRECISION_BITS 6
+#define ROTATION_PRECISION_BITS 4
+
+#define ABS_ZOOM_BITS 3
+#define ABS_ROTATION_BITS 4
+#define ABS_TRANSLATION_BITS 7
+
+typedef enum {
+ GLOBAL_ZERO = 0,
+ GLOBAL_TRANSLATION = 1,
+ GLOBAL_ROTZOOM = 2,
+ GLOBAL_MOTION_TYPES
+} GLOBAL_MOTION_TYPE;
+
+// Currently this is specialized for rotzoom model only
+typedef struct {
+ int rotation; // positive or negative rotation angle in degrees
+ int zoom; // this is actually the zoom multiplier minus 1
+ int_mv mv;
+} Global_Motion_Params;
+
+extern const vp9_tree_index vp9_global_motion_types_tree
+ [TREE_SIZE(GLOBAL_MOTION_TYPES)];
+
+int_mv vp9_get_global_sb_center_mv(int col, int row, BLOCK_SIZE bsize,
+ Global_Motion_Params *model);
+int_mv vp9_get_global_sub8x8_center_mv(int col, int row, int block,
+ Global_Motion_Params *model);
+#endif // CONFIG_GLOBAL_MOTION
+
#ifdef __cplusplus
} // extern "C"
#endif
-
/*
* Copyright (c) 2012 The WebM project authors. All Rights Reserved.
*
int palette_counter;
int block_counter;
#endif // CONFIG_PALETTE
+#if CONFIG_GLOBAL_MOTION
+ int num_global_motion[MAX_REF_FRAMES];
+ Global_Motion_Params global_motion[MAX_REF_FRAMES][MAX_GLOBAL_MOTION_MODELS];
+#endif
} VP9_COMMON;
static INLINE YV12_BUFFER_CONFIG *get_ref_frame(VP9_COMMON *cm, int index) {
// Do border extension if there is motion or the
// width/height is not a multiple of 8 pixels.
if (is_scaled || scaled_mv.col || scaled_mv.row ||
- (frame_width & 0x7) || (frame_height & 0x7)) {
+ (frame_width & 0x7) || (frame_height & 0x7)) {
// Get reference block bottom right coordinate.
int x1 = ((x0_16 + (w - 1) * xs) >> SUBPEL_BITS) + 1;
int y1 = ((y0_16 + (h - 1) * ys) >> SUBPEL_BITS) + 1;
}
#endif // CONFIG_COMPOUND_MODES
+#if CONFIG_GLOBAL_MOTION
+static void read_global_motion_params(Global_Motion_Params *params,
+ vp9_prob *probs,
+ vp9_reader *r) {
+ GLOBAL_MOTION_TYPE gmtype = vp9_read_tree(r, vp9_global_motion_types_tree,
+ probs);
+ switch (gmtype) {
+ case GLOBAL_ZERO:
+ break;
+ case GLOBAL_TRANSLATION:
+ params->mv.as_mv.col =
+ vp9_read_primitive_symmetric(r, ABS_TRANSLATION_BITS);
+ params->mv.as_mv.row =
+ vp9_read_primitive_symmetric(r, ABS_TRANSLATION_BITS);
+ break;
+ case GLOBAL_ROTZOOM:
+ params->mv.as_mv.col =
+ vp9_read_primitive_symmetric(r, ABS_TRANSLATION_BITS);
+ params->mv.as_mv.row =
+ vp9_read_primitive_symmetric(r, ABS_TRANSLATION_BITS);
+ params->zoom =
+ vp9_read_primitive_symmetric(r, ABS_ZOOM_BITS);
+ params->rotation =
+ vp9_read_primitive_symmetric(r, ABS_ROTATION_BITS);
+ break;
+ default:
+ assert(0);
+ }
+}
+
+static void read_global_motion(VP9_COMMON *cm, vp9_reader *r) {
+ int frame, i;
+ vpx_memset(cm->num_global_motion, 0, sizeof(cm->num_global_motion));
+ vpx_memset(cm->global_motion, 0, sizeof(cm->global_motion));
+ for (frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) {
+ cm->num_global_motion[frame] = 1;
+ for (i = 0; i < cm->num_global_motion[frame]; ++i) {
+ read_global_motion_params(
+ cm->global_motion[frame], cm->fc.global_motion_types_prob, r);
+ }
+ }
+}
+#endif // CONFIG_GLOBAL_MOTION
+
static int read_compressed_header(VP9Decoder *pbi, const uint8_t *data,
size_t partition_size) {
VP9_COMMON *const cm = &pbi->common;
}
}
#endif // CONFIG_WEDGE_PARTITION
+#if CONFIG_GLOBAL_MOTION
+ read_global_motion(cm, &r);
+#endif // CONFIG_GLOBAL_MOTION
}
#if CONFIG_PALETTE
if (frame_is_intra_only(cm))
}
static INLINE int assign_mv(VP9_COMMON *cm, PREDICTION_MODE mode,
+ MV_REFERENCE_FRAME ref_frame[2],
int_mv mv[2], int_mv ref_mv[2],
int_mv nearest_mv[2], int_mv near_mv[2],
int is_compound, int allow_hp, vp9_reader *r) {
int i;
int ret = 1;
+ (void) ref_frame;
#if CONFIG_COMPOUND_MODES
assert(is_inter_mode(mode) || is_inter_compound_mode(mode));
#else
break;
}
case ZEROMV: {
+#if CONFIG_GLOBAL_MOTION
+ mv[0].as_int = cm->global_motion[ref_frame[0]][0].mv.as_int;
+ if (is_compound)
+ mv[1].as_int = cm->global_motion[ref_frame[1]][0].mv.as_int;
+#else
mv[0].as_int = 0;
if (is_compound)
mv[1].as_int = 0;
+#endif
break;
}
#if CONFIG_COMPOUND_MODES
}
case ZERO_ZEROMV: {
assert(is_compound);
+#if CONFIG_GLOBAL_MOTION
+ mv[0].as_int = cm->global_motion[ref_frame[0]][0].mv.as_int;
+ mv[1].as_int = cm->global_motion[ref_frame[1]][0].mv.as_int;
+#else
mv[0].as_int = 0;
mv[1].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
break;
}
#endif // CONFIG_COMPOUND_MODES
}
}
- if (!assign_mv(cm, b_mode, block,
+ if (!assign_mv(cm, b_mode, mbmi->ref_frame, block,
#if CONFIG_NEWMVREF
(b_mode == NEAR_FORNEWMV) ? ref_mvs[1] : ref_mvs[0],
#else
} else {
#if CONFIG_NEWMVREF
if (mbmi->mode == NEAR_FORNEWMV)
- xd->corrupted |= !assign_mv(cm, mbmi->mode, mbmi->mv, nearmv,
- nearestmv, nearmv, is_compound, allow_hp, r);
+ xd->corrupted |= !assign_mv(cm, mbmi->mode, mbmi->ref_frame, mbmi->mv,
+ nearmv, nearestmv, nearmv, is_compound,
+ allow_hp, r);
else
#endif // CONFIG_NEWMVREF
- xd->corrupted |= !assign_mv(cm, mbmi->mode, mbmi->mv, nearestmv,
- nearestmv, nearmv, is_compound, allow_hp, r);
+ xd->corrupted |= !assign_mv(cm, mbmi->mode, mbmi->ref_frame, mbmi->mv,
+ nearestmv, nearestmv, nearmv, is_compound,
+ allow_hp, r);
}
#if CONFIG_TX_SKIP
mbmi->uv_mode = mbmi->mode;
*p = (vp9_prob)inv_remap_prob(delp, *p);
}
}
+
+int vp9_read_primitive_uniform(vp9_reader *r, unsigned int num_values) {
+ const int l = get_unsigned_bits_gen(num_values);
+ int m, v;
+ if (l == 0)
+ return 0;
+ m = (1 << l) - num_values;
+ v = vp9_read_literal(r, l - 1);
+ if (v < m)
+ return v;
+ else
+ return (v << 1) + vp9_read_bit(r) - m;
+}
+
+int vp9_read_primitive_subexp(vp9_reader *r, unsigned int k) {
+ int mk = (1 << k);
+ int i = 0;
+ int word;
+ while (vp9_read_bit(r)) {
+ mk <<= 1;
+ ++i;
+ }
+ if (i == 0) {
+ word = vp9_read_literal(r, k);
+ } else {
+ word = vp9_read_literal(r, k + i - 1) + (mk >> 1);
+ }
+ return word;
+}
+
+int vp9_read_primitive_symmetric(vp9_reader *r, unsigned int mag_bits) {
+ if (vp9_read_bit(r)) {
+ int s = vp9_read_bit(r);
+ int x = vp9_read_literal(r, mag_bits) + 1;
+ return (s > 0 ? -x : x);
+ } else {
+ return 0;
+ }
+}
void vp9_diff_update_prob(vp9_reader *r, vp9_prob* p);
+// num_values is the number of values the symbol can take
+int vp9_read_primitive_uniform(vp9_reader *r, unsigned int num_values);
+
+// k is the parameter of the subexponential code
+int vp9_read_primitive_subexp(vp9_reader *r, unsigned int k);
+
+// mag_bits is number of bits for magnitude. The alphabet is of size
+// 2 * 2^mag_bits + 1, symmetric around 0, where one bit is used to
+// indicate 0 or non-zero, mag_bits bits are used to indicate magnitide
+// and 1 more bit for the sign if non-zero.
+int vp9_read_primitive_symmetric(vp9_reader *r, unsigned int mag_bits);
+
#ifdef __cplusplus
} // extern "C"
#endif
#if CONFIG_COMPOUND_MODES
static struct vp9_token inter_compound_mode_encodings[INTER_COMPOUND_MODES];
#endif // CONFIG_COMPOUND_MODES
+#if CONFIG_GLOBAL_MOTION
+static struct vp9_token global_motion_types_encodings[GLOBAL_MOTION_TYPES];
+#endif // CONFIG_GLOBAL_MOTION
#if CONFIG_SUPERTX
static int vp9_check_supertx(VP9_COMMON *cm, int mi_row, int mi_col,
vp9_tokens_from_tree(copy_mode_encodings_l2, vp9_copy_mode_tree_l2);
vp9_tokens_from_tree(copy_mode_encodings, vp9_copy_mode_tree);
#endif // CONFIG_COPY_MODE
+#if CONFIG_GLOBAL_MOTION
+ vp9_tokens_from_tree(global_motion_types_encodings,
+ vp9_global_motion_types_tree);
+#endif // CONFIG_GLOBAL_MOTION
}
static void write_intra_mode(vp9_writer *w, PREDICTION_MODE mode,
write_tile_info(cm, wb);
}
+#if CONFIG_GLOBAL_MOTION
+static void write_global_motion_params(Global_Motion_Params *params,
+ vp9_prob *probs,
+ vp9_writer *w) {
+ GLOBAL_MOTION_TYPE gmtype;
+ if (params->zoom == 0 && params->rotation == 0) {
+ if (params->mv.as_int == 0)
+ gmtype = GLOBAL_ZERO;
+ else
+ gmtype = GLOBAL_TRANSLATION;
+ } else {
+ gmtype = GLOBAL_ROTZOOM;
+ }
+ vp9_write_token(w, vp9_global_motion_types_tree, probs,
+ &global_motion_types_encodings[gmtype]);
+ switch (gmtype) {
+ case GLOBAL_ZERO:
+ break;
+ case GLOBAL_TRANSLATION:
+ vp9_write_primitive_symmetric(w, params->mv.as_mv.col,
+ ABS_TRANSLATION_BITS);
+ vp9_write_primitive_symmetric(w, params->mv.as_mv.row,
+ ABS_TRANSLATION_BITS);
+ break;
+ case GLOBAL_ROTZOOM:
+ vp9_write_primitive_symmetric(w, params->mv.as_mv.col,
+ ABS_TRANSLATION_BITS);
+ vp9_write_primitive_symmetric(w, params->mv.as_mv.row,
+ ABS_TRANSLATION_BITS);
+ vp9_write_primitive_symmetric(w, params->zoom, ABS_ZOOM_BITS);
+ vp9_write_primitive_symmetric(w, params->rotation, ABS_ROTATION_BITS);
+ break;
+ default:
+ assert(0);
+ }
+}
+
+static void write_global_motion(VP9_COMP *cpi, vp9_writer *w) {
+ VP9_COMMON *const cm = &cpi->common;
+ int frame, i;
+ for (frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) {
+ for (i = 0; i < cm->num_global_motion[frame]; ++i) {
+ if (!cpi->global_motion_used[frame]) {
+ vpx_memset(
+ cm->global_motion[frame], 0,
+ MAX_GLOBAL_MOTION_MODELS * sizeof(*cm->global_motion[frame]));
+ }
+ write_global_motion_params(
+ cm->global_motion[frame], cm->fc.global_motion_types_prob, w);
+ printf("Ref %d [%d] (used %d): %d %d %d %d\n",
+ frame, cm->current_video_frame, cpi->global_motion_used[frame],
+ cm->global_motion[frame][i].zoom,
+ cm->global_motion[frame][i].rotation,
+ cm->global_motion[frame][i].mv.as_mv.col,
+ cm->global_motion[frame][i].mv.as_mv.row);
+ }
+ }
+}
+#endif
+
static size_t write_compressed_header(VP9_COMP *cpi, uint8_t *data) {
VP9_COMMON *const cm = &cpi->common;
#if !CONFIG_TX_SKIP || CONFIG_SUPERTX
cm->counts.wedge_interinter[i]);
}
#endif // CONFIG_WEDGE_PARTITION
+#if CONFIG_GLOBAL_MOTION
+ write_global_motion(cpi, &header_bc);
+#endif // CONFIG_GLOBAL_MOTION
}
#if CONFIG_PALETTE
#include <stdio.h>
#include <memory.h>
#include <math.h>
+#include <assert.h>
#include "vp9_corner_detect.h"
frm_corners_nonmax_xy = fast_nonmax(frmbuf, width, height, stride,
(xy *)frm_corners, num_frm_corners,
NONMAX_BARRIER, &num_frm_corners_nonmax);
- memcpy(frm_corners, frm_corners_nonmax_xy,
- sizeof(int) * 2 * num_frm_corners_nonmax);
- free(frm_corners_nonmax_xy);
- return num_frm_corners_nonmax;
+ if (frm_corners_nonmax_xy &&
+ num_frm_corners_nonmax <= num_frm_corners) {
+ memcpy(frm_corners, frm_corners_nonmax_xy,
+ sizeof(xy) * num_frm_corners_nonmax);
+ free(frm_corners_nonmax_xy);
+ return num_frm_corners_nonmax;
+ } else {
+ return num_frm_corners;
+ }
}
//////////////////////////////////////////////////////////////////////////////
FAST_BARRIER, &num_points);
num_points =
(num_points <= max_points ? num_points : max_points);
- memcpy(points, frm_corners_xy, sizeof(int) * num_points * 2);
- free(frm_corners_xy);
- return NonmaxSuppression(buf, width, height, stride, points, num_points);
+ if (num_points > 0 && frm_corners_xy) {
+ memcpy(points, frm_corners_xy, sizeof(xy) * num_points);
+ free(frm_corners_xy);
+ return NonmaxSuppression(buf, width, height, stride, points, num_points);
+ } else {
+ return 0;
+ }
}
//////////////////////////////////////////////////////////////////////////////////
#include "vp9_corner_match.h"
-#define MATCH_SZ 21
+#define MATCH_SZ 15
#define MATCH_SZ_BY2 ((MATCH_SZ - 1)/2)
#define MATCH_SZ_SQ (MATCH_SZ * MATCH_SZ)
#define SEARCH_SZ 9
#if CONFIG_SUPERTX
#include "vp9/encoder/vp9_cost.h"
#endif
+#if CONFIG_GLOBAL_MOTION
+#include "vp9/encoder/vp9_global_motion.h"
+#endif // CONFIG_GLOBAL_MOTION
#include "vp9/encoder/vp9_encodeframe.h"
#include "vp9/encoder/vp9_encodemb.h"
#include "vp9/encoder/vp9_encodemv.h"
};
#endif // CONFIG_VP9_HIGHBITDEPTH
-static unsigned int get_sby_perpixel_variance(VP9_COMP *cpi,
- const struct buf_2d *ref,
- BLOCK_SIZE bs) {
+unsigned int get_sby_perpixel_ssd(VP9_COMP *cpi,
+ const struct buf_2d *ref,
+ BLOCK_SIZE bs) {
unsigned int sse;
const unsigned int var = cpi->fn_ptr[bs].vf(ref->buf, ref->stride,
VP9_VAR_OFFS, 0, &sse);
+ return var;
+}
+
+unsigned int get_sby_perpixel_variance(VP9_COMP *cpi,
+ const struct buf_2d *ref,
+ BLOCK_SIZE bs) {
+ const unsigned int var = get_sby_perpixel_ssd(cpi, ref, bs);
return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]);
}
#if CONFIG_VP9_HIGHBITDEPTH
-static unsigned int high_get_sby_perpixel_variance(
+unsigned int high_get_sby_perpixel_ssd(
VP9_COMP *cpi, const struct buf_2d *ref, BLOCK_SIZE bs, int bd) {
unsigned int var, sse;
switch (bd) {
0, &sse);
break;
}
+ return var;
+}
+
+unsigned int high_get_sby_perpixel_variance(
+ VP9_COMP *cpi, const struct buf_2d *ref, BLOCK_SIZE bs, int bd) {
+ const unsigned int var = high_get_sby_perpixel_ssd(cpi, ref, bs, bd);
return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]);
}
#endif // CONFIG_VP9_HIGHBITDEPTH
}
#endif
if (!frame_is_intra_only(cm)) {
+#if CONFIG_COPY_MODE
+ if (is_inter_block(mbmi) && mbmi->copy_mode == NOREF) {
+#else
+ if (is_inter_block(mbmi)) {
+#endif // CONFIG_COPY_MODE
+#if CONFIG_GLOBAL_MOTION
+ if (bsize >= BLOCK_8X8) {
+#if CONFIG_COMPOUND_MODES
+ if (mbmi->mode == ZEROMV || mbmi->mode == ZERO_ZEROMV) {
+ ++cpi->global_motion_used[mbmi->ref_frame[0]];
+ if (mbmi->mode == ZERO_ZEROMV)
+ ++cpi->global_motion_used[mbmi->ref_frame[1]];
+ }
+#else
+ if (mbmi->mode == ZEROMV) {
+ ++cpi->global_motion_used[mbmi->ref_frame[0]];
+ if (has_second_ref(mbmi))
+ ++cpi->global_motion_used[mbmi->ref_frame[1]];
+ }
+#endif // CONFIG_COMPOUND_MODES
+ } else {
+ const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];
+ const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];
+ int idx, idy;
+ for (idy = 0; idy < 2; idy += num_4x4_h) {
+ for (idx = 0; idx < 2; idx += num_4x4_w) {
+ const int j = idy * 2 + idx;
+ const PREDICTION_MODE b_mode = mi->bmi[j].as_mode;
+#if CONFIG_COMPOUND_MODES
+ if (b_mode == ZEROMV || b_mode == ZERO_ZEROMV) {
+ ++cpi->global_motion_used[mbmi->ref_frame[0]];
+ if (b_mode == ZERO_ZEROMV)
+ ++cpi->global_motion_used[mbmi->ref_frame[1]];
+ }
+#else
+ if (b_mode == ZEROMV) {
+ ++cpi->global_motion_used[mbmi->ref_frame[0]];
+ if (has_second_ref(mbmi))
+ ++cpi->global_motion_used[mbmi->ref_frame[1]];
+ }
+#endif // CONFIG_COMPOUND_MODES
+ }
+ }
+ }
+#endif // CONFIG_GLOBAL_MOTION
+ }
+
rd_opt->comp_pred_diff[SINGLE_REFERENCE] += ctx->single_pred_diff;
rd_opt->comp_pred_diff[COMPOUND_REFERENCE] += ctx->comp_pred_diff;
rd_opt->comp_pred_diff[REFERENCE_MODE_SELECT] += ctx->hybrid_pred_diff;
x->e_mbd.plane[i].subsampling_y);
}
-static void set_mode_info_seg_skip(MACROBLOCK *x, TX_MODE tx_mode,
+static void set_mode_info_seg_skip(VP9_COMMON *cm, MACROBLOCK *x,
RD_COST *rd_cost, BLOCK_SIZE bsize) {
+ TX_MODE tx_mode = cm->tx_mode;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
INTERP_FILTER filter_ref;
mbmi->uv_mode = DC_PRED;
mbmi->ref_frame[0] = LAST_FRAME;
mbmi->ref_frame[1] = NONE;
- mbmi->mv[0].as_int = 0;
mbmi->interp_filter = filter_ref;
+#if CONFIG_GLOBAL_MOTION
+ mbmi->mv[0].as_int = cm->global_motion[mbmi->ref_frame[0]][0].mv.as_int;
+ xd->mi[0].src_mi->bmi[0].as_mv[0].as_int =
+ cm->global_motion[mbmi->ref_frame[0]][0].mv.as_int;
+#else
+ mbmi->mv[0].as_int = 0;
xd->mi[0].src_mi->bmi[0].as_mv[0].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
x->skip = 1;
vp9_rd_cost_init(rd_cost);
x->rdmult = vp9_cyclic_refresh_get_rdmult(cpi->cyclic_refresh);
if (vp9_segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP))
- set_mode_info_seg_skip(x, cm->tx_mode, rd_cost, bsize);
+ set_mode_info_seg_skip(cm, x, rd_cost, bsize);
else
vp9_pick_inter_mode(cpi, x, tile, mi_row, mi_col, rd_cost, bsize, ctx);
}
#endif
+#if CONFIG_GLOBAL_MOTION
+#define MIN_TRANSLATION_THRESH 4
+static void convert_translation_to_params(
+ double *H, Global_Motion_Params *model) {
+ model->mv.as_mv.col = (int) floor(H[0] * 8 + 0.5);
+ model->mv.as_mv.row = (int) floor(H[1] * 8 + 0.5);
+ if (abs(model->mv.as_mv.col) < MIN_TRANSLATION_THRESH &&
+ abs(model->mv.as_mv.row) < MIN_TRANSLATION_THRESH) {
+ model->mv.as_int = 0;
+ }
+ model->mv.as_mv.col =
+ clamp(model->mv.as_mv.col,
+ -(1 << ABS_TRANSLATION_BITS), (1 << ABS_TRANSLATION_BITS));
+ model->mv.as_mv.row =
+ clamp(model->mv.as_mv.row,
+ -(1 << ABS_TRANSLATION_BITS), (1 << ABS_TRANSLATION_BITS));
+}
+
+static void convert_rotzoom_to_params(double *H, Global_Motion_Params *model) {
+ double z = sqrt(H[0] * H[0] + H[1] * H[1]) - 1.0;
+ double r = atan2(-H[1], H[0]) * 180.0 / M_PI;
+ assert(abs(H[0] - (1 + z) * cos(r * M_PI / 180.0)) < 1e-10);
+ assert(abs(H[1] + (1 + z) * sin(r * M_PI / 180.0)) < 1e-10);
+ model->zoom = (int) floor(z * (1 << ZOOM_PRECISION_BITS) + 0.5);
+ model->rotation = (int) floor(r * (1 << ROTATION_PRECISION_BITS) + 0.5);
+ model->zoom = clamp(
+ model->zoom, -(1 << ABS_ZOOM_BITS), (1 << ABS_ZOOM_BITS));
+ model->rotation = clamp(
+ model->rotation, -(1 << ABS_ROTATION_BITS), (1 << ABS_ROTATION_BITS));
+
+ convert_translation_to_params(H + 2, model);
+}
+
+static void convert_model_to_params(double *H, TransformationType type,
+ Global_Motion_Params *model) {
+ switch (type) {
+ case ROTZOOM:
+ convert_rotzoom_to_params(H, model);
+ break;
+ case TRANSLATION:
+ convert_translation_to_params(H, model);
+ break;
+ default:
+ break;
+ }
+}
+#endif // CONFIG_GLOBAL_MOTION
+
static void encode_frame_internal(VP9_COMP *cpi) {
SPEED_FEATURES *const sf = &cpi->sf;
RD_OPT *const rd_opt = &cpi->rd;
cm->tx_mode = select_tx_mode(cpi);
+#if CONFIG_GLOBAL_MOTION
+#define GLOBAL_MOTION_MODEL TRANSLATION
+ vp9_zero(cpi->global_motion_used);
+ vpx_memset(cm->num_global_motion, 0, sizeof(cm->num_global_motion));
+ cm->num_global_motion[LAST_FRAME] = 1;
+ cm->num_global_motion[GOLDEN_FRAME] = 1;
+ cm->num_global_motion[ALTREF_FRAME] = 1;
+ if (cpi->common.frame_type == INTER_FRAME && cpi->Source) {
+ YV12_BUFFER_CONFIG *ref_buf;
+ int num, frame;
+ double global_motion[9 * MAX_GLOBAL_MOTION_MODELS];
+ for (frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) {
+ ref_buf = get_ref_frame_buffer(cpi, frame);
+ if (ref_buf) {
+ if ((num =
+ vp9_compute_global_motion_multiple_block_based(
+ cpi, GLOBAL_MOTION_MODEL, cpi->Source, ref_buf,
+ BLOCK_16X16, MAX_GLOBAL_MOTION_MODELS, 0.5, global_motion))) {
+ /*
+ vp9_compute_global_motion_multiple_feature_based(
+ cpi, GLOBAL_MOTION_MODEL, cpi->Source, ref_buf,
+ MAX_GLOBAL_MOTION_MODELS, 0.5, global_motion))) {
+ */
+ int i;
+ for (i = 0; i < num; i++) {
+ convert_model_to_params(
+ global_motion + i * get_numparams(GLOBAL_MOTION_MODEL),
+ GLOBAL_MOTION_MODEL,
+ &cm->global_motion[frame][i]);
+ /*
+ printf("Ref %d [%d]: %d %d %d %d\n",
+ frame, cm->current_video_frame,
+ cm->global_motion[frame][i].zoom,
+ cm->global_motion[frame][i].rotation,
+ cm->global_motion[frame][i].mv.as_mv.col,
+ cm->global_motion[frame][i].mv.as_mv.row);
+ */
+ }
+ cm->num_global_motion[frame] = num;
+ }
+ }
+ }
+ }
+#endif // CONFIG_GLOBAL_MOTION
+
#if CONFIG_VP9_HIGHBITDEPTH
if (cm->use_highbitdepth)
x->fwd_txm4x4 = xd->lossless ? vp9_highbd_fwht4x4 : vp9_highbd_fdct4x4;
else
x->fwd_txm4x4 = xd->lossless ? vp9_fwht4x4 : vp9_fdct4x4;
x->highbd_itxm_add = xd->lossless ? vp9_highbd_iwht4x4_add :
- vp9_highbd_idct4x4_add;
+ vp9_highbd_idct4x4_add;
#else
x->fwd_txm4x4 = xd->lossless ? vp9_fwht4x4 : vp9_fdct4x4;
#endif // CONFIG_VP9_HIGHBITDEPTH
#if CONFIG_VP9_TEMPORAL_DENOISING
VP9_DENOISER denoiser;
#endif
+#if CONFIG_GLOBAL_MOTION
+ int global_motion_used[MAX_REF_FRAMES];
+#endif
} VP9_COMP;
void vp9_initialize_enc();
#define MAX_CORNERS 4096
-inline int get_numparams(TransformationType type) {
- switch (type) {
- case HOMOGRAPHY:
- return 9;
- case AFFINE:
- return 6;
- case ROTZOOM:
- return 4;
- case TRANSLATION:
- return 2;
- default:
- assert(0);
- return 0;
- }
-}
-
-inline ransacType get_ransacType(TransformationType type) {
+INLINE ransacType get_ransacType(TransformationType type) {
switch (type) {
case HOMOGRAPHY:
return ransacHomography;
}
}
-inline projectPointsType get_projectPointsType(TransformationType type) {
+INLINE projectPointsType get_projectPointsType(TransformationType type) {
switch (type) {
case HOMOGRAPHY:
return projectPointsHomography;
TransformationType type,
YV12_BUFFER_CONFIG *frm,
YV12_BUFFER_CONFIG *ref,
- int blocksize,
+ BLOCK_SIZE bsize,
double *H) {
VP9_COMMON *const cm = &cpi->common;
int num_correspondences = 0;
int *correspondences;
int num_inliers;
int *inlier_map = NULL;
-
+ int bwidth = num_4x4_blocks_wide_lookup[bsize] << 2;
+ int bheight = num_4x4_blocks_high_lookup[bsize] << 2;
int i;
MV motionfield[4096];
double confidence[4096];
- get_frame_motionfield(cpi, frm, ref, blocksize, motionfield, confidence);
+ vp9_get_frame_motionfield(cpi, frm, ref, bsize, motionfield, confidence);
correspondences = (int *)malloc(4 * cm->mb_rows * cm->mb_cols *
sizeof(*correspondences));
for (i = 0; i < cm->mb_rows * cm->mb_cols; i ++) {
- int x = (i % cm->mb_cols) * blocksize + blocksize/2;
- int y = (i / cm->mb_cols) * blocksize + blocksize/2;
+ int x = (i % cm->mb_cols) * bwidth + bwidth / 2;
+ int y = (i / cm->mb_cols) * bheight + bheight / 2;
if (confidence[i] > CONFIDENCE_THRESHOLD) {
- correspondences[num_correspondences*4] = x;
- correspondences[num_correspondences*4+1] = y;
- correspondences[num_correspondences*4+2] = motionfield[i].col + x;
- correspondences[num_correspondences*4+3] = motionfield[i].row + y;
+ correspondences[num_correspondences * 4] = x;
+ correspondences[num_correspondences * 4 + 1] = y;
+ correspondences[num_correspondences * 4 + 2] =
+ (double)motionfield[i].col / 8 + x;
+ correspondences[num_correspondences * 4 + 3] =
+ (double)motionfield[i].row / 8 + y;
num_correspondences++;
}
}
TransformationType type,
YV12_BUFFER_CONFIG *frm,
YV12_BUFFER_CONFIG *ref,
- int blocksize,
+ BLOCK_SIZE bsize,
int max_models,
double inlier_prob,
double *H) {
int num_inliers;
int num_models = 0;
int *inlier_map = NULL;
+ int bwidth = num_4x4_blocks_wide_lookup[bsize] << 2;
+ int bheight = num_4x4_blocks_high_lookup[bsize] << 2;
int i;
MV motionfield[4096];
double confidence[4096];
- get_frame_motionfield(cpi, frm, ref, blocksize, motionfield, confidence);
+ vp9_get_frame_motionfield(cpi, frm, ref, bsize, motionfield, confidence);
correspondences = (int *)malloc(4 * cm->mb_rows * cm->mb_cols *
sizeof(*correspondences));
for (i = 0; i < cm->mb_rows * cm->mb_cols; i ++) {
- int x = (i % cm->mb_cols) * blocksize + blocksize/2;
- int y = (i / cm->mb_cols) * blocksize + blocksize/2;
+ int x = (i % cm->mb_cols) * bwidth + bwidth / 2;
+ int y = (i / cm->mb_cols) * bheight + bheight / 2;
if (confidence[i] > CONFIDENCE_THRESHOLD) {
- correspondences[num_correspondences*4] = x;
- correspondences[num_correspondences*4+1] = y;
- correspondences[num_correspondences*4+2] = motionfield[i].col + x;
- correspondences[num_correspondences*4+3] = motionfield[i].row + y;
+ correspondences[num_correspondences * 4] = x;
+ correspondences[num_correspondences * 4 + 1] = y;
+ correspondences[num_correspondences * 4 + 2] =
+ (double)motionfield[i].col / 8 + x;
+ correspondences[num_correspondences * 4 + 3] =
+ (double)motionfield[i].row / 8 + y;
num_correspondences++;
}
}
struct VP9_COMP;
-static const int CONFIDENCE_THRESHOLD = 10;
+static const int CONFIDENCE_THRESHOLD = 1.0;
typedef enum {
UNKNOWN_TRANSFORM = -1,
TRANSLATION // translational motion 2-parameter
} TransformationType;
-inline int get_numparams(TransformationType type);
+static INLINE int get_numparams(TransformationType type) {
+ switch (type) {
+ case HOMOGRAPHY:
+ return 9;
+ case AFFINE:
+ return 6;
+ case ROTZOOM:
+ return 4;
+ case TRANSLATION:
+ return 2;
+ default:
+ assert(0);
+ return 0;
+ }
+}
-inline ransacType get_ransacType(TransformationType type);
+INLINE ransacType get_ransacType(TransformationType type);
-inline projectPointsType get_projectPointsType(TransformationType type);
+INLINE projectPointsType get_projectPointsType(TransformationType type);
// Returns number of models actually returned: 1 - if success, 0 - if failure
int vp9_compute_global_motion_single_feature_based(struct VP9_COMP *cpi,
TransformationType type,
YV12_BUFFER_CONFIG *frm,
YV12_BUFFER_CONFIG *ref,
- int blocksize,
+ BLOCK_SIZE bsize,
double *H);
// Returns number of models actually returned: 1+ - #models, 0 - if failure
TransformationType type,
YV12_BUFFER_CONFIG *frm,
YV12_BUFFER_CONFIG *ref,
- int blocksize,
+ BLOCK_SIZE bsize,
int max_models,
double inlier_prob,
double *H);
if (x->nmvsadcost) {
const MV diff = { mv->row - ref->row,
mv->col - ref->col };
- return ROUND_POWER_OF_TWO(mv_cost(&diff, x->nmvjointsadcost,
- x->nmvsadcost) * error_per_bit, 8);
+ const int cost = mv_cost(&diff, x->nmvjointsadcost, x->nmvsadcost);
+ return ROUND_POWER_OF_TWO(cost * error_per_bit, 8);
}
return 0;
}
int sadpb,
const vp9_variance_fn_ptr_t *fn_ptr,
const MV *best_mv,
+ int use_mvcost,
int *cost_list) {
static const MV neighbors[4] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
const struct buf_2d *const what = &x->plane[0].src;
cost_list[0] = fn_ptr->vf(what->buf, what->stride,
get_buf_from_mv(in_what, &this_mv),
in_what->stride, &sse) +
- mvsad_err_cost(x, &this_mv, &fcenter_mv, sadpb);
+ (use_mvcost ? mvsad_err_cost(x, &this_mv, &fcenter_mv, sadpb) : 0);
if (check_bounds(x, br, bc, 1)) {
for (i = 0; i < 4; i++) {
const MV this_mv = {br + neighbors[i].row,
cost_list[i + 1] = fn_ptr->vf(what->buf, what->stride,
get_buf_from_mv(in_what, &this_mv),
in_what->stride, &sse) +
- // mvsad_err_cost(x, &this_mv, &fcenter_mv, sadpb);
- mv_err_cost(&this_mv, &fcenter_mv, x->nmvjointcost, x->mvcost,
- x->errorperbit);
+ (use_mvcost ? mv_err_cost(&this_mv, &fcenter_mv,
+ x->nmvjointcost, x->mvcost,
+ x->errorperbit) : 0);
}
} else {
for (i = 0; i < 4; i++) {
cost_list[i + 1] = fn_ptr->vf(what->buf, what->stride,
get_buf_from_mv(in_what, &this_mv),
in_what->stride, &sse) +
- // mvsad_err_cost(x, &this_mv, &fcenter_mv, sadpb);
- mv_err_cost(&this_mv, &fcenter_mv, x->nmvjointcost, x->mvcost,
- x->errorperbit);
+ (use_mvcost ? mv_err_cost(&this_mv, &fcenter_mv,
+ x->nmvjointcost, x->mvcost,
+ x->errorperbit) : 0);
}
}
}
// Work out the start point for the search
bestsad = vfp->sdf(what->buf, what->stride,
- get_buf_from_mv(in_what, ref_mv), in_what->stride) +
- mvsad_err_cost(x, ref_mv, &fcenter_mv, sad_per_bit);
+ get_buf_from_mv(in_what, ref_mv), in_what->stride);
+ if (use_mvcost)
+ bestsad += mvsad_err_cost(x, ref_mv, &fcenter_mv, sad_per_bit);
// Search all possible scales upto the search param around the center point
// pick the scale of the point that is best as the starting scale of
// cost_list[4]: cost at delta {-1, 0} (top) from the best integer pel
if (cost_list) {
const MV best_mv = { br, bc };
- calc_int_cost_list(x, &fcenter_mv, sad_per_bit, vfp, &best_mv, cost_list);
+ calc_int_cost_list(x, &fcenter_mv, sad_per_bit, vfp, &best_mv,
+ use_mvcost, cost_list);
}
best_mv->row = br;
best_mv->col = bc;
// Work out the start point for the search
bestsad = vfp->sdf(what->buf, what->stride,
- get_buf_from_mv(in_what, ref_mv), in_what->stride) +
- mvsad_err_cost(x, ref_mv, &fcenter_mv, sad_per_bit);
+ get_buf_from_mv(in_what, ref_mv), in_what->stride);
+ if (use_mvcost)
+ bestsad += mvsad_err_cost(x, ref_mv, &fcenter_mv, sad_per_bit);
// Search all possible scales upto the search param around the center point
// pick the scale of the point that is best as the starting scale of
const MV this_mv = { br + neighbors[i].row,
bc + neighbors[i].col };
cost_list[i + 1] = vfp->sdf(what->buf, what->stride,
- get_buf_from_mv(in_what, &this_mv),
- in_what->stride);
+ get_buf_from_mv(in_what, &this_mv),
+ in_what->stride) +
+ (use_mvcost ?
+ mvsad_err_cost(x, &this_mv, &fcenter_mv, sad_per_bit) : 0);
}
} else {
for (i = 0; i < 4; i++) {
else
cost_list[i + 1] = vfp->sdf(what->buf, what->stride,
get_buf_from_mv(in_what, &this_mv),
- in_what->stride);
+ in_what->stride) +
+ (use_mvcost ?
+ mvsad_err_cost(x, &this_mv, &fcenter_mv, sad_per_bit) : 0);
}
}
} else {
// Return cost list.
if (cost_list) {
- calc_int_cost_list(x, ref_mv, sadpb, fn_ptr, dst_mv, cost_list);
+ calc_int_cost_list(x, ref_mv, sadpb, fn_ptr, dst_mv, 1, cost_list);
}
return bestsme;
}
#include "vp9/common/vp9_systemdependent.h"
#include "vp9/encoder/vp9_global_motion.h"
+unsigned int get_sby_perpixel_variance(VP9_COMP *cpi,
+ const struct buf_2d *ref,
+ BLOCK_SIZE bs);
+unsigned int get_sby_perpixel_ssd(VP9_COMP *cpi,
+ const struct buf_2d *ref,
+ BLOCK_SIZE bs);
+#if CONFIG_VP9_HIGHBITDEPTH
+unsigned int high_get_sby_perpixel_ssd(
+ VP9_COMP *cpi, const struct buf_2d *ref, BLOCK_SIZE bs, int bd);
+unsigned int high_get_sby_perpixel_variance(
+ VP9_COMP *cpi, const struct buf_2d *ref, BLOCK_SIZE bs, int bd);
+#endif
-static unsigned int do_motion_iteration(VP9_COMP *cpi,
- const MV *ref_mv,
- MV *dst_mv,
- int bsize,
- int mb_row,
- int mb_col,
- unsigned int *sse) {
- MACROBLOCK *const x = &cpi->mb;
- MACROBLOCKD *const xd = &x->e_mbd;
-
- PREDICTION_MODE tmp_mode = xd->mi[0].src_mi->mbmi.mode;
- MV tmp_mv = xd->mi[0].src_mi->mbmi.mv[0].as_mv;
- int tmp_frame = xd->mi[0].src_mi->mbmi.ref_frame[1];
- struct macroblockd_plane *const tmp_pd = &xd->plane[0];
- struct macroblockd_plane otherpd;
-
- const MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv;
-
- const int tmp_col_min = x->mv_col_min;
- const int tmp_col_max = x->mv_col_max;
- const int tmp_row_min = x->mv_row_min;
- const int tmp_row_max = x->mv_row_max;
+static int do_motion_iteration(MACROBLOCK *const x,
+ const vp9_variance_fn_ptr_t *v_fn_ptr,
+ const MV *ref_mv,
+ MV *dst_mv) {
MV ref_full;
- int cost_list[5];
- int sad = INT32_MAX;
- uint8_t tmpbuf[4096];
- BLOCK_SIZE block = bsize == 16 ? BLOCK_16X16 : BLOCK_8X8;
- const vp9_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[block];
+ unsigned int sse;
+ int besterr, distortion;
// Further step/diamond searches as necessary
- int step_param = mv_sf->reduce_first_step_size;
- step_param = MIN(step_param, MAX_MVSEARCH_STEPS - 2);
-
- otherpd.dst.buf = tmpbuf;
- xd->plane[0] = otherpd;
+ // int step_param = mv_sf->reduce_first_step_size;
+ // step_param = MIN(step_param, MAX_MVSEARCH_STEPS - 2);
+ int step_param = 0;
+ int subpel_iters_per_step = 2;
+ int allow_high_precision_mv = 1;
vp9_set_mv_search_range(x, ref_mv);
ref_full.row = ref_mv->row >> 3;
/*cpi->sf.search_method == HEX*/
- vp9_hex_search(x, &ref_full, step_param, x->errorperbit, 0,
- cond_cost_list(cpi, cost_list),
- &v_fn_ptr, 0, ref_mv, dst_mv);
-
+ vp9_hex_search(x, &ref_full, step_param, x->errorperbit, 0, NULL,
+ v_fn_ptr, 0, ref_mv, dst_mv);
- // Try sub-pixel MC
- // if (bestsme > error_thresh && bestsme < INT_MAX)
- {
- int distortion;
- unsigned int sse;
- cpi->find_fractional_mv_step(
- x, dst_mv, ref_mv, cpi->common.allow_high_precision_mv, x->errorperbit,
- &v_fn_ptr, 0, mv_sf->subpel_iters_per_step,
- cond_cost_list(cpi, cost_list),
- NULL, NULL,
- &distortion, &sse, NULL, 0, 0);
- }
+ besterr = vp9_find_best_sub_pixel_tree(
+ x, dst_mv, ref_mv, allow_high_precision_mv, x->errorperbit,
+ v_fn_ptr, 0, subpel_iters_per_step,
+ NULL, NULL, NULL, &distortion, &sse, NULL, 0, 0);
-#if CONFIG_COMPOUND_MODES
- if (has_second_ref(&xd->mi[0].src_mi->mbmi)) {
- xd->mi[0].src_mi->mbmi.mode = NEW_NEWMV;
- } else {
-#endif
- xd->mi[0].src_mi->mbmi.mode = NEWMV;
-#if CONFIG_COMPOUND_MODES
- }
-#endif
- xd->mi[0].src_mi->mbmi.mv[0].as_mv = *dst_mv;
-#if CONFIG_INTERINTRA
- xd->mi[0].src_mi->mbmi.ref_frame[1] = NONE;
-#endif
-
- vp9_build_inter_predictors_sby(xd, mb_row, mb_col, block);
-
- /* restore UMV window */
- x->mv_col_min = tmp_col_min;
- x->mv_col_max = tmp_col_max;
- x->mv_row_min = tmp_row_min;
- x->mv_row_max = tmp_row_max;
-
- if (bsize == 16) {
- sad = vp9_sad16x16(x->plane[0].src.buf, x->plane[0].src.stride,
- xd->plane[0].dst.buf, xd->plane[0].dst.stride);
- vp9_variance16x16(x->plane[0].src.buf, x->plane[0].src.stride,
- xd->plane[0].dst.buf, xd->plane[0].dst.stride, sse);
- } else if (bsize == 8) {
- sad = vp9_sad8x8(x->plane[0].src.buf, x->plane[0].src.stride,
- xd->plane[0].dst.buf, xd->plane[0].dst.stride);
- vp9_variance8x8(x->plane[0].src.buf, x->plane[0].src.stride,
- xd->plane[0].dst.buf, xd->plane[0].dst.stride, sse);
- }
- xd->mi[0].src_mi->mbmi.mode = tmp_mode;
- xd->mi[0].src_mi->mbmi.mv[0].as_mv = tmp_mv;
- xd->mi[0].src_mi->mbmi.ref_frame[1] = tmp_frame;
-
- xd->plane[0] = *tmp_pd;
-
- return sad;
+ return besterr;
}
-static int do_motion_search(VP9_COMP *cpi, const MV *ref_mv, int bsize,
- int_mv *dst_mv, int mb_row, int mb_col,
- unsigned int *sse) {
- MACROBLOCK *const x = &cpi->mb;
- MACROBLOCKD *const xd = &x->e_mbd;
- unsigned int err, tmp_err;
- MV tmp_mv;
-
- // Try zero MV first
- // FIXME should really use something like near/nearest MV and/or MV prediction
- if (bsize == 16) {
- err = vp9_sad16x16(x->plane[0].src.buf, x->plane[0].src.stride,
- xd->plane[0].pre[0].buf, xd->plane[0].pre[0].stride);
- } else {
- err = vp9_sad8x8(x->plane[0].src.buf, x->plane[0].src.stride,
- xd->plane[0].pre[0].buf, xd->plane[0].pre[0].stride);
- }
- dst_mv->as_int = 0;
-
- // Test last reference frame using the previous best mv as the
- // starting point (best reference) for the search
- tmp_err = do_motion_iteration(cpi, ref_mv, &tmp_mv,
- bsize, mb_row, mb_col, sse);
- if (tmp_err < err) {
- err = tmp_err;
- dst_mv->as_mv = tmp_mv;
- }
+static int do_motion_search(MACROBLOCK *const x,
+ const vp9_variance_fn_ptr_t *v_fn_ptr,
+ const MV *ref_mv,
+ int_mv *dst_mv) {
+ int err = do_motion_iteration(x, v_fn_ptr,
+ ref_mv, &dst_mv->as_mv);
// If the current best reference mv is not centered on 0,0 then do a 0,0
// based search as well.
if (ref_mv->row != 0 || ref_mv->col != 0) {
- unsigned int tmp_err;
+ int tmp_err;
MV zero_ref_mv = {0, 0}, tmp_mv;
- tmp_err = do_motion_iteration(cpi, &zero_ref_mv, &tmp_mv, bsize,
- mb_row, mb_col, sse);
+ tmp_err = do_motion_iteration(x, v_fn_ptr,
+ &zero_ref_mv, &tmp_mv);
if (tmp_err < err) {
dst_mv->as_mv = tmp_mv;
err = tmp_err;
}
}
-
return err;
}
-static void get_mb_motionfield(VP9_COMP *cpi,
+void vp9_get_frame_motionfield(struct VP9_COMP *cpi,
YV12_BUFFER_CONFIG *buf,
- int mb_y_offset,
YV12_BUFFER_CONFIG *ref,
- const MV *prev_ref_mv,
- int bsize,
- int mb_row,
- int mb_col,
- MV *mv,
+ BLOCK_SIZE bsize,
+ MV *motionfield,
double *confidence) {
- MACROBLOCK *const x = &cpi->mb;
- MACROBLOCKD *const xd = &x->e_mbd;
- VP9_COMMON *cm = &cpi->common;
- uint8_t *tmp_buf = x->plane[0].src.buf;
- int tmp_stride = x->plane[0].src.stride;
- uint8_t *tmp_dst_buf = xd->plane[0].dst.buf;
- int tmp_dst_stride = xd->plane[0].dst.stride;
-
- // FIXME in practice we're completely ignoring chroma here
- x->plane[0].src.buf = buf->y_buffer + mb_y_offset;
- x->plane[0].src.stride = buf->y_stride;
-
- xd->plane[0].dst.buf = get_frame_new_buffer(cm)->y_buffer + mb_y_offset;
- xd->plane[0].dst.stride = get_frame_new_buffer(cm)->y_stride;
-
- // Golden frame MV search, if it exists and is different than last frame
- if (ref) {
- int_mv intmv;
- unsigned int sse, sad;
- xd->plane[0].pre[0].buf = ref->y_buffer + mb_y_offset;
- xd->plane[0].pre[0].stride = ref->y_stride;
- sad = do_motion_search(cpi,
- prev_ref_mv,
- bsize,
- &intmv,
- mb_row, mb_col, &sse);
- *confidence = (sse)/(sad+1);
- *mv = intmv.as_mv;
- }
-
- x->plane[0].src.buf = tmp_buf;
- x->plane[0].src.stride = tmp_stride;
-
- xd->plane[0].dst.buf = tmp_dst_buf;
- xd->plane[0].dst.stride = tmp_dst_stride;
-}
-
-void get_frame_motionfield(struct VP9_COMP *cpi,
- YV12_BUFFER_CONFIG *buf,
- YV12_BUFFER_CONFIG *ref,
- int blocksize,
- MV *motionfield,
- double *confidence) {
- MACROBLOCK *const x = &cpi->mb;
+ MACROBLOCK mx;
+ MACROBLOCK *const x = &mx;
MACROBLOCKD *const xd = &x->e_mbd;
VP9_COMMON *const cm = &cpi->common;
- int mb_col, mb_row, offset = 0;
+ int mb_col, mb_row;
int mb_y_offset = 0, ref_y_offset = 0;
- int tmp_mv_row_min = x->mv_row_min, tmp_mv_row_max = x->mv_row_max;
- int tmp_up_available = xd->up_available;
- int tmp_left_available = xd->left_available;
- int tmp_y_dst_stride = xd->plane[0].dst.stride;
- int tmp_y_pre_stride = xd->plane[0].pre[0].stride;
- int tmp_uv_dst_stride = xd->plane[1].dst.stride;
- int bsize = blocksize;
int border = BORDER_MV_PIXELS_B16;
+ int bwidth = num_4x4_blocks_wide_lookup[bsize] << 2;
+ int bheight = num_4x4_blocks_high_lookup[bsize] << 2;
MV ref_top_mv = {0, 0};
- MODE_INFO mi_local;
- MODE_INFO *tmp_mi = xd->mi[0].src_mi;
- vp9_zero(mi_local);
- // Set up limit values for motion vectors to prevent them extending outside
-// // the UMV borders.
+
+ x->errorperbit =
+ vp9_compute_rd_mult(cpi, cm->base_qindex + cm->y_dc_delta_q) /
+ 64;
+ x->errorperbit += (x->errorperbit == 0);
+
+ // the UMV borders.
x->mv_row_min = -border;
- x->mv_row_max = (cm->mb_rows - 1) * (bsize/2) + border;
+ x->mv_row_max = cm->mi_rows * 8 + border;
xd->up_available = 0;
xd->plane[0].dst.stride = buf->y_stride;
- xd->plane[0].pre[0].stride = buf->y_stride;
xd->plane[1].dst.stride = buf->uv_stride;
- xd->mi[0].src_mi = &mi_local;
- mi_local.mbmi.sb_type = bsize == 16 ? BLOCK_16X16 : BLOCK_8X8;
- mi_local.mbmi.ref_frame[0] = LAST_FRAME;
- mi_local.mbmi.ref_frame[1] = NONE;
+ xd->plane[0].pre[0].stride = buf->y_stride;
for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
MV ref_left_mv = ref_top_mv;
int mb_y_in_offset = mb_y_offset;
// Set up limit values for motion vectors to prevent them extending outside
// the UMV borders.
x->mv_col_min = -border;
- x->mv_col_max = (cm->mb_cols - 1) * (bsize/2) + border;
+ x->mv_col_max = cm->mi_cols * 8 + border;
xd->left_available = 0;
for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
- MV mv;
- get_mb_motionfield(cpi, buf, mb_y_in_offset,
- ref, &ref_left_mv,
- blocksize,
- mb_row, mb_col, &mv,
- &confidence[mb_row*cm->mb_cols + mb_col]);
- motionfield[mb_row*cm->mb_cols + mb_col] = mv;
+ int_mv intmv;
+ unsigned int ssd, err;
+
+ x->plane[0].src.buf = buf->y_buffer + mb_y_in_offset;
+ x->plane[0].src.stride = buf->y_stride;
+ xd->plane[0].pre[0].buf = ref->y_buffer + ref_y_in_offset;
+ xd->plane[0].pre[0].stride = ref->y_stride;
+ ssd = get_sby_perpixel_ssd(cpi, &x->plane[0].src, bsize);
+ err =
+ do_motion_search(x,
+ &cpi->fn_ptr[bsize],
+ &ref_left_mv,
+ &intmv);
+ confidence[mb_row * cm->mb_cols + mb_col] = (double)ssd / (err + 1);
+ motionfield[mb_row * cm->mb_cols + mb_col] = intmv.as_mv;
if (mb_col == 0) {
ref_top_mv = ref_left_mv;
}
xd->left_available = 1;
- mb_y_in_offset += bsize;
- ref_y_in_offset += bsize;
- x->mv_col_min -= bsize;
- x->mv_col_max -= bsize;
+ mb_y_in_offset += bwidth;
+ ref_y_in_offset += bwidth;
+ x->mv_col_min -= bwidth;
+ x->mv_col_max -= bwidth;
}
xd->up_available = 1;
- mb_y_offset += buf->y_stride * bsize;
- ref_y_offset += ref->y_stride * bsize;
- x->mv_row_min -= bsize;
- x->mv_row_max -= bsize;
- offset += cm->mb_cols;
+ mb_y_offset += buf->y_stride * bheight;
+ ref_y_offset += ref->y_stride * bheight;
+ x->mv_row_min -= bheight;
+ x->mv_row_max -= bheight;
}
- xd->mi[0].src_mi = tmp_mi;
- x->mv_row_min = tmp_mv_row_min;
- x->mv_row_max = tmp_mv_row_max;
- xd->up_available = tmp_up_available;
- xd->left_available = tmp_left_available;
- xd->plane[0].dst.stride = tmp_y_dst_stride;
- xd->plane[0].pre[0].stride = tmp_y_pre_stride;
- xd->plane[1].dst.stride = tmp_uv_dst_stride;
}
-void vp9_get_motionfield(VP9_COMP *cpi, int ref, int blocksize,
- MV *motionfield, double *confidence) {
+void vp9_get_ref_motionfield(VP9_COMP *cpi, int ref, BLOCK_SIZE bsize,
+ MV *motionfield, double *confidence) {
YV12_BUFFER_CONFIG *ref_buf = get_ref_frame_buffer(cpi, ref);
- struct lookahead_entry *q_cur = vp9_lookahead_peek(cpi->lookahead, 0);
- if (q_cur) {
- get_frame_motionfield(cpi, &q_cur->img, ref_buf,
- blocksize, motionfield, confidence);
+ if (cpi->Source && ref_buf) {
+ vp9_get_frame_motionfield(cpi, cpi->Source, ref_buf,
+ bsize, motionfield, confidence);
}
}
struct VP9_COMP;
-void get_frame_motionfield(struct VP9_COMP *cpi,
- YV12_BUFFER_CONFIG *buf,
- YV12_BUFFER_CONFIG *ref,
- int blocksize,
- MV *motionfield,
- double *confidence);
+void vp9_get_frame_motionfield(struct VP9_COMP *cpi,
+ YV12_BUFFER_CONFIG *buf,
+ YV12_BUFFER_CONFIG *ref,
+ BLOCK_SIZE bsize,
+ MV *motionfield,
+ double *confidence);
-void vp9_get_motionfield(struct VP9_COMP *cpi, int ref,
- int blocksize, MV *motionfield, double *confidence);
+void vp9_get_ref_motionfield(struct VP9_COMP *cpi,
+ int ref,
+ BLOCK_SIZE bsize,
+ MV *motionfield,
+ double *confidence);
#ifdef __cplusplus
} // extern "C"
PREDICTION_MODE this_mode;
x->pred_mv_sad[ref_frame] = INT_MAX;
frame_mv[NEWMV][ref_frame].as_int = INVALID_MV;
+#if CONFIG_GLOBAL_MOTION
+ frame_mv[ZEROMV][ref_frame].as_int =
+ cm->global_motion[ref_frame][0].mv.as_int;
+#else
frame_mv[ZEROMV][ref_frame].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
if (xd->up_available)
filter_ref = xd->mi[-xd->mi_stride].src_mi->mbmi.interp_filter;
#endif
int rate_mv = 0;
int mode_rd_thresh;
-
+#if CONFIG_GLOBAL_MOTION
+ if (const_motion[ref_frame] && this_mode == NEARMV)
+#else // CONFIG_GLOBAL_MOTION
#if CONFIG_COMPOUND_MODES
if (const_motion[ref_frame] &&
(this_mode == NEARMV || this_mode == ZEROMV ||
if (const_motion[ref_frame] &&
(this_mode == NEARMV || this_mode == ZEROMV))
#endif
+#endif // CONFIG_GLOBAL_MOTION
continue;
if (!(cpi->sf.inter_mode_mask[bsize] & (1 << this_mode)))
#define MAX_PARAMDIM 9
#define MAX_MINPTS 4
+#define MAX_DEGENERATE_ITER 10
+#define MINPTS_MULTIPLIER 5
+
// svdcmp
// Adopted from Numerical Recipes in C
double *points2,
double *H);
+static int get_rand_indices(int npoints, int minpts, int *indices) {
+ int i, j;
+ int ptr = rand() % npoints;
+ if (minpts > npoints)
+ return 0;
+ indices[0] = ptr;
+ ptr = (ptr == npoints - 1 ? 0 : ptr + 1);
+ i = 1;
+ while (i < minpts) {
+ int index = rand() % npoints;
+ while (index) {
+ ptr = (ptr == npoints - 1 ? 0 : ptr + 1);
+ for (j = 0; j < i; ++j) {
+ if (indices[j] == ptr)
+ break;
+ }
+ if (j == i)
+ index--;
+ }
+ indices[i++] = ptr;
+ }
+ return 1;
+}
+
int ransac_(double *matched_points,
int npoints,
int *number_of_inliers,
projectPointsType projectPoints) {
static const double INLIER_THRESHOLD_NORMALIZED = 0.1;
- static const double INLIER_THRESHOLD_UNNORMALIZED = 1.5;
+ static const double INLIER_THRESHOLD_UNNORMALIZED = 0.5;
static const double PROBABILITY_REQUIRED = 0.9;
static const double EPS = 1e-12;
static const int MIN_TRIALS = 20;
INLIER_THRESHOLD_NORMALIZED :
INLIER_THRESHOLD_UNNORMALIZED);
int N = 10000, trial_count = 0;
- int i, j;
+ int i;
+ int ret_val = 0;
int max_inliers = 0;
double best_variance = 0.0;
double H[MAX_PARAMDIM];
double points1[2 * MAX_MINPTS];
double points2[2 * MAX_MINPTS];
+ int indices[MAX_MINPTS];
double *best_inlier_set1;
double *best_inlier_set2;
double *cnp1, *cnp2;
double T1[9], T2[9];
- srand((unsigned)time(NULL)) ;
- // srand( 12345 ) ;
- //
+ // srand((unsigned)time(NULL)) ;
+ // better to make this deterministic for a given sequence for ease of testing
+ srand(npoints);
+
*number_of_inliers = 0;
- if (npoints < minpts) {
+ if (npoints < minpts * MINPTS_MULTIPLIER) {
printf("Cannot find motion with %d matches\n", npoints);
return 1;
}
double sum_distance_squared = 0.0;
int degenerate = 1;
+ int num_degenerate_iter = 0;
while (degenerate) {
+ num_degenerate_iter++;
+ if (!get_rand_indices(npoints, minpts, indices)) {
+ ret_val = 1;
+ goto finish_ransac;
+ }
i = 0;
while (i < minpts) {
- int index = rand() % npoints;
- int duplicate = 0;
- for (j = 0; j < i; ++j) {
- if (points1[j*2] == corners1[index*2] &&
- points1[j*2+1] == corners1[index*2+1]) {
- duplicate = 1;
- break;
- }
- }
- if(duplicate) continue;
+ int index = indices[i];
// add to list
points1[i*2] = corners1[index*2];
points1[i*2+1] = corners1[index*2+1];
i++;
}
degenerate = isDegenerate(points1);
+ if (num_degenerate_iter > MAX_DEGENERATE_ITER) {
+ ret_val = 1;
+ goto finish_ransac;
+ }
}
if (findTransformation(minpts, points1, points2, H)) {
npoints, bestH,
best_inlier_mask));
*/
+finish_ransac:
free(best_inlier_set1);
free(best_inlier_set2);
free(inlier_set1);
free(image1_coord);
free(image2_coord);
free(inlier_mask);
- return 0;
+ return ret_val;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
#endif
break;
case ZEROMV:
+#if CONFIG_GLOBAL_MOTION
+ this_mv[0].as_int =
+ cpi->common.global_motion[mbmi->ref_frame[0]][0].mv.as_int;
+#if !CONFIG_COMPOUND_MODES
+ if (is_compound)
+ this_mv[1].as_int =
+ cpi->common.global_motion[mbmi->ref_frame[1]][0].mv.as_int;
+#endif
+#else // CONFIG_GLOBAL_MOTION
this_mv[0].as_int = 0;
#if !CONFIG_COMPOUND_MODES
if (is_compound)
this_mv[1].as_int = 0;
#endif
+#endif // CONFIG_GLOBAL_MOTION
break;
#if CONFIG_COMPOUND_MODES
case NEW_NEWMV:
this_mv[1].as_int = frame_mv[mbmi->ref_frame[1]].as_int;
break;
case ZERO_ZEROMV:
+#if CONFIG_GLOBAL_MOTION
+ this_mv[0].as_int =
+ cpi->common.global_motion[mbmi->ref_frame[0]][0].mv.as_int;
+ this_mv[1].as_int =
+ cpi->common.global_motion[mbmi->ref_frame[1]][0].mv.as_int;
+#else
this_mv[0].as_int = 0;
this_mv[1].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
break;
#endif
default:
const uint8_t *pre = &pd->pre[ref].buf[raster_block_offset(
BLOCK_8X8, i, pd->pre[ref].stride)];
#if CONFIG_VP9_HIGHBITDEPTH
- if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
- vp9_highbd_build_inter_predictor(pre, pd->pre[ref].stride,
- dst, pd->dst.stride,
- &mi->bmi[i].as_mv[ref].as_mv,
- &xd->block_refs[ref]->sf, width, height,
- ref, kernel, MV_PRECISION_Q3,
- mi_col * MI_SIZE + 4 * (i % 2),
- mi_row * MI_SIZE + 4 * (i / 2), xd->bd);
- } else {
- vp9_build_inter_predictor(pre, pd->pre[ref].stride,
- dst, pd->dst.stride,
- &mi->bmi[i].as_mv[ref].as_mv,
- &xd->block_refs[ref]->sf, width, height, ref,
- kernel, MV_PRECISION_Q3,
- mi_col * MI_SIZE + 4 * (i % 2),
- mi_row * MI_SIZE + 4 * (i / 2));
- }
+ if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
+ vp9_highbd_build_inter_predictor(pre, pd->pre[ref].stride,
+ dst, pd->dst.stride,
+ &mi->bmi[i].as_mv[ref].as_mv,
+ &xd->block_refs[ref]->sf, width, height,
+ ref, kernel, MV_PRECISION_Q3,
+ mi_col * MI_SIZE + 4 * (i % 2),
+ mi_row * MI_SIZE + 4 * (i / 2), xd->bd);
+ } else {
+ vp9_build_inter_predictor(pre, pd->pre[ref].stride,
+ dst, pd->dst.stride,
+ &mi->bmi[i].as_mv[ref].as_mv,
+ &xd->block_refs[ref]->sf, width, height, ref,
+ kernel, MV_PRECISION_Q3,
+ mi_col * MI_SIZE + 4 * (i % 2),
+ mi_row * MI_SIZE + 4 * (i / 2));
+ }
#else
vp9_build_inter_predictor(pre, pd->pre[ref].stride,
dst, pd->dst.stride,
vp9_update_mv_context(cm, xd, tile, mi, frame, mv_ref_list,
i, mi_row, mi_col);
#endif // CONFIG_NEWMVREF
+#if CONFIG_GLOBAL_MOTION
+ frame_mv[ZEROMV][frame].as_int = cm->global_motion[frame][0].mv.as_int;
+#else
frame_mv[ZEROMV][frame].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
vp9_append_sub8x8_mvs_for_idx(cm, xd, tile, i, ref, mi_row, mi_col,
#if CONFIG_NEWMVREF
mv_ref_list,
&ref_mvs_sub8x8[0][ref], &ref_mvs_sub8x8[1][ref]);
#endif // CONFIG_NEWMVREF
#if CONFIG_COMPOUND_MODES
+#if CONFIG_GLOBAL_MOTION
+ frame_mv[ZERO_ZEROMV][frame].as_int =
+ cm->global_motion[frame][0].mv.as_int;
+#else
frame_mv[ZERO_ZEROMV][frame].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
frame_mv[NEAREST_NEARESTMV][frame].as_int =
frame_mv[NEARESTMV][frame].as_int;
if (ref == 0) {
frame_mv[NEW_NEARMV][frame].as_int =
frame_mv[NEARMV][frame].as_int;
}
-#endif
+#endif // CONFIG_COMPOUND_MODES
}
// search for the best motion vector on this segment
if (!(inter_mode_mask & (1 << this_mode)))
continue;
+#if !CONFIG_GLOBAL_MOTION
if (!check_best_zero_mv(cpi, mbmi->mode_context, frame_mv,
this_mode, mbmi->ref_frame))
continue;
+#endif
vpx_memcpy(orig_pre, pd->pre, sizeof(orig_pre));
vpx_memcpy(bsi->rdstat[i][mode_idx].ta, t_above,
const MODE_INFO *left_mi = xd->left_available ?
xd->mi[-1].src_mi : NULL;
#endif // CONFIG_PALETTE
+
vp9_zero(best_mbmode);
x->skip_encode = sf->skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
#if CONFIG_NEWMVREF
frame_mv[NEAR_FORNEWMV][ref_frame].as_int = INVALID_MV;
#endif // CONFIG_NEWMVREF
+#if CONFIG_GLOBAL_MOTION
+ frame_mv[ZEROMV][ref_frame].as_int =
+ cm->global_motion[ref_frame][0].mv.as_int;
+#else
frame_mv[ZEROMV][ref_frame].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
#if CONFIG_COMPOUND_MODES
frame_mv[NEW_NEWMV][ref_frame].as_int = INVALID_MV;
+#if CONFIG_GLOBAL_MOTION
+ frame_mv[ZERO_ZEROMV][ref_frame].as_int =
+ cm->global_motion[ref_frame][0].mv.as_int;
+#else
frame_mv[ZERO_ZEROMV][ref_frame].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
#endif // CONFIG_COMPOUND_MODES
}
// an unfiltered alternative. We allow near/nearest as well
// because they may result in zero-zero MVs but be cheaper.
if (cpi->rc.is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) {
+ int_mv zmv;
ref_frame_skip_mask[0] = (1 << LAST_FRAME) | (1 << GOLDEN_FRAME);
ref_frame_skip_mask[1] = SECOND_REF_FRAME_MASK;
mode_skip_mask[ALTREF_FRAME] = ~INTER_NEAREST_NEAR_ZERO;
- if (frame_mv[NEARMV][ALTREF_FRAME].as_int != 0)
+#if CONFIG_GLOBAL_MOTION
+ zmv.as_int = cm->global_motion[ALTREF_FRAME][0].mv.as_int;
+#else
+ zmv.as_int = 0;
+#endif
+ if (frame_mv[NEARMV][ALTREF_FRAME].as_int != zmv.as_int)
mode_skip_mask[ALTREF_FRAME] |= (1 << NEARMV);
- if (frame_mv[NEARESTMV][ALTREF_FRAME].as_int != 0)
+ if (frame_mv[NEARESTMV][ALTREF_FRAME].as_int != zmv.as_int)
mode_skip_mask[ALTREF_FRAME] |= (1 << NEARESTMV);
#if CONFIG_COMPOUND_MODES
- if (frame_mv[NEAREST_NEARESTMV][ALTREF_FRAME].as_int != 0)
+ if (frame_mv[NEAREST_NEARESTMV][ALTREF_FRAME].as_int != zmv.as_int)
mode_skip_mask[ALTREF_FRAME] |= (1 << NEAREST_NEARESTMV);
- if (frame_mv[NEAREST_NEARMV][ALTREF_FRAME].as_int != 0)
+ if (frame_mv[NEAREST_NEARMV][ALTREF_FRAME].as_int != zmv.as_int)
mode_skip_mask[ALTREF_FRAME] |= (1 << NEAREST_NEARMV);
- if (frame_mv[NEAR_NEARESTMV][ALTREF_FRAME].as_int != 0)
+ if (frame_mv[NEAR_NEARESTMV][ALTREF_FRAME].as_int != zmv.as_int)
mode_skip_mask[ALTREF_FRAME] |= (1 << NEAR_NEARESTMV);
#endif // CONFIG_COMPOUND_MODES
}
continue;
if (const_motion)
+#if CONFIG_GLOBAL_MOTION
+ if (this_mode == NEARMV)
+#else // CONFIG_GLOBAL_MOTION
#if CONFIG_COMPOUND_MODES
if (this_mode == NEARMV || this_mode == ZEROMV ||
this_mode == ZERO_ZEROMV)
-#else
+#else // CONFIG_COMPOUND_MODES
if (this_mode == NEARMV || this_mode == ZEROMV)
#endif // CONFIG_COMPOUND_MODES
+#endif // CONFIG_GLOBAL_MOTION
continue;
}
continue;
}
}
+#if !CONFIG_GLOBAL_MOTION
} else {
const MV_REFERENCE_FRAME ref_frames[2] = {ref_frame, second_ref_frame};
if (!check_best_zero_mv(cpi, mbmi->mode_context, frame_mv,
this_mode, ref_frames))
continue;
+#endif // !CONFIG_GLOBAL_MOTION
}
#if CONFIG_INTERINTRA
if (ref_frame > INTRA_FRAME && second_ref_frame == INTRA_FRAME &&
const MV_REFERENCE_FRAME refs[2] = {best_mbmode.ref_frame[0],
best_mbmode.ref_frame[1]};
int comp_pred_mode = refs[1] > INTRA_FRAME;
+ int_mv zmv[2];
+#if CONFIG_GLOBAL_MOTION
+ zmv[0].as_int = cm->global_motion[refs[0]][0].mv.as_int;
+ zmv[1].as_int = cm->global_motion[refs[1]][0].mv.as_int;
+#else
+ zmv[0].as_int = 0;
+ zmv[1].as_int = 0;
+#endif
if (frame_mv[NEARESTMV][refs[0]].as_int == best_mbmode.mv[0].as_int &&
((comp_pred_mode && frame_mv[NEARESTMV][refs[1]].as_int ==
((comp_pred_mode && frame_mv[NEARMV][refs[1]].as_int ==
best_mbmode.mv[1].as_int) || !comp_pred_mode))
best_mbmode.mode = NEARMV;
- else if (best_mbmode.mv[0].as_int == 0 &&
- ((comp_pred_mode && best_mbmode.mv[1].as_int == 0) ||
+ else if (best_mbmode.mv[0].as_int == zmv[0].as_int &&
+ ((comp_pred_mode && best_mbmode.mv[1].as_int == zmv[1].as_int) ||
!comp_pred_mode))
best_mbmode.mode = ZEROMV;
}
const MV_REFERENCE_FRAME refs[2] = {best_mbmode.ref_frame[0],
best_mbmode.ref_frame[1]};
int comp_pred_mode = refs[1] > INTRA_FRAME;
+ int_mv zmv[2];
+#if CONFIG_GLOBAL_MOTION
+ zmv[0].as_int = cm->global_motion[refs[0]][0].mv.as_int;
+ zmv[1].as_int = cm->global_motion[refs[1]][0].mv.as_int;
+#else
+ zmv[0].as_int = 0;
+ zmv[1].as_int = 0;
+#endif
if (frame_mv[NEAREST_NEARESTMV][refs[0]].as_int == best_mbmode.mv[0].as_int
&& ((comp_pred_mode && frame_mv[NEAREST_NEARESTMV][refs[1]].as_int ==
((comp_pred_mode && frame_mv[NEAR_NEARESTMV][refs[1]].as_int ==
best_mbmode.mv[1].as_int) || !comp_pred_mode))
best_mbmode.mode = NEAR_NEARESTMV;
- else if (best_mbmode.mv[0].as_int == 0 &&
- ((comp_pred_mode && best_mbmode.mv[1].as_int == 0) || !comp_pred_mode))
+ else if (best_mbmode.mv[0].as_int == zmv[0].as_int &&
+ ((comp_pred_mode && best_mbmode.mv[1].as_int == zmv[1].as_int) ||
+ !comp_pred_mode))
best_mbmode.mode = ZERO_ZEROMV;
}
#endif
mbmi->uv_mode = DC_PRED;
mbmi->ref_frame[0] = LAST_FRAME;
mbmi->ref_frame[1] = NONE;
+#if CONFIG_GLOBAL_MOTION
+ mbmi->mv[0].as_int = cm->global_motion[mbmi->ref_frame[0]][0].mv.as_int;
+#else
mbmi->mv[0].as_int = 0;
+#endif
x->skip = 1;
// Search for best switchable filter by checking the variance of
ref_frame_skip_mask[1] |= SECOND_REF_FRAME_MASK;
}
frame_mv[NEWMV][ref_frame].as_int = INVALID_MV;
+#if CONFIG_GLOBAL_MOTION
+ frame_mv[ZEROMV][ref_frame].as_int =
+ cm->global_motion[ref_frame][0].mv.as_int;
+#else
frame_mv[ZEROMV][ref_frame].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
#if CONFIG_COMPOUND_MODES
frame_mv[NEW_NEWMV][ref_frame].as_int = INVALID_MV;
+#if CONFIG_GLOBAL_MOTION
+ frame_mv[ZERO_ZEROMV][ref_frame].as_int =
+ cm->global_motion[ref_frame][0].mv.as_int;
+#else
frame_mv[ZERO_ZEROMV][ref_frame].as_int = 0;
+#endif // CONFIG_GLOBAL_MOTION
#endif
}
}
static void encode_uniform(vp9_writer *w, int v) {
+ // NOTE: this is equivalent to vp9_encode_primitive_uniform(w, v, 191);
const int l = 8;
const int m = (1 << l) - 191;
if (v < m) {
upd);
return savings;
}
+
+void vp9_write_primitive_uniform(vp9_writer *w, int word,
+ unsigned int num_values) {
+ const int l = get_unsigned_bits_gen(num_values);
+ int m;
+ if (l == 0)
+ return;
+ m = (1 << l) - num_values;
+ if (word < m) {
+ vp9_write_literal(w, word, l - 1);
+ } else {
+ vp9_write_literal(w, m + ((word - m) >> 1), l - 1);
+ vp9_write_bit(w, (word - m) & 1);
+ }
+}
+
+void vp9_write_primitive_subexp(vp9_writer *w, int word,
+ unsigned int k) {
+ int mk = (1 << k);
+ int i = 0, j;
+ int tail;
+ while (word >= mk) {
+ mk <<= 1;
+ ++i;
+ }
+ if (i == 0) {
+ tail = word;
+ vp9_write_bit(w, 0);
+ if (k > 0)
+ vp9_write_literal(w, tail, k);
+ } else {
+ tail = word - (mk >> 1);
+ for (j = 0; j < i; j++)
+ vp9_write_bit(w, 1);
+ vp9_write_bit(w, 0);
+ if (k + i - 1 > 0)
+ vp9_write_literal(w, tail, k + i - 1);
+ }
+}
+
+void vp9_write_primitive_symmetric(vp9_writer *w, int word,
+ int abs_bits) {
+ if (word == 0) {
+ vp9_write_bit(w, 0);
+ } else {
+ const int x = abs(word);
+ const int s = word < 0;
+ vp9_write_bit(w, 1);
+ vp9_write_bit(w, s);
+ vp9_write_literal(w, x - 1, abs_bits);
+ }
+}
vp9_prob *bestp,
vp9_prob upd);
+// num_values is the number of values word can take
+void vp9_write_primitive_uniform(vp9_writer *w, int word,
+ unsigned int num_values);
+
+// k is the parameter of the subexponential code
+void vp9_write_primitive_subexp(vp9_writer *w, int word,
+ unsigned int k);
+//
+// mag_bits is number of bits for magnitude. The alphabet is of size
+// 2 * 2^mag_bits + 1, symmetric around 0, where one bit is used to
+// indicate 0 or non-zero, mag_bits bits are used to indicate magnitide
+// and 1 more bit for the sign if non-zero.
+void vp9_write_primitive_symmetric(vp9_writer *w, int word,
+ unsigned int mag_bits);
#ifdef __cplusplus
} // extern "C"
#endif
projects / libvpx / commitdiff