Implicit weighted prediction experiment
Adds an experiment to use a weighted prediction of two INTER
predictors, where the weight is one of (1/4, 3/4), (3/8, 5/8),
(1/2, 1/2), (5/8, 3/8) or (3/4, 1/4), and is chosen implicitly
based on consistency of the predictors to the already
reconstructed pixels to the top and left of the current macroblock
or superblock.
Currently the weighting is not applied to SPLITMV modes, which
default to the usual (1/2, 1/2) weighting. However the code is in
place controlled by a macro. The same weighting is used for Y and
UV components, where the weight is derived from analyzing the Y
component only.
Results (over compound inter-intra experiment)
derf: +0.18%
yt: +0.34%
hd: +0.49%
stdhd: +0.23%
The experiment suggests bigger benefit for explicitly signaled weights.
Change-Id: I5438539ff4485c5752874cd1eb078ff14bf5235a
diff --git a/configure b/configure
index a791ae5..dea79dd 100755
--- a/configure
+++ b/configure
@@ -249,6 +249,7 @@
useselectrefmv
modelcoefprob
loop_dering
+ implicit_compoundinter_weight
"
CONFIG_LIST="
external_build
diff --git a/vp9/common/vp9_blockd.h b/vp9/common/vp9_blockd.h
index 3dfef41..23d0bfd 100644
--- a/vp9/common/vp9_blockd.h
+++ b/vp9/common/vp9_blockd.h
@@ -288,7 +288,11 @@
int y_den;
int y_offset_q4;
int y_step_q4;
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+ convolve_fn_t predict[2][2][8]; // horiz, vert, weight (0 - 7)
+#else
convolve_fn_t predict[2][2][2]; // horiz, vert, avg
+#endif
};
typedef struct macroblockd {
diff --git a/vp9/common/vp9_convolve.c b/vp9/common/vp9_convolve.c
index b062e7d..3ab8bec 100644
--- a/vp9/common/vp9_convolve.c
+++ b/vp9/common/vp9_convolve.c
@@ -122,6 +122,78 @@
}
}
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+
+static inline uint8_t combine_qtr(uint8_t a, uint8_t b) {
+ return (((a) + (b) * 3 + 2) >> 2);
+}
+
+static inline uint8_t combine_3qtr(uint8_t a, uint8_t b) {
+ return (((a) * 3 + (b) + 2) >> 2);
+}
+
+static inline uint8_t combine_1by8(uint8_t a, uint8_t b) {
+ return (((a) * 1 + (b) * 7 + 4) >> 3);
+}
+
+static inline uint8_t combine_3by8(uint8_t a, uint8_t b) {
+ return (((a) * 3 + (b) * 5 + 4) >> 3);
+}
+
+static inline uint8_t combine_5by8(uint8_t a, uint8_t b) {
+ return (((a) * 5 + (b) * 3 + 4) >> 3);
+}
+
+static inline uint8_t combine_7by8(uint8_t a, uint8_t b) {
+ return (((a) * 7 + (b) * 1 + 4) >> 3);
+}
+
+// TODO(debargha): Implment with a separate weight parameter
+static void convolve_wtd_horiz_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x0, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h, int taps,
+ uint8_t (*combine)(uint8_t a, uint8_t b)) {
+ int x, y, k, sum;
+ const int16_t *filter_x_base = filter_x0;
+
+#if ALIGN_FILTERS_256
+ filter_x_base = (const int16_t *)(((intptr_t)filter_x0) & ~(intptr_t)0xff);
+#endif
+
+ /* Adjust base pointer address for this source line */
+ src -= taps / 2 - 1;
+
+ for (y = 0; y < h; ++y) {
+ /* Pointer to filter to use */
+ const int16_t *filter_x = filter_x0;
+
+ /* Initial phase offset */
+ int x0_q4 = (filter_x - filter_x_base) / taps;
+ int x_q4 = x0_q4;
+
+ for (x = 0; x < w; ++x) {
+ /* Per-pixel src offset */
+ int src_x = (x_q4 - x0_q4) >> 4;
+
+ for (sum = 0, k = 0; k < taps; ++k) {
+ sum += src[src_x + k] * filter_x[k];
+ }
+ sum += (VP9_FILTER_WEIGHT >> 1);
+ dst[x] = combine(dst[x], clip_pixel(sum >> VP9_FILTER_SHIFT));
+
+ /* Adjust source and filter to use for the next pixel */
+ x_q4 += x_step_q4;
+ filter_x = filter_x_base + (x_q4 & 0xf) * taps;
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+}
+
+#endif
+
static void convolve_vert_c(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int16_t *filter_x, int x_step_q4,
@@ -207,6 +279,52 @@
}
}
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+static void convolve_wtd_vert_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y0, int y_step_q4,
+ int w, int h, int taps,
+ uint8_t (*combine)(uint8_t a, uint8_t b)) {
+ int x, y, k, sum;
+
+ const int16_t *filter_y_base = filter_y0;
+
+#if ALIGN_FILTERS_256
+ filter_y_base = (const int16_t *)(((intptr_t)filter_y0) & ~(intptr_t)0xff);
+#endif
+
+ /* Adjust base pointer address for this source column */
+ src -= src_stride * (taps / 2 - 1);
+ for (x = 0; x < w; ++x) {
+ /* Pointer to filter to use */
+ const int16_t *filter_y = filter_y0;
+
+ /* Initial phase offset */
+ int y0_q4 = (filter_y - filter_y_base) / taps;
+ int y_q4 = y0_q4;
+
+ for (y = 0; y < h; ++y) {
+ /* Per-pixel src offset */
+ int src_y = (y_q4 - y0_q4) >> 4;
+
+ for (sum = 0, k = 0; k < taps; ++k) {
+ sum += src[(src_y + k) * src_stride] * filter_y[k];
+ }
+ sum += (VP9_FILTER_WEIGHT >> 1);
+ dst[y * dst_stride] = combine(dst[y * dst_stride],
+ clip_pixel(sum >> VP9_FILTER_SHIFT));
+
+ /* Adjust source and filter to use for the next pixel */
+ y_q4 += y_step_q4;
+ filter_y = filter_y_base + (y_q4 & 0xf) * taps;
+ }
+ ++src;
+ ++dst;
+ }
+}
+#endif
+
static void convolve_c(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int16_t *filter_x, int x_step_q4,
@@ -285,6 +403,68 @@
w, h, 8);
}
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+void vp9_convolve8_1by8_horiz_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_horiz_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_1by8);
+}
+
+void vp9_convolve8_qtr_horiz_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_horiz_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_qtr);
+}
+
+void vp9_convolve8_3by8_horiz_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_horiz_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_3by8);
+}
+
+void vp9_convolve8_5by8_horiz_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_horiz_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_5by8);
+}
+
+void vp9_convolve8_3qtr_horiz_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_horiz_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_3qtr);
+}
+
+void vp9_convolve8_7by8_horiz_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_horiz_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_7by8);
+}
+#endif
+
void vp9_convolve8_vert_c(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int16_t *filter_x, int x_step_q4,
@@ -305,6 +485,68 @@
w, h, 8);
}
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+void vp9_convolve8_1by8_vert_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_vert_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_1by8);
+}
+
+void vp9_convolve8_qtr_vert_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_vert_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_qtr);
+}
+
+void vp9_convolve8_3by8_vert_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_vert_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_3by8);
+}
+
+void vp9_convolve8_5by8_vert_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_vert_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_5by8);
+}
+
+void vp9_convolve8_3qtr_vert_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_vert_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_3qtr);
+}
+
+void vp9_convolve8_7by8_vert_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ convolve_wtd_vert_c(src, src_stride, dst, dst_stride,
+ filter_x, x_step_q4, filter_y, y_step_q4,
+ w, h, 8, combine_7by8);
+}
+#endif
+
void vp9_convolve8_c(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int16_t *filter_x, int x_step_q4,
@@ -337,6 +579,140 @@
w, h);
}
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+void vp9_convolve8_1by8_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ /* Fixed size intermediate buffer places limits on parameters. */
+ DECLARE_ALIGNED_ARRAY(16, uint8_t, temp, 16 * 16);
+ assert(w <= 16);
+ assert(h <= 16);
+
+ vp9_convolve8(src, src_stride,
+ temp, 16,
+ filter_x, x_step_q4,
+ filter_y, y_step_q4,
+ w, h);
+ vp9_convolve_1by8(temp, 16,
+ dst, dst_stride,
+ NULL, 0, /* These unused parameter should be removed! */
+ NULL, 0, /* These unused parameter should be removed! */
+ w, h);
+}
+
+void vp9_convolve8_qtr_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ /* Fixed size intermediate buffer places limits on parameters. */
+ DECLARE_ALIGNED_ARRAY(16, uint8_t, temp, 16 * 16);
+ assert(w <= 16);
+ assert(h <= 16);
+
+ vp9_convolve8(src, src_stride,
+ temp, 16,
+ filter_x, x_step_q4,
+ filter_y, y_step_q4,
+ w, h);
+ vp9_convolve_qtr(temp, 16,
+ dst, dst_stride,
+ NULL, 0, /* These unused parameter should be removed! */
+ NULL, 0, /* These unused parameter should be removed! */
+ w, h);
+}
+
+void vp9_convolve8_3by8_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ /* Fixed size intermediate buffer places limits on parameters. */
+ DECLARE_ALIGNED_ARRAY(16, uint8_t, temp, 16 * 16);
+ assert(w <= 16);
+ assert(h <= 16);
+
+ vp9_convolve8(src, src_stride,
+ temp, 16,
+ filter_x, x_step_q4,
+ filter_y, y_step_q4,
+ w, h);
+ vp9_convolve_3by8(temp, 16,
+ dst, dst_stride,
+ NULL, 0, /* These unused parameter should be removed! */
+ NULL, 0, /* These unused parameter should be removed! */
+ w, h);
+}
+
+void vp9_convolve8_5by8_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ /* Fixed size intermediate buffer places limits on parameters. */
+ DECLARE_ALIGNED_ARRAY(16, uint8_t, temp, 16 * 16);
+ assert(w <= 16);
+ assert(h <= 16);
+
+ vp9_convolve8(src, src_stride,
+ temp, 16,
+ filter_x, x_step_q4,
+ filter_y, y_step_q4,
+ w, h);
+ vp9_convolve_5by8(temp, 16,
+ dst, dst_stride,
+ NULL, 0, /* These unused parameter should be removed! */
+ NULL, 0, /* These unused parameter should be removed! */
+ w, h);
+}
+
+void vp9_convolve8_3qtr_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ /* Fixed size intermediate buffer places limits on parameters. */
+ DECLARE_ALIGNED_ARRAY(16, uint8_t, temp, 16 * 16);
+ assert(w <= 16);
+ assert(h <= 16);
+
+ vp9_convolve8(src, src_stride,
+ temp, 16,
+ filter_x, x_step_q4,
+ filter_y, y_step_q4,
+ w, h);
+ vp9_convolve_3qtr(temp, 16,
+ dst, dst_stride,
+ NULL, 0, /* These unused parameter should be removed! */
+ NULL, 0, /* These unused parameter should be removed! */
+ w, h);
+}
+
+void vp9_convolve8_7by8_c(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h) {
+ /* Fixed size intermediate buffer places limits on parameters. */
+ DECLARE_ALIGNED_ARRAY(16, uint8_t, temp, 16 * 16);
+ assert(w <= 16);
+ assert(h <= 16);
+
+ vp9_convolve8(src, src_stride,
+ temp, 16,
+ filter_x, x_step_q4,
+ filter_y, y_step_q4,
+ w, h);
+ vp9_convolve_7by8(temp, 16,
+ dst, dst_stride,
+ NULL, 0, /* These unused parameter should be removed! */
+ NULL, 0, /* These unused parameter should be removed! */
+ w, h);
+}
+#endif
+
void vp9_convolve_copy(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const int16_t *filter_x, int filter_x_stride,
@@ -374,3 +750,101 @@
dst += dst_stride;
}
}
+
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+void vp9_convolve_1by8(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int filter_x_stride,
+ const int16_t *filter_y, int filter_y_stride,
+ int w, int h) {
+ int x, y;
+
+ for (y = 0; y < h; ++y) {
+ for (x = 0; x < w; ++x) {
+ dst[x] = combine_1by8(dst[x], src[x]);
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+}
+
+void vp9_convolve_qtr(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int filter_x_stride,
+ const int16_t *filter_y, int filter_y_stride,
+ int w, int h) {
+ int x, y;
+
+ for (y = 0; y < h; ++y) {
+ for (x = 0; x < w; ++x) {
+ dst[x] = combine_qtr(dst[x], src[x]);
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+}
+
+void vp9_convolve_3by8(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int filter_x_stride,
+ const int16_t *filter_y, int filter_y_stride,
+ int w, int h) {
+ int x, y;
+
+ for (y = 0; y < h; ++y) {
+ for (x = 0; x < w; ++x) {
+ dst[x] = combine_3by8(dst[x], src[x]);
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+}
+
+void vp9_convolve_5by8(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int filter_x_stride,
+ const int16_t *filter_y, int filter_y_stride,
+ int w, int h) {
+ int x, y;
+
+ for (y = 0; y < h; ++y) {
+ for (x = 0; x < w; ++x) {
+ dst[x] = combine_5by8(dst[x], src[x]);
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+}
+
+void vp9_convolve_3qtr(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int filter_x_stride,
+ const int16_t *filter_y, int filter_y_stride,
+ int w, int h) {
+ int x, y;
+
+ for (y = 0; y < h; ++y) {
+ for (x = 0; x < w; ++x) {
+ dst[x] = combine_3qtr(dst[x], src[x]);
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+}
+
+void vp9_convolve_7by8(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int filter_x_stride,
+ const int16_t *filter_y, int filter_y_stride,
+ int w, int h) {
+ int x, y;
+
+ for (y = 0; y < h; ++y) {
+ for (x = 0; x < w; ++x) {
+ dst[x] = combine_7by8(dst[x], src[x]);
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+}
+#endif
diff --git a/vp9/common/vp9_convolve.h b/vp9/common/vp9_convolve.h
index 8c48561..bef2d85 100644
--- a/vp9/common/vp9_convolve.h
+++ b/vp9/common/vp9_convolve.h
@@ -10,6 +10,7 @@
#ifndef VP9_COMMON_CONVOLVE_H_
#define VP9_COMMON_CONVOLVE_H_
+#include "./vpx_config.h"
#include "vpx/vpx_integer.h"
typedef void (*convolve_fn_t)(const uint8_t *src, int src_stride,
@@ -32,6 +33,50 @@
const int16_t *filter_y, int y_step_q4,
int w, int h);
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+// Not a convolution, a block wtd (1/8, 7/8) average for (dst, src)
+void vp9_convolve_1by8(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h);
+
+// Not a convolution, a block wtd (1/4, 3/4) average for (dst, src)
+void vp9_convolve_qtr(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h);
+
+// Not a convolution, a block wtd (3/8, 5/8) average for (dst, src)
+void vp9_convolve_3by8(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h);
+
+// Not a convolution, a block wtd (5/8, 3/8) average for (dst, src)
+void vp9_convolve_5by8(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h);
+
+// Not a convolution, a block wtd (3/4, 1/4) average for (dst, src)
+void vp9_convolve_3qtr(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h);
+
+// Not a convolution, a block wtd (7/8, 1/8) average for (dst, src)
+void vp9_convolve_7by8(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h);
+#endif
+
struct subpix_fn_table {
const int16_t (*filter_x)[8];
const int16_t (*filter_y)[8];
diff --git a/vp9/common/vp9_reconinter.c b/vp9/common/vp9_reconinter.c
index bd4c83f..110af5e 100644
--- a/vp9/common/vp9_reconinter.c
+++ b/vp9/common/vp9_reconinter.c
@@ -39,6 +39,127 @@
// applied in one direction only, and not at all for 0,0, seems to give the
// best quality, but it may be worth trying an additional mode that does
// do the filtering on full-pel.
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+ if (scale->x_step_q4 == 16) {
+ if (scale->y_step_q4 == 16) {
+ // No scaling in either direction.
+ scale->predict[0][0][0] = vp9_convolve_copy;
+ scale->predict[0][0][1] = vp9_convolve_1by8;
+ scale->predict[0][0][2] = vp9_convolve_qtr;
+ scale->predict[0][0][3] = vp9_convolve_3by8;
+ scale->predict[0][0][4] = vp9_convolve_avg;
+ scale->predict[0][0][5] = vp9_convolve_5by8;
+ scale->predict[0][0][6] = vp9_convolve_3qtr;
+ scale->predict[0][0][7] = vp9_convolve_7by8;
+ scale->predict[0][1][0] = vp9_convolve8_vert;
+ scale->predict[0][1][1] = vp9_convolve8_1by8_vert;
+ scale->predict[0][1][2] = vp9_convolve8_qtr_vert;
+ scale->predict[0][1][3] = vp9_convolve8_3by8_vert;
+ scale->predict[0][1][4] = vp9_convolve8_avg_vert;
+ scale->predict[0][1][5] = vp9_convolve8_5by8_vert;
+ scale->predict[0][1][6] = vp9_convolve8_3qtr_vert;
+ scale->predict[0][1][7] = vp9_convolve8_7by8_vert;
+ scale->predict[1][0][0] = vp9_convolve8_horiz;
+ scale->predict[1][0][1] = vp9_convolve8_1by8_horiz;
+ scale->predict[1][0][2] = vp9_convolve8_qtr_horiz;
+ scale->predict[1][0][3] = vp9_convolve8_3by8_horiz;
+ scale->predict[1][0][4] = vp9_convolve8_avg_horiz;
+ scale->predict[1][0][5] = vp9_convolve8_5by8_horiz;
+ scale->predict[1][0][6] = vp9_convolve8_3qtr_horiz;
+ scale->predict[1][0][7] = vp9_convolve8_7by8_horiz;
+ } else {
+ // No scaling in x direction. Must always scale in the y direction.
+ scale->predict[0][0][0] = vp9_convolve8_vert;
+ scale->predict[0][0][1] = vp9_convolve8_1by8_vert;
+ scale->predict[0][0][2] = vp9_convolve8_qtr_vert;
+ scale->predict[0][0][3] = vp9_convolve8_3by8_vert;
+ scale->predict[0][0][4] = vp9_convolve8_avg_vert;
+ scale->predict[0][0][5] = vp9_convolve8_5by8_vert;
+ scale->predict[0][0][6] = vp9_convolve8_3qtr_vert;
+ scale->predict[0][0][7] = vp9_convolve8_7by8_vert;
+ scale->predict[0][1][0] = vp9_convolve8_vert;
+ scale->predict[0][1][1] = vp9_convolve8_1by8_vert;
+ scale->predict[0][1][2] = vp9_convolve8_qtr_vert;
+ scale->predict[0][1][3] = vp9_convolve8_3by8_vert;
+ scale->predict[0][1][4] = vp9_convolve8_avg_vert;
+ scale->predict[0][1][5] = vp9_convolve8_5by8_vert;
+ scale->predict[0][1][6] = vp9_convolve8_3qtr_vert;
+ scale->predict[0][1][7] = vp9_convolve8_7by8_vert;
+ scale->predict[1][0][0] = vp9_convolve8;
+ scale->predict[1][0][1] = vp9_convolve8_1by8;
+ scale->predict[1][0][2] = vp9_convolve8_qtr;
+ scale->predict[1][0][3] = vp9_convolve8_3by8;
+ scale->predict[1][0][4] = vp9_convolve8_avg;
+ scale->predict[1][0][5] = vp9_convolve8_5by8;
+ scale->predict[1][0][6] = vp9_convolve8_3qtr;
+ scale->predict[1][0][7] = vp9_convolve8_7by8;
+ }
+ } else {
+ if (scale->y_step_q4 == 16) {
+ // No scaling in the y direction. Must always scale in the x direction.
+ scale->predict[0][0][0] = vp9_convolve8_horiz;
+ scale->predict[0][0][1] = vp9_convolve8_1by8_horiz;
+ scale->predict[0][0][2] = vp9_convolve8_qtr_horiz;
+ scale->predict[0][0][3] = vp9_convolve8_3by8_horiz;
+ scale->predict[0][0][4] = vp9_convolve8_avg_horiz;
+ scale->predict[0][0][5] = vp9_convolve8_5by8_horiz;
+ scale->predict[0][0][6] = vp9_convolve8_3qtr_horiz;
+ scale->predict[0][0][7] = vp9_convolve8_7by8_horiz;
+ scale->predict[0][1][0] = vp9_convolve8;
+ scale->predict[0][1][1] = vp9_convolve8_1by8;
+ scale->predict[0][1][2] = vp9_convolve8_qtr;
+ scale->predict[0][1][3] = vp9_convolve8_3by8;
+ scale->predict[0][1][4] = vp9_convolve8_avg;
+ scale->predict[0][1][5] = vp9_convolve8_5by8;
+ scale->predict[0][1][6] = vp9_convolve8_3qtr;
+ scale->predict[0][1][7] = vp9_convolve8_7by8;
+ scale->predict[1][0][0] = vp9_convolve8_horiz;
+ scale->predict[1][0][1] = vp9_convolve8_1by8_horiz;
+ scale->predict[1][0][2] = vp9_convolve8_qtr_horiz;
+ scale->predict[1][0][3] = vp9_convolve8_3by8_horiz;
+ scale->predict[1][0][4] = vp9_convolve8_avg_horiz;
+ scale->predict[1][0][5] = vp9_convolve8_5by8_horiz;
+ scale->predict[1][0][6] = vp9_convolve8_3qtr_horiz;
+ scale->predict[1][0][7] = vp9_convolve8_7by8_horiz;
+ } else {
+ // Must always scale in both directions.
+ scale->predict[0][0][0] = vp9_convolve8;
+ scale->predict[0][0][1] = vp9_convolve8_1by8;
+ scale->predict[0][0][2] = vp9_convolve8_qtr;
+ scale->predict[0][0][3] = vp9_convolve8_3by8;
+ scale->predict[0][0][4] = vp9_convolve8_avg;
+ scale->predict[0][0][5] = vp9_convolve8_5by8;
+ scale->predict[0][0][6] = vp9_convolve8_3qtr;
+ scale->predict[0][0][7] = vp9_convolve8_7by8;
+ scale->predict[0][1][0] = vp9_convolve8;
+ scale->predict[0][1][1] = vp9_convolve8_1by8;
+ scale->predict[0][1][2] = vp9_convolve8_qtr;
+ scale->predict[0][1][3] = vp9_convolve8_3by8;
+ scale->predict[0][1][4] = vp9_convolve8_avg;
+ scale->predict[0][1][5] = vp9_convolve8_5by8;
+ scale->predict[0][1][6] = vp9_convolve8_3qtr;
+ scale->predict[0][1][7] = vp9_convolve8_7by8;
+ scale->predict[1][0][0] = vp9_convolve8;
+ scale->predict[1][0][1] = vp9_convolve8_1by8;
+ scale->predict[1][0][2] = vp9_convolve8_qtr;
+ scale->predict[1][0][3] = vp9_convolve8_3by8;
+ scale->predict[1][0][4] = vp9_convolve8_avg;
+ scale->predict[1][0][5] = vp9_convolve8_5by8;
+ scale->predict[1][0][6] = vp9_convolve8_3qtr;
+ scale->predict[1][0][7] = vp9_convolve8_7by8;
+ }
+ }
+ // 2D subpel motion always gets filtered in both directions
+ scale->predict[1][1][0] = vp9_convolve8;
+ scale->predict[1][1][1] = vp9_convolve8_1by8;
+ scale->predict[1][1][2] = vp9_convolve8_qtr;
+ scale->predict[1][1][3] = vp9_convolve8_3by8;
+ scale->predict[1][1][4] = vp9_convolve8_avg;
+ scale->predict[1][1][5] = vp9_convolve8_5by8;
+ scale->predict[1][1][6] = vp9_convolve8_3qtr;
+ scale->predict[1][1][7] = vp9_convolve8_7by8;
+}
+#else
if (scale->x_step_q4 == 16) {
if (scale->y_step_q4 == 16) {
// No scaling in either direction.
@@ -80,6 +201,7 @@
scale->predict[1][1][0] = vp9_convolve8;
scale->predict[1][1][1] = vp9_convolve8_avg;
}
+#endif
void vp9_setup_interp_filters(MACROBLOCKD *xd,
INTERPOLATIONFILTERTYPE mcomp_filter_type,
@@ -269,12 +391,11 @@
uint8_t *dst, int dst_stride,
const int_mv *mv_q3,
const struct scale_factors *scale,
- int w, int h, int do_avg,
+ int w, int h, int weight,
const struct subpix_fn_table *subpix) {
int_mv32 mv = scale_motion_vector_q3_to_q4(mv_q3, scale);
src += (mv.as_mv.row >> 4) * src_stride + (mv.as_mv.col >> 4);
-
- scale->predict[!!(mv.as_mv.col & 15)][!!(mv.as_mv.row & 15)][do_avg](
+ scale->predict[!!(mv.as_mv.col & 15)][!!(mv.as_mv.row & 15)][weight](
src, src_stride, dst, dst_stride,
subpix->filter_x[mv.as_mv.col & 15], scale->x_step_q4,
subpix->filter_y[mv.as_mv.row & 15], scale->y_step_q4,
@@ -289,7 +410,7 @@
const int_mv *fullpel_mv_q3,
const int_mv *frac_mv_q4,
const struct scale_factors *scale,
- int w, int h, int do_avg,
+ int w, int h, int weight,
const struct subpix_fn_table *subpix) {
const int mv_row_q4 = ((fullpel_mv_q3->as_mv.row >> 3) << 4)
+ (frac_mv_q4->as_mv.row & 0xf);
@@ -305,16 +426,67 @@
const int subpel_y = scaled_mv_row_q4 & 15;
src += (scaled_mv_row_q4 >> 4) * src_stride + (scaled_mv_col_q4 >> 4);
- scale->predict[!!subpel_x][!!subpel_y][do_avg](
+ scale->predict[!!subpel_x][!!subpel_y][weight](
src, src_stride, dst, dst_stride,
subpix->filter_x[subpel_x], scale->x_step_q4,
subpix->filter_y[subpel_y], scale->y_step_q4,
w, h);
}
+static void build_2x1_inter_predictor_wh(const BLOCKD *d0, const BLOCKD *d1,
+ struct scale_factors *scale,
+ uint8_t *predictor,
+ int block_size, int stride,
+ int which_mv, int weight,
+ int width, int height,
+ const struct subpix_fn_table *subpix,
+ int row, int col) {
+ assert(d1->predictor - d0->predictor == block_size);
+ assert(d1->pre == d0->pre + block_size);
+
+ set_scaled_offsets(&scale[which_mv], row, col);
+
+ if (d0->bmi.as_mv[which_mv].as_int == d1->bmi.as_mv[which_mv].as_int) {
+ uint8_t **base_pre = which_mv ? d0->base_second_pre : d0->base_pre;
+
+ vp9_build_inter_predictor(*base_pre + d0->pre,
+ d0->pre_stride,
+ predictor, stride,
+ &d0->bmi.as_mv[which_mv],
+ &scale[which_mv],
+ width, height,
+ weight, subpix);
+
+ } else {
+ uint8_t **base_pre0 = which_mv ? d0->base_second_pre : d0->base_pre;
+ uint8_t **base_pre1 = which_mv ? d1->base_second_pre : d1->base_pre;
+
+ vp9_build_inter_predictor(*base_pre0 + d0->pre,
+ d0->pre_stride,
+ predictor, stride,
+ &d0->bmi.as_mv[which_mv],
+ &scale[which_mv],
+ width > block_size ? block_size : width, height,
+ weight, subpix);
+
+ if (width <= block_size) return;
+
+ set_scaled_offsets(&scale[which_mv], row, col + block_size);
+
+ vp9_build_inter_predictor(*base_pre1 + d1->pre,
+ d1->pre_stride,
+ predictor + block_size, stride,
+ &d1->bmi.as_mv[which_mv],
+ &scale[which_mv],
+ width - block_size, height,
+ weight, subpix);
+ }
+}
+
static void build_2x1_inter_predictor(const BLOCKD *d0, const BLOCKD *d1,
struct scale_factors *scale,
- int block_size, int stride, int which_mv,
+ int block_size, int stride,
+ int which_mv, int weight,
const struct subpix_fn_table *subpix,
int row, int col) {
assert(d1->predictor - d0->predictor == block_size);
@@ -330,8 +502,8 @@
d0->predictor, stride,
&d0->bmi.as_mv[which_mv],
&scale[which_mv],
- 2 * block_size, block_size, which_mv,
- subpix);
+ 2 * block_size, block_size,
+ weight, subpix);
} else {
uint8_t **base_pre0 = which_mv ? d0->base_second_pre : d0->base_pre;
@@ -342,8 +514,8 @@
d0->predictor, stride,
&d0->bmi.as_mv[which_mv],
&scale[which_mv],
- block_size, block_size, which_mv,
- subpix);
+ block_size, block_size,
+ weight, subpix);
set_scaled_offsets(&scale[which_mv], row, col + block_size);
@@ -352,103 +524,8 @@
d1->predictor, stride,
&d1->bmi.as_mv[which_mv],
&scale[which_mv],
- block_size, block_size, which_mv,
- subpix);
- }
-}
-
-/*encoder only*/
-void vp9_build_inter4x4_predictors_mbuv(MACROBLOCKD *xd,
- int mb_row,
- int mb_col) {
- int i, j;
- BLOCKD *blockd = xd->block;
-
- /* build uv mvs */
- for (i = 0; i < 2; i++) {
- for (j = 0; j < 2; j++) {
- int yoffset = i * 8 + j * 2;
- int uoffset = 16 + i * 2 + j;
- int voffset = 20 + i * 2 + j;
- int temp;
-
- temp = blockd[yoffset ].bmi.as_mv[0].as_mv.row
- + blockd[yoffset + 1].bmi.as_mv[0].as_mv.row
- + blockd[yoffset + 4].bmi.as_mv[0].as_mv.row
- + blockd[yoffset + 5].bmi.as_mv[0].as_mv.row;
-
- if (temp < 0) temp -= 4;
- else temp += 4;
-
- xd->block[uoffset].bmi.as_mv[0].as_mv.row = (temp / 8) &
- xd->fullpixel_mask;
-
- temp = blockd[yoffset ].bmi.as_mv[0].as_mv.col
- + blockd[yoffset + 1].bmi.as_mv[0].as_mv.col
- + blockd[yoffset + 4].bmi.as_mv[0].as_mv.col
- + blockd[yoffset + 5].bmi.as_mv[0].as_mv.col;
-
- if (temp < 0) temp -= 4;
- else temp += 4;
-
- blockd[uoffset].bmi.as_mv[0].as_mv.col = (temp / 8) &
- xd->fullpixel_mask;
-
- blockd[voffset].bmi.as_mv[0].as_mv.row =
- blockd[uoffset].bmi.as_mv[0].as_mv.row;
- blockd[voffset].bmi.as_mv[0].as_mv.col =
- blockd[uoffset].bmi.as_mv[0].as_mv.col;
-
- if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
- temp = blockd[yoffset ].bmi.as_mv[1].as_mv.row
- + blockd[yoffset + 1].bmi.as_mv[1].as_mv.row
- + blockd[yoffset + 4].bmi.as_mv[1].as_mv.row
- + blockd[yoffset + 5].bmi.as_mv[1].as_mv.row;
-
- if (temp < 0) {
- temp -= 4;
- } else {
- temp += 4;
- }
-
- blockd[uoffset].bmi.as_mv[1].as_mv.row = (temp / 8) &
- xd->fullpixel_mask;
-
- temp = blockd[yoffset ].bmi.as_mv[1].as_mv.col
- + blockd[yoffset + 1].bmi.as_mv[1].as_mv.col
- + blockd[yoffset + 4].bmi.as_mv[1].as_mv.col
- + blockd[yoffset + 5].bmi.as_mv[1].as_mv.col;
-
- if (temp < 0) {
- temp -= 4;
- } else {
- temp += 4;
- }
-
- blockd[uoffset].bmi.as_mv[1].as_mv.col = (temp / 8) &
- xd->fullpixel_mask;
-
- blockd[voffset].bmi.as_mv[1].as_mv.row =
- blockd[uoffset].bmi.as_mv[1].as_mv.row;
- blockd[voffset].bmi.as_mv[1].as_mv.col =
- blockd[uoffset].bmi.as_mv[1].as_mv.col;
- }
- }
- }
-
- for (i = 16; i < 24; i += 2) {
- const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
- const int x = 4 * (i & 1);
- const int y = ((i - 16) >> 1) * 4;
-
- int which_mv;
- BLOCKD *d0 = &blockd[i];
- BLOCKD *d1 = &blockd[i + 1];
-
- for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
- build_2x1_inter_predictor(d0, d1, xd->scale_factor_uv, 4, 8, which_mv,
- &xd->subpix, mb_row * 8 + y, mb_col * 8 + x);
- }
+ block_size, block_size,
+ weight, subpix);
}
}
@@ -488,7 +565,358 @@
(xd->mb_to_bottom_edge + (16 << 3)) >> 1 : mv->row;
}
-/*encoder only*/
+#define AVERAGE_WEIGHT (1 << (2 * CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT))
+
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+
+// Whether to use implicit weighting for UV
+#define USE_IMPLICIT_WEIGHT_UV
+
+// Whether to use implicit weighting for SplitMV
+// #define USE_IMPLICIT_WEIGHT_SPLITMV
+
+// #define SEARCH_MIN3
+static int64_t get_consistency_metric(MACROBLOCKD *xd,
+ uint8_t *tmp_y, int tmp_ystride) {
+ int block_size = 16 << xd->mode_info_context->mbmi.sb_type;
+ uint8_t *rec_y = xd->dst.y_buffer;
+ int rec_ystride = xd->dst.y_stride;
+ int64_t metric = 0;
+ int i;
+ if (xd->up_available) {
+ for (i = 0; i < block_size; ++i) {
+ int diff = abs(*(rec_y - rec_ystride + i) -
+ *(tmp_y + i));
+#ifdef SEARCH_MIN3
+ // Searches for the min abs diff among 3 pixel neighbors in the border
+ int diff1 = xd->left_available ?
+ abs(*(rec_y - rec_ystride + i - 1) - *(tmp_y + i)) : diff;
+ int diff2 = i < block_size - 1 ?
+ abs(*(rec_y - rec_ystride + i + 1) - *(tmp_y + i)) : diff;
+ diff = diff <= diff1 ? diff : diff1;
+ diff = diff <= diff2 ? diff : diff2;
+#endif
+ metric += diff;
+ }
+ }
+ if (xd->left_available) {
+ for (i = 0; i < block_size; ++i) {
+ int diff = abs(*(rec_y - 1 + i * rec_ystride) -
+ *(tmp_y + i * tmp_ystride));
+#ifdef SEARCH_MIN3
+ // Searches for the min abs diff among 3 pixel neighbors in the border
+ int diff1 = xd->up_available ?
+ abs(*(rec_y - 1 + (i - 1) * rec_ystride) -
+ *(tmp_y + i * tmp_ystride)) : diff;
+ int diff2 = i < block_size - 1 ?
+ abs(*(rec_y - 1 + (i + 1) * rec_ystride) -
+ *(tmp_y + i * tmp_ystride)) : diff;
+ diff = diff <= diff1 ? diff : diff1;
+ diff = diff <= diff2 ? diff : diff2;
+#endif
+ metric += diff;
+ }
+ }
+ return metric;
+}
+
+static int get_weight(MACROBLOCKD *xd, int64_t metric_1, int64_t metric_2) {
+ int weight = AVERAGE_WEIGHT;
+ if (2 * metric_1 < metric_2)
+ weight = 6;
+ else if (4 * metric_1 < 3 * metric_2)
+ weight = 5;
+ else if (2 * metric_2 < metric_1)
+ weight = 2;
+ else if (4 * metric_2 < 3 * metric_1)
+ weight = 3;
+ return weight;
+}
+
+#ifdef USE_IMPLICIT_WEIGHT_SPLITMV
+static int get_implicit_compoundinter_weight_splitmv(
+ MACROBLOCKD *xd, int mb_row, int mb_col) {
+ MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
+ BLOCKD *blockd = xd->block;
+ const int use_second_ref = mbmi->second_ref_frame > 0;
+ int64_t metric_2 = 0, metric_1 = 0;
+ int i, which_mv, weight;
+ uint8_t tmp_y[256];
+ const int tmp_ystride = 16;
+
+ if (!use_second_ref) return 0;
+ if (!(xd->up_available || xd->left_available))
+ return AVERAGE_WEIGHT;
+
+ assert(xd->mode_info_context->mbmi.mode == SPLITMV);
+
+ which_mv = 1; // second predictor
+ if (xd->mode_info_context->mbmi.partitioning != PARTITIONING_4X4) {
+ for (i = 0; i < 16; i += 8) {
+ BLOCKD *d0 = &blockd[i];
+ BLOCKD *d1 = &blockd[i + 2];
+ const int y = i & 8;
+
+ blockd[i + 0].bmi = xd->mode_info_context->bmi[i + 0];
+ blockd[i + 2].bmi = xd->mode_info_context->bmi[i + 2];
+
+ if (mbmi->need_to_clamp_mvs) {
+ clamp_mv_to_umv_border(&blockd[i + 0].bmi.as_mv[which_mv].as_mv, xd);
+ clamp_mv_to_umv_border(&blockd[i + 2].bmi.as_mv[which_mv].as_mv, xd);
+ }
+ if (i == 0) {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y, 8, 16,
+ which_mv, 0, 16, 1,
+ &xd->subpix, mb_row * 16 + y, mb_col * 16);
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y, 8, 16,
+ which_mv, 0, 1, 8,
+ &xd->subpix, mb_row * 16 + y, mb_col * 16);
+ } else {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y + 8 * 16,
+ 8, 16, which_mv, 0, 1, 8,
+ &xd->subpix, mb_row * 16 + y, mb_col * 16);
+ }
+ }
+ } else {
+ for (i = 0; i < 16; i += 2) {
+ BLOCKD *d0 = &blockd[i];
+ BLOCKD *d1 = &blockd[i + 1];
+ const int x = (i & 3) * 4;
+ const int y = (i >> 2) * 4;
+
+ blockd[i + 0].bmi = xd->mode_info_context->bmi[i + 0];
+ blockd[i + 1].bmi = xd->mode_info_context->bmi[i + 1];
+
+ if (i >= 4 && (i & 3) != 0) continue;
+
+ if (i == 0) {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y, 4, 16,
+ which_mv, 0, 8, 1, &xd->subpix,
+ mb_row * 16 + y, mb_col * 16 + x);
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y, 4, 16,
+ which_mv, 0, 1, 4, &xd->subpix,
+ mb_row * 16 + y, mb_col * 16 + x);
+ } else if (i < 4) {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y + x, 4, 16,
+ which_mv, 0, 8, 1, &xd->subpix,
+ mb_row * 16 + y, mb_col * 16 + x);
+ } else {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y + y * 16,
+ 4, 16, which_mv, 0, 1, 4, &xd->subpix,
+ mb_row * 16 + y, mb_col * 16 + x);
+ }
+ }
+ }
+ metric_2 = get_consistency_metric(xd, tmp_y, tmp_ystride);
+
+ which_mv = 0; // first predictor
+ if (xd->mode_info_context->mbmi.partitioning != PARTITIONING_4X4) {
+ for (i = 0; i < 16; i += 8) {
+ BLOCKD *d0 = &blockd[i];
+ BLOCKD *d1 = &blockd[i + 2];
+ const int y = i & 8;
+
+ blockd[i + 0].bmi = xd->mode_info_context->bmi[i + 0];
+ blockd[i + 2].bmi = xd->mode_info_context->bmi[i + 2];
+
+ if (mbmi->need_to_clamp_mvs) {
+ clamp_mv_to_umv_border(&blockd[i + 0].bmi.as_mv[which_mv].as_mv, xd);
+ clamp_mv_to_umv_border(&blockd[i + 2].bmi.as_mv[which_mv].as_mv, xd);
+ }
+ if (i == 0) {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y, 8, 16,
+ which_mv, 0, 16, 1,
+ &xd->subpix, mb_row * 16 + y, mb_col * 16);
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y, 8, 16,
+ which_mv, 0, 1, 8,
+ &xd->subpix, mb_row * 16 + y, mb_col * 16);
+ } else {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y + 8 * 16,
+ 8, 16, which_mv, 0, 1, 8,
+ &xd->subpix, mb_row * 16 + y, mb_col * 16);
+ }
+ }
+ } else {
+ for (i = 0; i < 16; i += 2) {
+ BLOCKD *d0 = &blockd[i];
+ BLOCKD *d1 = &blockd[i + 1];
+ const int x = (i & 3) * 4;
+ const int y = (i >> 2) * 4;
+
+ blockd[i + 0].bmi = xd->mode_info_context->bmi[i + 0];
+ blockd[i + 1].bmi = xd->mode_info_context->bmi[i + 1];
+
+ if (i >= 4 && (i & 3) != 0) continue;
+
+ if (i == 0) {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y, 4, 16,
+ which_mv, 0, 8, 1, &xd->subpix,
+ mb_row * 16 + y, mb_col * 16 + x);
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y, 4, 16,
+ which_mv, 0, 1, 4, &xd->subpix,
+ mb_row * 16 + y, mb_col * 16 + x);
+ } else if (i < 4) {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y + x, 4, 16,
+ which_mv, 0, 8, 1, &xd->subpix,
+ mb_row * 16 + y, mb_col * 16 + x);
+ } else {
+ build_2x1_inter_predictor_wh(d0, d1, xd->scale_factor, tmp_y + y * 16,
+ 4, 16, which_mv, 0, 1, 4, &xd->subpix,
+ mb_row * 16 + y, mb_col * 16 + x);
+ }
+ }
+ }
+ metric_1 = get_consistency_metric(xd, tmp_y, tmp_ystride);
+
+ // Choose final weight for averaging
+ weight = get_weight(xd, metric_1, metric_2);
+ return weight;
+}
+#endif
+
+static int get_implicit_compoundinter_weight(MACROBLOCKD *xd,
+ int mb_row,
+ int mb_col) {
+ const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
+ int64_t metric_2 = 0, metric_1 = 0;
+ int n, clamp_mvs, pre_stride;
+ uint8_t *base_pre;
+ int_mv ymv;
+ uint8_t tmp_y[4096];
+ const int tmp_ystride = 64;
+ int weight;
+ int edge[4];
+ int block_size = 16 << xd->mode_info_context->mbmi.sb_type;
+
+ if (!use_second_ref) return 0;
+ if (!(xd->up_available || xd->left_available))
+ return AVERAGE_WEIGHT;
+
+ edge[0] = xd->mb_to_top_edge;
+ edge[1] = xd->mb_to_bottom_edge;
+ edge[2] = xd->mb_to_left_edge;
+ edge[3] = xd->mb_to_right_edge;
+
+ clamp_mvs = xd->mode_info_context->mbmi.need_to_clamp_secondmv;
+ base_pre = xd->second_pre.y_buffer;
+ pre_stride = xd->second_pre.y_stride;
+ ymv.as_int = xd->mode_info_context->mbmi.mv[1].as_int;
+ // First generate the second predictor
+ for (n = 0; n < block_size; n += 16) {
+ xd->mb_to_left_edge = edge[2] - (n << 3);
+ xd->mb_to_right_edge = edge[3] + ((16 - n) << 3);
+ if (clamp_mvs)
+ clamp_mv_to_umv_border(&ymv.as_mv, xd);
+ set_scaled_offsets(&xd->scale_factor[1], mb_row * 16, mb_col * 16 + n);
+ // predict a single row of pixels
+ vp9_build_inter_predictor(
+ base_pre + scaled_buffer_offset(n, 0, pre_stride, &xd->scale_factor[1]),
+ pre_stride, tmp_y + n, tmp_ystride, &ymv, &xd->scale_factor[1],
+ 16, 1, 0, &xd->subpix);
+ }
+ xd->mb_to_left_edge = edge[2];
+ xd->mb_to_right_edge = edge[3];
+ for (n = 0; n < block_size; n += 16) {
+ xd->mb_to_top_edge = edge[0] - (n << 3);
+ xd->mb_to_bottom_edge = edge[1] + ((16 - n) << 3);
+ if (clamp_mvs)
+ clamp_mv_to_umv_border(&ymv.as_mv, xd);
+ set_scaled_offsets(&xd->scale_factor[1], mb_row * 16 + n, mb_col * 16);
+ // predict a single col of pixels
+ vp9_build_inter_predictor(
+ base_pre + scaled_buffer_offset(0, n, pre_stride, &xd->scale_factor[1]),
+ pre_stride, tmp_y + n * tmp_ystride, tmp_ystride, &ymv,
+ &xd->scale_factor[1], 1, 16, 0, &xd->subpix);
+ }
+ xd->mb_to_top_edge = edge[0];
+ xd->mb_to_bottom_edge = edge[1];
+ // Compute consistency metric
+ metric_2 = get_consistency_metric(xd, tmp_y, tmp_ystride);
+
+ clamp_mvs = xd->mode_info_context->mbmi.need_to_clamp_mvs;
+ base_pre = xd->pre.y_buffer;
+ pre_stride = xd->pre.y_stride;
+ ymv.as_int = xd->mode_info_context->mbmi.mv[0].as_int;
+ // Now generate the first predictor
+ for (n = 0; n < block_size; n += 16) {
+ xd->mb_to_left_edge = edge[2] - (n << 3);
+ xd->mb_to_right_edge = edge[3] + ((16 - n) << 3);
+ if (clamp_mvs)
+ clamp_mv_to_umv_border(&ymv.as_mv, xd);
+ set_scaled_offsets(&xd->scale_factor[0], mb_row * 16, mb_col * 16 + n);
+ // predict a single row of pixels
+ vp9_build_inter_predictor(
+ base_pre + scaled_buffer_offset(n, 0, pre_stride, &xd->scale_factor[0]),
+ pre_stride, tmp_y + n, tmp_ystride, &ymv, &xd->scale_factor[0],
+ 16, 1, 0, &xd->subpix);
+ }
+ xd->mb_to_left_edge = edge[2];
+ xd->mb_to_right_edge = edge[3];
+ for (n = 0; n < block_size; n += 16) {
+ xd->mb_to_top_edge = edge[0] - (n << 3);
+ xd->mb_to_bottom_edge = edge[1] + ((16 - n) << 3);
+ if (clamp_mvs)
+ clamp_mv_to_umv_border(&ymv.as_mv, xd);
+ set_scaled_offsets(&xd->scale_factor[0], mb_row * 16 + n, mb_col * 16);
+ // predict a single col of pixels
+ vp9_build_inter_predictor(
+ base_pre + scaled_buffer_offset(0, n, pre_stride, &xd->scale_factor[0]),
+ pre_stride, tmp_y + n * tmp_ystride, tmp_ystride, &ymv,
+ &xd->scale_factor[0], 1, 16, 0, &xd->subpix);
+ }
+ xd->mb_to_top_edge = edge[0];
+ xd->mb_to_bottom_edge = edge[1];
+ metric_1 = get_consistency_metric(xd, tmp_y, tmp_ystride);
+
+ // Choose final weight for averaging
+ weight = get_weight(xd, metric_1, metric_2);
+ return weight;
+}
+
+static void build_inter16x16_predictors_mby_w(MACROBLOCKD *xd,
+ uint8_t *dst_y,
+ int dst_ystride,
+ int weight,
+ int mb_row,
+ int mb_col) {
+ const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
+ int which_mv;
+
+ for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
+ const int clamp_mvs = which_mv ?
+ xd->mode_info_context->mbmi.need_to_clamp_secondmv :
+ xd->mode_info_context->mbmi.need_to_clamp_mvs;
+
+ uint8_t *base_pre = which_mv ? xd->second_pre.y_buffer : xd->pre.y_buffer;
+ int pre_stride = which_mv ? xd->second_pre.y_stride : xd->pre.y_stride;
+ int_mv ymv;
+ ymv.as_int = xd->mode_info_context->mbmi.mv[which_mv].as_int;
+
+ if (clamp_mvs)
+ clamp_mv_to_umv_border(&ymv.as_mv, xd);
+
+ set_scaled_offsets(&xd->scale_factor[which_mv], mb_row * 16, mb_col * 16);
+
+ vp9_build_inter_predictor(base_pre, pre_stride,
+ dst_y, dst_ystride,
+ &ymv, &xd->scale_factor[which_mv],
+ 16, 16, which_mv ? weight : 0, &xd->subpix);
+ }
+}
+
+void vp9_build_inter16x16_predictors_mby(MACROBLOCKD *xd,
+ uint8_t *dst_y,
+ int dst_ystride,
+ int mb_row,
+ int mb_col) {
+ int weight = get_implicit_compoundinter_weight(xd, mb_row, mb_col);
+
+ build_inter16x16_predictors_mby_w(xd, dst_y, dst_ystride, weight,
+ mb_row, mb_col);
+}
+
+#else
+
void vp9_build_inter16x16_predictors_mby(MACROBLOCKD *xd,
uint8_t *dst_y,
int dst_ystride,
@@ -518,6 +946,86 @@
16, 16, which_mv, &xd->subpix);
}
}
+#endif
+
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+static void build_inter16x16_predictors_mbuv_w(MACROBLOCKD *xd,
+ uint8_t *dst_u,
+ uint8_t *dst_v,
+ int dst_uvstride,
+ int weight,
+ int mb_row,
+ int mb_col) {
+ const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
+ int which_mv;
+
+ for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
+ const int clamp_mvs =
+ which_mv ? xd->mode_info_context->mbmi.need_to_clamp_secondmv
+ : xd->mode_info_context->mbmi.need_to_clamp_mvs;
+ uint8_t *uptr, *vptr;
+ int pre_stride = which_mv ? xd->second_pre.uv_stride
+ : xd->pre.uv_stride;
+ int_mv _o16x16mv;
+ int_mv _16x16mv;
+
+ _16x16mv.as_int = xd->mode_info_context->mbmi.mv[which_mv].as_int;
+
+ if (clamp_mvs)
+ clamp_mv_to_umv_border(&_16x16mv.as_mv, xd);
+
+ _o16x16mv = _16x16mv;
+ /* calc uv motion vectors */
+ if (_16x16mv.as_mv.row < 0)
+ _16x16mv.as_mv.row -= 1;
+ else
+ _16x16mv.as_mv.row += 1;
+
+ if (_16x16mv.as_mv.col < 0)
+ _16x16mv.as_mv.col -= 1;
+ else
+ _16x16mv.as_mv.col += 1;
+
+ _16x16mv.as_mv.row /= 2;
+ _16x16mv.as_mv.col /= 2;
+
+ _16x16mv.as_mv.row &= xd->fullpixel_mask;
+ _16x16mv.as_mv.col &= xd->fullpixel_mask;
+
+ uptr = (which_mv ? xd->second_pre.u_buffer : xd->pre.u_buffer);
+ vptr = (which_mv ? xd->second_pre.v_buffer : xd->pre.v_buffer);
+
+ set_scaled_offsets(&xd->scale_factor_uv[which_mv],
+ mb_row * 16, mb_col * 16);
+
+ vp9_build_inter_predictor_q4(
+ uptr, pre_stride, dst_u, dst_uvstride, &_16x16mv, &_o16x16mv,
+ &xd->scale_factor_uv[which_mv], 8, 8,
+ which_mv ? weight : 0, &xd->subpix);
+
+ vp9_build_inter_predictor_q4(
+ vptr, pre_stride, dst_v, dst_uvstride, &_16x16mv, &_o16x16mv,
+ &xd->scale_factor_uv[which_mv], 8, 8,
+ which_mv ? weight : 0, &xd->subpix);
+ }
+}
+
+void vp9_build_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
+ uint8_t *dst_u,
+ uint8_t *dst_v,
+ int dst_uvstride,
+ int mb_row,
+ int mb_col) {
+#ifdef USE_IMPLICIT_WEIGHT_UV
+ int weight = get_implicit_compoundinter_weight(xd, mb_row, mb_col);
+#else
+ int weight = AVERAGE_WEIGHT;
+#endif
+ build_inter16x16_predictors_mbuv_w(xd, dst_u, dst_v, dst_uvstride,
+ weight, mb_row, mb_col);
+}
+
+#else
void vp9_build_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
uint8_t *dst_u,
@@ -567,31 +1075,28 @@
set_scaled_offsets(&xd->scale_factor_uv[which_mv],
mb_row * 16, mb_col * 16);
- vp9_build_inter_predictor_q4(uptr, pre_stride,
- dst_u, dst_uvstride,
- &_16x16mv, &_o16x16mv,
- &xd->scale_factor_uv[which_mv],
- 8, 8, which_mv, &xd->subpix);
+ vp9_build_inter_predictor_q4(
+ uptr, pre_stride, dst_u, dst_uvstride, &_16x16mv, &_o16x16mv,
+ &xd->scale_factor_uv[which_mv], 8, 8,
+ which_mv << (2 * CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT), &xd->subpix);
- vp9_build_inter_predictor_q4(vptr, pre_stride,
- dst_v, dst_uvstride,
- &_16x16mv, &_o16x16mv,
- &xd->scale_factor_uv[which_mv],
- 8, 8, which_mv, &xd->subpix);
+ vp9_build_inter_predictor_q4(
+ vptr, pre_stride, dst_v, dst_uvstride, &_16x16mv, &_o16x16mv,
+ &xd->scale_factor_uv[which_mv], 8, 8,
+ which_mv << (2 * CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT), &xd->subpix);
}
}
+#endif
-void vp9_build_inter32x32_predictors_sb(MACROBLOCKD *x,
- uint8_t *dst_y,
- uint8_t *dst_u,
- uint8_t *dst_v,
- int dst_ystride,
- int dst_uvstride,
- int mb_row,
- int mb_col) {
- uint8_t *y1 = x->pre.y_buffer, *u1 = x->pre.u_buffer, *v1 = x->pre.v_buffer;
- uint8_t *y2 = x->second_pre.y_buffer, *u2 = x->second_pre.u_buffer,
- *v2 = x->second_pre.v_buffer;
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+static void build_inter32x32_predictors_sby_w(MACROBLOCKD *x,
+ uint8_t *dst_y,
+ int dst_ystride,
+ int weight,
+ int mb_row,
+ int mb_col) {
+ uint8_t *y1 = x->pre.y_buffer;
+ uint8_t *y2 = x->second_pre.y_buffer;
int edge[4], n;
edge[0] = x->mb_to_top_edge;
@@ -601,7 +1106,6 @@
for (n = 0; n < 4; n++) {
const int x_idx = n & 1, y_idx = n >> 1;
- int scaled_uv_offset;
x->mb_to_top_edge = edge[0] - ((y_idx * 16) << 3);
x->mb_to_bottom_edge = edge[1] + (((1 - y_idx) * 16) << 3);
@@ -612,6 +1116,118 @@
y_idx * 16,
x->pre.y_stride,
&x->scale_factor[0]);
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.y_buffer = y2 +
+ scaled_buffer_offset(x_idx * 16,
+ y_idx * 16,
+ x->second_pre.y_stride,
+ &x->scale_factor[1]);
+ }
+ build_inter16x16_predictors_mby_w(x,
+ dst_y + y_idx * 16 * dst_ystride + x_idx * 16,
+ dst_ystride, weight, mb_row + y_idx, mb_col + x_idx);
+ }
+ x->mb_to_top_edge = edge[0];
+ x->mb_to_bottom_edge = edge[1];
+ x->mb_to_left_edge = edge[2];
+ x->mb_to_right_edge = edge[3];
+
+ x->pre.y_buffer = y1;
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.y_buffer = y2;
+ }
+}
+
+void vp9_build_inter32x32_predictors_sby(MACROBLOCKD *x,
+ uint8_t *dst_y,
+ int dst_ystride,
+ int mb_row,
+ int mb_col) {
+ int weight = get_implicit_compoundinter_weight(x, mb_row, mb_col);
+ build_inter32x32_predictors_sby_w(x, dst_y, dst_ystride, weight,
+ mb_row, mb_col);
+}
+
+#else
+
+// TODO(all): Can we use 32x32 specific implementations of this rather than
+// using 16x16 implementations ?
+void vp9_build_inter32x32_predictors_sby(MACROBLOCKD *x,
+ uint8_t *dst_y,
+ int dst_ystride,
+ int mb_row,
+ int mb_col) {
+ uint8_t *y1 = x->pre.y_buffer;
+ uint8_t *y2 = x->second_pre.y_buffer;
+ int edge[4], n;
+
+ edge[0] = x->mb_to_top_edge;
+ edge[1] = x->mb_to_bottom_edge;
+ edge[2] = x->mb_to_left_edge;
+ edge[3] = x->mb_to_right_edge;
+
+ for (n = 0; n < 4; n++) {
+ const int x_idx = n & 1, y_idx = n >> 1;
+
+ x->mb_to_top_edge = edge[0] - ((y_idx * 16) << 3);
+ x->mb_to_bottom_edge = edge[1] + (((1 - y_idx) * 16) << 3);
+ x->mb_to_left_edge = edge[2] - ((x_idx * 16) << 3);
+ x->mb_to_right_edge = edge[3] + (((1 - x_idx) * 16) << 3);
+
+ x->pre.y_buffer = y1 + scaled_buffer_offset(x_idx * 16,
+ y_idx * 16,
+ x->pre.y_stride,
+ &x->scale_factor[0]);
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.y_buffer = y2 +
+ scaled_buffer_offset(x_idx * 16,
+ y_idx * 16,
+ x->second_pre.y_stride,
+ &x->scale_factor[1]);
+ }
+ vp9_build_inter16x16_predictors_mby(x,
+ dst_y + y_idx * 16 * dst_ystride + x_idx * 16,
+ dst_ystride, mb_row + y_idx, mb_col + x_idx);
+ }
+ x->mb_to_top_edge = edge[0];
+ x->mb_to_bottom_edge = edge[1];
+ x->mb_to_left_edge = edge[2];
+ x->mb_to_right_edge = edge[3];
+
+ x->pre.y_buffer = y1;
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.y_buffer = y2;
+ }
+}
+
+#endif
+
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+static void build_inter32x32_predictors_sbuv_w(MACROBLOCKD *x,
+ uint8_t *dst_u,
+ uint8_t *dst_v,
+ int dst_uvstride,
+ int weight,
+ int mb_row,
+ int mb_col) {
+ uint8_t *u1 = x->pre.u_buffer, *v1 = x->pre.v_buffer;
+ uint8_t *u2 = x->second_pre.u_buffer, *v2 = x->second_pre.v_buffer;
+ int edge[4], n;
+
+ edge[0] = x->mb_to_top_edge;
+ edge[1] = x->mb_to_bottom_edge;
+ edge[2] = x->mb_to_left_edge;
+ edge[3] = x->mb_to_right_edge;
+
+ for (n = 0; n < 4; n++) {
+ int scaled_uv_offset;
+ const int x_idx = n & 1, y_idx = n >> 1;
+
+ x->mb_to_top_edge = edge[0] - ((y_idx * 16) << 3);
+ x->mb_to_bottom_edge = edge[1] + (((1 - y_idx) * 16) << 3);
+ x->mb_to_left_edge = edge[2] - ((x_idx * 16) << 3);
+ x->mb_to_right_edge = edge[3] + (((1 - x_idx) * 16) << 3);
+
scaled_uv_offset = scaled_buffer_offset(x_idx * 8,
y_idx * 8,
x->pre.uv_stride,
@@ -620,11 +1236,6 @@
x->pre.v_buffer = v1 + scaled_uv_offset;
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
- x->second_pre.y_buffer = y2 +
- scaled_buffer_offset(x_idx * 16,
- y_idx * 16,
- x->second_pre.y_stride,
- &x->scale_factor[1]);
scaled_uv_offset = scaled_buffer_offset(x_idx * 8,
y_idx * 8,
x->second_pre.uv_stride,
@@ -633,28 +1244,114 @@
x->second_pre.v_buffer = v2 + scaled_uv_offset;
}
- vp9_build_inter16x16_predictors_mb(x,
- dst_y + y_idx * 16 * dst_ystride + x_idx * 16,
+ build_inter16x16_predictors_mbuv_w(x,
dst_u + y_idx * 8 * dst_uvstride + x_idx * 8,
dst_v + y_idx * 8 * dst_uvstride + x_idx * 8,
- dst_ystride, dst_uvstride, mb_row + y_idx, mb_col + x_idx);
+ dst_uvstride, weight, mb_row + y_idx, mb_col + x_idx);
}
-
x->mb_to_top_edge = edge[0];
x->mb_to_bottom_edge = edge[1];
x->mb_to_left_edge = edge[2];
x->mb_to_right_edge = edge[3];
- x->pre.y_buffer = y1;
x->pre.u_buffer = u1;
x->pre.v_buffer = v1;
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
- x->second_pre.y_buffer = y2;
x->second_pre.u_buffer = u2;
x->second_pre.v_buffer = v2;
}
+}
+void vp9_build_inter32x32_predictors_sbuv(MACROBLOCKD *xd,
+ uint8_t *dst_u,
+ uint8_t *dst_v,
+ int dst_uvstride,
+ int mb_row,
+ int mb_col) {
+#ifdef USE_IMPLICIT_WEIGHT_UV
+ int weight = get_implicit_compoundinter_weight(xd, mb_row, mb_col);
+#else
+ int weight = AVERAGE_WEIGHT;
+#endif
+ build_inter32x32_predictors_sbuv_w(xd, dst_u, dst_v, dst_uvstride,
+ weight, mb_row, mb_col);
+}
+
+#else
+
+void vp9_build_inter32x32_predictors_sbuv(MACROBLOCKD *x,
+ uint8_t *dst_u,
+ uint8_t *dst_v,
+ int dst_uvstride,
+ int mb_row,
+ int mb_col) {
+ uint8_t *u1 = x->pre.u_buffer, *v1 = x->pre.v_buffer;
+ uint8_t *u2 = x->second_pre.u_buffer, *v2 = x->second_pre.v_buffer;
+ int edge[4], n;
+
+ edge[0] = x->mb_to_top_edge;
+ edge[1] = x->mb_to_bottom_edge;
+ edge[2] = x->mb_to_left_edge;
+ edge[3] = x->mb_to_right_edge;
+
+ for (n = 0; n < 4; n++) {
+ int scaled_uv_offset;
+ const int x_idx = n & 1, y_idx = n >> 1;
+
+ x->mb_to_top_edge = edge[0] - ((y_idx * 16) << 3);
+ x->mb_to_bottom_edge = edge[1] + (((1 - y_idx) * 16) << 3);
+ x->mb_to_left_edge = edge[2] - ((x_idx * 16) << 3);
+ x->mb_to_right_edge = edge[3] + (((1 - x_idx) * 16) << 3);
+
+ scaled_uv_offset = scaled_buffer_offset(x_idx * 8,
+ y_idx * 8,
+ x->pre.uv_stride,
+ &x->scale_factor_uv[0]);
+ x->pre.u_buffer = u1 + scaled_uv_offset;
+ x->pre.v_buffer = v1 + scaled_uv_offset;
+
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ scaled_uv_offset = scaled_buffer_offset(x_idx * 8,
+ y_idx * 8,
+ x->second_pre.uv_stride,
+ &x->scale_factor_uv[1]);
+ x->second_pre.u_buffer = u2 + scaled_uv_offset;
+ x->second_pre.v_buffer = v2 + scaled_uv_offset;
+ }
+
+ vp9_build_inter16x16_predictors_mbuv(x,
+ dst_u + y_idx * 8 * dst_uvstride + x_idx * 8,
+ dst_v + y_idx * 8 * dst_uvstride + x_idx * 8,
+ dst_uvstride, mb_row + y_idx, mb_col + x_idx);
+ }
+ x->mb_to_top_edge = edge[0];
+ x->mb_to_bottom_edge = edge[1];
+ x->mb_to_left_edge = edge[2];
+ x->mb_to_right_edge = edge[3];
+
+ x->pre.u_buffer = u1;
+ x->pre.v_buffer = v1;
+
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.u_buffer = u2;
+ x->second_pre.v_buffer = v2;
+ }
+}
+#endif
+
+void vp9_build_inter32x32_predictors_sb(MACROBLOCKD *x,
+ uint8_t *dst_y,
+ uint8_t *dst_u,
+ uint8_t *dst_v,
+ int dst_ystride,
+ int dst_uvstride,
+ int mb_row,
+ int mb_col) {
+ vp9_build_inter32x32_predictors_sby(x, dst_y, dst_ystride,
+ mb_row, mb_col);
+ vp9_build_inter32x32_predictors_sbuv(x, dst_u, dst_v, dst_uvstride,
+ mb_row, mb_col);
#if CONFIG_COMP_INTERINTRA_PRED
if (x->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
vp9_build_interintra_32x32_predictors_sb(
@@ -663,17 +1360,133 @@
#endif
}
-void vp9_build_inter64x64_predictors_sb(MACROBLOCKD *x,
- uint8_t *dst_y,
- uint8_t *dst_u,
- uint8_t *dst_v,
- int dst_ystride,
- int dst_uvstride,
- int mb_row,
- int mb_col) {
- uint8_t *y1 = x->pre.y_buffer, *u1 = x->pre.u_buffer, *v1 = x->pre.v_buffer;
- uint8_t *y2 = x->second_pre.y_buffer, *u2 = x->second_pre.u_buffer,
- *v2 = x->second_pre.v_buffer;
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+static void build_inter64x64_predictors_sby_w(MACROBLOCKD *x,
+ uint8_t *dst_y,
+ int dst_ystride,
+ int weight,
+ int mb_row,
+ int mb_col) {
+ uint8_t *y1 = x->pre.y_buffer;
+ uint8_t *y2 = x->second_pre.y_buffer;
+ int edge[4], n;
+
+ edge[0] = x->mb_to_top_edge;
+ edge[1] = x->mb_to_bottom_edge;
+ edge[2] = x->mb_to_left_edge;
+ edge[3] = x->mb_to_right_edge;
+
+ for (n = 0; n < 4; n++) {
+ const int x_idx = n & 1, y_idx = n >> 1;
+
+ x->mb_to_top_edge = edge[0] - ((y_idx * 32) << 3);
+ x->mb_to_bottom_edge = edge[1] + (((1 - y_idx) * 32) << 3);
+ x->mb_to_left_edge = edge[2] - ((x_idx * 32) << 3);
+ x->mb_to_right_edge = edge[3] + (((1 - x_idx) * 32) << 3);
+
+ x->pre.y_buffer = y1 + scaled_buffer_offset(x_idx * 32,
+ y_idx * 32,
+ x->pre.y_stride,
+ &x->scale_factor[0]);
+
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.y_buffer = y2 +
+ scaled_buffer_offset(x_idx * 32,
+ y_idx * 32,
+ x->second_pre.y_stride,
+ &x->scale_factor[1]);
+ }
+
+ build_inter32x32_predictors_sby_w(x,
+ dst_y + y_idx * 32 * dst_ystride + x_idx * 32,
+ dst_ystride, weight, mb_row + y_idx * 2, mb_col + x_idx * 2);
+ }
+
+ x->mb_to_top_edge = edge[0];
+ x->mb_to_bottom_edge = edge[1];
+ x->mb_to_left_edge = edge[2];
+ x->mb_to_right_edge = edge[3];
+
+ x->pre.y_buffer = y1;
+
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.y_buffer = y2;
+ }
+}
+
+void vp9_build_inter64x64_predictors_sby(MACROBLOCKD *x,
+ uint8_t *dst_y,
+ int dst_ystride,
+ int mb_row,
+ int mb_col) {
+ int weight = get_implicit_compoundinter_weight(x, mb_row, mb_col);
+ build_inter64x64_predictors_sby_w(x, dst_y, dst_ystride, weight,
+ mb_row, mb_col);
+}
+
+#else
+
+void vp9_build_inter64x64_predictors_sby(MACROBLOCKD *x,
+ uint8_t *dst_y,
+ int dst_ystride,
+ int mb_row,
+ int mb_col) {
+ uint8_t *y1 = x->pre.y_buffer;
+ uint8_t *y2 = x->second_pre.y_buffer;
+ int edge[4], n;
+
+ edge[0] = x->mb_to_top_edge;
+ edge[1] = x->mb_to_bottom_edge;
+ edge[2] = x->mb_to_left_edge;
+ edge[3] = x->mb_to_right_edge;
+
+ for (n = 0; n < 4; n++) {
+ const int x_idx = n & 1, y_idx = n >> 1;
+
+ x->mb_to_top_edge = edge[0] - ((y_idx * 32) << 3);
+ x->mb_to_bottom_edge = edge[1] + (((1 - y_idx) * 32) << 3);
+ x->mb_to_left_edge = edge[2] - ((x_idx * 32) << 3);
+ x->mb_to_right_edge = edge[3] + (((1 - x_idx) * 32) << 3);
+
+ x->pre.y_buffer = y1 + scaled_buffer_offset(x_idx * 32,
+ y_idx * 32,
+ x->pre.y_stride,
+ &x->scale_factor[0]);
+
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.y_buffer = y2 +
+ scaled_buffer_offset(x_idx * 32,
+ y_idx * 32,
+ x->second_pre.y_stride,
+ &x->scale_factor[1]);
+ }
+
+ vp9_build_inter32x32_predictors_sby(x,
+ dst_y + y_idx * 32 * dst_ystride + x_idx * 32,
+ dst_ystride, mb_row + y_idx * 2, mb_col + x_idx * 2);
+ }
+
+ x->mb_to_top_edge = edge[0];
+ x->mb_to_bottom_edge = edge[1];
+ x->mb_to_left_edge = edge[2];
+ x->mb_to_right_edge = edge[3];
+
+ x->pre.y_buffer = y1;
+
+ if (x->mode_info_context->mbmi.second_ref_frame > 0) {
+ x->second_pre.y_buffer = y2;
+ }
+}
+#endif
+
+void vp9_build_inter64x64_predictors_sbuv(MACROBLOCKD *x,
+ uint8_t *dst_u,
+ uint8_t *dst_v,
+ int dst_uvstride,
+ int mb_row,
+ int mb_col) {
+ uint8_t *u1 = x->pre.u_buffer, *v1 = x->pre.v_buffer;
+ uint8_t *u2 = x->second_pre.u_buffer, *v2 = x->second_pre.v_buffer;
int edge[4], n;
edge[0] = x->mb_to_top_edge;
@@ -690,10 +1503,6 @@
x->mb_to_left_edge = edge[2] - ((x_idx * 32) << 3);
x->mb_to_right_edge = edge[3] + (((1 - x_idx) * 32) << 3);
- x->pre.y_buffer = y1 + scaled_buffer_offset(x_idx * 32,
- y_idx * 32,
- x->pre.y_stride,
- &x->scale_factor[0]);
scaled_uv_offset = scaled_buffer_offset(x_idx * 16,
y_idx * 16,
x->pre.uv_stride,
@@ -702,11 +1511,6 @@
x->pre.v_buffer = v1 + scaled_uv_offset;
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
- x->second_pre.y_buffer = y2 +
- scaled_buffer_offset(x_idx * 32,
- y_idx * 32,
- x->second_pre.y_stride,
- &x->scale_factor[1]);
scaled_uv_offset = scaled_buffer_offset(x_idx * 16,
y_idx * 16,
x->second_pre.uv_stride,
@@ -715,11 +1519,10 @@
x->second_pre.v_buffer = v2 + scaled_uv_offset;
}
- vp9_build_inter32x32_predictors_sb(x,
- dst_y + y_idx * 32 * dst_ystride + x_idx * 32,
+ vp9_build_inter32x32_predictors_sbuv(x,
dst_u + y_idx * 16 * dst_uvstride + x_idx * 16,
dst_v + y_idx * 16 * dst_uvstride + x_idx * 16,
- dst_ystride, dst_uvstride, mb_row + y_idx * 2, mb_col + x_idx * 2);
+ dst_uvstride, mb_row + y_idx * 2, mb_col + x_idx * 2);
}
x->mb_to_top_edge = edge[0];
@@ -727,16 +1530,27 @@
x->mb_to_left_edge = edge[2];
x->mb_to_right_edge = edge[3];
- x->pre.y_buffer = y1;
x->pre.u_buffer = u1;
x->pre.v_buffer = v1;
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
- x->second_pre.y_buffer = y2;
x->second_pre.u_buffer = u2;
x->second_pre.v_buffer = v2;
}
+}
+void vp9_build_inter64x64_predictors_sb(MACROBLOCKD *x,
+ uint8_t *dst_y,
+ uint8_t *dst_u,
+ uint8_t *dst_v,
+ int dst_ystride,
+ int dst_uvstride,
+ int mb_row,
+ int mb_col) {
+ vp9_build_inter64x64_predictors_sby(x, dst_y, dst_ystride,
+ mb_row, mb_col);
+ vp9_build_inter64x64_predictors_sbuv(x, dst_u, dst_v, dst_uvstride,
+ mb_row, mb_col);
#if CONFIG_COMP_INTERINTRA_PRED
if (x->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
vp9_build_interintra_64x64_predictors_sb(x, dst_y, dst_u, dst_v,
@@ -752,6 +1566,11 @@
BLOCKD *blockd = xd->block;
int which_mv = 0;
const int use_second_ref = mbmi->second_ref_frame > 0;
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT && defined(USE_IMPLICIT_WEIGHT_SPLITMV)
+ int weight = get_implicit_compoundinter_weight_splitmv(xd, mb_row, mb_col);
+#else
+ int weight = AVERAGE_WEIGHT;
+#endif
if (xd->mode_info_context->mbmi.partitioning != PARTITIONING_4X4) {
for (i = 0; i < 16; i += 8) {
@@ -768,9 +1587,9 @@
clamp_mv_to_umv_border(&blockd[i + 2].bmi.as_mv[which_mv].as_mv, xd);
}
- build_2x1_inter_predictor(d0, d1, xd->scale_factor, 8, 16,
- which_mv, &xd->subpix,
- mb_row * 16 + y, mb_col * 16);
+ build_2x1_inter_predictor(d0, d1, xd->scale_factor, 8, 16, which_mv,
+ which_mv ? weight : 0,
+ &xd->subpix, mb_row * 16 + y, mb_col * 16);
}
}
} else {
@@ -784,13 +1603,18 @@
blockd[i + 1].bmi = xd->mode_info_context->bmi[i + 1];
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
- build_2x1_inter_predictor(d0, d1, xd->scale_factor, 4, 16,
- which_mv, &xd->subpix,
+ build_2x1_inter_predictor(d0, d1, xd->scale_factor, 4, 16, which_mv,
+ which_mv ? weight : 0,
+ &xd->subpix,
mb_row * 16 + y, mb_col * 16 + x);
}
}
}
-
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+#if !defined(USE_IMPLICIT_WEIGHT_UV)
+ weight = AVERAGE_WEIGHT;
+#endif
+#endif
for (i = 16; i < 24; i += 2) {
BLOCKD *d0 = &blockd[i];
BLOCKD *d1 = &blockd[i + 1];
@@ -798,8 +1622,8 @@
const int y = ((i - 16) >> 1) * 4;
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
- build_2x1_inter_predictor(d0, d1, xd->scale_factor_uv, 4, 8,
- which_mv, &xd->subpix,
+ build_2x1_inter_predictor(d0, d1, xd->scale_factor_uv, 4, 8, which_mv,
+ which_mv ? weight : 0, &xd->subpix,
mb_row * 8 + y, mb_col * 8 + x);
}
}
@@ -876,9 +1700,14 @@
vp9_build_inter16x16_predictors_mby(xd, dst_y, dst_ystride, mb_row, mb_col);
vp9_build_inter16x16_predictors_mbuv(xd, dst_u, dst_v, dst_uvstride,
mb_row, mb_col);
+#if CONFIG_COMP_INTERINTRA_PRED
+ if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
+ vp9_build_interintra_16x16_predictors_mb(xd, dst_y, dst_u, dst_v,
+ dst_ystride, dst_uvstride);
+ }
+#endif
}
-
void vp9_build_inter_predictors_mb(MACROBLOCKD *xd,
int mb_row,
int mb_col) {
@@ -888,15 +1717,116 @@
&xd->predictor[320], 16, 8,
mb_row, mb_col);
-#if CONFIG_COMP_INTERINTRA_PRED
- if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
- vp9_build_interintra_16x16_predictors_mb(xd, xd->predictor,
- &xd->predictor[256],
- &xd->predictor[320], 16, 8);
- }
-#endif
} else {
build_4x4uvmvs(xd);
build_inter4x4_predictors_mb(xd, mb_row, mb_col);
}
}
+
+/*encoder only*/
+void vp9_build_inter4x4_predictors_mbuv(MACROBLOCKD *xd,
+ int mb_row,
+ int mb_col) {
+ int i, j;
+ int weight;
+ BLOCKD *blockd = xd->block;
+
+ /* build uv mvs */
+ for (i = 0; i < 2; i++) {
+ for (j = 0; j < 2; j++) {
+ int yoffset = i * 8 + j * 2;
+ int uoffset = 16 + i * 2 + j;
+ int voffset = 20 + i * 2 + j;
+ int temp;
+
+ temp = blockd[yoffset ].bmi.as_mv[0].as_mv.row
+ + blockd[yoffset + 1].bmi.as_mv[0].as_mv.row
+ + blockd[yoffset + 4].bmi.as_mv[0].as_mv.row
+ + blockd[yoffset + 5].bmi.as_mv[0].as_mv.row;
+
+ if (temp < 0)
+ temp -= 4;
+ else
+ temp += 4;
+
+ xd->block[uoffset].bmi.as_mv[0].as_mv.row = (temp / 8) &
+ xd->fullpixel_mask;
+
+ temp = blockd[yoffset ].bmi.as_mv[0].as_mv.col
+ + blockd[yoffset + 1].bmi.as_mv[0].as_mv.col
+ + blockd[yoffset + 4].bmi.as_mv[0].as_mv.col
+ + blockd[yoffset + 5].bmi.as_mv[0].as_mv.col;
+
+ if (temp < 0)
+ temp -= 4;
+ else
+ temp += 4;
+
+ blockd[uoffset].bmi.as_mv[0].as_mv.col = (temp / 8) &
+ xd->fullpixel_mask;
+
+ blockd[voffset].bmi.as_mv[0].as_mv.row =
+ blockd[uoffset].bmi.as_mv[0].as_mv.row;
+ blockd[voffset].bmi.as_mv[0].as_mv.col =
+ blockd[uoffset].bmi.as_mv[0].as_mv.col;
+
+ if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
+ temp = blockd[yoffset ].bmi.as_mv[1].as_mv.row
+ + blockd[yoffset + 1].bmi.as_mv[1].as_mv.row
+ + blockd[yoffset + 4].bmi.as_mv[1].as_mv.row
+ + blockd[yoffset + 5].bmi.as_mv[1].as_mv.row;
+
+ if (temp < 0) {
+ temp -= 4;
+ } else {
+ temp += 4;
+ }
+
+ blockd[uoffset].bmi.as_mv[1].as_mv.row = (temp / 8) &
+ xd->fullpixel_mask;
+
+ temp = blockd[yoffset ].bmi.as_mv[1].as_mv.col
+ + blockd[yoffset + 1].bmi.as_mv[1].as_mv.col
+ + blockd[yoffset + 4].bmi.as_mv[1].as_mv.col
+ + blockd[yoffset + 5].bmi.as_mv[1].as_mv.col;
+
+ if (temp < 0) {
+ temp -= 4;
+ } else {
+ temp += 4;
+ }
+
+ blockd[uoffset].bmi.as_mv[1].as_mv.col = (temp / 8) &
+ xd->fullpixel_mask;
+
+ blockd[voffset].bmi.as_mv[1].as_mv.row =
+ blockd[uoffset].bmi.as_mv[1].as_mv.row;
+ blockd[voffset].bmi.as_mv[1].as_mv.col =
+ blockd[uoffset].bmi.as_mv[1].as_mv.col;
+ }
+ }
+ }
+
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT && \
+ defined(USE_IMPLICIT_WEIGHT_SPLITMV) && \
+ defined(USE_IMPLICIT_WEIGHT_UV)
+ weight = get_implicit_compoundinter_weight_splitmv(xd, mb_row, mb_col);
+#else
+ weight = AVERAGE_WEIGHT;
+#endif
+ for (i = 16; i < 24; i += 2) {
+ const int use_second_ref = xd->mode_info_context->mbmi.second_ref_frame > 0;
+ const int x = 4 * (i & 1);
+ const int y = ((i - 16) >> 1) * 4;
+
+ int which_mv;
+ BLOCKD *d0 = &blockd[i];
+ BLOCKD *d1 = &blockd[i + 1];
+
+ for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
+ build_2x1_inter_predictor(d0, d1, xd->scale_factor_uv, 4, 8, which_mv,
+ which_mv ? weight : 0,
+ &xd->subpix, mb_row * 8 + y, mb_col * 8 + x);
+ }
+ }
+}
diff --git a/vp9/common/vp9_rtcd_defs.sh b/vp9/common/vp9_rtcd_defs.sh
index c1153ed..8de6850 100644
--- a/vp9/common/vp9_rtcd_defs.sh
+++ b/vp9/common/vp9_rtcd_defs.sh
@@ -276,6 +276,62 @@
prototype void vp9_convolve8_avg_vert "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
specialize vp9_convolve8_avg_vert ssse3
+#if CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT
+prototype void vp9_convolve8_1by8 "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_1by8
+
+prototype void vp9_convolve8_qtr "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_qtr
+
+prototype void vp9_convolve8_3by8 "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_3by8
+
+prototype void vp9_convolve8_5by8 "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_5by8
+
+prototype void vp9_convolve8_3qtr "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_3qtr
+
+prototype void vp9_convolve8_7by8 "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_7by8
+
+prototype void vp9_convolve8_1by8_horiz "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_1by8_horiz
+
+prototype void vp9_convolve8_qtr_horiz "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_qtr_horiz
+
+prototype void vp9_convolve8_3by8_horiz "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_3by8_horiz
+
+prototype void vp9_convolve8_5by8_horiz "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_5by8_horiz
+
+prototype void vp9_convolve8_3qtr_horiz "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_3qtr_horiz
+
+prototype void vp9_convolve8_7by8_horiz "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_7by8_horiz
+
+prototype void vp9_convolve8_1by8_vert "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_1by8_vert
+
+prototype void vp9_convolve8_qtr_vert "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_qtr_vert
+
+prototype void vp9_convolve8_3by8_vert "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_3by8_vert
+
+prototype void vp9_convolve8_5by8_vert "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_5by8_vert
+
+prototype void vp9_convolve8_3qtr_vert "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_3qtr_vert
+
+prototype void vp9_convolve8_7by8_vert "const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h"
+specialize vp9_convolve8_7by8_vert
+#endif
+
#
# dct
#
diff --git a/vp9/decoder/vp9_decodemv.c b/vp9/decoder/vp9_decodemv.c
index ddfdaba..9cb1814 100644
--- a/vp9/decoder/vp9_decodemv.c
+++ b/vp9/decoder/vp9_decodemv.c
@@ -815,7 +815,7 @@
second_ref_fb_idx = cm->active_ref_idx[mbmi->second_ref_frame - 1];
setup_pred_block(&xd->second_pre, &cm->yv12_fb[second_ref_fb_idx],
- mb_row, mb_col, &xd->scale_factor[1], &xd->scale_factor_uv[1]);
+ mb_row, mb_col, &xd->scale_factor[1], &xd->scale_factor_uv[1]);
vp9_find_mv_refs(cm, xd, mi, use_prev_in_find_mv_refs ? prev_mi : NULL,
mbmi->second_ref_frame,
diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c
index 8023740..246d4ac 100644
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -195,16 +195,6 @@
xd->dst.y_stride,
xd->dst.uv_stride,
mb_row, mb_col);
-#if CONFIG_COMP_INTERINTRA_PRED
- if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
- vp9_build_interintra_16x16_predictors_mb(xd,
- xd->dst.y_buffer,
- xd->dst.u_buffer,
- xd->dst.v_buffer,
- xd->dst.y_stride,
- xd->dst.uv_stride);
- }
-#endif
}
}
}
@@ -212,7 +202,7 @@
static void decode_16x16(VP9D_COMP *pbi, MACROBLOCKD *xd,
BOOL_DECODER* const bc) {
TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
-#ifdef DEC_DEBUG
+#if 0 // def DEC_DEBUG
if (dec_debug) {
int i;
printf("\n");
@@ -250,7 +240,7 @@
// First do Y
// if the first one is DCT_DCT assume all the rest are as well
TX_TYPE tx_type = get_tx_type_8x8(xd, 0);
-#ifdef DEC_DEBUG
+#if 0 // def DEC_DEBUG
if (dec_debug) {
int i;
printf("\n");
@@ -322,7 +312,7 @@
xd->predictor + 16 * 16, xd->dst.u_buffer, xd->dst.v_buffer,
xd->dst.uv_stride, xd);
}
-#ifdef DEC_DEBUG
+#if 0 // def DEC_DEBUG
if (dec_debug) {
int i;
printf("\n");
@@ -340,6 +330,17 @@
TX_TYPE tx_type;
int i, eobtotal = 0;
MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
+#if 0 // def DEC_DEBUG
+ if (dec_debug) {
+ int i;
+ printf("\n");
+ printf("predictor\n");
+ for (i = 0; i < 384; i++) {
+ printf("%3d ", xd->predictor[i]);
+ if (i % 16 == 15) printf("\n");
+ }
+ }
+#endif
if (mode == I8X8_PRED) {
for (i = 0; i < 4; i++) {
int ib = vp9_i8x8_block[i];
@@ -420,7 +421,7 @@
xd->dst.uv_stride,
xd);
} else {
-#ifdef DEC_DEBUG
+#if 0 // def DEC_DEBUG
if (dec_debug) {
int i;
printf("\n");
@@ -834,14 +835,14 @@
skip_recon_mb(pbi, xd, mb_row, mb_col);
return;
}
-#ifdef DEC_DEBUG
+#if 0 // def DEC_DEBUG
if (dec_debug)
printf("Decoding mb: %d %d\n", xd->mode_info_context->mbmi.mode, tx_size);
#endif
// moved to be performed before detokenization
-// if (xd->segmentation_enabled)
-// mb_init_dequantizer(pbi, xd);
+ // if (xd->segmentation_enabled)
+ // mb_init_dequantizer(pbi, xd);
/* do prediction */
if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
@@ -852,7 +853,7 @@
}
}
} else {
-#ifdef DEC_DEBUG
+#if 0 // def DEC_DEBUG
if (dec_debug)
printf("Decoding mb: %d %d interp %d\n",
xd->mode_info_context->mbmi.mode, tx_size,
@@ -872,6 +873,13 @@
if (dec_debug) {
int i, j;
printf("\n");
+ printf("predictor y\n");
+ for (i = 0; i < 16; i++) {
+ for (j = 0; j < 16; j++)
+ printf("%3d ", xd->predictor[i * 16 + j]);
+ printf("\n");
+ }
+ printf("\n");
printf("final y\n");
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++)
@@ -994,9 +1002,10 @@
mb_col < pc->cur_tile_mb_col_end; mb_col += 4) {
if (vp9_read(bc, pc->sb64_coded)) {
#ifdef DEC_DEBUG
- dec_debug = (pc->current_video_frame == 1 && mb_row == 0 && mb_col == 0);
+ dec_debug = (pc->current_video_frame == 11 && pc->show_frame &&
+ mb_row == 8 && mb_col == 0);
if (dec_debug)
- printf("Debug\n");
+ printf("Debug Decode SB64\n");
#endif
set_offsets(pbi, 64, mb_row, mb_col);
vp9_decode_mb_mode_mv(pbi, xd, mb_row, mb_col, bc);
@@ -1019,8 +1028,10 @@
if (vp9_read(bc, pc->sb32_coded)) {
#ifdef DEC_DEBUG
- dec_debug = (pc->current_video_frame == 1 &&
- mb_row + y_idx_sb == 0 && mb_col + x_idx_sb == 0);
+ dec_debug = (pc->current_video_frame == 11 && pc->show_frame &&
+ mb_row + y_idx_sb == 8 && mb_col + x_idx_sb == 0);
+ if (dec_debug)
+ printf("Debug Decode SB32\n");
#endif
set_offsets(pbi, 32, mb_row + y_idx_sb, mb_col + x_idx_sb);
vp9_decode_mb_mode_mv(pbi,
@@ -1043,8 +1054,10 @@
continue;
}
#ifdef DEC_DEBUG
- dec_debug = (pc->current_video_frame == 1 &&
- mb_row + y_idx == 0 && mb_col + x_idx == 0);
+ dec_debug = (pc->current_video_frame == 11 && pc->show_frame &&
+ mb_row + y_idx == 8 && mb_col + x_idx == 0);
+ if (dec_debug)
+ printf("Debug Decode MB\n");
#endif
set_offsets(pbi, 16, mb_row + y_idx, mb_col + x_idx);
diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index 5e17c55..e4d097d 100644
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -757,7 +757,7 @@
// as a predictor for MBs that follow in the SB
if (cm->frame_type == KEY_FRAME) {
int r, d;
-#ifdef ENC_DEBUG
+#if 0 // ENC_DEBUG
if (enc_debug)
printf("intra pick_mb_modes %d %d\n", mb_row, mb_col);
#endif
@@ -776,7 +776,7 @@
} else {
int seg_id, r, d;
-#ifdef ENC_DEBUG
+#if 0 // ENC_DEBUG
if (enc_debug)
printf("inter pick_mb_modes %d %d\n", mb_row, mb_col);
#endif
@@ -2057,8 +2057,8 @@
assert(!xd->mode_info_context->mbmi.sb_type);
#ifdef ENC_DEBUG
- enc_debug = (cpi->common.current_video_frame == 1 &&
- mb_row == 0 && mb_col == 0 && output_enabled);
+ enc_debug = (cpi->common.current_video_frame == 11 && cm->show_frame &&
+ mb_row == 8 && mb_col == 0 && output_enabled);
if (enc_debug)
printf("Encode MB %d %d output %d\n", mb_row, mb_col, output_enabled);
#endif
@@ -2105,7 +2105,7 @@
}
if (mbmi->ref_frame == INTRA_FRAME) {
-#ifdef ENC_DEBUG
+#if 0 // def ENC_DEBUG
if (enc_debug) {
printf("Mode %d skip %d tx_size %d\n", mbmi->mode, x->skip,
mbmi->txfm_size);
@@ -2316,10 +2316,16 @@
const int mis = cm->mode_info_stride;
#ifdef ENC_DEBUG
- enc_debug = (cpi->common.current_video_frame == 1 &&
- mb_row == 0 && mb_col == 0 && output_enabled);
- if (enc_debug)
+ enc_debug = (cpi->common.current_video_frame == 11 && cm->show_frame &&
+ mb_row == 8 && mb_col == 0 && output_enabled);
+ if (enc_debug) {
printf("Encode SB32 %d %d output %d\n", mb_row, mb_col, output_enabled);
+ printf("Mode %d skip %d tx_size %d ref %d ref2 %d mv %d %d interp %d\n",
+ mi->mbmi.mode, x->skip, mi->mbmi.txfm_size,
+ mi->mbmi.ref_frame, mi->mbmi.second_ref_frame,
+ mi->mbmi.mv[0].as_mv.row, mi->mbmi.mv[0].as_mv.col,
+ mi->mbmi.interp_filter);
+ }
#endif
if (cm->frame_type == KEY_FRAME) {
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
@@ -2537,8 +2543,8 @@
const int mis = cm->mode_info_stride;
#ifdef ENC_DEBUG
- enc_debug = (cpi->common.current_video_frame == 1 &&
- mb_row == 0 && mb_col == 0 && output_enabled);
+ enc_debug = (cpi->common.current_video_frame == 11 && cm->show_frame &&
+ mb_row == 8 && mb_col == 0 && output_enabled);
if (enc_debug)
printf("Encode SB64 %d %d output %d\n", mb_row, mb_col, output_enabled);
#endif
diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index 04b732a..a765782 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -2424,13 +2424,15 @@
&xd->scale_factor[0],
4, 4, 0 /* no avg */, &xd->subpix);
+ // TODO(debargha): Make this work properly with the
+ // implicit-compoundinter-weight experiment when implicit
+ // weighting for splitmv modes is turned on.
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
- vp9_build_inter_predictor(*(bd->base_second_pre) + bd->pre,
- bd->pre_stride,
- bd->predictor, 16,
- &bd->bmi.as_mv[1],
- &xd->scale_factor[1],
- 4, 4, 1 /* avg */, &xd->subpix);
+ vp9_build_inter_predictor(
+ *(bd->base_second_pre) + bd->pre, bd->pre_stride, bd->predictor, 16,
+ &bd->bmi.as_mv[1], &xd->scale_factor[1], 4, 4,
+ 1 << (2 * CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT) /* avg */,
+ &xd->subpix);
}
vp9_subtract_b(be, bd, 16);
@@ -2486,12 +2488,14 @@
for (which_mv = 0; which_mv < 1 + use_second_ref; ++which_mv) {
uint8_t **base_pre = which_mv ? bd->base_second_pre : bd->base_pre;
- vp9_build_inter_predictor(*base_pre + bd->pre,
- bd->pre_stride,
- bd->predictor, 16,
- &bd->bmi.as_mv[which_mv],
- &xd->scale_factor[which_mv],
- 8, 8, which_mv, &xd->subpix);
+ // TODO(debargha): Make this work properly with the
+ // implicit-compoundinter-weight experiment when implicit
+ // weighting for splitmv modes is turned on.
+ vp9_build_inter_predictor(
+ *base_pre + bd->pre, bd->pre_stride, bd->predictor, 16,
+ &bd->bmi.as_mv[which_mv], &xd->scale_factor[which_mv], 8, 8,
+ which_mv << (2 * CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT),
+ &xd->subpix);
}
vp9_subtract_4b_c(be, bd, 16);
@@ -3866,27 +3870,10 @@
unsigned int sse, var;
int tmp_rate_y, tmp_rate_u, tmp_rate_v;
int tmp_dist_y, tmp_dist_u, tmp_dist_v;
- // TODO(jkoleszar): these 2 y/uv should be replaced with one call to
- // vp9_build_interintra_16x16_predictors_mb().
- vp9_build_inter16x16_predictors_mby(xd, xd->predictor, 16,
- mb_row, mb_col);
-
-#if CONFIG_COMP_INTERINTRA_PRED
- if (is_comp_interintra_pred) {
- vp9_build_interintra_16x16_predictors_mby(xd, xd->predictor, 16);
- }
-#endif
-
- vp9_build_inter16x16_predictors_mbuv(xd, xd->predictor + 256,
- xd->predictor + 320, 8,
- mb_row, mb_col);
-
-#if CONFIG_COMP_INTERINTRA_PRED
- if (is_comp_interintra_pred) {
- vp9_build_interintra_16x16_predictors_mbuv(xd, xd->predictor + 256,
- xd->predictor + 320, 8);
- }
-#endif
+ vp9_build_inter16x16_predictors_mb(xd, xd->predictor,
+ xd->predictor + 256,
+ xd->predictor + 320,
+ 16, 8, mb_row, mb_col);
var = vp9_variance16x16(*(b->base_src), b->src_stride,
xd->predictor, 16, &sse);
// Note our transform coeffs are 8 times an orthogonal transform.
@@ -3986,24 +3973,10 @@
xd->dst.uv_stride,
mb_row, mb_col);
} else {
- // TODO(jkoleszar): These y/uv fns can be replaced with their mb
- // equivalent
- vp9_build_inter16x16_predictors_mby(xd, xd->predictor, 16,
- mb_row, mb_col);
-#if CONFIG_COMP_INTERINTRA_PRED
- if (is_comp_interintra_pred) {
- vp9_build_interintra_16x16_predictors_mby(xd, xd->predictor, 16);
- }
-#endif
- vp9_build_inter16x16_predictors_mbuv(xd, &xd->predictor[256],
- &xd->predictor[320], 8,
- mb_row, mb_col);
-#if CONFIG_COMP_INTERINTRA_PRED
- if (is_comp_interintra_pred) {
- vp9_build_interintra_16x16_predictors_mbuv(xd, &xd->predictor[256],
- &xd->predictor[320], 8);
- }
-#endif
+ vp9_build_inter16x16_predictors_mb(xd, xd->predictor,
+ xd->predictor + 256,
+ xd->predictor + 320,
+ 16, 8, mb_row, mb_col);
}
}
@@ -4586,7 +4559,7 @@
vpx_memcpy(x->partition_info, &tmp_best_partition,
sizeof(PARTITION_INFO));
for (i = 0; i < 16; i++) {
- xd->block[i].bmi = tmp_best_bmodes[i];
+ xd->block[i].bmi = xd->mode_info_context->bmi[i] = tmp_best_bmodes[i];
}
}
diff --git a/vp9/encoder/vp9_temporal_filter.c b/vp9/encoder/vp9_temporal_filter.c
index dc1d3d4..22a12f4 100644
--- a/vp9/encoder/vp9_temporal_filter.c
+++ b/vp9/encoder/vp9_temporal_filter.c
@@ -54,7 +54,10 @@
&pred[0], 16,
&subpel_mv,
&xd->scale_factor[which_mv],
- 16, 16, which_mv, &xd->subpix);
+ 16, 16,
+ which_mv <<
+ (2 * CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT),
+ &xd->subpix);
stride = (stride + 1) >> 1;
@@ -62,13 +65,19 @@
&pred[256], 8,
&fullpel_mv, &subpel_mv,
&xd->scale_factor_uv[which_mv],
- 8, 8, which_mv, &xd->subpix);
+ 8, 8,
+ which_mv <<
+ (2 * CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT),
+ &xd->subpix);
vp9_build_inter_predictor_q4(v_mb_ptr, stride,
&pred[320], 8,
&fullpel_mv, &subpel_mv,
&xd->scale_factor_uv[which_mv],
- 8, 8, which_mv, &xd->subpix);
+ 8, 8,
+ which_mv <<
+ (2 * CONFIG_IMPLICIT_COMPOUNDINTER_WEIGHT),
+ &xd->subpix);
}
void vp9_temporal_filter_apply_c(uint8_t *frame1,
diff --git a/vpxenc.c b/vpxenc.c
index e915efd..87205e6 100644
--- a/vpxenc.c
+++ b/vpxenc.c
@@ -1488,7 +1488,7 @@
const unsigned int bsize2 = bsize >> 1;
unsigned int match = 1;
unsigned int i, j;
- yloc[0] = yloc[1] = -1;
+ yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
for (j = 0; match && j < img1->d_w; j += bsize) {
int k, l;
@@ -1502,13 +1502,17 @@
(i + k) * img2->stride[VPX_PLANE_Y] + j + l)) {
yloc[0] = i + k;
yloc[1] = j + l;
+ yloc[2] = *(img1->planes[VPX_PLANE_Y] +
+ (i + k) * img1->stride[VPX_PLANE_Y] + j + l);
+ yloc[3] = *(img2->planes[VPX_PLANE_Y] +
+ (i + k) * img2->stride[VPX_PLANE_Y] + j + l);
match = 0;
break;
}
}
}
}
- uloc[0] = uloc[1] = -1;
+ uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
for (i = 0, match = 1; match && i < (img1->d_h + 1) / 2; i += bsize2) {
for (j = 0; j < match && (img1->d_w + 1) / 2; j += bsize2) {
int k, l;
@@ -1522,13 +1526,17 @@
(i + k) * img2->stride[VPX_PLANE_U] + j + l)) {
uloc[0] = i + k;
uloc[1] = j + l;
+ uloc[2] = *(img1->planes[VPX_PLANE_U] +
+ (i + k) * img1->stride[VPX_PLANE_U] + j + l);
+ uloc[3] = *(img2->planes[VPX_PLANE_U] +
+ (i + k) * img2->stride[VPX_PLANE_V] + j + l);
match = 0;
break;
}
}
}
}
- vloc[0] = vloc[1] = -1;
+ vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
for (i = 0, match = 1; match && i < (img1->d_h + 1) / 2; i += bsize2) {
for (j = 0; j < match && (img1->d_w + 1) / 2; j += bsize2) {
int k, l;
@@ -1542,6 +1550,10 @@
(i + k) * img2->stride[VPX_PLANE_V] + j + l)) {
vloc[0] = i + k;
vloc[1] = j + l;
+ vloc[2] = *(img1->planes[VPX_PLANE_V] +
+ (i + k) * img1->stride[VPX_PLANE_V] + j + l);
+ vloc[3] = *(img2->planes[VPX_PLANE_V] +
+ (i + k) * img2->stride[VPX_PLANE_V] + j + l);
match = 0;
break;
}
@@ -2454,14 +2466,18 @@
ctx_exit_on_error(&stream->decoder, "Failed to get decoder reference frame");
if (!compare_img(&enc_img, &dec_img)) {
- int y[2], u[2], v[2];
+ int y[4], u[4], v[4];
find_mismatch(&enc_img, &dec_img, y, u, v);
stream->decoder.err = 1;
warn_or_exit_on_error(&stream->decoder, fatal == TEST_DECODE_FATAL,
- "Stream %d: Encode/decode mismatch on frame %d"
- " at Y[%d, %d], U[%d, %d], V[%d, %d]",
+ "Stream %d: Encode/decode mismatch on frame %d at"
+ " Y[%d, %d] {%d/%d},"
+ " U[%d, %d] {%d/%d},"
+ " V[%d, %d] {%d/%d}",
stream->index, stream->frames_out,
- y[0], y[1], u[0], u[1], v[0], v[1]);
+ y[0], y[1], y[2], y[3],
+ u[0], u[1], u[2], u[3],
+ v[0], v[1], v[2], v[3]);
stream->mismatch_seen = stream->frames_out;
}
