Move global motion estimation code to aom_dsp/
Relocate the core flow estimation code (ie, all of the code which
handles models in double precision, before we integerize) to a
new directory aom_dsp/flow_estimation/ .
This is a major step toward the ultimate goal of making the
flow estimation code codec-independent, but this step is not quite
completed here.
No behavioural changes are made here, only structural changes. So
this patch has no impact on BDRATE and overall speed.
Change-Id: Icbdabbfed451d9e5b0a9e5d51d341b31b03cc547
diff --git a/aom_dsp/aom_dsp.cmake b/aom_dsp/aom_dsp.cmake
index 389dedd..c5c2db7 100644
--- a/aom_dsp/aom_dsp.cmake
+++ b/aom_dsp/aom_dsp.cmake
@@ -174,6 +174,22 @@
"${AOM_ROOT}/aom_dsp/variance.c"
"${AOM_ROOT}/aom_dsp/variance.h")
+ # Flow estimation library
+ if(NOT CONFIG_REALTIME_ONLY)
+ list(APPEND AOM_DSP_ENCODER_SOURCES
+ "${AOM_ROOT}/aom_dsp/flow_estimation/corner_detect.c"
+ "${AOM_ROOT}/aom_dsp/flow_estimation/corner_match.c"
+ "${AOM_ROOT}/aom_dsp/flow_estimation/disflow.c"
+ "${AOM_ROOT}/aom_dsp/flow_estimation/flow_estimation.c"
+ "${AOM_ROOT}/aom_dsp/flow_estimation/ransac.c")
+
+ list(APPEND AOM_DSP_ENCODER_INTRIN_SSE4_1
+ "${AOM_ROOT}/aom_dsp/flow_estimation/x86/corner_match_sse4.c")
+
+ list(APPEND AOM_DSP_ENCODER_INTRIN_AVX2
+ "${AOM_ROOT}/aom_dsp/flow_estimation/x86/corner_match_avx2.c")
+ endif()
+
list(APPEND AOM_DSP_ENCODER_ASM_SSE2 "${AOM_ROOT}/aom_dsp/x86/sad4d_sse2.asm"
"${AOM_ROOT}/aom_dsp/x86/sad_sse2.asm"
"${AOM_ROOT}/aom_dsp/x86/subpel_variance_sse2.asm"
diff --git a/aom_dsp/aom_dsp_rtcd_defs.pl b/aom_dsp/aom_dsp_rtcd_defs.pl
index 58614be..241d2c7 100755
--- a/aom_dsp/aom_dsp_rtcd_defs.pl
+++ b/aom_dsp/aom_dsp_rtcd_defs.pl
@@ -2000,6 +2000,12 @@
specialize qw/aom_highbd_comp_mask_pred sse2 avx2/;
}
+ # Flow estimation library
+ if (aom_config("CONFIG_REALTIME_ONLY") ne "yes") {
+ add_proto qw/double av1_compute_cross_correlation/, "unsigned char *im1, int stride1, int x1, int y1, unsigned char *im2, int stride2, int x2, int y2";
+ specialize qw/av1_compute_cross_correlation sse4_1 avx2/;
+ }
+
} # CONFIG_AV1_ENCODER
1;
diff --git a/aom_dsp/flow_estimation/corner_detect.c b/aom_dsp/flow_estimation/corner_detect.c
new file mode 100644
index 0000000..a00852f
--- /dev/null
+++ b/aom_dsp/flow_estimation/corner_detect.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2022, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 3-Clause Clear License
+ * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
+ * License was not distributed with this source code in the LICENSE file, you
+ * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. 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
+ * aomedia.org/license/patent-license/.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <math.h>
+#include <assert.h>
+
+#include "third_party/fastfeat/fast.h"
+
+#include "aom_dsp/flow_estimation/corner_detect.h"
+
+// Fast_9 wrapper
+#define FAST_BARRIER 18
+int av1_fast_corner_detect(unsigned char *buf, int width, int height,
+ int stride, int *points, int max_points) {
+ int num_points;
+ xy *const frm_corners_xy = aom_fast9_detect_nonmax(buf, width, height, stride,
+ FAST_BARRIER, &num_points);
+ num_points = (num_points <= max_points ? num_points : max_points);
+ if (num_points > 0 && frm_corners_xy) {
+ memcpy(points, frm_corners_xy, sizeof(*frm_corners_xy) * num_points);
+ free(frm_corners_xy);
+ return num_points;
+ }
+ free(frm_corners_xy);
+ return 0;
+}
diff --git a/av1/encoder/corner_detect.h b/aom_dsp/flow_estimation/corner_detect.h
similarity index 75%
rename from av1/encoder/corner_detect.h
rename to aom_dsp/flow_estimation/corner_detect.h
index 15062f2..4481c4e 100644
--- a/av1/encoder/corner_detect.h
+++ b/aom_dsp/flow_estimation/corner_detect.h
@@ -9,14 +9,22 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
-#ifndef AOM_AV1_ENCODER_CORNER_DETECT_H_
-#define AOM_AV1_ENCODER_CORNER_DETECT_H_
+#ifndef AOM_AOM_DSP_FLOW_ESTIMATION_CORNER_DETECT_H_
+#define AOM_AOM_DSP_FLOW_ESTIMATION_CORNER_DETECT_H_
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
int av1_fast_corner_detect(unsigned char *buf, int width, int height,
int stride, int *points, int max_points);
-#endif // AOM_AV1_ENCODER_CORNER_DETECT_H_
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AOM_AOM_DSP_FLOW_ESTIMATION_CORNER_DETECT_H_
diff --git a/av1/encoder/corner_match.c b/aom_dsp/flow_estimation/corner_match.c
similarity index 67%
rename from av1/encoder/corner_match.c
rename to aom_dsp/flow_estimation/corner_match.c
index 3631be9..16884df 100644
--- a/av1/encoder/corner_match.c
+++ b/aom_dsp/flow_estimation/corner_match.c
@@ -1,21 +1,26 @@
/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
+ * Copyright (c) 2022, Alliance for Open Media. All rights reserved
*
- * 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.
+ * This source code is subject to the terms of the BSD 3-Clause Clear License
+ * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
+ * License was not distributed with this source code in the LICENSE file, you
+ * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. 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
+ * aomedia.org/license/patent-license/.
*/
#include <stdlib.h>
#include <memory.h>
#include <math.h>
-#include "config/av1_rtcd.h"
+#include "config/aom_dsp_rtcd.h"
-#include "av1/encoder/corner_match.h"
+#include "aom_dsp/flow_estimation/corner_detect.h"
+#include "aom_dsp/flow_estimation/corner_match.h"
+#include "aom_dsp/flow_estimation/flow_estimation.h"
+#include "aom_dsp/flow_estimation/ransac.h"
+#include "aom_scale/yv12config.h"
#define SEARCH_SZ 9
#define SEARCH_SZ_BY2 ((SEARCH_SZ - 1) / 2)
@@ -139,7 +144,7 @@
}
}
-int av1_determine_correspondence(unsigned char *src, int *src_corners,
+int aom_determine_correspondence(unsigned char *src, int *src_corners,
int num_src_corners, unsigned char *ref,
int *ref_corners, int num_ref_corners,
int width, int height, int src_stride,
@@ -190,3 +195,72 @@
correspondences, num_correspondences);
return num_correspondences;
}
+
+static bool get_inliers_from_indices(MotionModel *params,
+ int *correspondences) {
+ int *inliers_tmp = (int *)aom_calloc(2 * MAX_CORNERS, sizeof(*inliers_tmp));
+ if (!inliers_tmp) return false;
+
+ for (int i = 0; i < params->num_inliers; i++) {
+ int index = params->inliers[i];
+ inliers_tmp[2 * i] = correspondences[4 * index];
+ inliers_tmp[2 * i + 1] = correspondences[4 * index + 1];
+ }
+ memcpy(params->inliers, inliers_tmp, sizeof(*inliers_tmp) * 2 * MAX_CORNERS);
+ aom_free(inliers_tmp);
+ return true;
+}
+
+int av1_compute_global_motion_feature_based(
+ TransformationType type, unsigned char *src_buffer, int src_width,
+ int src_height, int src_stride, int *src_corners, int num_src_corners,
+ YV12_BUFFER_CONFIG *ref, int bit_depth, int *num_inliers_by_motion,
+ MotionModel *params_by_motion, int num_motions) {
+ int i;
+ int num_ref_corners;
+ int num_correspondences;
+ int *correspondences;
+ int ref_corners[2 * MAX_CORNERS];
+ unsigned char *ref_buffer = ref->y_buffer;
+ RansacFunc ransac = av1_get_ransac_type(type);
+
+ if (ref->flags & YV12_FLAG_HIGHBITDEPTH) {
+ ref_buffer = av1_downconvert_frame(ref, bit_depth);
+ }
+
+ num_ref_corners =
+ av1_fast_corner_detect(ref_buffer, ref->y_width, ref->y_height,
+ ref->y_stride, ref_corners, MAX_CORNERS);
+
+ // find correspondences between the two images
+ correspondences =
+ (int *)aom_malloc(num_src_corners * 4 * sizeof(*correspondences));
+ if (!correspondences) return 0;
+ num_correspondences = aom_determine_correspondence(
+ src_buffer, (int *)src_corners, num_src_corners, ref_buffer,
+ (int *)ref_corners, num_ref_corners, src_width, src_height, src_stride,
+ ref->y_stride, correspondences);
+
+ ransac(correspondences, num_correspondences, num_inliers_by_motion,
+ params_by_motion, num_motions);
+
+ // Set num_inliers = 0 for motions with too few inliers so they are ignored.
+ for (i = 0; i < num_motions; ++i) {
+ if (num_inliers_by_motion[i] < MIN_INLIER_PROB * num_correspondences ||
+ num_correspondences == 0) {
+ num_inliers_by_motion[i] = 0;
+ } else if (!get_inliers_from_indices(¶ms_by_motion[i],
+ correspondences)) {
+ aom_free(correspondences);
+ return 0;
+ }
+ }
+
+ aom_free(correspondences);
+
+ // Return true if any one of the motions has inliers.
+ for (i = 0; i < num_motions; ++i) {
+ if (num_inliers_by_motion[i] > 0) return 1;
+ }
+ return 0;
+}
diff --git a/av1/encoder/corner_match.h b/aom_dsp/flow_estimation/corner_match.h
similarity index 60%
rename from av1/encoder/corner_match.h
rename to aom_dsp/flow_estimation/corner_match.h
index 45c90f3..71afadf 100644
--- a/av1/encoder/corner_match.h
+++ b/aom_dsp/flow_estimation/corner_match.h
@@ -8,13 +8,21 @@
* 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.
*/
-#ifndef AOM_AV1_ENCODER_CORNER_MATCH_H_
-#define AOM_AV1_ENCODER_CORNER_MATCH_H_
+
+#ifndef AOM_AOM_DSP_FLOW_ESTIMATION_CORNER_MATCH_H_
+#define AOM_AOM_DSP_FLOW_ESTIMATION_CORNER_MATCH_H_
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
+#include "aom_dsp/flow_estimation/flow_estimation.h"
+#include "aom_scale/yv12config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
#define MATCH_SZ 13
#define MATCH_SZ_BY2 ((MATCH_SZ - 1) / 2)
#define MATCH_SZ_SQ (MATCH_SZ * MATCH_SZ)
@@ -24,10 +32,20 @@
int rx, ry;
} Correspondence;
-int av1_determine_correspondence(unsigned char *src, int *src_corners,
+int aom_determine_correspondence(unsigned char *src, int *src_corners,
int num_src_corners, unsigned char *ref,
int *ref_corners, int num_ref_corners,
int width, int height, int src_stride,
int ref_stride, int *correspondence_pts);
-#endif // AOM_AV1_ENCODER_CORNER_MATCH_H_
+int av1_compute_global_motion_feature_based(
+ TransformationType type, unsigned char *src_buffer, int src_width,
+ int src_height, int src_stride, int *src_corners, int num_src_corners,
+ YV12_BUFFER_CONFIG *ref, int bit_depth, int *num_inliers_by_motion,
+ MotionModel *params_by_motion, int num_motions);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AOM_AOM_DSP_FLOW_ESTIMATION_CORNER_MATCH_H_
diff --git a/aom_dsp/flow_estimation/disflow.c b/aom_dsp/flow_estimation/disflow.c
new file mode 100644
index 0000000..bc33d6b
--- /dev/null
+++ b/aom_dsp/flow_estimation/disflow.c
@@ -0,0 +1,635 @@
+/*
+ * Copyright (c) 2022, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 3-Clause Clear License
+ * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
+ * License was not distributed with this source code in the LICENSE file, you
+ * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. 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
+ * aomedia.org/license/patent-license/.
+ */
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "aom_dsp/flow_estimation/disflow.h"
+#include "aom_dsp/flow_estimation/flow_estimation.h"
+#include "aom_dsp/flow_estimation/ransac.h"
+
+#include "aom_scale/yv12config.h"
+
+#include "av1/common/resize.h"
+
+// Number of pyramid levels in disflow computation
+#define N_LEVELS 2
+// Size of square patches in the disflow dense grid
+#define PATCH_SIZE 8
+// Center point of square patch
+#define PATCH_CENTER ((PATCH_SIZE + 1) >> 1)
+// Step size between patches, lower value means greater patch overlap
+#define PATCH_STEP 1
+// Minimum size of border padding for disflow
+#define MIN_PAD 7
+// Warp error convergence threshold for disflow
+#define DISFLOW_ERROR_TR 0.01
+// Max number of iterations if warp convergence is not found
+#define DISFLOW_MAX_ITR 10
+
+// Struct for an image pyramid
+typedef struct {
+ int n_levels;
+ int pad_size;
+ int has_gradient;
+ int widths[N_LEVELS];
+ int heights[N_LEVELS];
+ int strides[N_LEVELS];
+ int level_loc[N_LEVELS];
+ unsigned char *level_buffer;
+ double *level_dx_buffer;
+ double *level_dy_buffer;
+} ImagePyramid;
+
+// Don't use points around the frame border since they are less reliable
+static INLINE int valid_point(int x, int y, int width, int height) {
+ return (x > (PATCH_SIZE + PATCH_CENTER)) &&
+ (x < (width - PATCH_SIZE - PATCH_CENTER)) &&
+ (y > (PATCH_SIZE + PATCH_CENTER)) &&
+ (y < (height - PATCH_SIZE - PATCH_CENTER));
+}
+
+static int determine_disflow_correspondence(int *frm_corners,
+ int num_frm_corners, double *flow_u,
+ double *flow_v, int width,
+ int height, int stride,
+ double *correspondences) {
+ int num_correspondences = 0;
+ int x, y;
+ for (int i = 0; i < num_frm_corners; ++i) {
+ x = frm_corners[2 * i];
+ y = frm_corners[2 * i + 1];
+ if (valid_point(x, y, width, height)) {
+ correspondences[4 * num_correspondences] = x;
+ correspondences[4 * num_correspondences + 1] = y;
+ correspondences[4 * num_correspondences + 2] = x + flow_u[y * stride + x];
+ correspondences[4 * num_correspondences + 3] = y + flow_v[y * stride + x];
+ num_correspondences++;
+ }
+ }
+ return num_correspondences;
+}
+
+static double getCubicValue(double p[4], double x) {
+ return p[1] + 0.5 * x *
+ (p[2] - p[0] +
+ x * (2.0 * p[0] - 5.0 * p[1] + 4.0 * p[2] - p[3] +
+ x * (3.0 * (p[1] - p[2]) + p[3] - p[0])));
+}
+
+static void get_subcolumn(unsigned char *ref, double col[4], int stride, int x,
+ int y_start) {
+ int i;
+ for (i = 0; i < 4; ++i) {
+ col[i] = ref[(i + y_start) * stride + x];
+ }
+}
+
+static double bicubic(unsigned char *ref, double x, double y, int stride) {
+ double arr[4];
+ int k;
+ int i = (int)x;
+ int j = (int)y;
+ for (k = 0; k < 4; ++k) {
+ double arr_temp[4];
+ get_subcolumn(ref, arr_temp, stride, i + k - 1, j - 1);
+ arr[k] = getCubicValue(arr_temp, y - j);
+ }
+ return getCubicValue(arr, x - i);
+}
+
+// Interpolate a warped block using bicubic interpolation when possible
+static unsigned char interpolate(unsigned char *ref, double x, double y,
+ int width, int height, int stride) {
+ if (x < 0 && y < 0)
+ return ref[0];
+ else if (x < 0 && y > height - 1)
+ return ref[(height - 1) * stride];
+ else if (x > width - 1 && y < 0)
+ return ref[width - 1];
+ else if (x > width - 1 && y > height - 1)
+ return ref[(height - 1) * stride + (width - 1)];
+ else if (x < 0) {
+ int v;
+ int i = (int)y;
+ double a = y - i;
+ if (y > 1 && y < height - 2) {
+ double arr[4];
+ get_subcolumn(ref, arr, stride, 0, i - 1);
+ return clamp((int)(getCubicValue(arr, a) + 0.5), 0, 255);
+ }
+ v = (int)(ref[i * stride] * (1 - a) + ref[(i + 1) * stride] * a + 0.5);
+ return clamp(v, 0, 255);
+ } else if (y < 0) {
+ int v;
+ int j = (int)x;
+ double b = x - j;
+ if (x > 1 && x < width - 2) {
+ double arr[4] = { ref[j - 1], ref[j], ref[j + 1], ref[j + 2] };
+ return clamp((int)(getCubicValue(arr, b) + 0.5), 0, 255);
+ }
+ v = (int)(ref[j] * (1 - b) + ref[j + 1] * b + 0.5);
+ return clamp(v, 0, 255);
+ } else if (x > width - 1) {
+ int v;
+ int i = (int)y;
+ double a = y - i;
+ if (y > 1 && y < height - 2) {
+ double arr[4];
+ get_subcolumn(ref, arr, stride, width - 1, i - 1);
+ return clamp((int)(getCubicValue(arr, a) + 0.5), 0, 255);
+ }
+ v = (int)(ref[i * stride + width - 1] * (1 - a) +
+ ref[(i + 1) * stride + width - 1] * a + 0.5);
+ return clamp(v, 0, 255);
+ } else if (y > height - 1) {
+ int v;
+ int j = (int)x;
+ double b = x - j;
+ if (x > 1 && x < width - 2) {
+ int row = (height - 1) * stride;
+ double arr[4] = { ref[row + j - 1], ref[row + j], ref[row + j + 1],
+ ref[row + j + 2] };
+ return clamp((int)(getCubicValue(arr, b) + 0.5), 0, 255);
+ }
+ v = (int)(ref[(height - 1) * stride + j] * (1 - b) +
+ ref[(height - 1) * stride + j + 1] * b + 0.5);
+ return clamp(v, 0, 255);
+ } else if (x > 1 && y > 1 && x < width - 2 && y < height - 2) {
+ return clamp((int)(bicubic(ref, x, y, stride) + 0.5), 0, 255);
+ } else {
+ int i = (int)y;
+ int j = (int)x;
+ double a = y - i;
+ double b = x - j;
+ int v = (int)(ref[i * stride + j] * (1 - a) * (1 - b) +
+ ref[i * stride + j + 1] * (1 - a) * b +
+ ref[(i + 1) * stride + j] * a * (1 - b) +
+ ref[(i + 1) * stride + j + 1] * a * b);
+ return clamp(v, 0, 255);
+ }
+}
+
+// Warps a block using flow vector [u, v] and computes the mse
+static double compute_warp_and_error(unsigned char *ref, unsigned char *frm,
+ int width, int height, int stride, int x,
+ int y, double u, double v, int16_t *dt) {
+ int i, j;
+ unsigned char warped;
+ double x_w, y_w;
+ double mse = 0;
+ int16_t err = 0;
+ for (i = y; i < y + PATCH_SIZE; ++i)
+ for (j = x; j < x + PATCH_SIZE; ++j) {
+ x_w = (double)j + u;
+ y_w = (double)i + v;
+ warped = interpolate(ref, x_w, y_w, width, height, stride);
+ err = warped - frm[j + i * stride];
+ mse += err * err;
+ dt[(i - y) * PATCH_SIZE + (j - x)] = err;
+ }
+
+ mse /= (PATCH_SIZE * PATCH_SIZE);
+ return mse;
+}
+
+// Computes the components of the system of equations used to solve for
+// a flow vector. This includes:
+// 1.) The hessian matrix for optical flow. This matrix is in the
+// form of:
+//
+// M = |sum(dx * dx) sum(dx * dy)|
+// |sum(dx * dy) sum(dy * dy)|
+//
+// 2.) b = |sum(dx * dt)|
+// |sum(dy * dt)|
+// Where the sums are computed over a square window of PATCH_SIZE.
+static INLINE void compute_flow_system(const double *dx, int dx_stride,
+ const double *dy, int dy_stride,
+ const int16_t *dt, int dt_stride,
+ double *M, double *b) {
+ for (int i = 0; i < PATCH_SIZE; i++) {
+ for (int j = 0; j < PATCH_SIZE; j++) {
+ M[0] += dx[i * dx_stride + j] * dx[i * dx_stride + j];
+ M[1] += dx[i * dx_stride + j] * dy[i * dy_stride + j];
+ M[3] += dy[i * dy_stride + j] * dy[i * dy_stride + j];
+
+ b[0] += dx[i * dx_stride + j] * dt[i * dt_stride + j];
+ b[1] += dy[i * dy_stride + j] * dt[i * dt_stride + j];
+ }
+ }
+
+ M[2] = M[1];
+}
+
+// Solves a general Mx = b where M is a 2x2 matrix and b is a 2x1 matrix
+static INLINE void solve_2x2_system(const double *M, const double *b,
+ double *output_vec) {
+ double M_0 = M[0];
+ double M_3 = M[3];
+ double det = (M_0 * M_3) - (M[1] * M[2]);
+ if (det < 1e-5) {
+ // Handle singular matrix
+ // TODO(sarahparker) compare results using pseudo inverse instead
+ M_0 += 1e-10;
+ M_3 += 1e-10;
+ det = (M_0 * M_3) - (M[1] * M[2]);
+ }
+ const double det_inv = 1 / det;
+ const double mult_b0 = det_inv * b[0];
+ const double mult_b1 = det_inv * b[1];
+ output_vec[0] = M_3 * mult_b0 - M[1] * mult_b1;
+ output_vec[1] = -M[2] * mult_b0 + M_0 * mult_b1;
+}
+
+/*
+static INLINE void image_difference(const uint8_t *src, int src_stride,
+ const uint8_t *ref, int ref_stride,
+ int16_t *dst, int dst_stride, int height,
+ int width) {
+ const int block_unit = 8;
+ // Take difference in 8x8 blocks to make use of optimized diff function
+ for (int i = 0; i < height; i += block_unit) {
+ for (int j = 0; j < width; j += block_unit) {
+ aom_subtract_block(block_unit, block_unit, dst + i * dst_stride + j,
+ dst_stride, src + i * src_stride + j, src_stride,
+ ref + i * ref_stride + j, ref_stride);
+ }
+ }
+}
+*/
+
+static INLINE void convolve_2d_sobel_y(const uint8_t *src, int src_stride,
+ double *dst, int dst_stride, int w,
+ int h, int dir, double norm) {
+ int16_t im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];
+ DECLARE_ALIGNED(256, static const int16_t, sobel_a[3]) = { 1, 0, -1 };
+ DECLARE_ALIGNED(256, static const int16_t, sobel_b[3]) = { 1, 2, 1 };
+ const int taps = 3;
+ int im_h = h + taps - 1;
+ int im_stride = w;
+ const int fo_vert = 1;
+ const int fo_horiz = 1;
+
+ // horizontal filter
+ const uint8_t *src_horiz = src - fo_vert * src_stride;
+ const int16_t *x_filter = dir ? sobel_a : sobel_b;
+ for (int y = 0; y < im_h; ++y) {
+ for (int x = 0; x < w; ++x) {
+ int16_t sum = 0;
+ for (int k = 0; k < taps; ++k) {
+ sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];
+ }
+ im_block[y * im_stride + x] = sum;
+ }
+ }
+
+ // vertical filter
+ int16_t *src_vert = im_block + fo_vert * im_stride;
+ const int16_t *y_filter = dir ? sobel_b : sobel_a;
+ for (int y = 0; y < h; ++y) {
+ for (int x = 0; x < w; ++x) {
+ int16_t sum = 0;
+ for (int k = 0; k < taps; ++k) {
+ sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];
+ }
+ dst[y * dst_stride + x] = sum * norm;
+ }
+ }
+}
+
+// Compute an image gradient using a sobel filter.
+// If dir == 1, compute the x gradient. If dir == 0, compute y. This function
+// assumes the images have been padded so that they can be processed in units
+// of 8.
+static INLINE void sobel_xy_image_gradient(const uint8_t *src, int src_stride,
+ double *dst, int dst_stride,
+ int height, int width, int dir) {
+ double norm = 1.0;
+ // TODO(sarahparker) experiment with doing this over larger block sizes
+ const int block_unit = 8;
+ // Filter in 8x8 blocks to eventually make use of optimized convolve function
+ for (int i = 0; i < height; i += block_unit) {
+ for (int j = 0; j < width; j += block_unit) {
+ convolve_2d_sobel_y(src + i * src_stride + j, src_stride,
+ dst + i * dst_stride + j, dst_stride, block_unit,
+ block_unit, dir, norm);
+ }
+ }
+}
+
+static void free_pyramid(ImagePyramid *pyr) {
+ aom_free(pyr->level_buffer);
+ if (pyr->has_gradient) {
+ aom_free(pyr->level_dx_buffer);
+ aom_free(pyr->level_dy_buffer);
+ }
+ aom_free(pyr);
+}
+
+static ImagePyramid *alloc_pyramid(int width, int height, int pad_size,
+ int compute_gradient) {
+ ImagePyramid *pyr = aom_calloc(1, sizeof(*pyr));
+ if (!pyr) return NULL;
+ pyr->has_gradient = compute_gradient;
+ // 2 * width * height is the upper bound for a buffer that fits
+ // all pyramid levels + padding for each level
+ const int buffer_size = sizeof(*pyr->level_buffer) * 2 * width * height +
+ (width + 2 * pad_size) * 2 * pad_size * N_LEVELS;
+ pyr->level_buffer = aom_malloc(buffer_size);
+ if (!pyr->level_buffer) {
+ free_pyramid(pyr);
+ return NULL;
+ }
+ memset(pyr->level_buffer, 0, buffer_size);
+
+ if (compute_gradient) {
+ const int gradient_size =
+ sizeof(*pyr->level_dx_buffer) * 2 * width * height +
+ (width + 2 * pad_size) * 2 * pad_size * N_LEVELS;
+ pyr->level_dx_buffer = aom_calloc(1, gradient_size);
+ pyr->level_dy_buffer = aom_calloc(1, gradient_size);
+ if (!(pyr->level_dx_buffer && pyr->level_dy_buffer)) {
+ free_pyramid(pyr);
+ return NULL;
+ }
+ }
+ return pyr;
+}
+
+static INLINE void update_level_dims(ImagePyramid *frm_pyr, int level) {
+ frm_pyr->widths[level] = frm_pyr->widths[level - 1] >> 1;
+ frm_pyr->heights[level] = frm_pyr->heights[level - 1] >> 1;
+ frm_pyr->strides[level] = frm_pyr->widths[level] + 2 * frm_pyr->pad_size;
+ // Point the beginning of the next level buffer to the correct location inside
+ // the padded border
+ frm_pyr->level_loc[level] =
+ frm_pyr->level_loc[level - 1] +
+ frm_pyr->strides[level - 1] *
+ (2 * frm_pyr->pad_size + frm_pyr->heights[level - 1]);
+}
+
+// Compute coarse to fine pyramids for a frame
+static void compute_flow_pyramids(unsigned char *frm, const int frm_width,
+ const int frm_height, const int frm_stride,
+ int n_levels, int pad_size, int compute_grad,
+ ImagePyramid *frm_pyr) {
+ int cur_width, cur_height, cur_stride, cur_loc;
+ assert((frm_width >> n_levels) > 0);
+ assert((frm_height >> n_levels) > 0);
+
+ // Initialize first level
+ frm_pyr->n_levels = n_levels;
+ frm_pyr->pad_size = pad_size;
+ frm_pyr->widths[0] = frm_width;
+ frm_pyr->heights[0] = frm_height;
+ frm_pyr->strides[0] = frm_width + 2 * frm_pyr->pad_size;
+ // Point the beginning of the level buffer to the location inside
+ // the padded border
+ frm_pyr->level_loc[0] =
+ frm_pyr->strides[0] * frm_pyr->pad_size + frm_pyr->pad_size;
+ // This essentially copies the original buffer into the pyramid buffer
+ // without the original padding
+ av1_resize_plane(frm, frm_height, frm_width, frm_stride,
+ frm_pyr->level_buffer + frm_pyr->level_loc[0],
+ frm_pyr->heights[0], frm_pyr->widths[0],
+ frm_pyr->strides[0]);
+
+ if (compute_grad) {
+ cur_width = frm_pyr->widths[0];
+ cur_height = frm_pyr->heights[0];
+ cur_stride = frm_pyr->strides[0];
+ cur_loc = frm_pyr->level_loc[0];
+ assert(frm_pyr->has_gradient && frm_pyr->level_dx_buffer != NULL &&
+ frm_pyr->level_dy_buffer != NULL);
+ // Computation x gradient
+ sobel_xy_image_gradient(frm_pyr->level_buffer + cur_loc, cur_stride,
+ frm_pyr->level_dx_buffer + cur_loc, cur_stride,
+ cur_height, cur_width, 1);
+
+ // Computation y gradient
+ sobel_xy_image_gradient(frm_pyr->level_buffer + cur_loc, cur_stride,
+ frm_pyr->level_dy_buffer + cur_loc, cur_stride,
+ cur_height, cur_width, 0);
+ }
+
+ // Start at the finest level and resize down to the coarsest level
+ for (int level = 1; level < n_levels; ++level) {
+ update_level_dims(frm_pyr, level);
+ cur_width = frm_pyr->widths[level];
+ cur_height = frm_pyr->heights[level];
+ cur_stride = frm_pyr->strides[level];
+ cur_loc = frm_pyr->level_loc[level];
+
+ av1_resize_plane(frm_pyr->level_buffer + frm_pyr->level_loc[level - 1],
+ frm_pyr->heights[level - 1], frm_pyr->widths[level - 1],
+ frm_pyr->strides[level - 1],
+ frm_pyr->level_buffer + cur_loc, cur_height, cur_width,
+ cur_stride);
+
+ if (compute_grad) {
+ assert(frm_pyr->has_gradient && frm_pyr->level_dx_buffer != NULL &&
+ frm_pyr->level_dy_buffer != NULL);
+ // Computation x gradient
+ sobel_xy_image_gradient(frm_pyr->level_buffer + cur_loc, cur_stride,
+ frm_pyr->level_dx_buffer + cur_loc, cur_stride,
+ cur_height, cur_width, 1);
+
+ // Computation y gradient
+ sobel_xy_image_gradient(frm_pyr->level_buffer + cur_loc, cur_stride,
+ frm_pyr->level_dy_buffer + cur_loc, cur_stride,
+ cur_height, cur_width, 0);
+ }
+ }
+}
+
+static INLINE void compute_flow_at_point(unsigned char *frm, unsigned char *ref,
+ double *dx, double *dy, int x, int y,
+ int width, int height, int stride,
+ double *u, double *v) {
+ double M[4] = { 0 };
+ double b[2] = { 0 };
+ double tmp_output_vec[2] = { 0 };
+ double error = 0;
+ int16_t dt[PATCH_SIZE * PATCH_SIZE];
+ double o_u = *u;
+ double o_v = *v;
+
+ for (int itr = 0; itr < DISFLOW_MAX_ITR; itr++) {
+ error = compute_warp_and_error(ref, frm, width, height, stride, x, y, *u,
+ *v, dt);
+ if (error <= DISFLOW_ERROR_TR) break;
+ compute_flow_system(dx, stride, dy, stride, dt, PATCH_SIZE, M, b);
+ solve_2x2_system(M, b, tmp_output_vec);
+ *u += tmp_output_vec[0];
+ *v += tmp_output_vec[1];
+ }
+ if (fabs(*u - o_u) > PATCH_SIZE || fabs(*v - o_u) > PATCH_SIZE) {
+ *u = o_u;
+ *v = o_v;
+ }
+}
+
+// make sure flow_u and flow_v start at 0
+static bool compute_flow_field(ImagePyramid *frm_pyr, ImagePyramid *ref_pyr,
+ double *flow_u, double *flow_v) {
+ int cur_width, cur_height, cur_stride, cur_loc, patch_loc, patch_center;
+ double *u_upscale =
+ aom_malloc(frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_u));
+ double *v_upscale =
+ aom_malloc(frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_v));
+ if (!(u_upscale && v_upscale)) {
+ aom_free(u_upscale);
+ aom_free(v_upscale);
+ return false;
+ }
+
+ assert(frm_pyr->n_levels == ref_pyr->n_levels);
+
+ // Compute flow field from coarsest to finest level of the pyramid
+ for (int level = frm_pyr->n_levels - 1; level >= 0; --level) {
+ cur_width = frm_pyr->widths[level];
+ cur_height = frm_pyr->heights[level];
+ cur_stride = frm_pyr->strides[level];
+ cur_loc = frm_pyr->level_loc[level];
+
+ for (int i = PATCH_SIZE; i < cur_height - PATCH_SIZE; i += PATCH_STEP) {
+ for (int j = PATCH_SIZE; j < cur_width - PATCH_SIZE; j += PATCH_STEP) {
+ patch_loc = i * cur_stride + j;
+ patch_center = patch_loc + PATCH_CENTER * cur_stride + PATCH_CENTER;
+ compute_flow_at_point(frm_pyr->level_buffer + cur_loc,
+ ref_pyr->level_buffer + cur_loc,
+ frm_pyr->level_dx_buffer + cur_loc + patch_loc,
+ frm_pyr->level_dy_buffer + cur_loc + patch_loc, j,
+ i, cur_width, cur_height, cur_stride,
+ flow_u + patch_center, flow_v + patch_center);
+ }
+ }
+ // TODO(sarahparker) Replace this with upscale function in resize.c
+ if (level > 0) {
+ int h_upscale = frm_pyr->heights[level - 1];
+ int w_upscale = frm_pyr->widths[level - 1];
+ int s_upscale = frm_pyr->strides[level - 1];
+ for (int i = 0; i < h_upscale; ++i) {
+ for (int j = 0; j < w_upscale; ++j) {
+ u_upscale[j + i * s_upscale] =
+ flow_u[(int)(j >> 1) + (int)(i >> 1) * cur_stride];
+ v_upscale[j + i * s_upscale] =
+ flow_v[(int)(j >> 1) + (int)(i >> 1) * cur_stride];
+ }
+ }
+ memcpy(flow_u, u_upscale,
+ frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_u));
+ memcpy(flow_v, v_upscale,
+ frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_v));
+ }
+ }
+ aom_free(u_upscale);
+ aom_free(v_upscale);
+ return true;
+}
+
+int av1_compute_global_motion_disflow_based(
+ TransformationType type, unsigned char *frm_buffer, int frm_width,
+ int frm_height, int frm_stride, int *frm_corners, int num_frm_corners,
+ YV12_BUFFER_CONFIG *ref, int bit_depth, int *num_inliers_by_motion,
+ MotionModel *params_by_motion, int num_motions) {
+ unsigned char *ref_buffer = ref->y_buffer;
+ const int ref_width = ref->y_width;
+ const int ref_height = ref->y_height;
+ const int pad_size = AOMMAX(PATCH_SIZE, MIN_PAD);
+ int num_correspondences;
+ double *correspondences;
+ RansacFuncDouble ransac = av1_get_ransac_double_prec_type(type);
+ assert(frm_width == ref_width);
+ assert(frm_height == ref_height);
+
+ // Ensure the number of pyramid levels will work with the frame resolution
+ const int msb =
+ frm_width < frm_height ? get_msb(frm_width) : get_msb(frm_height);
+ const int n_levels = AOMMIN(msb, N_LEVELS);
+
+ if (ref->flags & YV12_FLAG_HIGHBITDEPTH) {
+ ref_buffer = av1_downconvert_frame(ref, bit_depth);
+ }
+
+ // TODO(sarahparker) We will want to do the source pyramid computation
+ // outside of this function so it doesn't get recomputed for every
+ // reference. We also don't need to compute every pyramid level for the
+ // reference in advance, since lower levels can be overwritten once their
+ // flow field is computed and upscaled. I'll add these optimizations
+ // once the full implementation is working.
+ // Allocate frm image pyramids
+ int compute_gradient = 1;
+ ImagePyramid *frm_pyr =
+ alloc_pyramid(frm_width, frm_height, pad_size, compute_gradient);
+ if (!frm_pyr) return 0;
+ compute_flow_pyramids(frm_buffer, frm_width, frm_height, frm_stride, n_levels,
+ pad_size, compute_gradient, frm_pyr);
+ // Allocate ref image pyramids
+ compute_gradient = 0;
+ ImagePyramid *ref_pyr =
+ alloc_pyramid(ref_width, ref_height, pad_size, compute_gradient);
+ if (!ref_pyr) {
+ free_pyramid(frm_pyr);
+ return 0;
+ }
+ compute_flow_pyramids(ref_buffer, ref_width, ref_height, ref->y_stride,
+ n_levels, pad_size, compute_gradient, ref_pyr);
+
+ int ret = 0;
+ double *flow_u =
+ aom_malloc(frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_u));
+ double *flow_v =
+ aom_malloc(frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_v));
+ if (!(flow_u && flow_v)) goto Error;
+
+ memset(flow_u, 0,
+ frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_u));
+ memset(flow_v, 0,
+ frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_v));
+
+ if (!compute_flow_field(frm_pyr, ref_pyr, flow_u, flow_v)) goto Error;
+
+ // find correspondences between the two images using the flow field
+ correspondences = aom_malloc(num_frm_corners * 4 * sizeof(*correspondences));
+ if (!correspondences) goto Error;
+ num_correspondences = determine_disflow_correspondence(
+ frm_corners, num_frm_corners, flow_u, flow_v, frm_width, frm_height,
+ frm_pyr->strides[0], correspondences);
+ ransac(correspondences, num_correspondences, num_inliers_by_motion,
+ params_by_motion, num_motions);
+
+ // Set num_inliers = 0 for motions with too few inliers so they are ignored.
+ for (int i = 0; i < num_motions; ++i) {
+ if (num_inliers_by_motion[i] < MIN_INLIER_PROB * num_correspondences) {
+ num_inliers_by_motion[i] = 0;
+ }
+ }
+
+ // Return true if any one of the motions has inliers.
+ for (int i = 0; i < num_motions; ++i) {
+ if (num_inliers_by_motion[i] > 0) {
+ ret = 1;
+ break;
+ }
+ }
+
+ aom_free(correspondences);
+Error:
+ free_pyramid(frm_pyr);
+ free_pyramid(ref_pyr);
+ aom_free(flow_u);
+ aom_free(flow_v);
+ return ret;
+}
diff --git a/aom_dsp/flow_estimation/disflow.h b/aom_dsp/flow_estimation/disflow.h
new file mode 100644
index 0000000..52fb261
--- /dev/null
+++ b/aom_dsp/flow_estimation/disflow.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
+ *
+ * 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.
+ */
+
+#ifndef AOM_AOM_DSP_FLOW_ESTIMATION_DISFLOW_H_
+#define AOM_AOM_DSP_FLOW_ESTIMATION_DISFLOW_H_
+
+#include "aom_dsp/flow_estimation/flow_estimation.h"
+#include "aom_scale/yv12config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int av1_compute_global_motion_disflow_based(
+ TransformationType type, unsigned char *frm_buffer, int frm_width,
+ int frm_height, int frm_stride, int *frm_corners, int num_frm_corners,
+ YV12_BUFFER_CONFIG *ref, int bit_depth, int *num_inliers_by_motion,
+ MotionModel *params_by_motion, int num_motions);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AOM_AOM_DSP_FLOW_ESTIMATION_DISFLOW_H_
diff --git a/aom_dsp/flow_estimation/flow_estimation.c b/aom_dsp/flow_estimation/flow_estimation.c
new file mode 100644
index 0000000..ef3bfcd
--- /dev/null
+++ b/aom_dsp/flow_estimation/flow_estimation.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2022, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 3-Clause Clear License
+ * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
+ * License was not distributed with this source code in the LICENSE file, you
+ * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. 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
+ * aomedia.org/license/patent-license/.
+ */
+
+#include <assert.h>
+
+#include "aom_dsp/flow_estimation/corner_match.h"
+#include "aom_dsp/flow_estimation/disflow.h"
+#include "aom_dsp/flow_estimation/flow_estimation.h"
+#include "aom_ports/mem.h"
+#include "aom_scale/yv12config.h"
+
+int aom_compute_global_motion(TransformationType type,
+ unsigned char *src_buffer, int src_width,
+ int src_height, int src_stride, int *src_corners,
+ int num_src_corners, YV12_BUFFER_CONFIG *ref,
+ int bit_depth,
+ GlobalMotionEstimationType gm_estimation_type,
+ int *num_inliers_by_motion,
+ MotionModel *params_by_motion, int num_motions) {
+ switch (gm_estimation_type) {
+ case GLOBAL_MOTION_FEATURE_BASED:
+ return av1_compute_global_motion_feature_based(
+ type, src_buffer, src_width, src_height, src_stride, src_corners,
+ num_src_corners, ref, bit_depth, num_inliers_by_motion,
+ params_by_motion, num_motions);
+ case GLOBAL_MOTION_DISFLOW_BASED:
+ return av1_compute_global_motion_disflow_based(
+ type, src_buffer, src_width, src_height, src_stride, src_corners,
+ num_src_corners, ref, bit_depth, num_inliers_by_motion,
+ params_by_motion, num_motions);
+ default: assert(0 && "Unknown global motion estimation type");
+ }
+ return 0;
+}
+
+unsigned char *av1_downconvert_frame(YV12_BUFFER_CONFIG *frm, int bit_depth) {
+ int i, j;
+ uint16_t *orig_buf = CONVERT_TO_SHORTPTR(frm->y_buffer);
+ uint8_t *buf_8bit = frm->y_buffer_8bit;
+ assert(buf_8bit);
+ if (!frm->buf_8bit_valid) {
+ for (i = 0; i < frm->y_height; ++i) {
+ for (j = 0; j < frm->y_width; ++j) {
+ buf_8bit[i * frm->y_stride + j] =
+ orig_buf[i * frm->y_stride + j] >> (bit_depth - 8);
+ }
+ }
+ frm->buf_8bit_valid = 1;
+ }
+ return buf_8bit;
+}
diff --git a/aom_dsp/flow_estimation/flow_estimation.h b/aom_dsp/flow_estimation/flow_estimation.h
new file mode 100644
index 0000000..ab9d328
--- /dev/null
+++ b/aom_dsp/flow_estimation/flow_estimation.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
+ *
+ * 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.
+ */
+
+#ifndef AOM_AOM_DSP_FLOW_ESTIMATION_H_
+#define AOM_AOM_DSP_FLOW_ESTIMATION_H_
+
+#include "aom_ports/mem.h"
+#include "aom_scale/yv12config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_PARAMDIM 9
+#define MAX_CORNERS 4096
+#define MIN_INLIER_PROB 0.1
+
+/* clang-format off */
+enum {
+ IDENTITY = 0, // identity transformation, 0-parameter
+ TRANSLATION = 1, // translational motion 2-parameter
+ ROTZOOM = 2, // simplified affine with rotation + zoom only, 4-parameter
+ AFFINE = 3, // affine, 6-parameter
+ TRANS_TYPES,
+} UENUM1BYTE(TransformationType);
+/* clang-format on */
+
+// number of parameters used by each transformation in TransformationTypes
+static const int trans_model_params[TRANS_TYPES] = { 0, 2, 4, 6 };
+
+typedef enum {
+ GLOBAL_MOTION_FEATURE_BASED,
+ GLOBAL_MOTION_DISFLOW_BASED,
+} GlobalMotionEstimationType;
+
+typedef struct {
+ double params[MAX_PARAMDIM - 1];
+ int *inliers;
+ int num_inliers;
+} MotionModel;
+
+int aom_compute_global_motion(TransformationType type,
+ unsigned char *src_buffer, int src_width,
+ int src_height, int src_stride, int *src_corners,
+ int num_src_corners, YV12_BUFFER_CONFIG *ref,
+ int bit_depth,
+ GlobalMotionEstimationType gm_estimation_type,
+ int *num_inliers_by_motion,
+ MotionModel *params_by_motion, int num_motions);
+
+unsigned char *av1_downconvert_frame(YV12_BUFFER_CONFIG *frm, int bit_depth);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AOM_AOM_DSP_FLOW_ESTIMATION_H_
diff --git a/av1/encoder/ransac.c b/aom_dsp/flow_estimation/ransac.c
similarity index 97%
rename from av1/encoder/ransac.c
rename to aom_dsp/flow_estimation/ransac.c
index f878fce..42216b0 100644
--- a/av1/encoder/ransac.c
+++ b/aom_dsp/flow_estimation/ransac.c
@@ -1,13 +1,15 @@
/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
+ * Copyright (c) 2022, Alliance for Open Media. All rights reserved
*
- * 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.
+ * This source code is subject to the terms of the BSD 3-Clause Clear License
+ * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
+ * License was not distributed with this source code in the LICENSE file, you
+ * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. 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
+ * aomedia.org/license/patent-license/.
*/
+
#include <memory.h>
#include <math.h>
#include <time.h>
@@ -15,8 +17,10 @@
#include <stdlib.h>
#include <assert.h>
+#include "aom_dsp/flow_estimation/ransac.h"
#include "aom_dsp/mathutils.h"
-#include "av1/encoder/ransac.h"
+
+// TODO(rachelbarker): Remove dependence on code in av1/encoder/
#include "av1/encoder/random.h"
#define MAX_MINPTS 4
diff --git a/av1/encoder/ransac.h b/aom_dsp/flow_estimation/ransac.h
similarity index 80%
rename from av1/encoder/ransac.h
rename to aom_dsp/flow_estimation/ransac.h
index 583d971..aa3a243 100644
--- a/av1/encoder/ransac.h
+++ b/aom_dsp/flow_estimation/ransac.h
@@ -9,16 +9,19 @@
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
-#ifndef AOM_AV1_ENCODER_RANSAC_H_
-#define AOM_AV1_ENCODER_RANSAC_H_
+#ifndef AOM_AOM_DSP_FLOW_ESTIMATION_RANSAC_H_
+#define AOM_AOM_DSP_FLOW_ESTIMATION_RANSAC_H_
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <memory.h>
-#include "av1/common/warped_motion.h"
-#include "av1/encoder/global_motion.h"
+#include "aom_dsp/flow_estimation/flow_estimation.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
typedef int (*RansacFunc)(int *matched_points, int npoints,
int *num_inliers_by_motion,
@@ -28,4 +31,9 @@
MotionModel *params_by_motion, int num_motions);
RansacFunc av1_get_ransac_type(TransformationType type);
RansacFuncDouble av1_get_ransac_double_prec_type(TransformationType type);
-#endif // AOM_AV1_ENCODER_RANSAC_H_
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AOM_AOM_DSP_FLOW_ESTIMATION_RANSAC_H_
diff --git a/av1/encoder/x86/corner_match_avx2.c b/aom_dsp/flow_estimation/x86/corner_match_avx2.c
similarity index 97%
rename from av1/encoder/x86/corner_match_avx2.c
rename to aom_dsp/flow_estimation/x86/corner_match_avx2.c
index 033ae37..9830ad8 100644
--- a/av1/encoder/x86/corner_match_avx2.c
+++ b/aom_dsp/flow_estimation/x86/corner_match_avx2.c
@@ -12,10 +12,10 @@
#include <math.h>
#include <immintrin.h>
-#include "config/av1_rtcd.h"
+#include "config/aom_dsp_rtcd.h"
#include "aom_ports/mem.h"
-#include "av1/encoder/corner_match.h"
+#include "aom_dsp/flow_estimation/corner_match.h"
DECLARE_ALIGNED(16, static const uint8_t,
byte_mask[16]) = { 255, 255, 255, 255, 255, 255, 255, 255,
diff --git a/av1/encoder/x86/corner_match_sse4.c b/aom_dsp/flow_estimation/x86/corner_match_sse4.c
similarity index 97%
rename from av1/encoder/x86/corner_match_sse4.c
rename to aom_dsp/flow_estimation/x86/corner_match_sse4.c
index 1a879da..40eec6c 100644
--- a/av1/encoder/x86/corner_match_sse4.c
+++ b/aom_dsp/flow_estimation/x86/corner_match_sse4.c
@@ -16,10 +16,10 @@
#include <smmintrin.h>
-#include "config/av1_rtcd.h"
+#include "config/aom_dsp_rtcd.h"
#include "aom_ports/mem.h"
-#include "av1/encoder/corner_match.h"
+#include "aom_dsp/flow_estimation/corner_match.h"
DECLARE_ALIGNED(16, static const uint8_t,
byte_mask[16]) = { 255, 255, 255, 255, 255, 255, 255, 255,
diff --git a/av1/av1.cmake b/av1/av1.cmake
index 0051fac..ae1eba7 100644
--- a/av1/av1.cmake
+++ b/av1/av1.cmake
@@ -137,10 +137,6 @@
"${AOM_ROOT}/av1/encoder/compound_type.h"
"${AOM_ROOT}/av1/encoder/context_tree.c"
"${AOM_ROOT}/av1/encoder/context_tree.h"
- "${AOM_ROOT}/av1/encoder/corner_detect.c"
- "${AOM_ROOT}/av1/encoder/corner_detect.h"
- "${AOM_ROOT}/av1/encoder/corner_match.c"
- "${AOM_ROOT}/av1/encoder/corner_match.h"
"${AOM_ROOT}/av1/encoder/cost.c"
"${AOM_ROOT}/av1/encoder/cost.h"
"${AOM_ROOT}/av1/encoder/encodeframe.c"
@@ -211,8 +207,6 @@
"${AOM_ROOT}/av1/encoder/picklpf.h"
"${AOM_ROOT}/av1/encoder/pickrst.c"
"${AOM_ROOT}/av1/encoder/pickrst.h"
- "${AOM_ROOT}/av1/encoder/ransac.c"
- "${AOM_ROOT}/av1/encoder/ransac.h"
"${AOM_ROOT}/av1/encoder/ratectrl.c"
"${AOM_ROOT}/av1/encoder/ratectrl.h"
"${AOM_ROOT}/av1/encoder/rc_utils.h"
@@ -335,7 +329,6 @@
list(APPEND AOM_AV1_ENCODER_INTRIN_SSE4_1
"${AOM_ROOT}/av1/encoder/x86/av1_fwd_txfm1d_sse4.c"
"${AOM_ROOT}/av1/encoder/x86/av1_fwd_txfm2d_sse4.c"
- "${AOM_ROOT}/av1/encoder/x86/corner_match_sse4.c"
"${AOM_ROOT}/av1/encoder/x86/encodetxb_sse4.c"
"${AOM_ROOT}/av1/encoder/x86/highbd_fwd_txfm_sse4.c"
"${AOM_ROOT}/av1/encoder/x86/rdopt_sse4.c"
@@ -343,7 +336,6 @@
list(APPEND AOM_AV1_ENCODER_INTRIN_AVX2
"${AOM_ROOT}/av1/encoder/x86/av1_quantize_avx2.c"
- "${AOM_ROOT}/av1/encoder/x86/corner_match_avx2.c"
"${AOM_ROOT}/av1/encoder/x86/error_intrin_avx2.c"
"${AOM_ROOT}/av1/encoder/x86/av1_fwd_txfm_avx2.h"
"${AOM_ROOT}/av1/encoder/x86/av1_fwd_txfm2d_avx2.c"
diff --git a/av1/common/av1_rtcd_defs.pl b/av1/common/av1_rtcd_defs.pl
index ca299aa..b5baaae 100644
--- a/av1/common/av1_rtcd_defs.pl
+++ b/av1/common/av1_rtcd_defs.pl
@@ -554,11 +554,6 @@
add_proto qw/int64_t av1_calc_frame_error/, "const uint8_t *const ref, int stride, const uint8_t *const dst, int p_width, int p_height, int p_stride";
specialize qw/av1_calc_frame_error sse2 avx2/;
-if (aom_config("CONFIG_AV1_ENCODER") eq "yes") {
- add_proto qw/double av1_compute_cross_correlation/, "unsigned char *im1, int stride1, int x1, int y1, unsigned char *im2, int stride2, int x2, int y2";
- specialize qw/av1_compute_cross_correlation sse4_1 avx2/;
-}
-
# LOOP_RESTORATION functions
add_proto qw/void av1_apply_selfguided_restoration/, "const uint8_t *dat, int width, int height, int stride, int eps, const int *xqd, uint8_t *dst, int dst_stride, int32_t *tmpbuf, int bit_depth, int highbd";
specialize qw/av1_apply_selfguided_restoration sse4_1 avx2 neon/;
diff --git a/av1/common/convolve.c b/av1/common/convolve.c
index 63dda39..54b2bb0 100644
--- a/av1/common/convolve.c
+++ b/av1/common/convolve.c
@@ -73,45 +73,6 @@
}
}
-void av1_convolve_2d_sobel_y_c(const uint8_t *src, int src_stride, double *dst,
- int dst_stride, int w, int h, int dir,
- double norm) {
- int16_t im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];
- DECLARE_ALIGNED(256, static const int16_t, sobel_a[3]) = { 1, 0, -1 };
- DECLARE_ALIGNED(256, static const int16_t, sobel_b[3]) = { 1, 2, 1 };
- const int taps = 3;
- int im_h = h + taps - 1;
- int im_stride = w;
- const int fo_vert = 1;
- const int fo_horiz = 1;
-
- // horizontal filter
- const uint8_t *src_horiz = src - fo_vert * src_stride;
- const int16_t *x_filter = dir ? sobel_a : sobel_b;
- for (int y = 0; y < im_h; ++y) {
- for (int x = 0; x < w; ++x) {
- int16_t sum = 0;
- for (int k = 0; k < taps; ++k) {
- sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];
- }
- im_block[y * im_stride + x] = sum;
- }
- }
-
- // vertical filter
- int16_t *src_vert = im_block + fo_vert * im_stride;
- const int16_t *y_filter = dir ? sobel_b : sobel_a;
- for (int y = 0; y < h; ++y) {
- for (int x = 0; x < w; ++x) {
- int16_t sum = 0;
- for (int k = 0; k < taps; ++k) {
- sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];
- }
- dst[y * dst_stride + x] = sum * norm;
- }
- }
-}
-
void av1_convolve_2d_sr_c(const uint8_t *src, int src_stride, uint8_t *dst,
int dst_stride, int w, int h,
const InterpFilterParams *filter_params_x,
diff --git a/av1/common/convolve.h b/av1/common/convolve.h
index f597d8e..36c0c84 100644
--- a/av1/common/convolve.h
+++ b/av1/common/convolve.h
@@ -126,11 +126,6 @@
int scaled, ConvolveParams *conv_params,
int bd);
-// TODO(sarahparker) This will need to be integerized and optimized
-void av1_convolve_2d_sobel_y_c(const uint8_t *src, int src_stride, double *dst,
- int dst_stride, int w, int h, int dir,
- double norm);
-
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/common/mv.h b/av1/common/mv.h
index e70ce90..a61287b 100644
--- a/av1/common/mv.h
+++ b/av1/common/mv.h
@@ -17,6 +17,7 @@
#include "av1/common/common.h"
#include "av1/common/common_data.h"
#include "aom_dsp/aom_filter.h"
+#include "aom_dsp/flow_estimation/flow_estimation.h"
#ifdef __cplusplus
extern "C" {
@@ -107,16 +108,6 @@
#define WARPEDDIFF_PREC_BITS (WARPEDMODEL_PREC_BITS - WARPEDPIXEL_PREC_BITS)
-/* clang-format off */
-enum {
- IDENTITY = 0, // identity transformation, 0-parameter
- TRANSLATION = 1, // translational motion 2-parameter
- ROTZOOM = 2, // simplified affine with rotation + zoom only, 4-parameter
- AFFINE = 3, // affine, 6-parameter
- TRANS_TYPES,
-} UENUM1BYTE(TransformationType);
-/* clang-format on */
-
// Number of types used for global motion (must be >= 3 and <= TRANS_TYPES)
// The following can be useful:
// GLOBAL_TRANS_TYPES 3 - up to rotation-zoom
@@ -130,9 +121,6 @@
int local_warp_allowed;
} WarpTypesAllowed;
-// number of parameters used by each transformation in TransformationTypes
-static const int trans_model_params[TRANS_TYPES] = { 0, 2, 4, 6 };
-
// The order of values in the wmmat matrix below is best described
// by the homography:
// [x' (m2 m3 m0 [x
diff --git a/av1/common/warped_motion.h b/av1/common/warped_motion.h
index 14dc0fe..d6fe325 100644
--- a/av1/common/warped_motion.h
+++ b/av1/common/warped_motion.h
@@ -25,7 +25,6 @@
#include "av1/common/mv.h"
#include "av1/common/convolve.h"
-#define MAX_PARAMDIM 9
#define LEAST_SQUARES_SAMPLES_MAX_BITS 3
#define LEAST_SQUARES_SAMPLES_MAX (1 << LEAST_SQUARES_SAMPLES_MAX_BITS)
#define SAMPLES_ARRAY_SIZE (LEAST_SQUARES_SAMPLES_MAX * 2)
diff --git a/av1/encoder/corner_detect.c b/av1/encoder/corner_detect.c
deleted file mode 100644
index 597bb30..0000000
--- a/av1/encoder/corner_detect.c
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * 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.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <memory.h>
-#include <math.h>
-#include <assert.h>
-
-#include "third_party/fastfeat/fast.h"
-
-#include "av1/encoder/corner_detect.h"
-
-// Fast_9 wrapper
-#define FAST_BARRIER 18
-int av1_fast_corner_detect(unsigned char *buf, int width, int height,
- int stride, int *points, int max_points) {
- int num_points;
- xy *const frm_corners_xy = aom_fast9_detect_nonmax(buf, width, height, stride,
- FAST_BARRIER, &num_points);
- num_points = (num_points <= max_points ? num_points : max_points);
- if (num_points > 0 && frm_corners_xy) {
- memcpy(points, frm_corners_xy, sizeof(*frm_corners_xy) * num_points);
- free(frm_corners_xy);
- return num_points;
- }
- free(frm_corners_xy);
- return 0;
-}
diff --git a/av1/encoder/global_motion.c b/av1/encoder/global_motion.c
index 5e03d79..9e84e53 100644
--- a/av1/encoder/global_motion.c
+++ b/av1/encoder/global_motion.c
@@ -21,50 +21,15 @@
#include "av1/encoder/global_motion.h"
#include "av1/common/convolve.h"
-#include "av1/common/resize.h"
#include "av1/common/warped_motion.h"
#include "av1/encoder/segmentation.h"
-#include "av1/encoder/corner_detect.h"
-#include "av1/encoder/corner_match.h"
-#include "av1/encoder/ransac.h"
-
-#define MIN_INLIER_PROB 0.1
#define MIN_TRANS_THRESH (1 * GM_TRANS_DECODE_FACTOR)
// Border over which to compute the global motion
#define ERRORADV_BORDER 0
-// Number of pyramid levels in disflow computation
-#define N_LEVELS 2
-// Size of square patches in the disflow dense grid
-#define PATCH_SIZE 8
-// Center point of square patch
-#define PATCH_CENTER ((PATCH_SIZE + 1) >> 1)
-// Step size between patches, lower value means greater patch overlap
-#define PATCH_STEP 1
-// Minimum size of border padding for disflow
-#define MIN_PAD 7
-// Warp error convergence threshold for disflow
-#define DISFLOW_ERROR_TR 0.01
-// Max number of iterations if warp convergence is not found
-#define DISFLOW_MAX_ITR 10
-
-// Struct for an image pyramid
-typedef struct {
- int n_levels;
- int pad_size;
- int has_gradient;
- int widths[N_LEVELS];
- int heights[N_LEVELS];
- int strides[N_LEVELS];
- int level_loc[N_LEVELS];
- unsigned char *level_buffer;
- double *level_dx_buffer;
- double *level_dy_buffer;
-} ImagePyramid;
-
int av1_is_enough_erroradvantage(double best_erroradvantage, int params_cost) {
return best_erroradvantage < erroradv_tr &&
best_erroradvantage * params_cost < erroradv_prod_tr;
@@ -358,39 +323,6 @@
return best_error;
}
-unsigned char *av1_downconvert_frame(YV12_BUFFER_CONFIG *frm, int bit_depth) {
- int i, j;
- uint16_t *orig_buf = CONVERT_TO_SHORTPTR(frm->y_buffer);
- uint8_t *buf_8bit = frm->y_buffer_8bit;
- assert(buf_8bit);
- if (!frm->buf_8bit_valid) {
- for (i = 0; i < frm->y_height; ++i) {
- for (j = 0; j < frm->y_width; ++j) {
- buf_8bit[i * frm->y_stride + j] =
- orig_buf[i * frm->y_stride + j] >> (bit_depth - 8);
- }
- }
- frm->buf_8bit_valid = 1;
- }
- return buf_8bit;
-}
-
-static bool get_inliers_from_indices(MotionModel *params,
- int *correspondences) {
- int *inliers_tmp = (int *)aom_malloc(2 * MAX_CORNERS * sizeof(*inliers_tmp));
- if (!inliers_tmp) return false;
- memset(inliers_tmp, 0, 2 * MAX_CORNERS * sizeof(*inliers_tmp));
-
- for (int i = 0; i < params->num_inliers; i++) {
- int index = params->inliers[i];
- inliers_tmp[2 * i] = correspondences[4 * index];
- inliers_tmp[2 * i + 1] = correspondences[4 * index + 1];
- }
- memcpy(params->inliers, inliers_tmp, sizeof(*inliers_tmp) * 2 * MAX_CORNERS);
- aom_free(inliers_tmp);
- return true;
-}
-
#define FEAT_COUNT_TR 3
#define SEG_COUNT_TR 0.40
void av1_compute_feature_segmentation_map(uint8_t *segment_map, int width,
@@ -420,625 +352,3 @@
if (seg_count < (width * height * SEG_COUNT_TR))
memset(segment_map, 1, width * height * sizeof(*segment_map));
}
-
-static int compute_global_motion_feature_based(
- TransformationType type, unsigned char *src_buffer, int src_width,
- int src_height, int src_stride, int *src_corners, int num_src_corners,
- YV12_BUFFER_CONFIG *ref, int bit_depth, int *num_inliers_by_motion,
- MotionModel *params_by_motion, int num_motions) {
- int i;
- int num_ref_corners;
- int num_correspondences;
- int *correspondences;
- int ref_corners[2 * MAX_CORNERS];
- unsigned char *ref_buffer = ref->y_buffer;
- RansacFunc ransac = av1_get_ransac_type(type);
-
- if (ref->flags & YV12_FLAG_HIGHBITDEPTH) {
- ref_buffer = av1_downconvert_frame(ref, bit_depth);
- }
-
- num_ref_corners =
- av1_fast_corner_detect(ref_buffer, ref->y_width, ref->y_height,
- ref->y_stride, ref_corners, MAX_CORNERS);
-
- // find correspondences between the two images
- correspondences =
- (int *)malloc(num_src_corners * 4 * sizeof(*correspondences));
- if (!correspondences) return 0;
- num_correspondences = av1_determine_correspondence(
- src_buffer, (int *)src_corners, num_src_corners, ref_buffer,
- (int *)ref_corners, num_ref_corners, src_width, src_height, src_stride,
- ref->y_stride, correspondences);
-
- ransac(correspondences, num_correspondences, num_inliers_by_motion,
- params_by_motion, num_motions);
-
- // Set num_inliers = 0 for motions with too few inliers so they are ignored.
- for (i = 0; i < num_motions; ++i) {
- if (num_inliers_by_motion[i] < MIN_INLIER_PROB * num_correspondences ||
- num_correspondences == 0) {
- num_inliers_by_motion[i] = 0;
- } else if (!get_inliers_from_indices(¶ms_by_motion[i],
- correspondences)) {
- free(correspondences);
- return 0;
- }
- }
-
- free(correspondences);
-
- // Return true if any one of the motions has inliers.
- for (i = 0; i < num_motions; ++i) {
- if (num_inliers_by_motion[i] > 0) return 1;
- }
- return 0;
-}
-
-// Don't use points around the frame border since they are less reliable
-static INLINE int valid_point(int x, int y, int width, int height) {
- return (x > (PATCH_SIZE + PATCH_CENTER)) &&
- (x < (width - PATCH_SIZE - PATCH_CENTER)) &&
- (y > (PATCH_SIZE + PATCH_CENTER)) &&
- (y < (height - PATCH_SIZE - PATCH_CENTER));
-}
-
-static int determine_disflow_correspondence(int *frm_corners,
- int num_frm_corners, double *flow_u,
- double *flow_v, int width,
- int height, int stride,
- double *correspondences) {
- int num_correspondences = 0;
- int x, y;
- for (int i = 0; i < num_frm_corners; ++i) {
- x = frm_corners[2 * i];
- y = frm_corners[2 * i + 1];
- if (valid_point(x, y, width, height)) {
- correspondences[4 * num_correspondences] = x;
- correspondences[4 * num_correspondences + 1] = y;
- correspondences[4 * num_correspondences + 2] = x + flow_u[y * stride + x];
- correspondences[4 * num_correspondences + 3] = y + flow_v[y * stride + x];
- num_correspondences++;
- }
- }
- return num_correspondences;
-}
-
-static double getCubicValue(double p[4], double x) {
- return p[1] + 0.5 * x *
- (p[2] - p[0] +
- x * (2.0 * p[0] - 5.0 * p[1] + 4.0 * p[2] - p[3] +
- x * (3.0 * (p[1] - p[2]) + p[3] - p[0])));
-}
-
-static void get_subcolumn(unsigned char *ref, double col[4], int stride, int x,
- int y_start) {
- int i;
- for (i = 0; i < 4; ++i) {
- col[i] = ref[(i + y_start) * stride + x];
- }
-}
-
-static double bicubic(unsigned char *ref, double x, double y, int stride) {
- double arr[4];
- int k;
- int i = (int)x;
- int j = (int)y;
- for (k = 0; k < 4; ++k) {
- double arr_temp[4];
- get_subcolumn(ref, arr_temp, stride, i + k - 1, j - 1);
- arr[k] = getCubicValue(arr_temp, y - j);
- }
- return getCubicValue(arr, x - i);
-}
-
-// Interpolate a warped block using bicubic interpolation when possible
-static unsigned char interpolate(unsigned char *ref, double x, double y,
- int width, int height, int stride) {
- if (x < 0 && y < 0)
- return ref[0];
- else if (x < 0 && y > height - 1)
- return ref[(height - 1) * stride];
- else if (x > width - 1 && y < 0)
- return ref[width - 1];
- else if (x > width - 1 && y > height - 1)
- return ref[(height - 1) * stride + (width - 1)];
- else if (x < 0) {
- int v;
- int i = (int)y;
- double a = y - i;
- if (y > 1 && y < height - 2) {
- double arr[4];
- get_subcolumn(ref, arr, stride, 0, i - 1);
- return clamp((int)(getCubicValue(arr, a) + 0.5), 0, 255);
- }
- v = (int)(ref[i * stride] * (1 - a) + ref[(i + 1) * stride] * a + 0.5);
- return clamp(v, 0, 255);
- } else if (y < 0) {
- int v;
- int j = (int)x;
- double b = x - j;
- if (x > 1 && x < width - 2) {
- double arr[4] = { ref[j - 1], ref[j], ref[j + 1], ref[j + 2] };
- return clamp((int)(getCubicValue(arr, b) + 0.5), 0, 255);
- }
- v = (int)(ref[j] * (1 - b) + ref[j + 1] * b + 0.5);
- return clamp(v, 0, 255);
- } else if (x > width - 1) {
- int v;
- int i = (int)y;
- double a = y - i;
- if (y > 1 && y < height - 2) {
- double arr[4];
- get_subcolumn(ref, arr, stride, width - 1, i - 1);
- return clamp((int)(getCubicValue(arr, a) + 0.5), 0, 255);
- }
- v = (int)(ref[i * stride + width - 1] * (1 - a) +
- ref[(i + 1) * stride + width - 1] * a + 0.5);
- return clamp(v, 0, 255);
- } else if (y > height - 1) {
- int v;
- int j = (int)x;
- double b = x - j;
- if (x > 1 && x < width - 2) {
- int row = (height - 1) * stride;
- double arr[4] = { ref[row + j - 1], ref[row + j], ref[row + j + 1],
- ref[row + j + 2] };
- return clamp((int)(getCubicValue(arr, b) + 0.5), 0, 255);
- }
- v = (int)(ref[(height - 1) * stride + j] * (1 - b) +
- ref[(height - 1) * stride + j + 1] * b + 0.5);
- return clamp(v, 0, 255);
- } else if (x > 1 && y > 1 && x < width - 2 && y < height - 2) {
- return clamp((int)(bicubic(ref, x, y, stride) + 0.5), 0, 255);
- } else {
- int i = (int)y;
- int j = (int)x;
- double a = y - i;
- double b = x - j;
- int v = (int)(ref[i * stride + j] * (1 - a) * (1 - b) +
- ref[i * stride + j + 1] * (1 - a) * b +
- ref[(i + 1) * stride + j] * a * (1 - b) +
- ref[(i + 1) * stride + j + 1] * a * b);
- return clamp(v, 0, 255);
- }
-}
-
-// Warps a block using flow vector [u, v] and computes the mse
-static double compute_warp_and_error(unsigned char *ref, unsigned char *frm,
- int width, int height, int stride, int x,
- int y, double u, double v, int16_t *dt) {
- int i, j;
- unsigned char warped;
- double x_w, y_w;
- double mse = 0;
- int16_t err = 0;
- for (i = y; i < y + PATCH_SIZE; ++i)
- for (j = x; j < x + PATCH_SIZE; ++j) {
- x_w = (double)j + u;
- y_w = (double)i + v;
- warped = interpolate(ref, x_w, y_w, width, height, stride);
- err = warped - frm[j + i * stride];
- mse += err * err;
- dt[(i - y) * PATCH_SIZE + (j - x)] = err;
- }
-
- mse /= (PATCH_SIZE * PATCH_SIZE);
- return mse;
-}
-
-// Computes the components of the system of equations used to solve for
-// a flow vector. This includes:
-// 1.) The hessian matrix for optical flow. This matrix is in the
-// form of:
-//
-// M = |sum(dx * dx) sum(dx * dy)|
-// |sum(dx * dy) sum(dy * dy)|
-//
-// 2.) b = |sum(dx * dt)|
-// |sum(dy * dt)|
-// Where the sums are computed over a square window of PATCH_SIZE.
-static INLINE void compute_flow_system(const double *dx, int dx_stride,
- const double *dy, int dy_stride,
- const int16_t *dt, int dt_stride,
- double *M, double *b) {
- for (int i = 0; i < PATCH_SIZE; i++) {
- for (int j = 0; j < PATCH_SIZE; j++) {
- M[0] += dx[i * dx_stride + j] * dx[i * dx_stride + j];
- M[1] += dx[i * dx_stride + j] * dy[i * dy_stride + j];
- M[3] += dy[i * dy_stride + j] * dy[i * dy_stride + j];
-
- b[0] += dx[i * dx_stride + j] * dt[i * dt_stride + j];
- b[1] += dy[i * dy_stride + j] * dt[i * dt_stride + j];
- }
- }
-
- M[2] = M[1];
-}
-
-// Solves a general Mx = b where M is a 2x2 matrix and b is a 2x1 matrix
-static INLINE void solve_2x2_system(const double *M, const double *b,
- double *output_vec) {
- double M_0 = M[0];
- double M_3 = M[3];
- double det = (M_0 * M_3) - (M[1] * M[2]);
- if (det < 1e-5) {
- // Handle singular matrix
- // TODO(sarahparker) compare results using pseudo inverse instead
- M_0 += 1e-10;
- M_3 += 1e-10;
- det = (M_0 * M_3) - (M[1] * M[2]);
- }
- const double det_inv = 1 / det;
- const double mult_b0 = det_inv * b[0];
- const double mult_b1 = det_inv * b[1];
- output_vec[0] = M_3 * mult_b0 - M[1] * mult_b1;
- output_vec[1] = -M[2] * mult_b0 + M_0 * mult_b1;
-}
-
-/*
-static INLINE void image_difference(const uint8_t *src, int src_stride,
- const uint8_t *ref, int ref_stride,
- int16_t *dst, int dst_stride, int height,
- int width) {
- const int block_unit = 8;
- // Take difference in 8x8 blocks to make use of optimized diff function
- for (int i = 0; i < height; i += block_unit) {
- for (int j = 0; j < width; j += block_unit) {
- aom_subtract_block(block_unit, block_unit, dst + i * dst_stride + j,
- dst_stride, src + i * src_stride + j, src_stride,
- ref + i * ref_stride + j, ref_stride);
- }
- }
-}
-*/
-
-// Compute an image gradient using a sobel filter.
-// If dir == 1, compute the x gradient. If dir == 0, compute y. This function
-// assumes the images have been padded so that they can be processed in units
-// of 8.
-static INLINE void sobel_xy_image_gradient(const uint8_t *src, int src_stride,
- double *dst, int dst_stride,
- int height, int width, int dir) {
- double norm = 1.0;
- // TODO(sarahparker) experiment with doing this over larger block sizes
- const int block_unit = 8;
- // Filter in 8x8 blocks to eventually make use of optimized convolve function
- for (int i = 0; i < height; i += block_unit) {
- for (int j = 0; j < width; j += block_unit) {
- av1_convolve_2d_sobel_y_c(src + i * src_stride + j, src_stride,
- dst + i * dst_stride + j, dst_stride,
- block_unit, block_unit, dir, norm);
- }
- }
-}
-
-static void free_pyramid(ImagePyramid *pyr) {
- aom_free(pyr->level_buffer);
- if (pyr->has_gradient) {
- aom_free(pyr->level_dx_buffer);
- aom_free(pyr->level_dy_buffer);
- }
- aom_free(pyr);
-}
-
-static ImagePyramid *alloc_pyramid(int width, int height, int pad_size,
- int compute_gradient) {
- ImagePyramid *pyr = aom_calloc(1, sizeof(*pyr));
- if (!pyr) return NULL;
- pyr->has_gradient = compute_gradient;
- // 2 * width * height is the upper bound for a buffer that fits
- // all pyramid levels + padding for each level
- const int buffer_size = sizeof(*pyr->level_buffer) * 2 * width * height +
- (width + 2 * pad_size) * 2 * pad_size * N_LEVELS;
- pyr->level_buffer = aom_malloc(buffer_size);
- if (!pyr->level_buffer) {
- free_pyramid(pyr);
- return NULL;
- }
- memset(pyr->level_buffer, 0, buffer_size);
-
- if (compute_gradient) {
- const int gradient_size =
- sizeof(*pyr->level_dx_buffer) * 2 * width * height +
- (width + 2 * pad_size) * 2 * pad_size * N_LEVELS;
- pyr->level_dx_buffer = aom_calloc(1, gradient_size);
- pyr->level_dy_buffer = aom_calloc(1, gradient_size);
- if (!(pyr->level_dx_buffer && pyr->level_dy_buffer)) {
- free_pyramid(pyr);
- return NULL;
- }
- }
- return pyr;
-}
-
-static INLINE void update_level_dims(ImagePyramid *frm_pyr, int level) {
- frm_pyr->widths[level] = frm_pyr->widths[level - 1] >> 1;
- frm_pyr->heights[level] = frm_pyr->heights[level - 1] >> 1;
- frm_pyr->strides[level] = frm_pyr->widths[level] + 2 * frm_pyr->pad_size;
- // Point the beginning of the next level buffer to the correct location inside
- // the padded border
- frm_pyr->level_loc[level] =
- frm_pyr->level_loc[level - 1] +
- frm_pyr->strides[level - 1] *
- (2 * frm_pyr->pad_size + frm_pyr->heights[level - 1]);
-}
-
-// Compute coarse to fine pyramids for a frame
-static void compute_flow_pyramids(unsigned char *frm, const int frm_width,
- const int frm_height, const int frm_stride,
- int n_levels, int pad_size, int compute_grad,
- ImagePyramid *frm_pyr) {
- int cur_width, cur_height, cur_stride, cur_loc;
- assert((frm_width >> n_levels) > 0);
- assert((frm_height >> n_levels) > 0);
-
- // Initialize first level
- frm_pyr->n_levels = n_levels;
- frm_pyr->pad_size = pad_size;
- frm_pyr->widths[0] = frm_width;
- frm_pyr->heights[0] = frm_height;
- frm_pyr->strides[0] = frm_width + 2 * frm_pyr->pad_size;
- // Point the beginning of the level buffer to the location inside
- // the padded border
- frm_pyr->level_loc[0] =
- frm_pyr->strides[0] * frm_pyr->pad_size + frm_pyr->pad_size;
- // This essentially copies the original buffer into the pyramid buffer
- // without the original padding
- av1_resize_plane(frm, frm_height, frm_width, frm_stride,
- frm_pyr->level_buffer + frm_pyr->level_loc[0],
- frm_pyr->heights[0], frm_pyr->widths[0],
- frm_pyr->strides[0]);
-
- if (compute_grad) {
- cur_width = frm_pyr->widths[0];
- cur_height = frm_pyr->heights[0];
- cur_stride = frm_pyr->strides[0];
- cur_loc = frm_pyr->level_loc[0];
- assert(frm_pyr->has_gradient && frm_pyr->level_dx_buffer != NULL &&
- frm_pyr->level_dy_buffer != NULL);
- // Computation x gradient
- sobel_xy_image_gradient(frm_pyr->level_buffer + cur_loc, cur_stride,
- frm_pyr->level_dx_buffer + cur_loc, cur_stride,
- cur_height, cur_width, 1);
-
- // Computation y gradient
- sobel_xy_image_gradient(frm_pyr->level_buffer + cur_loc, cur_stride,
- frm_pyr->level_dy_buffer + cur_loc, cur_stride,
- cur_height, cur_width, 0);
- }
-
- // Start at the finest level and resize down to the coarsest level
- for (int level = 1; level < n_levels; ++level) {
- update_level_dims(frm_pyr, level);
- cur_width = frm_pyr->widths[level];
- cur_height = frm_pyr->heights[level];
- cur_stride = frm_pyr->strides[level];
- cur_loc = frm_pyr->level_loc[level];
-
- av1_resize_plane(frm_pyr->level_buffer + frm_pyr->level_loc[level - 1],
- frm_pyr->heights[level - 1], frm_pyr->widths[level - 1],
- frm_pyr->strides[level - 1],
- frm_pyr->level_buffer + cur_loc, cur_height, cur_width,
- cur_stride);
-
- if (compute_grad) {
- assert(frm_pyr->has_gradient && frm_pyr->level_dx_buffer != NULL &&
- frm_pyr->level_dy_buffer != NULL);
- // Computation x gradient
- sobel_xy_image_gradient(frm_pyr->level_buffer + cur_loc, cur_stride,
- frm_pyr->level_dx_buffer + cur_loc, cur_stride,
- cur_height, cur_width, 1);
-
- // Computation y gradient
- sobel_xy_image_gradient(frm_pyr->level_buffer + cur_loc, cur_stride,
- frm_pyr->level_dy_buffer + cur_loc, cur_stride,
- cur_height, cur_width, 0);
- }
- }
-}
-
-static INLINE void compute_flow_at_point(unsigned char *frm, unsigned char *ref,
- double *dx, double *dy, int x, int y,
- int width, int height, int stride,
- double *u, double *v) {
- double M[4] = { 0 };
- double b[2] = { 0 };
- double tmp_output_vec[2] = { 0 };
- double error = 0;
- int16_t dt[PATCH_SIZE * PATCH_SIZE];
- double o_u = *u;
- double o_v = *v;
-
- for (int itr = 0; itr < DISFLOW_MAX_ITR; itr++) {
- error = compute_warp_and_error(ref, frm, width, height, stride, x, y, *u,
- *v, dt);
- if (error <= DISFLOW_ERROR_TR) break;
- compute_flow_system(dx, stride, dy, stride, dt, PATCH_SIZE, M, b);
- solve_2x2_system(M, b, tmp_output_vec);
- *u += tmp_output_vec[0];
- *v += tmp_output_vec[1];
- }
- if (fabs(*u - o_u) > PATCH_SIZE || fabs(*v - o_u) > PATCH_SIZE) {
- *u = o_u;
- *v = o_v;
- }
-}
-
-// make sure flow_u and flow_v start at 0
-static bool compute_flow_field(ImagePyramid *frm_pyr, ImagePyramid *ref_pyr,
- double *flow_u, double *flow_v) {
- int cur_width, cur_height, cur_stride, cur_loc, patch_loc, patch_center;
- double *u_upscale =
- aom_malloc(frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_u));
- double *v_upscale =
- aom_malloc(frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_v));
- if (!(u_upscale && v_upscale)) {
- aom_free(u_upscale);
- aom_free(v_upscale);
- return false;
- }
-
- assert(frm_pyr->n_levels == ref_pyr->n_levels);
-
- // Compute flow field from coarsest to finest level of the pyramid
- for (int level = frm_pyr->n_levels - 1; level >= 0; --level) {
- cur_width = frm_pyr->widths[level];
- cur_height = frm_pyr->heights[level];
- cur_stride = frm_pyr->strides[level];
- cur_loc = frm_pyr->level_loc[level];
-
- for (int i = PATCH_SIZE; i < cur_height - PATCH_SIZE; i += PATCH_STEP) {
- for (int j = PATCH_SIZE; j < cur_width - PATCH_SIZE; j += PATCH_STEP) {
- patch_loc = i * cur_stride + j;
- patch_center = patch_loc + PATCH_CENTER * cur_stride + PATCH_CENTER;
- compute_flow_at_point(frm_pyr->level_buffer + cur_loc,
- ref_pyr->level_buffer + cur_loc,
- frm_pyr->level_dx_buffer + cur_loc + patch_loc,
- frm_pyr->level_dy_buffer + cur_loc + patch_loc, j,
- i, cur_width, cur_height, cur_stride,
- flow_u + patch_center, flow_v + patch_center);
- }
- }
- // TODO(sarahparker) Replace this with upscale function in resize.c
- if (level > 0) {
- int h_upscale = frm_pyr->heights[level - 1];
- int w_upscale = frm_pyr->widths[level - 1];
- int s_upscale = frm_pyr->strides[level - 1];
- for (int i = 0; i < h_upscale; ++i) {
- for (int j = 0; j < w_upscale; ++j) {
- u_upscale[j + i * s_upscale] =
- flow_u[(int)(j >> 1) + (int)(i >> 1) * cur_stride];
- v_upscale[j + i * s_upscale] =
- flow_v[(int)(j >> 1) + (int)(i >> 1) * cur_stride];
- }
- }
- memcpy(flow_u, u_upscale,
- frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_u));
- memcpy(flow_v, v_upscale,
- frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_v));
- }
- }
- aom_free(u_upscale);
- aom_free(v_upscale);
- return true;
-}
-
-static int compute_global_motion_disflow_based(
- TransformationType type, unsigned char *frm_buffer, int frm_width,
- int frm_height, int frm_stride, int *frm_corners, int num_frm_corners,
- YV12_BUFFER_CONFIG *ref, int bit_depth, int *num_inliers_by_motion,
- MotionModel *params_by_motion, int num_motions) {
- unsigned char *ref_buffer = ref->y_buffer;
- const int ref_width = ref->y_width;
- const int ref_height = ref->y_height;
- const int pad_size = AOMMAX(PATCH_SIZE, MIN_PAD);
- int num_correspondences;
- double *correspondences;
- RansacFuncDouble ransac = av1_get_ransac_double_prec_type(type);
- assert(frm_width == ref_width);
- assert(frm_height == ref_height);
-
- // Ensure the number of pyramid levels will work with the frame resolution
- const int msb =
- frm_width < frm_height ? get_msb(frm_width) : get_msb(frm_height);
- const int n_levels = AOMMIN(msb, N_LEVELS);
-
- if (ref->flags & YV12_FLAG_HIGHBITDEPTH) {
- ref_buffer = av1_downconvert_frame(ref, bit_depth);
- }
-
- // TODO(sarahparker) We will want to do the source pyramid computation
- // outside of this function so it doesn't get recomputed for every
- // reference. We also don't need to compute every pyramid level for the
- // reference in advance, since lower levels can be overwritten once their
- // flow field is computed and upscaled. I'll add these optimizations
- // once the full implementation is working.
- // Allocate frm image pyramids
- int compute_gradient = 1;
- ImagePyramid *frm_pyr =
- alloc_pyramid(frm_width, frm_height, pad_size, compute_gradient);
- if (!frm_pyr) return 0;
- compute_flow_pyramids(frm_buffer, frm_width, frm_height, frm_stride, n_levels,
- pad_size, compute_gradient, frm_pyr);
- // Allocate ref image pyramids
- compute_gradient = 0;
- ImagePyramid *ref_pyr =
- alloc_pyramid(ref_width, ref_height, pad_size, compute_gradient);
- if (!ref_pyr) {
- free_pyramid(frm_pyr);
- return 0;
- }
- compute_flow_pyramids(ref_buffer, ref_width, ref_height, ref->y_stride,
- n_levels, pad_size, compute_gradient, ref_pyr);
-
- int ret = 0;
- double *flow_u =
- aom_malloc(frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_u));
- double *flow_v =
- aom_malloc(frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_v));
- if (!(flow_u && flow_v)) goto Error;
-
- memset(flow_u, 0,
- frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_u));
- memset(flow_v, 0,
- frm_pyr->strides[0] * frm_pyr->heights[0] * sizeof(*flow_v));
-
- if (!compute_flow_field(frm_pyr, ref_pyr, flow_u, flow_v)) goto Error;
-
- // find correspondences between the two images using the flow field
- correspondences = aom_malloc(num_frm_corners * 4 * sizeof(*correspondences));
- if (!correspondences) goto Error;
- num_correspondences = determine_disflow_correspondence(
- frm_corners, num_frm_corners, flow_u, flow_v, frm_width, frm_height,
- frm_pyr->strides[0], correspondences);
- ransac(correspondences, num_correspondences, num_inliers_by_motion,
- params_by_motion, num_motions);
-
- // Set num_inliers = 0 for motions with too few inliers so they are ignored.
- for (int i = 0; i < num_motions; ++i) {
- if (num_inliers_by_motion[i] < MIN_INLIER_PROB * num_correspondences) {
- num_inliers_by_motion[i] = 0;
- }
- }
-
- // Return true if any one of the motions has inliers.
- for (int i = 0; i < num_motions; ++i) {
- if (num_inliers_by_motion[i] > 0) {
- ret = 1;
- break;
- }
- }
-
- aom_free(correspondences);
-Error:
- free_pyramid(frm_pyr);
- free_pyramid(ref_pyr);
- aom_free(flow_u);
- aom_free(flow_v);
- return ret;
-}
-
-int av1_compute_global_motion(TransformationType type,
- unsigned char *src_buffer, int src_width,
- int src_height, int src_stride, int *src_corners,
- int num_src_corners, YV12_BUFFER_CONFIG *ref,
- int bit_depth,
- GlobalMotionEstimationType gm_estimation_type,
- int *num_inliers_by_motion,
- MotionModel *params_by_motion, int num_motions) {
- switch (gm_estimation_type) {
- case GLOBAL_MOTION_FEATURE_BASED:
- return compute_global_motion_feature_based(
- type, src_buffer, src_width, src_height, src_stride, src_corners,
- num_src_corners, ref, bit_depth, num_inliers_by_motion,
- params_by_motion, num_motions);
- case GLOBAL_MOTION_DISFLOW_BASED:
- return compute_global_motion_disflow_based(
- type, src_buffer, src_width, src_height, src_stride, src_corners,
- num_src_corners, ref, bit_depth, num_inliers_by_motion,
- params_by_motion, num_motions);
- default: assert(0 && "Unknown global motion estimation type");
- }
- return 0;
-}
diff --git a/av1/encoder/global_motion.h b/av1/encoder/global_motion.h
index a70bfa8..4fa3253 100644
--- a/av1/encoder/global_motion.h
+++ b/av1/encoder/global_motion.h
@@ -13,34 +13,18 @@
#define AOM_AV1_ENCODER_GLOBAL_MOTION_H_
#include "aom/aom_integer.h"
+#include "aom_dsp/flow_estimation/flow_estimation.h"
#include "aom_scale/yv12config.h"
#include "aom_util/aom_thread.h"
-#include "av1/common/mv.h"
-#include "av1/common/warped_motion.h"
-
#ifdef __cplusplus
extern "C" {
#endif
-#define MAX_CORNERS 4096
#define RANSAC_NUM_MOTIONS 1
#define GM_REFINEMENT_COUNT 5
#define MAX_DIRECTIONS 2
-typedef enum {
- GLOBAL_MOTION_FEATURE_BASED,
- GLOBAL_MOTION_DISFLOW_BASED,
-} GlobalMotionEstimationType;
-
-unsigned char *av1_downconvert_frame(YV12_BUFFER_CONFIG *frm, int bit_depth);
-
-typedef struct {
- double params[MAX_PARAMDIM - 1];
- int *inliers;
- int num_inliers;
-} MotionModel;
-
// The structure holds a valid reference frame type and its temporal distance
// from the source frame.
typedef struct {
@@ -129,29 +113,6 @@
int64_t best_frame_error, uint8_t *segment_map, int segment_map_stride,
int64_t erroradv_threshold);
-/*
- Computes "num_motions" candidate global motion parameters between two frames.
- The array "params_by_motion" should be length 8 * "num_motions". The ordering
- of each set of parameters is best described by the homography:
-
- [x' (m2 m3 m0 [x
- z . y' = m4 m5 m1 * y
- 1] m6 m7 1) 1]
-
- where m{i} represents the ith value in any given set of parameters.
-
- "num_inliers" should be length "num_motions", and will be populated with the
- number of inlier feature points for each motion. Params for which the
- num_inliers entry is 0 should be ignored by the caller.
-*/
-int av1_compute_global_motion(TransformationType type,
- unsigned char *src_buffer, int src_width,
- int src_height, int src_stride, int *src_corners,
- int num_src_corners, YV12_BUFFER_CONFIG *ref,
- int bit_depth,
- GlobalMotionEstimationType gm_estimation_type,
- int *num_inliers_by_motion,
- MotionModel *params_by_motion, int num_motions);
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/encoder/global_motion_facade.c b/av1/encoder/global_motion_facade.c
index 5cddc7e..cdcaf65 100644
--- a/av1/encoder/global_motion_facade.c
+++ b/av1/encoder/global_motion_facade.c
@@ -11,7 +11,9 @@
#include "aom_dsp/binary_codes_writer.h"
-#include "av1/encoder/corner_detect.h"
+#include "aom_dsp/flow_estimation/corner_detect.h"
+#include "aom_dsp/flow_estimation/flow_estimation.h"
+#include "av1/common/warped_motion.h"
#include "av1/encoder/encoder.h"
#include "av1/encoder/ethread.h"
#include "av1/encoder/rdopt.h"
@@ -121,7 +123,7 @@
params_by_motion[i].num_inliers = 0;
}
- av1_compute_global_motion(model, src_buffer, src_width, src_height,
+ aom_compute_global_motion(model, src_buffer, src_width, src_height,
src_stride, src_corners, num_src_corners,
ref_buf[frame], cpi->common.seq_params->bit_depth,
gm_estimation_type, inliers_by_motion,
diff --git a/test/corner_match_test.cc b/test/corner_match_test.cc
index e59cc27..673205a 100644
--- a/test/corner_match_test.cc
+++ b/test/corner_match_test.cc
@@ -12,14 +12,14 @@
#include <new>
#include <tuple>
-#include "config/av1_rtcd.h"
+#include "config/aom_dsp_rtcd.h"
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
#include "test/acm_random.h"
#include "test/util.h"
#include "test/register_state_check.h"
-#include "av1/encoder/corner_match.h"
+#include "aom_dsp/flow_estimation/corner_match.h"
namespace test_libaom {
diff --git a/test/test.cmake b/test/test.cmake
index 3959d23..398f1e5 100644
--- a/test/test.cmake
+++ b/test/test.cmake
@@ -204,9 +204,13 @@
"${AOM_ROOT}/test/av1_k_means_test.cc")
list(APPEND AOM_UNIT_TEST_ENCODER_INTRIN_SSE4_1
- "${AOM_ROOT}/test/corner_match_test.cc"
"${AOM_ROOT}/test/simd_cmp_sse4.cc")
+ if(NOT CONFIG_REALTIME_ONLY)
+ list(APPEND AOM_UNIT_TEST_ENCODER_INTRIN_SSE4_1
+ "${AOM_ROOT}/test/corner_match_test.cc")
+ endif()
+
if(CONFIG_ACCOUNTING)
list(APPEND AOM_UNIT_TEST_COMMON_SOURCES
"${AOM_ROOT}/test/accounting_test.cc")
