Merge "Cleaning up vp9_ratectrl.c."
diff --git a/build/make/rtcd.sh b/build/make/rtcd.sh
index 2967b5a..ed03713 100755
--- a/build/make/rtcd.sh
+++ b/build/make/rtcd.sh
@@ -209,6 +209,10 @@
#define RTCD_EXTERN extern
#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+
$(process_forward_decls)
$(declare_function_pointers c $ALL_ARCHS)
@@ -219,6 +223,11 @@
common_bottom() {
cat <<EOF
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
#endif
EOF
}
diff --git a/example_xma.c b/example_xma.c
deleted file mode 100644
index 7aa8798..0000000
--- a/example_xma.c
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-
-/* This is a simple program showing how to initialize the decoder in XMA mode */
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-#define VPX_CODEC_DISABLE_COMPAT 1
-#include "vpx_config.h"
-#include "vpx/vpx_decoder.h"
-#include "vpx/vpx_integer.h"
-#if CONFIG_VP9_DECODER
-#include "vpx/vp8dx.h"
-#endif
-
-static char *exec_name;
-static int verbose = 0;
-
-static const struct {
- const char *name;
- const vpx_codec_iface_t *iface;
-} ifaces[] = {
-#if CONFIG_VP9_DECODER
- {"vp9", &vpx_codec_vp8_dx_algo},
-#endif
-};
-
-static void usage_exit(void) {
- int i;
-
- printf("Usage: %s <options>\n\n"
- "Options:\n"
- "\t--codec <name>\tCodec to use (default=%s)\n"
- "\t-h <height>\tHeight of the simulated video frame, in pixels\n"
- "\t-w <width> \tWidth of the simulated video frame, in pixels\n"
- "\t-v \tVerbose mode (show individual segment sizes)\n"
- "\t--help \tShow this message\n"
- "\n"
- "Included decoders:\n"
- "\n",
- exec_name,
- ifaces[0].name);
-
- for (i = 0; i < sizeof(ifaces) / sizeof(ifaces[0]); i++)
- printf(" %-6s - %s\n",
- ifaces[i].name,
- vpx_codec_iface_name(ifaces[i].iface));
-
- exit(EXIT_FAILURE);
-}
-
-static void usage_error(const char *fmt, ...) {
- va_list ap;
- va_start(ap, fmt);
- vprintf(fmt, ap);
- printf("\n");
- usage_exit();
-}
-
-void my_mem_dtor(vpx_codec_mmap_t *mmap) {
- if (verbose)
- printf("freeing segment %d\n", mmap->id);
-
- free(mmap->priv);
-}
-
-int main(int argc, char **argv) {
- vpx_codec_ctx_t decoder;
- vpx_codec_iface_t *iface = ifaces[0].iface;
- vpx_codec_iter_t iter;
- vpx_codec_dec_cfg_t cfg;
- vpx_codec_err_t res = VPX_CODEC_OK;
- unsigned int alloc_sz = 0;
- unsigned int w = 352;
- unsigned int h = 288;
- int i;
-
- exec_name = argv[0];
-
- for (i = 1; i < argc; i++) {
- if (!strcmp(argv[i], "--codec")) {
- if (i + 1 < argc) {
- int j, k = -1;
-
- i++;
-
- for (j = 0; j < sizeof(ifaces) / sizeof(ifaces[0]); j++)
- if (!strcmp(ifaces[j].name, argv[i]))
- k = j;
-
- if (k >= 0)
- iface = ifaces[k].iface;
- else
- usage_error("Error: Unrecognized argument (%s) to --codec\n",
- argv[i]);
- } else
- usage_error("Error: Option --codec requires argument.\n");
- } else if (!strcmp(argv[i], "-v"))
- verbose = 1;
- else if (!strcmp(argv[i], "-h"))
- if (i + 1 < argc) {
- h = atoi(argv[++i]);
- } else
- usage_error("Error: Option -h requires argument.\n");
- else if (!strcmp(argv[i], "-w"))
- if (i + 1 < argc) {
- w = atoi(argv[++i]);
- } else
- usage_error("Error: Option -w requires argument.\n");
- else if (!strcmp(argv[i], "--help"))
- usage_exit();
- else
- usage_error("Error: Unrecognized option %s\n\n", argv[i]);
- }
-
- if (argc == 1)
- printf("Using built-in defaults. For options, rerun with --help\n\n");
-
- /* XMA mode is not supported on all decoders! */
- if (!(vpx_codec_get_caps(iface) & VPX_CODEC_CAP_XMA)) {
- printf("%s does not support XMA mode!\n", vpx_codec_iface_name(iface));
- return EXIT_FAILURE;
- }
-
- /* The codec knows how much memory to allocate based on the size of the
- * encoded frames. This data can be parsed from the bitstream with
- * vpx_codec_peek_stream_info() if a bitstream is available. Otherwise,
- * a fixed size can be used that will be the upper limit on the frame
- * size the decoder can decode.
- */
- cfg.w = w;
- cfg.h = h;
-
- /* Initialize the decoder in XMA mode. */
- if (vpx_codec_dec_init(&decoder, iface, &cfg, VPX_CODEC_USE_XMA)) {
- printf("Failed to initialize decoder in XMA mode: %s\n", vpx_codec_error(&decoder));
- return EXIT_FAILURE;
- }
-
- /* Iterate through the list of memory maps, allocating them with the
- * requested alignment.
- */
- iter = NULL;
-
- do {
- vpx_codec_mmap_t mmap;
- unsigned int align;
-
- res = vpx_codec_get_mem_map(&decoder, &mmap, &iter);
- align = mmap.align ? mmap.align - 1 : 0;
-
- if (!res) {
- if (verbose)
- printf("Allocating segment %u, size %lu, align %u %s\n",
- mmap.id, mmap.sz, mmap.align,
- mmap.flags & VPX_CODEC_MEM_ZERO ? "(ZEROED)" : "");
-
- if (mmap.flags & VPX_CODEC_MEM_ZERO)
- mmap.priv = calloc(1, mmap.sz + align);
- else
- mmap.priv = malloc(mmap.sz + align);
-
- mmap.base = (void *)((((uintptr_t)mmap.priv) + align) & ~(uintptr_t)align);
- mmap.dtor = my_mem_dtor;
- alloc_sz += mmap.sz + align;
-
- if (vpx_codec_set_mem_map(&decoder, &mmap, 1)) {
- printf("Failed to set mmap: %s\n", vpx_codec_error(&decoder));
- return EXIT_FAILURE;
- }
- } else if (res != VPX_CODEC_LIST_END) {
- printf("Failed to get mmap: %s\n", vpx_codec_error(&decoder));
- return EXIT_FAILURE;
- }
- } while (res != VPX_CODEC_LIST_END);
-
- printf("%s\n %d bytes external memory required for %dx%d.\n",
- decoder.name, alloc_sz, cfg.w, cfg.h);
- vpx_codec_destroy(&decoder);
- return EXIT_SUCCESS;
-
-}
diff --git a/examples.mk b/examples.mk
index 66b719c..b29ab9c 100644
--- a/examples.mk
+++ b/examples.mk
@@ -26,6 +26,7 @@
vpxdec.SRCS += ivfdec.c ivfdec.h
vpxdec.SRCS += tools_common.c tools_common.h
vpxdec.SRCS += webmdec.c webmdec.h
+vpxdec.SRCS += y4menc.c y4menc.h
vpxdec.SRCS += nestegg/halloc/halloc.h
vpxdec.SRCS += nestegg/halloc/src/align.h
vpxdec.SRCS += nestegg/halloc/src/halloc.c
@@ -109,11 +110,13 @@
vp8cx_set_ref.GUID = C5E31F7F-96F6-48BD-BD3E-10EBF6E8057A
vp8cx_set_ref.DESCRIPTION = VP8 set encoder reference frame
-# C file is provided, not generated automatically.
-UTILS-$(CONFIG_MULTI_RES_ENCODING) += vp8_multi_resolution_encoder.c
-vp8_multi_resolution_encoder.SRCS += $(LIBYUV_SRCS)
-vp8_multi_resolution_encoder.GUID = 04f8738e-63c8-423b-90fa-7c2703a374de
-vp8_multi_resolution_encoder.DESCRIPTION = VP8 Multiple-resolution Encoding
+
+ifeq ($(CONFIG_MULTI_RES_ENCODING),yes)
+GEN_EXAMPLES-$(CONFIG_VP8_DECODER) += vp8_multi_resolution_encoder.c
+vp8_multi_resolution_encoder.SRCS += $(LIBYUV_SRCS)
+vp8_multi_resolution_encoder.GUID = 04f8738e-63c8-423b-90fa-7c2703a374de
+vp8_multi_resolution_encoder.DESCRIPTION = VP8 Multiple-resolution Encoding
+endif
# Handle extra library flags depending on codec configuration
diff --git a/vp8_multi_resolution_encoder.c b/examples/vp8_multi_resolution_encoder.c
similarity index 100%
rename from vp8_multi_resolution_encoder.c
rename to examples/vp8_multi_resolution_encoder.c
diff --git a/test/codec_factory.h b/test/codec_factory.h
index 2ca6ff0..c060e86 100644
--- a/test/codec_factory.h
+++ b/test/codec_factory.h
@@ -10,7 +10,6 @@
#ifndef TEST_CODEC_FACTORY_H_
#define TEST_CODEC_FACTORY_H_
-extern "C" {
#include "./vpx_config.h"
#include "vpx/vpx_decoder.h"
#include "vpx/vpx_encoder.h"
@@ -20,7 +19,6 @@
#if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
#include "vpx/vp8dx.h"
#endif
-}
#include "test/decode_test_driver.h"
#include "test/encode_test_driver.h"
diff --git a/test/idct8x8_test.cc b/test/idct8x8_test.cc
index d8c61ff..5f4c33a 100644
--- a/test/idct8x8_test.cc
+++ b/test/idct8x8_test.cc
@@ -14,9 +14,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-extern "C" {
#include "./vp9_rtcd.h"
-}
#include "test/acm_random.h"
#include "vpx/vpx_integer.h"
diff --git a/test/idct_test.cc b/test/idct_test.cc
index 2c7fa0e..1bbf80a 100644
--- a/test/idct_test.cc
+++ b/test/idct_test.cc
@@ -8,10 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-extern "C" {
#include "./vpx_config.h"
#include "./vp8_rtcd.h"
-}
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "third_party/googletest/src/include/gtest/gtest.h"
diff --git a/test/pp_filter_test.cc b/test/pp_filter_test.cc
index e5ac9db..ff7bb08 100644
--- a/test/pp_filter_test.cc
+++ b/test/pp_filter_test.cc
@@ -10,12 +10,10 @@
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "third_party/googletest/src/include/gtest/gtest.h"
-extern "C" {
#include "./vpx_config.h"
#include "./vp8_rtcd.h"
#include "vpx/vpx_integer.h"
#include "vpx_mem/vpx_mem.h"
-}
typedef void (*post_proc_func_t)(unsigned char *src_ptr,
unsigned char *dst_ptr,
diff --git a/test/sad_test.cc b/test/sad_test.cc
index 453b3a8..4a91b0b 100644
--- a/test/sad_test.cc
+++ b/test/sad_test.cc
@@ -13,7 +13,6 @@
#include <limits.h>
#include <stdio.h>
-extern "C" {
#include "./vpx_config.h"
#if CONFIG_VP8_ENCODER
#include "./vp8_rtcd.h"
@@ -22,7 +21,6 @@
#include "./vp9_rtcd.h"
#endif
#include "vpx_mem/vpx_mem.h"
-}
#include "test/acm_random.h"
#include "test/clear_system_state.h"
diff --git a/test/sixtap_predict_test.cc b/test/sixtap_predict_test.cc
index 0f5c0a5..3434662 100644
--- a/test/sixtap_predict_test.cc
+++ b/test/sixtap_predict_test.cc
@@ -16,12 +16,10 @@
#include "test/register_state_check.h"
#include "test/util.h"
#include "third_party/googletest/src/include/gtest/gtest.h"
-extern "C" {
#include "./vpx_config.h"
#include "./vp8_rtcd.h"
#include "vpx/vpx_integer.h"
#include "vpx_mem/vpx_mem.h"
-}
namespace {
diff --git a/test/test_vector_test.cc b/test/test_vector_test.cc
index 6d93bb8..4adf9af 100644
--- a/test/test_vector_test.cc
+++ b/test/test_vector_test.cc
@@ -19,9 +19,7 @@
#include "test/test_vectors.h"
#include "test/util.h"
#include "test/webm_video_source.h"
-extern "C" {
#include "vpx_mem/vpx_mem.h"
-}
namespace {
diff --git a/test/tile_independence_test.cc b/test/tile_independence_test.cc
index 863a366..d714452 100644
--- a/test/tile_independence_test.cc
+++ b/test/tile_independence_test.cc
@@ -17,9 +17,7 @@
#include "test/i420_video_source.h"
#include "test/util.h"
#include "test/md5_helper.h"
-extern "C" {
#include "vpx_mem/vpx_mem.h"
-}
namespace {
class TileIndependenceTest : public ::libvpx_test::EncoderTest,
diff --git a/test/vp8_fdct4x4_test.cc b/test/vp8_fdct4x4_test.cc
index 25465c5..e3c292e 100644
--- a/test/vp8_fdct4x4_test.cc
+++ b/test/vp8_fdct4x4_test.cc
@@ -15,9 +15,7 @@
#include <string.h>
#include <sys/types.h>
-extern "C" {
#include "./vp8_rtcd.h"
-}
#include "test/acm_random.h"
#include "third_party/googletest/src/include/gtest/gtest.h"
diff --git a/vp8/common/onyx.h b/vp8/common/onyx.h
index 209a25d..119e40c 100644
--- a/vp8/common/onyx.h
+++ b/vp8/common/onyx.h
@@ -39,8 +39,8 @@
typedef enum
{
- USAGE_STREAM_FROM_SERVER = 0x0,
- USAGE_LOCAL_FILE_PLAYBACK = 0x1,
+ USAGE_LOCAL_FILE_PLAYBACK = 0x0,
+ USAGE_STREAM_FROM_SERVER = 0x1,
USAGE_CONSTRAINED_QUALITY = 0x2,
USAGE_CONSTANT_QUALITY = 0x3
} END_USAGE;
diff --git a/vp9/common/vp9_blockd.h b/vp9/common/vp9_blockd.h
index 21e2b16..ad78b0d 100644
--- a/vp9/common/vp9_blockd.h
+++ b/vp9/common/vp9_blockd.h
@@ -122,7 +122,6 @@
TX_SIZE tx_size;
int_mv mv[2]; // for each reference frame used
int_mv ref_mvs[MAX_REF_FRAMES][MAX_MV_REF_CANDIDATES];
- int_mv best_mv[2];
uint8_t mode_context[MAX_REF_FRAMES];
@@ -242,6 +241,9 @@
/* pointer to current frame */
const YV12_BUFFER_CONFIG *cur_buf;
+ /* mc buffer */
+ DECLARE_ALIGNED(16, uint8_t, mc_buf[80 * 2 * 80 * 2]);
+
int lossless;
/* Inverse transform function pointers. */
void (*itxm_add)(const int16_t *input, uint8_t *dest, int stride, int eob);
diff --git a/vp9/common/vp9_reconinter.c b/vp9/common/vp9_reconinter.c
index 397f446..b5a9248 100644
--- a/vp9/common/vp9_reconinter.c
+++ b/vp9/common/vp9_reconinter.c
@@ -20,15 +20,16 @@
#include "vp9/common/vp9_reconinter.h"
#include "vp9/common/vp9_reconintra.h"
-static void build_mc_border(const uint8_t *src, uint8_t *dst, int stride,
- int x, int y, int b_w, int b_h, int w, int h) {
+static void build_mc_border(const uint8_t *src, int src_stride,
+ uint8_t *dst, int dst_stride,
+ int x, int y, int b_w, int b_h, int w, int h) {
// Get a pointer to the start of the real data for this row.
- const uint8_t *ref_row = src - x - y * stride;
+ const uint8_t *ref_row = src - x - y * src_stride;
if (y >= h)
- ref_row += (h - 1) * stride;
+ ref_row += (h - 1) * src_stride;
else if (y > 0)
- ref_row += y * stride;
+ ref_row += y * src_stride;
do {
int right = 0, copy;
@@ -49,16 +50,16 @@
memset(dst, ref_row[0], left);
if (copy)
- memmove(dst + left, ref_row + x + left, copy);
+ memcpy(dst + left, ref_row + x + left, copy);
if (right)
memset(dst + left + copy, ref_row[w - 1], right);
- dst += stride;
+ dst += dst_stride;
++y;
if (y > 0 && y < h)
- ref_row += stride;
+ ref_row += src_stride;
} while (--b_h);
}
@@ -281,7 +282,7 @@
MV32 scaled_mv;
int xs, ys, x0, y0, x0_16, y0_16, x1, y1, frame_width,
- frame_height, subpel_x, subpel_y;
+ frame_height, subpel_x, subpel_y, buf_stride;
uint8_t *ref_frame, *buf_ptr;
const YV12_BUFFER_CONFIG *ref_buf = xd->block_refs[ref]->buf;
@@ -308,7 +309,7 @@
scaled_mv = vp9_scale_mv(&mv_q4, mi_x + x, mi_y + y, sf);
xs = sf->x_step_q4;
ys = sf->y_step_q4;
- // Get block position in the scaled reference frame.
+ // Map the top left corner of the block into the reference frame.
x0 = sf->scale_value_x(x0, sf);
y0 = sf->scale_value_y(y0, sf);
x0_16 = sf->scale_value_x(x0_16, sf);
@@ -321,7 +322,7 @@
subpel_x = scaled_mv.col & SUBPEL_MASK;
subpel_y = scaled_mv.row & SUBPEL_MASK;
- // Get reference block top left coordinate.
+ // Calculate the top left corner of the best matching block in the reference frame.
x0 += scaled_mv.col >> SUBPEL_BITS;
y0 += scaled_mv.row >> SUBPEL_BITS;
x0_16 += scaled_mv.col;
@@ -329,24 +330,28 @@
// Get reference block bottom right coordinate.
x1 = ((x0_16 + (w - 1) * xs) >> SUBPEL_BITS) + 1;
- y1 = ((y0_16 + (h - 1) * xs) >> SUBPEL_BITS) + 1;
+ y1 = ((y0_16 + (h - 1) * ys) >> SUBPEL_BITS) + 1;
// Get reference block pointer.
buf_ptr = ref_frame + y0 * pre_buf->stride + x0;
+ buf_stride = pre_buf->stride;
- // Do border extension if there is motion or
+ // Do border extension if there is motion or the
// width/height is not a multiple of 8 pixels.
if (scaled_mv.col || scaled_mv.row ||
(frame_width & 0x7) || (frame_height & 0x7)) {
+ int x_pad = 0, y_pad = 0;
- if (subpel_x) {
+ if (subpel_x || (sf->x_step_q4 & SUBPEL_MASK)) {
x0 -= VP9_INTERP_EXTEND - 1;
x1 += VP9_INTERP_EXTEND;
+ x_pad = 1;
}
- if (subpel_y) {
+ if (subpel_y || (sf->y_step_q4 & SUBPEL_MASK)) {
y0 -= VP9_INTERP_EXTEND - 1;
y1 += VP9_INTERP_EXTEND;
+ y_pad = 1;
}
// Skip border extension if block is inside the frame.
@@ -354,12 +359,14 @@
y0 < 0 || y0 > frame_height - 1 || y1 < 0 || y1 > frame_height - 1) {
uint8_t *buf_ptr1 = ref_frame + y0 * pre_buf->stride + x0;
// Extend the border.
- build_mc_border(buf_ptr1, buf_ptr1, pre_buf->stride, x0, y0, x1 - x0,
- y1 - y0, frame_width, frame_height);
+ build_mc_border(buf_ptr1, pre_buf->stride, xd->mc_buf, x1 - x0,
+ x0, y0, x1 - x0, y1 - y0, frame_width, frame_height);
+ buf_stride = x1 - x0;
+ buf_ptr = xd->mc_buf + y_pad * 3 * buf_stride + x_pad * 3;
}
}
- inter_predictor(buf_ptr, pre_buf->stride, dst, dst_buf->stride, subpel_x,
+ inter_predictor(buf_ptr, buf_stride, dst, dst_buf->stride, subpel_x,
subpel_y, sf, w, h, ref, &xd->subpix, xs, ys);
}
}
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c
index ec4dc14..2ab4c79 100644
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -260,6 +260,7 @@
struct segmentation *seg = &cm->seg;
MB_MODE_INFO *const mi = &m->mbmi;
const MV_REFERENCE_FRAME rf = mi->ref_frame[0];
+ const MV_REFERENCE_FRAME sec_rf = mi->ref_frame[1];
const MB_PREDICTION_MODE mode = mi->mode;
const int segment_id = mi->segment_id;
int skip_coeff;
@@ -355,11 +356,11 @@
active_section = 11;
#endif
vp9_encode_mv(cpi, bc, &m->bmi[j].as_mv[0].as_mv,
- &mi->best_mv[0].as_mv, nmvc, allow_hp);
+ &mi->ref_mvs[rf][0].as_mv, nmvc, allow_hp);
if (has_second_ref(mi))
vp9_encode_mv(cpi, bc, &m->bmi[j].as_mv[1].as_mv,
- &mi->best_mv[1].as_mv, nmvc, allow_hp);
+ &mi->ref_mvs[sec_rf][0].as_mv, nmvc, allow_hp);
}
}
}
@@ -368,11 +369,11 @@
active_section = 5;
#endif
vp9_encode_mv(cpi, bc, &mi->mv[0].as_mv,
- &mi->best_mv[0].as_mv, nmvc, allow_hp);
+ &mi->ref_mvs[rf][0].as_mv, nmvc, allow_hp);
if (has_second_ref(mi))
vp9_encode_mv(cpi, bc, &mi->mv[1].as_mv,
- &mi->best_mv[1].as_mv, nmvc, allow_hp);
+ &mi->ref_mvs[sec_rf][0].as_mv, nmvc, allow_hp);
}
}
}
diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index a66b9fb..9966cb6 100644
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -500,17 +500,8 @@
if (is_inter_block(mbmi) &&
(mbmi->sb_type < BLOCK_8X8 || mbmi->mode == NEWMV)) {
int_mv best_mv[2];
- const MV_REFERENCE_FRAME rf1 = mbmi->ref_frame[0];
- const MV_REFERENCE_FRAME rf2 = mbmi->ref_frame[1];
- best_mv[0].as_int = ctx->best_ref_mv[0].as_int;
- best_mv[1].as_int = ctx->best_ref_mv[1].as_int;
- if (mbmi->mode == NEWMV) {
- best_mv[0].as_int = mbmi->ref_mvs[rf1][0].as_int;
- if (rf2 > 0)
- best_mv[1].as_int = mbmi->ref_mvs[rf2][0].as_int;
- }
- mbmi->best_mv[0].as_int = best_mv[0].as_int;
- mbmi->best_mv[1].as_int = best_mv[1].as_int;
+ for (i = 0; i < 2; ++i)
+ best_mv[i].as_int = mbmi->ref_mvs[mbmi->ref_frame[i]][0].as_int;
vp9_update_mv_count(cpi, x, best_mv);
}
diff --git a/vp9/encoder/vp9_firstpass.c b/vp9/encoder/vp9_firstpass.c
index 0a5af18..cdc5dfd 100644
--- a/vp9/encoder/vp9_firstpass.c
+++ b/vp9/encoder/vp9_firstpass.c
@@ -504,6 +504,7 @@
int new_mv_count = 0;
int sum_in_vectors = 0;
uint32_t lastmv_as_int = 0;
+ struct twopass_rc *const twopass = &cpi->twopass;
int_mv zero_ref_mv;
@@ -830,23 +831,22 @@
fps.duration = (double)(cpi->source->ts_end - cpi->source->ts_start);
// don't want to do output stats with a stack variable!
- cpi->twopass.this_frame_stats = fps;
- output_stats(cpi, cpi->output_pkt_list, &cpi->twopass.this_frame_stats);
- accumulate_stats(&cpi->twopass.total_stats, &fps);
+ twopass->this_frame_stats = fps;
+ output_stats(cpi, cpi->output_pkt_list, &twopass->this_frame_stats);
+ accumulate_stats(&twopass->total_stats, &fps);
}
// Copy the previous Last Frame back into gf and and arf buffers if
// the prediction is good enough... but also dont allow it to lag too far
- if ((cpi->twopass.sr_update_lag > 3) ||
+ if ((twopass->sr_update_lag > 3) ||
((cm->current_video_frame > 0) &&
- (cpi->twopass.this_frame_stats.pcnt_inter > 0.20) &&
- ((cpi->twopass.this_frame_stats.intra_error /
- DOUBLE_DIVIDE_CHECK(cpi->twopass.this_frame_stats.coded_error)) >
- 2.0))) {
+ (twopass->this_frame_stats.pcnt_inter > 0.20) &&
+ ((twopass->this_frame_stats.intra_error /
+ DOUBLE_DIVIDE_CHECK(twopass->this_frame_stats.coded_error)) > 2.0))) {
vp8_yv12_copy_frame(lst_yv12, gld_yv12);
- cpi->twopass.sr_update_lag = 1;
+ twopass->sr_update_lag = 1;
} else {
- cpi->twopass.sr_update_lag++;
+ twopass->sr_update_lag++;
}
// swap frame pointers so last frame refers to the frame we just compressed
swap_yv12(lst_yv12, new_yv12);
@@ -1034,37 +1034,38 @@
void vp9_init_second_pass(VP9_COMP *cpi) {
FIRSTPASS_STATS this_frame;
FIRSTPASS_STATS *start_pos;
+ struct twopass_rc *const twopass = &cpi->twopass;
- zero_stats(&cpi->twopass.total_stats);
- zero_stats(&cpi->twopass.total_left_stats);
+ zero_stats(&twopass->total_stats);
+ zero_stats(&twopass->total_left_stats);
- if (!cpi->twopass.stats_in_end)
+ if (!twopass->stats_in_end)
return;
- cpi->twopass.total_stats = *cpi->twopass.stats_in_end;
- cpi->twopass.total_left_stats = cpi->twopass.total_stats;
+ twopass->total_stats = *twopass->stats_in_end;
+ twopass->total_left_stats = twopass->total_stats;
// each frame can have a different duration, as the frame rate in the source
// isn't guaranteed to be constant. The frame rate prior to the first frame
// encoded in the second pass is a guess. However the sum duration is not.
// Its calculated based on the actual durations of all frames from the first
// pass.
- vp9_new_framerate(cpi, 10000000.0 * cpi->twopass.total_stats.count /
- cpi->twopass.total_stats.duration);
+ vp9_new_framerate(cpi, 10000000.0 * twopass->total_stats.count /
+ twopass->total_stats.duration);
cpi->output_framerate = cpi->oxcf.framerate;
- cpi->twopass.bits_left = (int64_t)(cpi->twopass.total_stats.duration *
- cpi->oxcf.target_bandwidth / 10000000.0);
+ twopass->bits_left = (int64_t)(twopass->total_stats.duration *
+ cpi->oxcf.target_bandwidth / 10000000.0);
// Calculate a minimum intra value to be used in determining the IIratio
// scores used in the second pass. We have this minimum to make sure
// that clips that are static but "low complexity" in the intra domain
// are still boosted appropriately for KF/GF/ARF
- cpi->twopass.kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
- cpi->twopass.gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
+ twopass->kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
+ twopass->gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
// This variable monitors how far behind the second ref update is lagging
- cpi->twopass.sr_update_lag = 1;
+ twopass->sr_update_lag = 1;
// Scan the first pass file and calculate an average Intra / Inter error score
// ratio for the sequence.
@@ -1072,43 +1073,43 @@
double sum_iiratio = 0.0;
double IIRatio;
- start_pos = cpi->twopass.stats_in; // Note the starting "file" position.
+ start_pos = twopass->stats_in; // Note the starting "file" position.
- while (input_stats(&cpi->twopass, &this_frame) != EOF) {
+ while (input_stats(twopass, &this_frame) != EOF) {
IIRatio = this_frame.intra_error
/ DOUBLE_DIVIDE_CHECK(this_frame.coded_error);
IIRatio = (IIRatio < 1.0) ? 1.0 : (IIRatio > 20.0) ? 20.0 : IIRatio;
sum_iiratio += IIRatio;
}
- cpi->twopass.avg_iiratio = sum_iiratio /
- DOUBLE_DIVIDE_CHECK((double)cpi->twopass.total_stats.count);
+ twopass->avg_iiratio = sum_iiratio /
+ DOUBLE_DIVIDE_CHECK((double)twopass->total_stats.count);
// Reset file position
- reset_fpf_position(&cpi->twopass, start_pos);
+ reset_fpf_position(twopass, start_pos);
}
// Scan the first pass file and calculate a modified total error based upon
// the bias/power function used to allocate bits.
{
- double av_error = cpi->twopass.total_stats.ssim_weighted_pred_err /
- DOUBLE_DIVIDE_CHECK(cpi->twopass.total_stats.count);
+ double av_error = twopass->total_stats.ssim_weighted_pred_err /
+ DOUBLE_DIVIDE_CHECK(twopass->total_stats.count);
- start_pos = cpi->twopass.stats_in; // Note starting "file" position
+ start_pos = twopass->stats_in; // Note starting "file" position
- cpi->twopass.modified_error_total = 0.0;
- cpi->twopass.modified_error_min =
+ twopass->modified_error_total = 0.0;
+ twopass->modified_error_min =
(av_error * cpi->oxcf.two_pass_vbrmin_section) / 100;
- cpi->twopass.modified_error_max =
+ twopass->modified_error_max =
(av_error * cpi->oxcf.two_pass_vbrmax_section) / 100;
- while (input_stats(&cpi->twopass, &this_frame) != EOF) {
- cpi->twopass.modified_error_total +=
+ while (input_stats(twopass, &this_frame) != EOF) {
+ twopass->modified_error_total +=
calculate_modified_err(cpi, &this_frame);
}
- cpi->twopass.modified_error_left = cpi->twopass.modified_error_total;
+ twopass->modified_error_left = twopass->modified_error_total;
- reset_fpf_position(&cpi->twopass, start_pos); // Reset file position
+ reset_fpf_position(twopass, start_pos);
}
}
@@ -2060,7 +2061,8 @@
this_frame_coded_error = this_frame.coded_error;
// keyframe and section processing !
- if (rc->frames_to_key == 0) {
+ if (rc->frames_to_key == 0 ||
+ (cpi->common.frame_flags & FRAMEFLAGS_KEY)) {
// Define next KF group and assign bits to it
this_frame_copy = this_frame;
find_next_key_frame(cpi, &this_frame_copy);
@@ -2231,12 +2233,13 @@
double recent_loop_decay[8] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
RATE_CONTROL *const rc = &cpi->rc;
+ struct twopass_rc *const twopass = &cpi->twopass;
vp9_zero(next_frame);
vp9_clear_system_state(); // __asm emms;
- start_position = cpi->twopass.stats_in;
+ start_position = twopass->stats_in;
cpi->common.frame_type = KEY_FRAME;
// is this a forced key frame by interval
@@ -2253,14 +2256,14 @@
// Take a copy of the initial frame details
first_frame = *this_frame;
- cpi->twopass.kf_group_bits = 0; // Total bits available to kf group
- cpi->twopass.kf_group_error_left = 0; // Group modified error score.
+ twopass->kf_group_bits = 0; // Total bits available to kf group
+ twopass->kf_group_error_left = 0; // Group modified error score.
kf_mod_err = calculate_modified_err(cpi, this_frame);
// find the next keyframe
i = 0;
- while (cpi->twopass.stats_in < cpi->twopass.stats_in_end) {
+ while (twopass->stats_in < twopass->stats_in_end) {
// Accumulate kf group error
kf_group_err += calculate_modified_err(cpi, this_frame);
@@ -2272,11 +2275,11 @@
// load a the next frame's stats
last_frame = *this_frame;
- input_stats(&cpi->twopass, this_frame);
+ input_stats(twopass, this_frame);
// Provided that we are not at the end of the file...
if (cpi->oxcf.auto_key &&
- lookup_next_frame_stats(&cpi->twopass, &next_frame) != EOF) {
+ lookup_next_frame_stats(twopass, &next_frame) != EOF) {
// Normal scene cut check
if (test_candidate_kf(cpi, &last_frame, this_frame, &next_frame))
break;
@@ -2326,7 +2329,7 @@
tmp_frame = first_frame;
// Reset to the start of the group
- reset_fpf_position(&cpi->twopass, start_position);
+ reset_fpf_position(twopass, start_position);
kf_group_err = 0;
kf_group_intra_err = 0;
@@ -2340,17 +2343,17 @@
kf_group_coded_err += tmp_frame.coded_error;
// Load a the next frame's stats
- input_stats(&cpi->twopass, &tmp_frame);
+ input_stats(twopass, &tmp_frame);
}
rc->next_key_frame_forced = 1;
- } else if (cpi->twopass.stats_in == cpi->twopass.stats_in_end) {
+ } else if (twopass->stats_in == twopass->stats_in_end) {
rc->next_key_frame_forced = 1;
} else {
rc->next_key_frame_forced = 0;
}
// Special case for the last key frame of the file
- if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end) {
+ if (twopass->stats_in >= twopass->stats_in_end) {
// Accumulate kf group error
kf_group_err += calculate_modified_err(cpi, this_frame);
@@ -2362,8 +2365,7 @@
}
// Calculate the number of bits that should be assigned to the kf group.
- if ((cpi->twopass.bits_left > 0) &&
- (cpi->twopass.modified_error_left > 0.0)) {
+ if (twopass->bits_left > 0 && twopass->modified_error_left > 0.0) {
// Max for a single normal frame (not key frame)
int max_bits = frame_max_bits(cpi);
@@ -2372,19 +2374,18 @@
// Default allocation based on bits left and relative
// complexity of the section
- cpi->twopass.kf_group_bits = (int64_t)(cpi->twopass.bits_left *
- (kf_group_err /
- cpi->twopass.modified_error_left));
+ twopass->kf_group_bits = (int64_t)(twopass->bits_left *
+ (kf_group_err / twopass->modified_error_left));
// Clip based on maximum per frame rate defined by the user.
max_grp_bits = (int64_t)max_bits * (int64_t)rc->frames_to_key;
- if (cpi->twopass.kf_group_bits > max_grp_bits)
- cpi->twopass.kf_group_bits = max_grp_bits;
+ if (twopass->kf_group_bits > max_grp_bits)
+ twopass->kf_group_bits = max_grp_bits;
} else {
- cpi->twopass.kf_group_bits = 0;
+ twopass->kf_group_bits = 0;
}
// Reset the first pass file position
- reset_fpf_position(&cpi->twopass, start_position);
+ reset_fpf_position(twopass, start_position);
// Determine how big to make this keyframe based on how well the subsequent
// frames use inter blocks.
@@ -2396,7 +2397,7 @@
for (i = 0; i < rc->frames_to_key; i++) {
double r;
- if (EOF == input_stats(&cpi->twopass, &next_frame))
+ if (EOF == input_stats(twopass, &next_frame))
break;
// Monitor for static sections.
@@ -2408,11 +2409,11 @@
// For the first few frames collect data to decide kf boost.
if (i <= (rc->max_gf_interval * 2)) {
- if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
+ if (next_frame.intra_error > twopass->kf_intra_err_min)
r = (IIKFACTOR2 * next_frame.intra_error /
DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
else
- r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min /
+ r = (IIKFACTOR2 * twopass->kf_intra_err_min /
DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
if (r > RMAX)
@@ -2434,21 +2435,21 @@
FIRSTPASS_STATS sectionstats;
zero_stats(§ionstats);
- reset_fpf_position(&cpi->twopass, start_position);
+ reset_fpf_position(twopass, start_position);
for (i = 0; i < rc->frames_to_key; i++) {
- input_stats(&cpi->twopass, &next_frame);
+ input_stats(twopass, &next_frame);
accumulate_stats(§ionstats, &next_frame);
}
avg_stats(§ionstats);
- cpi->twopass.section_intra_rating = (int) (sectionstats.intra_error /
+ twopass->section_intra_rating = (int) (sectionstats.intra_error /
DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
}
// Reset the first pass file position
- reset_fpf_position(&cpi->twopass, start_position);
+ reset_fpf_position(twopass, start_position);
// Work out how many bits to allocate for the key frame itself
if (1) {
@@ -2465,7 +2466,7 @@
// Make a note of baseline boost and the zero motion
// accumulator value for use elsewhere.
rc->kf_boost = kf_boost;
- cpi->twopass.kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
+ twopass->kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
// We do three calculations for kf size.
// The first is based on the error score for the whole kf group.
@@ -2480,11 +2481,9 @@
// cpi->rc.frames_to_key-1 because key frame itself is taken
// care of by kf_boost.
if (zero_motion_accumulator >= 0.99) {
- allocation_chunks =
- ((rc->frames_to_key - 1) * 10) + kf_boost;
+ allocation_chunks = ((rc->frames_to_key - 1) * 10) + kf_boost;
} else {
- allocation_chunks =
- ((rc->frames_to_key - 1) * 100) + kf_boost;
+ allocation_chunks = ((rc->frames_to_key - 1) * 100) + kf_boost;
}
// Prevent overflow
@@ -2494,58 +2493,54 @@
allocation_chunks /= divisor;
}
- cpi->twopass.kf_group_bits = (cpi->twopass.kf_group_bits < 0) ? 0
- : cpi->twopass.kf_group_bits;
+ twopass->kf_group_bits = (twopass->kf_group_bits < 0) ? 0
+ : twopass->kf_group_bits;
// Calculate the number of bits to be spent on the key frame
- cpi->twopass.kf_bits = (int)((double)kf_boost *
- ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks));
+ twopass->kf_bits = (int)((double)kf_boost *
+ ((double)twopass->kf_group_bits / allocation_chunks));
// If the key frame is actually easier than the average for the
// kf group (which does sometimes happen... eg a blank intro frame)
// Then use an alternate calculation based on the kf error score
// which should give a smaller key frame.
if (kf_mod_err < kf_group_err / rc->frames_to_key) {
- double alt_kf_grp_bits =
- ((double)cpi->twopass.bits_left *
+ double alt_kf_grp_bits = ((double)twopass->bits_left *
(kf_mod_err * (double)rc->frames_to_key) /
- DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left));
+ DOUBLE_DIVIDE_CHECK(twopass->modified_error_left));
alt_kf_bits = (int)((double)kf_boost *
(alt_kf_grp_bits / (double)allocation_chunks));
- if (cpi->twopass.kf_bits > alt_kf_bits) {
- cpi->twopass.kf_bits = alt_kf_bits;
- }
+ if (twopass->kf_bits > alt_kf_bits)
+ twopass->kf_bits = alt_kf_bits;
} else {
// Else if it is much harder than other frames in the group make sure
// it at least receives an allocation in keeping with its relative
// error score
- alt_kf_bits = (int)((double)cpi->twopass.bits_left *
- (kf_mod_err /
- DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left)));
+ alt_kf_bits = (int)((double)twopass->bits_left * (kf_mod_err /
+ DOUBLE_DIVIDE_CHECK(twopass->modified_error_left)));
- if (alt_kf_bits > cpi->twopass.kf_bits) {
- cpi->twopass.kf_bits = alt_kf_bits;
+ if (alt_kf_bits > twopass->kf_bits) {
+ twopass->kf_bits = alt_kf_bits;
}
}
- cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
+ twopass->kf_group_bits -= twopass->kf_bits;
// Peer frame bit target for this frame
- rc->per_frame_bandwidth = cpi->twopass.kf_bits;
+ rc->per_frame_bandwidth = twopass->kf_bits;
// Convert to a per second bitrate
- cpi->target_bandwidth = (int)(cpi->twopass.kf_bits *
- cpi->output_framerate);
+ cpi->target_bandwidth = (int)(twopass->kf_bits * cpi->output_framerate);
}
// Note the total error score of the kf group minus the key frame itself
- cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err);
+ twopass->kf_group_error_left = (int)(kf_group_err - kf_mod_err);
// Adjust the count of total modified error left.
// The count of bits left is adjusted elsewhere based on real coded frame
// sizes.
- cpi->twopass.modified_error_left -= kf_group_err;
+ twopass->modified_error_left -= kf_group_err;
}
void vp9_twopass_postencode_update(VP9_COMP *cpi, uint64_t bytes_used) {
diff --git a/vp9/encoder/vp9_mcomp.c b/vp9/encoder/vp9_mcomp.c
index 88d527a..e81dd0d 100644
--- a/vp9/encoder/vp9_mcomp.c
+++ b/vp9/encoder/vp9_mcomp.c
@@ -174,8 +174,10 @@
error_per_bit + 4096) >> 13 : 0)
-#define SP(x) (((x) & 7) << 1) // convert motion vector component to offset
- // for svf calc
+// convert motion vector component to offset for svf calc
+static INLINE int sp(int x) {
+ return (x & 7) << 1;
+}
#define IFMVCV(r, c, s, e) \
if (c >= minc && c <= maxc && r >= minr && r <= maxr) \
@@ -183,12 +185,14 @@
else \
e;
-/* pointer to predictor base of a motionvector */
-#define PRE(r, c) (y + (((r) >> 3) * y_stride + ((c) >> 3) -(offset)))
+static INLINE uint8_t *pre(uint8_t *buf, int stride, int r, int c, int offset) {
+ return &buf[(r >> 3) * stride + (c >> 3) - offset];
+}
/* returns subpixel variance error function */
#define DIST(r, c) \
- vfp->svf(PRE(r, c), y_stride, SP(c), SP(r), z, src_stride, &sse)
+ vfp->svf(pre(y, y_stride, r, c, offset), y_stride, sp(c), sp(r), z, \
+ src_stride, &sse)
/* checks if (r, c) has better score than previous best */
#define CHECK_BETTER(v, r, c) \
@@ -358,7 +362,7 @@
#undef DIST
/* returns subpixel variance error function */
#define DIST(r, c) \
- vfp->svaf(PRE(r, c), y_stride, SP(c), SP(r), \
+ vfp->svaf(pre(y, y_stride, r, c, offset), y_stride, sp(c), sp(r), \
z, src_stride, &sse, second_pred)
int vp9_find_best_sub_pixel_comp_tree(MACROBLOCK *x,
diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c
index 59d36ee..3e1daca 100644
--- a/vp9/encoder/vp9_onyx_if.c
+++ b/vp9/encoder/vp9_onyx_if.c
@@ -3279,12 +3279,12 @@
vp9_twopass_postencode_update(cpi, *size);
}
-static void check_initial_width(VP9_COMP *cpi, YV12_BUFFER_CONFIG *sd) {
+static void check_initial_width(VP9_COMP *cpi, int subsampling_x,
+ int subsampling_y) {
VP9_COMMON *const cm = &cpi->common;
if (!cpi->initial_width) {
- // TODO(agrange) Subsampling defaults to assuming sampled chroma.
- cm->subsampling_x = sd != NULL ? (sd->uv_width < sd->y_width) : 1;
- cm->subsampling_y = sd != NULL ? (sd->uv_height < sd->y_height) : 1;
+ cm->subsampling_x = subsampling_x;
+ cm->subsampling_y = subsampling_y;
alloc_raw_frame_buffers(cpi);
cpi->initial_width = cm->width;
cpi->initial_height = cm->height;
@@ -3298,8 +3298,10 @@
VP9_COMP *cpi = (VP9_COMP *) ptr;
struct vpx_usec_timer timer;
int res = 0;
+ const int subsampling_x = sd->uv_width < sd->y_width;
+ const int subsampling_y = sd->uv_height < sd->y_height;
- check_initial_width(cpi, sd);
+ check_initial_width(cpi, subsampling_x, subsampling_y);
vpx_usec_timer_start(&timer);
if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, frame_flags,
cpi->active_map_enabled ? cpi->active_map : NULL))
@@ -3798,7 +3800,7 @@
VP9_COMP *cpi = (VP9_COMP *)comp;
VP9_COMMON *cm = &cpi->common;
- check_initial_width(cpi, NULL);
+ check_initial_width(cpi, 1, 1);
if (width) {
cm->width = width;
diff --git a/vp9/encoder/vp9_picklpf.c b/vp9/encoder/vp9_picklpf.c
index 4ca85ee..a4ceabd 100644
--- a/vp9/encoder/vp9_picklpf.c
+++ b/vp9/encoder/vp9_picklpf.c
@@ -20,65 +20,43 @@
#include "vp9/common/vp9_loopfilter.h"
#include "./vpx_scale_rtcd.h"
-// Enforce a minimum filter level based upon baseline Q
static int get_min_filter_level(VP9_COMP *cpi, int base_qindex) {
- int min_filter_level;
- min_filter_level = 0;
-
- return min_filter_level;
+ return 0;
}
-// Enforce a maximum filter level based upon baseline Q
static int get_max_filter_level(VP9_COMP *cpi, int base_qindex) {
- int max_filter_level = MAX_LOOP_FILTER;
- (void)base_qindex;
-
- if (cpi->twopass.section_intra_rating > 8)
- max_filter_level = MAX_LOOP_FILTER * 3 / 4;
-
- return max_filter_level;
+ return cpi->twopass.section_intra_rating > 8 ? MAX_LOOP_FILTER * 3 / 4
+ : MAX_LOOP_FILTER;
}
-
// Stub function for now Alt LF not used
void vp9_set_alt_lf_level(VP9_COMP *cpi, int filt_val) {
}
void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, int partial) {
+ MACROBLOCKD *const xd = &cpi->mb.e_mbd;
VP9_COMMON *const cm = &cpi->common;
struct loopfilter *const lf = &cm->lf;
-
- int best_err = 0;
- int filt_err = 0;
const int min_filter_level = get_min_filter_level(cpi, cm->base_qindex);
const int max_filter_level = get_max_filter_level(cpi, cm->base_qindex);
-
- int filter_step;
- int filt_high = 0;
- // Start search at previous frame filter level
- int filt_mid = lf->filter_level;
- int filt_low = 0;
+ int best_err = 0;
+ int filt_err = 0;
int filt_best;
int filt_direction = 0;
-
- int Bias = 0; // Bias against raising loop filter in favor of lowering it.
-
- // Make a copy of the unfiltered / processed recon buffer
- vpx_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
+ // Start the search at the previous frame filter level unless it is now out of
+ // range.
+ int filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level);
+ int filter_step = filt_mid < 16 ? 4 : filt_mid / 4;
lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0
: cpi->oxcf.sharpness;
- // Start the search at the previous frame filter level unless it is now out of
- // range.
- filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level);
-
- // Define the initial step size
- filter_step = filt_mid < 16 ? 4 : filt_mid / 4;
+ // Make a copy of the unfiltered / processed recon buffer
+ vpx_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
// Get baseline error score
vp9_set_alt_lf_level(cpi, filt_mid);
- vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_mid, 1, partial);
+ vp9_loop_filter_frame(cm, xd, filt_mid, 1, partial);
best_err = vp9_calc_ss_err(sd, cm->frame_to_show);
filt_best = filt_mid;
@@ -87,35 +65,32 @@
vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
while (filter_step > 0) {
- Bias = (best_err >> (15 - (filt_mid / 8))) * filter_step;
+ const int filt_high = MIN(filt_mid + filter_step, max_filter_level);
+ const int filt_low = MAX(filt_mid - filter_step, min_filter_level);
+
+ // Bias against raising loop filter in favor of lowering it.
+ int bias = (best_err >> (15 - (filt_mid / 8))) * filter_step;
if (cpi->twopass.section_intra_rating < 20)
- Bias = Bias * cpi->twopass.section_intra_rating / 20;
+ bias = bias * cpi->twopass.section_intra_rating / 20;
// yx, bias less for large block size
- if (cpi->common.tx_mode != ONLY_4X4)
- Bias >>= 1;
+ if (cm->tx_mode != ONLY_4X4)
+ bias >>= 1;
- filt_high = ((filt_mid + filter_step) > max_filter_level)
- ? max_filter_level
- : (filt_mid + filter_step);
- filt_low = ((filt_mid - filter_step) < min_filter_level)
- ? min_filter_level
- : (filt_mid - filter_step);
-
- if ((filt_direction <= 0) && (filt_low != filt_mid)) {
+ if (filt_direction <= 0 && filt_low != filt_mid) {
// Get Low filter error score
vp9_set_alt_lf_level(cpi, filt_low);
- vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_low, 1, partial);
+ vp9_loop_filter_frame(cm, xd, filt_low, 1, partial);
filt_err = vp9_calc_ss_err(sd, cm->frame_to_show);
- // Re-instate the unfiltered frame
+ // Re-instate the unfiltered frame
vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
// If value is close to the best so far then bias towards a lower loop
// filter value.
- if ((filt_err - Bias) < best_err) {
+ if ((filt_err - bias) < best_err) {
// Was it actually better than the previous best?
if (filt_err < best_err)
best_err = filt_err;
@@ -125,9 +100,9 @@
}
// Now look at filt_high
- if ((filt_direction >= 0) && (filt_high != filt_mid)) {
+ if (filt_direction >= 0 && filt_high != filt_mid) {
vp9_set_alt_lf_level(cpi, filt_high);
- vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_high, 1, partial);
+ vp9_loop_filter_frame(cm, xd, filt_high, 1, partial);
filt_err = vp9_calc_ss_err(sd, cm->frame_to_show);
@@ -135,7 +110,7 @@
vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
// Was it better than the previous best?
- if (filt_err < (best_err - Bias)) {
+ if (filt_err < (best_err - bias)) {
best_err = filt_err;
filt_best = filt_high;
}
diff --git a/vp9/encoder/vp9_pickmode.c b/vp9/encoder/vp9_pickmode.c
index 17d1f59..f317f2a 100644
--- a/vp9/encoder/vp9_pickmode.c
+++ b/vp9/encoder/vp9_pickmode.c
@@ -174,7 +174,7 @@
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
x->pred_mv_sad[ref_frame] = INT_MAX;
if (cpi->ref_frame_flags & flag_list[ref_frame]) {
- vp9_setup_buffer_inter(cpi, x, tile, get_ref_frame_idx(cpi, ref_frame),
+ vp9_setup_buffer_inter(cpi, x, tile,
ref_frame, block_size, mi_row, mi_col,
frame_mv[NEARESTMV], frame_mv[NEARMV], yv12_mb);
}
diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index fa6b362..3c1bd39 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -419,18 +419,12 @@
struct macroblock_plane *const p = &x->plane[i];
struct macroblockd_plane *const pd = &xd->plane[i];
const BLOCK_SIZE bs = get_plane_block_size(bsize, pd);
- int rate;
- int64_t dist;
(void) cpi->fn_ptr[bs].vf(p->src.buf, p->src.stride,
pd->dst.buf, pd->dst.stride, &sse);
if (i == 0)
x->pred_sse[ref] = sse;
- // sse works better than var, since there is no dc prediction used
- model_rd_from_var_lapndz(sse, 1 << num_pels_log2_lookup[bs],
- pd->dequant[1] >> 3, &rate, &dist);
- rate_sum += rate;
- dist_sum += (int)dist;
+ dist_sum += (int)sse;
}
*out_rate_sum = rate_sum;
@@ -2276,41 +2270,38 @@
void vp9_setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x,
const TileInfo *const tile,
- int idx, MV_REFERENCE_FRAME frame_type,
+ MV_REFERENCE_FRAME ref_frame,
BLOCK_SIZE block_size,
int mi_row, int mi_col,
int_mv frame_nearest_mv[MAX_REF_FRAMES],
int_mv frame_near_mv[MAX_REF_FRAMES],
struct buf_2d yv12_mb[4][MAX_MB_PLANE]) {
- VP9_COMMON *cm = &cpi->common;
- YV12_BUFFER_CONFIG *yv12 = &cm->yv12_fb[cpi->common.ref_frame_map[idx]];
+ const VP9_COMMON *cm = &cpi->common;
+ const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = &xd->mi_8x8[0]->mbmi;
- const struct scale_factors *const sf = &cm->frame_refs[frame_type - 1].sf;
-
+ MODE_INFO *const mi = xd->mi_8x8[0];
+ int_mv *const candidates = mi->mbmi.ref_mvs[ref_frame];
+ const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf;
// TODO(jkoleszar): Is the UV buffer ever used here? If so, need to make this
// use the UV scaling factors.
- setup_pred_block(xd, yv12_mb[frame_type], yv12, mi_row, mi_col, sf, sf);
+ setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, sf, sf);
// Gets an initial list of candidate vectors from neighbours and orders them
- vp9_find_mv_refs(cm, xd, tile, xd->mi_8x8[0],
- xd->last_mi,
- frame_type,
- mbmi->ref_mvs[frame_type], mi_row, mi_col);
+ vp9_find_mv_refs(cm, xd, tile, mi, xd->last_mi, ref_frame, candidates,
+ mi_row, mi_col);
// Candidate refinement carried out at encoder and decoder
- vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv,
- mbmi->ref_mvs[frame_type],
- &frame_nearest_mv[frame_type],
- &frame_near_mv[frame_type]);
+ vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates,
+ &frame_nearest_mv[ref_frame],
+ &frame_near_mv[ref_frame]);
// Further refinement that is encode side only to test the top few candidates
// in full and choose the best as the centre point for subsequent searches.
// The current implementation doesn't support scaling.
if (!vp9_is_scaled(sf) && block_size >= BLOCK_8X8)
- mv_pred(cpi, x, yv12_mb[frame_type][0].buf, yv12->y_stride,
- frame_type, block_size);
+ mv_pred(cpi, x, yv12_mb[ref_frame][0].buf, yv12->y_stride,
+ ref_frame, block_size);
}
YV12_BUFFER_CONFIG *vp9_get_scaled_ref_frame(VP9_COMP *cpi, int ref_frame) {
@@ -3173,7 +3164,7 @@
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
x->pred_mv_sad[ref_frame] = INT_MAX;
if (cpi->ref_frame_flags & flag_list[ref_frame]) {
- vp9_setup_buffer_inter(cpi, x, tile, get_ref_frame_idx(cpi, ref_frame),
+ vp9_setup_buffer_inter(cpi, x, tile,
ref_frame, block_size, mi_row, mi_col,
frame_mv[NEARESTMV], frame_mv[NEARMV], yv12_mb);
}
@@ -3798,7 +3789,7 @@
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) {
if (cpi->ref_frame_flags & flag_list[ref_frame]) {
- vp9_setup_buffer_inter(cpi, x, tile, get_ref_frame_idx(cpi, ref_frame),
+ vp9_setup_buffer_inter(cpi, x, tile,
ref_frame, block_size, mi_row, mi_col,
frame_mv[NEARESTMV], frame_mv[NEARMV],
yv12_mb);
diff --git a/vp9/encoder/vp9_rdopt.h b/vp9/encoder/vp9_rdopt.h
index 696cf6b..9ac1f54 100644
--- a/vp9/encoder/vp9_rdopt.h
+++ b/vp9/encoder/vp9_rdopt.h
@@ -39,7 +39,7 @@
void vp9_setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x,
const TileInfo *const tile,
- int idx, MV_REFERENCE_FRAME frame_type,
+ MV_REFERENCE_FRAME ref_frame,
BLOCK_SIZE block_size,
int mi_row, int mi_col,
int_mv frame_nearest_mv[MAX_REF_FRAMES],
diff --git a/vp9/encoder/vp9_sad_c.c b/vp9/encoder/vp9_sad_c.c
index 55d595b..58c5df4 100644
--- a/vp9/encoder/vp9_sad_c.c
+++ b/vp9/encoder/vp9_sad_c.c
@@ -8,31 +8,44 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-
#include <stdlib.h>
+
#include "./vp9_rtcd.h"
#include "./vpx_config.h"
-#include "vp9/encoder/vp9_sadmxn.h"
-#include "vp9/encoder/vp9_variance.h"
+
#include "vpx/vpx_integer.h"
+#include "vp9/encoder/vp9_variance.h"
+
+static INLINE unsigned int sad(const uint8_t *a, int a_stride,
+ const uint8_t *b, int b_stride,
+ int width, int height) {
+ int y, x;
+ unsigned int sad = 0;
+
+ for (y = 0; y < height; y++) {
+ for (x = 0; x < width; x++)
+ sad += abs(a[x] - b[x]);
+
+ a += a_stride;
+ b += b_stride;
+ }
+
+ return sad;
+}
#define sad_mxn_func(m, n) \
-unsigned int vp9_sad##m##x##n##_c(const uint8_t *src_ptr, \
- int src_stride, \
- const uint8_t *ref_ptr, \
- int ref_stride, \
+unsigned int vp9_sad##m##x##n##_c(const uint8_t *src_ptr, int src_stride, \
+ const uint8_t *ref_ptr, int ref_stride, \
unsigned int max_sad) { \
- return sad_mx_n_c(src_ptr, src_stride, ref_ptr, ref_stride, m, n); \
+ return sad(src_ptr, src_stride, ref_ptr, ref_stride, m, n); \
} \
-unsigned int vp9_sad##m##x##n##_avg_c(const uint8_t *src_ptr, \
- int src_stride, \
- const uint8_t *ref_ptr, \
- int ref_stride, \
+unsigned int vp9_sad##m##x##n##_avg_c(const uint8_t *src_ptr, int src_stride, \
+ const uint8_t *ref_ptr, int ref_stride, \
const uint8_t *second_pred, \
unsigned int max_sad) { \
uint8_t comp_pred[m * n]; \
comp_avg_pred(comp_pred, second_pred, m, n, ref_ptr, ref_stride); \
- return sad_mx_n_c(src_ptr, src_stride, comp_pred, m, m, n); \
+ return sad(src_ptr, src_stride, comp_pred, m, m, n); \
}
sad_mxn_func(64, 64)
@@ -49,567 +62,263 @@
sad_mxn_func(4, 8)
sad_mxn_func(4, 4)
-void vp9_sad64x32x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad64x32(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad64x32(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad64x32(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad64x32(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad64x32(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad32x64x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad32x64(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad32x64(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad32x64(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad32x64(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad32x64(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad32x16x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad32x16(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad32x16(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad32x16(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad32x16(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad32x16(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad16x32x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad16x32(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad16x32(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad16x32(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad16x32(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad16x32(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad64x64x3_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad64x64x3_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad64x64(src_ptr, src_stride, ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad64x64(src_ptr, src_stride, ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad64x64(src_ptr, src_stride, ref_ptr + 2, ref_stride,
- 0x7fffffff);
+ int i;
+ for (i = 0; i < 3; ++i)
+ sad_array[i] = vp9_sad64x64(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad32x32x3_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad32x32x3_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr, ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 1, ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 2, ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 3; ++i)
+ sad_array[i] = vp9_sad32x32(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad64x64x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad64x64x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad64x64(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad32x32x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad32x32x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad32x32(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad16x16x3_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad16x16x3_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr, ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 1, ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 2, ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 3; ++i)
+ sad_array[i] = vp9_sad16x16(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad16x16x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad16x16x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
uint32_t *sad_array) {
- sad_array[0] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad16x16(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad16x8x3_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad16x8x3_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr, ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 1, ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 2, ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 3; ++i)
+ sad_array[i] = vp9_sad16x8(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad16x8x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad16x8x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
uint32_t *sad_array) {
- sad_array[0] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad16x8(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad8x8x3_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad8x8x3_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr, ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 1, ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 2, ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 3; ++i)
+ sad_array[i] = vp9_sad8x8(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad8x8x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad8x8x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
uint32_t *sad_array) {
- sad_array[0] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad8x8(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad8x16x3_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad8x16x3_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr, ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 1, ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 2, ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 3; ++i)
+ sad_array[i] = vp9_sad8x16(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad8x16x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad8x16x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
uint32_t *sad_array) {
- sad_array[0] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad8x16(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad4x4x3_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad4x4x3_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr, ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 1, ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 2, ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 3; ++i)
+ sad_array[i] = vp9_sad4x4(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad4x4x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
+void vp9_sad4x4x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
uint32_t *sad_array) {
- sad_array[0] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad4x4(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad64x64x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad64x64(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad64x64(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad32x32x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad32x32(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad32x32(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad16x16x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad16x16(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad16x16(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad16x8x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad16x8(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad16x8(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad8x8x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad8x8(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad8x8(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad8x16x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad8x16(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad8x16(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad8x4x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad8x4(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad8x4x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
- uint32_t *sad_array) {
- sad_array[0] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad8x4(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+void vp9_sad8x4x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
+ uint32_t *sad_array) {
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad8x4(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad4x8x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad4x8(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
-void vp9_sad4x8x8_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
- uint32_t *sad_array) {
- sad_array[0] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr, ref_stride,
- 0x7fffffff);
- sad_array[1] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr + 1, ref_stride,
- 0x7fffffff);
- sad_array[2] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr + 2, ref_stride,
- 0x7fffffff);
- sad_array[3] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr + 3, ref_stride,
- 0x7fffffff);
- sad_array[4] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr + 4, ref_stride,
- 0x7fffffff);
- sad_array[5] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr + 5, ref_stride,
- 0x7fffffff);
- sad_array[6] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr + 6, ref_stride,
- 0x7fffffff);
- sad_array[7] = vp9_sad4x8(src_ptr, src_stride,
- ref_ptr + 7, ref_stride,
- 0x7fffffff);
+void vp9_sad4x8x8_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t *ref_ptr, int ref_stride,
+ uint32_t *sad_array) {
+ int i;
+ for (i = 0; i < 8; ++i)
+ sad_array[i] = vp9_sad4x8(src_ptr, src_stride, ref_ptr + i, ref_stride,
+ 0x7fffffff);
}
-void vp9_sad4x4x4d_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t* const ref_ptr[],
- int ref_stride,
+void vp9_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride,
+ const uint8_t* const ref_ptr[], int ref_stride,
unsigned int *sad_array) {
- sad_array[0] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr[0], ref_stride, 0x7fffffff);
- sad_array[1] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr[1], ref_stride, 0x7fffffff);
- sad_array[2] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr[2], ref_stride, 0x7fffffff);
- sad_array[3] = vp9_sad4x4(src_ptr, src_stride,
- ref_ptr[3], ref_stride, 0x7fffffff);
+ int i;
+ for (i = 0; i < 4; ++i)
+ sad_array[i] = vp9_sad4x4(src_ptr, src_stride, ref_ptr[i], ref_stride,
+ 0x7fffffff);
}
diff --git a/vp9/encoder/vp9_sadmxn.h b/vp9/encoder/vp9_sadmxn.h
deleted file mode 100644
index 1bae4dd..0000000
--- a/vp9/encoder/vp9_sadmxn.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef VP9_ENCODER_VP9_SADMXN_H_
-#define VP9_ENCODER_VP9_SADMXN_H_
-
-#include "./vpx_config.h"
-#include "vpx/vpx_integer.h"
-
-static INLINE unsigned int sad_mx_n_c(const uint8_t *src_ptr,
- int src_stride,
- const uint8_t *ref_ptr,
- int ref_stride,
- int m,
- int n) {
- int r, c;
- unsigned int sad = 0;
-
- for (r = 0; r < n; r++) {
- for (c = 0; c < m; c++) {
- sad += abs(src_ptr[c] - ref_ptr[c]);
- }
-
- src_ptr += src_stride;
- ref_ptr += ref_stride;
- }
-
- return sad;
-}
-
-#endif // VP9_ENCODER_VP9_SADMXN_H_
diff --git a/vp9/vp9cx.mk b/vp9/vp9cx.mk
index 9ea0f54..dd33099 100644
--- a/vp9/vp9cx.mk
+++ b/vp9/vp9cx.mk
@@ -44,7 +44,6 @@
VP9_CX_SRCS-yes += encoder/vp9_ratectrl.h
VP9_CX_SRCS-yes += encoder/vp9_rdopt.h
VP9_CX_SRCS-yes += encoder/vp9_pickmode.h
-VP9_CX_SRCS-yes += encoder/vp9_sadmxn.h
VP9_CX_SRCS-yes += encoder/vp9_tokenize.h
VP9_CX_SRCS-yes += encoder/vp9_treewriter.h
VP9_CX_SRCS-yes += encoder/vp9_variance.h
diff --git a/vpxdec.c b/vpxdec.c
index 731feed..c067609 100644
--- a/vpxdec.c
+++ b/vpxdec.c
@@ -33,6 +33,7 @@
#include "./tools_common.h"
#include "./webmdec.h"
+#include "./y4menc.h"
static const char *exec_name;
@@ -691,31 +692,19 @@
}
if (use_y4m && !noblit) {
- char buffer[128];
-
if (!single_file) {
fprintf(stderr, "YUV4MPEG2 not supported with output patterns,"
" try --i420 or --yv12.\n");
return EXIT_FAILURE;
}
- if (vpx_input_ctx.file_type == FILE_TYPE_WEBM)
+ if (vpx_input_ctx.file_type == FILE_TYPE_WEBM) {
if (webm_guess_framerate(input.webm_ctx, input.vpx_input_ctx)) {
fprintf(stderr, "Failed to guess framerate -- error parsing "
"webm file?\n");
return EXIT_FAILURE;
}
-
-
- /*Note: We can't output an aspect ratio here because IVF doesn't
- store one, and neither does VP8.
- That will have to wait until these tools support WebM natively.*/
- snprintf(buffer, sizeof(buffer), "YUV4MPEG2 W%u H%u F%u:%u I%c ",
- vpx_input_ctx.width, vpx_input_ctx.height,
- vpx_input_ctx.framerate.numerator,
- vpx_input_ctx.framerate.denominator,
- 'p');
- fwrite(buffer, 1, strlen(buffer), out);
+ }
}
/* Try to determine the codec from the fourcc. */
@@ -863,14 +852,8 @@
if (!noblit) {
if (frame_out == 1 && img && use_y4m) {
- /* Write out the color format to terminate the header line */
- const char *color =
- img->fmt == VPX_IMG_FMT_444A ? "C444alpha\n" :
- img->fmt == VPX_IMG_FMT_I444 ? "C444\n" :
- img->fmt == VPX_IMG_FMT_I422 ? "C422\n" :
- "C420jpeg\n";
-
- fwrite(color, 1, strlen(color), out);
+ y4m_write_file_header(out, vpx_input_ctx.width, vpx_input_ctx.height,
+ &vpx_input_ctx.framerate, img->fmt);
}
if (img && do_scale) {
@@ -916,7 +899,7 @@
out = out_open(out_fn, do_md5);
} else {
if (use_y4m)
- fwrite("FRAME\n", 1, 6, out);
+ y4m_write_frame_header(out);
}
if (do_md5)
diff --git a/y4menc.c b/y4menc.c
new file mode 100644
index 0000000..8321b43
--- /dev/null
+++ b/y4menc.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "./y4menc.h"
+
+void y4m_write_file_header(FILE *file, int width, int height,
+ const struct VpxRational *framerate,
+ vpx_img_fmt_t fmt) {
+ const char *color = fmt == VPX_IMG_FMT_444A ? "C444alpha\n" :
+ fmt == VPX_IMG_FMT_I444 ? "C444\n" :
+ fmt == VPX_IMG_FMT_I422 ? "C422\n" :
+ "C420jpeg\n";
+
+ // Note: We can't output an aspect ratio here because IVF doesn't
+ // store one, and neither does VP8.
+ // That will have to wait until these tools support WebM natively.*/
+ fprintf(file, "YUV4MPEG2 W%u H%u F%u:%u I%c %s", width, height,
+ framerate->numerator, framerate->denominator, 'p', color);
+}
+
+void y4m_write_frame_header(FILE *file) {
+ fprintf(file, "FRAME\n");
+}
diff --git a/y4menc.h b/y4menc.h
new file mode 100644
index 0000000..e5f7978
--- /dev/null
+++ b/y4menc.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef Y4MENC_H_
+#define Y4MENC_H_
+
+#include <stdio.h>
+
+#include "./tools_common.h"
+
+#include "vpx/vpx_decoder.h"
+
+void y4m_write_file_header(FILE *file, int width, int height,
+ const struct VpxRational *framerate,
+ vpx_img_fmt_t fmt);
+
+void y4m_write_frame_header(FILE *file);
+
+
+#endif // Y4MENC_H_
